实践 GoF 的设计模式：代理模式

// demo/db/cache.gopackage db
// 关键点1: 定义代理对象，实现被代理对象的接口type CacheProxy struct {  // 关键点2: 组合被代理对象，这里应该是抽象接口，提升可扩展性    db    Db    cache sync.Map // key为tableName，value为sync.Map[key: primaryId, value: interface{}]    hit   int    miss  int}
// 关键点3: 在具体接口实现上，嵌入代理本身的逻辑func (c *CacheProxy) Query(tableName string, primaryKey interface{}, result interface{}) error {    cache, ok := c.cache.Load(tableName)    if ok {        if record, ok := cache.(*sync.Map).Load(primaryKey); ok {            c.hit++            result = record            return nil        }    }    c.miss++    if err := c.db.Query(tableName, primaryKey, result); err != nil {        return err    }    cache.(*sync.Map).Store(primaryKey, result)    return nil}
func (c *CacheProxy) Insert(tableName string, primaryKey interface{}, record interface{}) error {    if err := c.db.Insert(tableName, primaryKey, record); err != nil {        return err    }    cache, ok := c.cache.Load(tableName)    if !ok {        return nil    }    cache.(*sync.Map).Store(primaryKey, record)    return nil}
...
// 关键点4: 代理也可以有自己特有方法，提供一些辅助的功能func (c *CacheProxy) Hit() int {    return c.hit}
func (c *CacheProxy) Miss() int {    return c.miss}
...

// 客户端只看到抽象的Db接口func client(db Db) {    table := NewTable("region").      WithType(reflect.TypeOf(new(testRegion))).      WithTableIteratorFactory(NewRandomTableIteratorFactory())    db.CreateTable(table)    table.Insert(1, &testRegion{Id: 1, Name: "region"})
    result := new(testRegion)    db.Query("region", 1, result)}
func main() {    // 关键点5: 在初始化阶段，完成缓存的实例化，并依赖注入到客户端    cache := NewCacheProxy(&memoryDb{tables: sync.Map{}})    client(cache)}

// net/http/httputil/reverseproxy.gopackage httputil
type ReverseProxy struct {    // 修改前端请求，然后通过Transport将修改后的请求转发给后端    Director func(*http.Request)    // 可理解为Subject，通过Transport来调用被代理对象的ServeHTTP方法处理请求    Transport http.RoundTripper    // 修改后端响应，并将修改后的响应返回给前端    ModifyResponse func(*http.Response) error    // 错误处理    ErrorHandler func(http.ResponseWriter, *http.Request, error)    ...}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {    // 初始化transport    transport := p.Transport    if transport == nil {        transport = http.DefaultTransport    }    ...    // 修改前端请求    p.Director(outreq)    ...    // 将请求转发给后端    res, err := transport.RoundTrip(outreq)    ...    // 修改后端响应    if !p.modifyResponse(rw, res, outreq) {        return    }    ...    // 给前端返回响应    err = p.copyResponse(rw, res.Body, p.flushInterval(res))    ...}

func proxy(c *gin.Context) {    remote, err := url.Parse("https://yrunz.com")    if err != nil {        panic(err)    }
    proxy := httputil.NewSingleHostReverseProxy(remote)    proxy.Director = func(req *http.Request) {        req.Header = c.Request.Header        req.Host = remote.Host        req.URL.Scheme = remote.Scheme        req.URL.Host = remote.Host        req.URL.Path = c.Param("proxyPath")    }
    proxy.ServeHTTP(c.Writer, c.Request)}
func main() {    r := gin.Default()    r.Any("/*proxyPath", proxy)    r.Run(":8080")}