码厩技术博客

#483 Golang 反射简单示例

• 2021/02/09, Golang 反射简单示例
• 2021/02/17, Golang reflect 包
• 2021/04/06, Go 反射

通过反射（Reflection），我们可以在程序运行时，动态的增删该一些信息（类型，方法，变量），用来完成一些特殊的任务。
主要是实现不同类型都支持的一些方法。在 ORM，序列化等方面都有应用。

这种动态获取信息的能力让程序的开发变得更加灵活，但也会损失部分性能，毕竟需要进行很多类型检查、值转换等操作。
而且，滥用的话会导致程序变得复杂，可读性下降。

示例 1

type Person struct {
    Name string
    Age  int
}

func Insert(db *sql.DB, v interface{}) error {
    value := reflect.ValueOf(v)
    typ := reflect.TypeOf(v)

    sql := "INSERT INTO persons ("
    placeholders := "VALUES ("
    for i := 0; i < typ.Elem().NumField(); i++ {
        fieldName := typ.Elem().Field(i).Name
        sql += fmt.Sprintf("%s, ", fieldName)
        placeholders += "?, "
    }
    sql = sql[:len(sql)-2] + ")"
    placeholders = placeholders[:len(placeholders)-2] + ")"

    args := make([]interface{}, typ.Elem().NumField())
    for i := 0; i < typ.Elem().NumField(); i++ {
        args[i] = value.Elem().Field(i).Interface()
    }

    _, err := db.Exec(sql+placeholders, args...)
    return err
}

示例 2

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name    string
    Age     int
    Address string
}

// 定义结构体方法
func (p Person) Hello() string {
    return "Hello, " + p.Name
}

func main() {
    p := Person{
        Name:    "Alice",
        Age:     30,
        Address: "123 Main St",
    }

    fmt.Println("获取变量的反射类型：===============")
    pType := reflect.TypeOf(p)                  // &reflect.rtype
    fmt.Printf("Type: %s, %#v\n", pType, pType) // main.Person
    // fmt.Println("Type:", pType.Elem()) // panic: reflect: Elem of invalid type main.Person
    pType2 := reflect.TypeOf(&p)
    fmt.Printf("Type: %s, %#v\n", pType2, pType2)               // *main.Person
    fmt.Printf("Type: %s, %#v\n", pType2.Elem(), pType2.Elem()) // main.Person （指针类型的基础类型）

    fmt.Println("获取变量的反射值：===============")
    pValue := reflect.ValueOf(p) // main.Person
    fmt.Printf("Value: %s, %#v\n", pValue, pValue)
    pValue2 := reflect.ValueOf(&p)
    fmt.Printf("Value: %s, %#v\n", pValue2, pValue2) // 地址
    fmt.Printf("Value: %s, %#v\n", pValue2.Elem(), pValue2.Elem())

    fmt.Println("遍历结构体字段：===============")
    for i := 0; i < pType.NumField(); i++ {
        field := pType.Field(i)
        value := pValue.Field(i)
        fmt.Printf("%s: %v\n", field.Name, value.Interface())
    }

    fmt.Println("修改结构体字段值：===============")
    ageField1 := pValue.FieldByName("Age")
    fmt.Printf("Value: %#v\n", ageField1)
    // ageField1.SetInt(31) // panic: reflect: reflect.Value.SetInt using unaddressable value
    // ageField1.Elem().SetInt(31) // panic: reflect: call of reflect.Value.Elem on int Value
    ageField2 := pValue2.Elem().FieldByName("Age")
    fmt.Printf("Value: %#v\n", ageField2)
    ageField2.SetInt(31) // 只有指针类型才能通过反射修改
    fmt.Println("New Age:", p.Age)

    fmt.Println("调用结构体方法：===============")
    helloMethod := pValue.MethodByName("Hello")
    result := helloMethod.Call(nil)
    fmt.Println(result)

    // panic: reflect: call of reflect.Value.FieldByName on ptr Value
    pValue2.FieldByName("Age")

    // panic: reflect: reflect.Value.SetInt using unaddressable value
    // a := reflect.Indirect(pValue)
    b := reflect.Indirect(pValue2)
    b.FieldByName("Age").SetInt(33)
    fmt.Printf("%#v\n", b)
}

