【Go实现】实践GoF的23种设计模式：代理模式

 // demo/db/cache.go
 package 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.go
 package 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")
 }