http包的作用及使用
go的http包是go的web编程的核心内容，go的web框架本质上都是基于http提供的组件进行再度封装。我们来看一下http基本的使用：
func main() {
http.Handle("/get", GetVal())
http.Handle("/hello", Hello())
http.Handle("/demo", http.HandlerFunc(Demo))
if err := http.ListenAndServe("0.0.0.0:9191", nil); err != nil {
fmt.Println("err: %v", err)
}
}
func GetVal() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
val := "get\n"
fmt.Fprintf(w, val)
}
}
func Hello() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
val := "hello\n"
w.Write([]byte(val))
}
}
func Demo(w http.ResponseWriter, r *http.Request) {
val := "get\n"
fmt.Fprintf(w, val)
}
代码非常简单，就是为路由注册一个handler来处理请求并写入响应，我们来探究一下它的内部是如何实现的
源码分析
http包下的重要数据结构
ServerMux
type ServeMux struct {
mu sync.RWMutex //保证读写路由表的并发安全
m map[string]muxEntry
}
它是http包中的路由器组件，存储路由及handler的信息，能够通过路由规则快速匹配到对应的handler(高版本go使用的前缀树方式，低版本使用map的方式).
muxEntry
type muxEntry struct {
explict bool
handler Handler
}
Handler
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
请求处理的业务逻辑函数，由用户自己定义，通过ServeHttp方法进行处理
HandlerFunc
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
它完全是为了方便用户使用，通过定义函数的方法替代定义结构体来注册handler
http包的工作流程------使用默认路由
注册路由
func Handle(pattern string, handler Handler) {
DefaultServeMux.register(pattern, handler)
}
//DefaultServeMux
func (mux *ServeMux) register(pattern string, handler Handler) {
if err := mux.registerErr(pattern, handler); err != nil {
panic(err)
}
}
func (mux *ServeMux) registerErr(patstr string, handler Handler) error {
if patstr == "" {
return errors.New("http: invalid pattern")
}
if handler == nil {
return errors.New("http: nil handler")
}
if f, ok := handler.(HandlerFunc); ok && f == nil {
return errors.New("http: nil handler")
}
pat, err := parsePattern(patstr)
if err != nil {
return fmt.Errorf("parsing %q: %w", patstr, err)
}
// Get the caller's location, for better conflict error messages.
// Skip register and whatever calls it.
_, file, line, ok := runtime.Caller(3)
if !ok {
pat.loc = "unknown location"
} else {
pat.loc = fmt.Sprintf("%s:%d", file, line)
}
mux.mu.Lock()
defer mux.mu.Unlock()
// Check for conflict.
if err := mux.index.possiblyConflictingPatterns(pat, func(pat2 *pattern) error {
if pat.conflictsWith(pat2) {
d := describeConflict(pat, pat2)
return fmt.Errorf("pattern %q (registered at %s) conflicts with pattern %q (registered at %s):\n%s",
pat, pat.loc, pat2, pat2.loc, d)
}
return nil
}); err != nil {
return err
}
mux.tree.addPattern(pat, handler)
mux.index.addPattern(pat)
mux.patterns = append(mux.patterns, pat)
return nil
}
简单来说，但直接执行http.Handler方法注册路由时，就是将pattern及handler挂载到默认的ServeMux上。
DefaultServerMux会在挂载之前执行一系列的校验操作，并为了优化路由匹配性能引入一些复杂的数据结构和操作
server监听
入口-绑定port、监听请求
func (srv *Server) ListenAndServe() error {
if srv.shuttingDown() {
return ErrServerClosed
}
addr := srv.Addr
if addr == "" {
addr = ":http"
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
return srv.Serve(ln)
}
循环阻塞、等待请求、协程处理
简化版代码
func (srv *Server) Serve(l net.Listener) error {
baseCtx := context.Background()
if srv.BaseContext != nil {
baseCtx = srv.BaseContext(origListener)
if baseCtx == nil {
panic("BaseContext returned a nil context")
}
}
var tempDelay time.Duration // how long to sleep on accept failure
ctx := context.WithValue(baseCtx, ServerContextKey, srv)
for {
rw, err := l.Accept()
c := srv.newConn(rw)
c.setState(c.rwc, StateNew, runHooks) // before Serve can return
go c.serve(connCtx)
}
}
server会启动一个协程不断接收新来的请求，并新开一个协程处理请求来提高go的并发性和性能
请求处理逻辑
func (c *conn) serve(ctx context.Context) {
//根据不同的配置往ctx注入信息
// 针对不同的err信息进行处理
//for循环不断读取conn的信息------针对长链接
for {
w, err := c.readRequest(ctx)
//处理w和err，可能会推出循环
serverHandler{c.server}.ServeHTTP(w, w.req) //处理请求
//判断是否服用连接，不复用则退出循环
}
}
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
handler := sh.srv.Handler
if handler == nil {
handler = DefaultServeMux
}
if !sh.srv.DisableGeneralOptionsHandler && req.RequestURI == "*" && req.Method == "OPTIONS" {
handler = globalOptionsHandler{}
}
handler.ServeHTTP(rw, req)
}
如果传进来的handler为空则使用我们之前说的defaultServerMux，否则使用我们自己的路由器处理请求