• reflect.TypeOf：获取变量的类型

• reflect.ValueOf：获取变量的值

• Type.NumField：获取结构体字段数量

• Type.Field：获取结构体字段信息

• Value.Field：获取结构体字段的值

• Value.FieldByName：根据字段名获取结构体字段的值
• Value.SetInt：设置整数类型字段的值
• Value.MethodByName：根据方法名获取结构体方法
• Value.Call：调用结构体方法

#482 假期要开始了！！！

#481 Python logging 日志模块 [编辑中]

:) 本文正在编辑中，暂时不提供浏览...

#480 古代政府合法性

之前讲过一次权力从何而来，今天上午又聊了一下钱莉芳的两部小说（《天意》、《天命》）
干脆再说说，我们国家古代政权的合法性问题。

#479 关于尺寸的一些参考

#478 读：天意 + 天命

最近读了钱莉芳写的几篇科幻小说。

#477 Tornado: max_clients limit reached, request queued

看到日志里面有很多 tornado 的 max_clients limit reached, request queued. 日志。

#476 GO111MODULE 是什么？

每一个 Golang 初学者都会遇到 GOPATH 和 Go Module 的问题，至少在最近的一两年是这样的。
简单的说，就是由于 Golang 诞生于谷歌，所以早期的项目工程化受谷歌内部开发流程影响很大。谷歌内部不同项目的代码放在一起，方便相互引用。GOPATH 就是这种代码管理方式的体现，所有的包都放在一个固定的开发目录下。
但是谷歌外面的世界，可能是受开源生态的影响，我们习惯将代码拆分成不同的包，分散在不通的仓库，需要什么包就导入什么包。所以虽然有一些人一直在吹捧 GOPATH 模式，但是大多数人还是喜欢传统的包模式。
所以在 Go Module 之前，官方或者社区也都有出一些解决方案，其中最有名的是 dep、vender。但随着最终方案 Go Module 的确定，他们已经完成了历史使命，而我最近两个月才开始学 Go，当然就跳过他们了。

#475 Golang HTTP Server

最简模式

package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "hello world\n")
}

func main() {
    http.HandleFunc("/", hello)

    http.ListenAndServe(":8080", nil)
}

重点是记住这两点：

1. func hello(w http.ResponseWriter, req *http.Request)
2. http.HandleFunc 注册一个函数到指定路径上

ListenAndServe 流程分析

https://github.com/golang/go/blob/master/src/net/http/server.go#L3240
https://github.com/golang/go/blob/master/src/net/http/server.go#L2976

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

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)
}

主要的逻辑：

1. net.Listen("tcp", addr) -> net.Listener
2. for 循环：
3. net.Listener.Accept() -> net.Conn
4. http.Server.newConn(conn) -> http.Conn
5. go http.Conn.serve(ctx)
6. goroutine 中又是一个 for 循环：
7. http.Conn.readRequest(ctx) -> http.response
8. serverHandler{c.server}.ServeHTTP(w, w.req)
9. 最后这个 serverHandler.ServeHTTP 就比较关键了：
   优先采用 http.Server 上的 Handler；
   如果没有，则用默认的 http.DefaultServeMux 实现简单的 URL 路由。
   这也是为什么 ListenAndServe 传了个 nil 进来，srv.Handler 为 nil 就用 DefaultServeMux。

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

func (mux *ServeMux) match(path string) (h Handler, pattern string)
func (mux *ServeMux) redirectToPathSlash(host, path string, u *url.URL) (*url.URL, bool)
func (mux *ServeMux) shouldRedirectRLocked(host, path string) bool
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
func (mux *ServeMux) handler(host, path string) (h Handler, pattern string)
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)
func (mux *ServeMux) Handle(pattern string, handler Handler)
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))

DefaultServeMux

