初探Go标准库—net/http

func main() {
	http.HandleFunc("/index", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprint(w, "What is the http.Handler")
	})
	_ = http.ListenAndServe(":8080", nil)
}

type ResponseWriter interface {
	Header() Header
	Writer([]byte) (int, error)
	WriteHeader(statusCode) int
}

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if use121 {
		DefaultServeMux.mux121.handleFunc(pattern, handler)
	} else {
		DefaultServeMux.register(pattern, HandlerFunc(handler))
	}
}

type ServeMux struct {
	mu     sync.RWMutex
	tree   routingNode
	index  routingIndex
	mux121 serveMux121 // used only when GODEBUG=httpmuxgo121=1
}
// DefaultServeMux is the default [ServeMux] used by [Serve].
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

func (mux *serveMux121) handleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if handler == nil {
		panic("http: nil handler")
	}
	mux.handle(pattern, HandlerFunc(handler))
}

type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}

type Handler interface {
	ServeHTTP(w ResponseWriter, r *Request)
}
func (mux *serveMux121) handle(pattern string, handler Handler) {}

type greeting string

func (g *greeting) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	fmt.Fprint(w, *g)
}

func main() {
	var g = greeting("hello")
	http.Handle("/greeting", &g)
}

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

type Server struct {
  Addr string
  Handler Handler
  TLSConfig *tls.Config
  ReadTimeout time.Duration
  ReadHeaderTimeout time.Duration
  WriteTimeout time.Duration
  IdleTimeout time.Duration
}

func (s *Server) ListenAndServe() error {
	if s.shuttingDown() {
		return ErrServerClosed
	}
	addr := s.Addr
	if addr == "" {
		addr = ":http"
	}
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}
	return s.Serve(ln)
}

	for {
		rw, err := l.Accept()
		if err != nil {
			if s.shuttingDown() {
				return ErrServerClosed
			}
			if ne, ok := err.(net.Error); ok && ne.Temporary() {
				if tempDelay == 0 {
					tempDelay = 5 * time.Millisecond
				} else {
					tempDelay *= 2
				}
				if max := 1 * time.Second; tempDelay > max {
					tempDelay = max
				}
				s.logf("http: Accept error: %v; retrying in %v", err, tempDelay)
				time.Sleep(tempDelay)
				continue
			}
			return err
		}
		connCtx := ctx
		if cc := s.ConnContext; cc != nil {
			connCtx = cc(connCtx, rw)
			if connCtx == nil {
				panic("ConnContext returned nil")
			}
		}
		tempDelay = 0
		c := s.newConn(rw)
		c.setState(c.rwc, StateNew, runHooks) // before Serve can return
		go c.serve(connCtx)
	}

func (c *conn) serve(ctx context.Context) {
  for {
    w, err := c.readRequest(ctx)
    serverHandler{c.server}.ServeHTTP(w, w.req)
    w.finishRequest()
  }
}

type serverHandler struct {
  srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
  handler := sh.srv.Handler
  if handler == nil {
    handler = DefaultServeMux
  }
  handler.ServeHTTP(rw, req)
}

type greeting string

func (g greeting) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	fmt.Fprint(w, g)
}

func main() {
	var g = greeting("hello")
	mux := http.NewServeMux()
	mux.Handle("/greeting", g)

	server := &http.Server{
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  20 * time.Second,
		WriteTimeout: 20 * time.Second,
	}
	server.ListenAndServe()
}

// 定义一个 middleware 中间件类型
type Middleware func(http.Handler) http.Handler

func WithLogger(handler http.Handler) http.Handler {
	// 将函数转换为中间类型 handlerFunc
	return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		now := time.Now()
		log.Default().Printf("start to Record the time, now: %s", now)

		defer func() {
			log.Default().Printf("The total request used %d ms", time.Since(now).Milliseconds())
		}()

		handler.ServeHTTP(rw, req)
	})
}

func (g greeting) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	fmt.Fprint(w, g)
}

func main() {
	var g = greeting("hello")
	mux := http.NewServeMux()
	mux.Handle("/greeting", WithLogger(g))

func PanicRecover(handler http.Handler) http.Handler {
	return http.HandlerFunc((func(rw http.ResponseWriter, req *http.Request) {
		if err := recover(); err != nil {
			log.Default().Fatal(string(debug.Stack()))
		}
		handler.ServeHTTP(rw, req)
	}))
}

mux.Handle("/", PanicRecover(WithLogger(Metric(http.HandlerFunc(index)))))
mux.Handle("/greeting", PanicRecover(WithLogger(Metric(greeting("welcome, dj")))))

package mhttp

import (
	"net/http"
)

// 定义一个 middleware 中间件类型
type Middleware func(http.Handler) http.Handler

// 设计一个自己的Mutex, 简化middlewares应用逻辑
type MyServeMutex struct {
	Sm          *http.ServeMux
	Middlewares []Middleware
}

// new 一个ServeMutex
func NewServeMux() *MyServeMutex {
	return &MyServeMutex{
		Sm: http.NewServeMux(),
	}
}

// use 一middlewares列表
func (m *MyServeMutex) Use(mw ...Middleware) {
	m.Middlewares = append(m.Middlewares, mw...)
}

// 应用middlewares集
// 注意这里应该是 右结合
func applyMiddlewares(handler http.Handler, middlewares ...Middleware) http.Handler {
	for i := len(middlewares) - 1; i >= 0; i -= 1 {
		handler = middlewares[i](handler)
	}
	return handler
}

func (m *MyServeMutex) Handel(pattern string, handler http.Handler) {
	newHandler := applyMiddlewares(handler, m.Middlewares...)
	m.Sm.Handle(pattern, newHandler)
}

// 处理函数
func (m *MyServeMutex) HandleFunc(pattern string, handleFunc http.HandlerFunc) {
	handler := http.Handler(handleFunc)
	newHandler := applyMiddlewares(handler, m.Middlewares...)
	m.Sm.Handle(pattern, newHandler)
}