// ==================================================================
// 封装 handler，添加到路由表 =========================================
// ==================================================================
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    // https://github.com/golang/go/blob/master/src/net/http/server.go#L2505
    // func (mux *ServeMux) Handle(pattern string, handler Handler)
    // 把 handler 注册到 mux.m (map[string]muxEntry) 上
    // muxEntry{h: handler, pattern: pattern}
    mux.Handle(pattern, HandlerFunc(handler))
}

// 封装普通函数为 Handler
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// ==================================================================
// 路由匹配 =========================================================
// ==================================================================
ServeHTTP -> Handler -> handler -> match
          -> redirectToPathSlash -> shouldRedirectRLocked -> 跳转(http.RedirectHandler)

默认路由规则：

1. 优先完整匹配
2. URL 前缀匹配，最长的路由规则优先

另一种方式 (http.Handle)

不用 http.HandleFunc，而是传入一个 Handler（实现 ServeHTTP 方法的结构体）。

package main

import (
    "fmt"
    "net/http"
)

type HelloHandler struct {
    content string
}

func (h *HelloHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, h.content)
}

func main() {
    http.Handle("/", &HelloHandler{"hello world\n"})

    http.ListenAndServe(":8080", nil)
}

func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

http.Handle 和 http.HandleFunc 都只是给默认路由（DefaultServeMux）上注册一个规则，知道这一点就可以了。

重点是 mux.Handle 和 Handler 接口。

还可以这样

package main

import (
    "fmt"
    "net/http"
)

type HelloHandler struct {
    content string
}

func (h *HelloHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, h.content)
}

func main() {
    http.ListenAndServe(":8080", &HelloHandler{"hello world\n"})
}

知道背后的流程就豁然开朗了。

当然，这样也是可以的：

func hello(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "hello world\n")
}
func main() {
    http.ListenAndServe(":8080", http.HandlerFunc(hello))
}

整理总结

• http.Conn
• http.Server
• 到处都是 Hander（接口），路由（mux）也是 Handler
• func(w http.ResponseWriter, req *http.Request)

实现正则路由

GitHub 上一搜索 golang mux golang router 就有，这是几个可以参考的方案：

1. gorilla/mux
2. julienschmidt/httprouter
3. go-chi/chi
4. celrenheit/lion
5. beego/mux

我自己实现一个简单的路由机制，参考 Django：

<name> OR <converter:name>

其中：converter 内置支持 str, int, slug, uuid, path, 可以自定义，默认是 str; name 可以是合法的 Go 变量名。

中间件

通过 Handler 套娃实现中间件：

type LogMiddleware struct {
    handler Handler
}
func (this LogMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    this.handler.ServeHTTP(w, r)
    fmt.Printf("%s %s %v\n", r.Method, r.URL.RequestURI(), time.Since(start))
}
mux := ...
http.ListenAndServe(":8000", LogMiddleware{mux})

系统内置 Handler：

grep -E "func.+ServeHTTP" src/net/http -R | grep -Fv "_test.go"
src/net/http/cgi/host.go:func (h *Handler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
src/net/http/fs.go:func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/httputil/reverseproxy.go:func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
src/net/http/pprof/pprof.go:func (name handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
src/net/http/server.go:func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/server.go:func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/server.go:func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/server.go:func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
src/net/http/server.go:func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/server.go:func (globalOptionsHandler) ServeHTTP(w ResponseWriter, r *Request) {
src/net/http/server.go:func (h initALPNRequest) ServeHTTP(rw ResponseWriter, req *Request) {
src/net/http/triv.go:func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
src/net/http/triv.go:func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {

有待分析。

优雅重启

参考资料与拓展阅读

• Eli Bendersky's website, Life of an HTTP request in a Go server
• 通过分析gin、beego源码，读懂web框架对http请求处理流程的本质

#474 Node Socket 编程 EMFILE 错误的一种情况

本月，听了同事做的一次技术分享，觉得很有意思的问题，我在这里隐去业务细节，只保留技术部分，做个总结归纳，最后用一个业务无关的脚本来模拟一下这个过程。
同事的分享就好比是先逐步实验发现一个现象，然后研究出他背后的原理是什么。我在这里作为事后的归纳总结，就直接冲着背后的原理说了。