GoF设计模式之代理模式

上一篇：【Go实现】实践GoF的23种设计模式：访问者模式

简单的分布式应用系统（示例代码工程）：https://github.com/ruanrunxue/Practice-Design-Pattern--Go-Implementation

简介

GoF 对代理模式（Proxy Pattern）的定义如下：

Provide a surrogate or placeholder for another object to control access to it.

也即，代理模式为一个对象提供一种代理以控制对该对象的访问。

它是一个使用率非常高的设计模式，在现实生活中，也是很常见。比如，演唱会门票黄牛。假设你需要看一场演唱会，但官网上门票已经售罄，于是就当天到现场通过黄牛高价买了一张。在这个例子中，黄牛就相当于演唱会门票的代理，在正式渠道无法购买门票的情况下，你通过代理完成了该目标。

从演唱会门票的例子我们也能看出，使用代理模式的关键在于，当 Client 不方便直接访问一个对象时，提供一个代理对象控制该对象的访问。Client 实际上访问的是代理对象，代理对象会将 Client 的请求转给本体对象去处理。

UML 结构

场景上下文

在简单的分布式应用系统（示例代码工程）中，db 模块用来存储服务注册和监控信息，它是一个 key-value 数据库。为了提升访问数据库的性能，我们决定为它新增一层缓存：

另外，我们希望客户端在使用数据库时，并不感知缓存的存在，这些，代理模式可以做到。

代码实现

//demo/db/cache.go
packagedb

//关键点1:定义代理对象，实现被代理对象的接口
typeCacheProxystruct{
//关键点2:组合被代理对象，这里应该是抽象接口，提升可扩展性
dbDb
cachesync.Map//key为tableName，value为sync.Map[key:primaryId,value:interface{}]
hitint
missint
}

//关键点3:在具体接口实现上，嵌入代理本身的逻辑
func(c*CacheProxy)Query(tableNamestring,primaryKeyinterface{},resultinterface{})error{
cache,ok:=c.cache.Load(tableName)
ifok{
ifrecord,ok:=cache.(*sync.Map).Load(primaryKey);ok{
c.hit++
result=record
returnnil
}
}
c.miss++
iferr:=c.db.Query(tableName,primaryKey,result);err!=nil{
returnerr
}
cache.(*sync.Map).Store(primaryKey,result)
returnnil
}

func(c*CacheProxy)Insert(tableNamestring,primaryKeyinterface{},recordinterface{})error{
iferr:=c.db.Insert(tableName,primaryKey,record);err!=nil{
returnerr
}
cache,ok:=c.cache.Load(tableName)
if!ok{
returnnil
}
cache.(*sync.Map).Store(primaryKey,record)
returnnil
}

...

//关键点4:代理也可以有自己特有方法，提供一些辅助的功能
func(c*CacheProxy)Hit()int{
returnc.hit
}

func(c*CacheProxy)Miss()int{
returnc.miss
}

...

客户端这样使用：

//客户端只看到抽象的Db接口
funcclient(dbDb){
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)
}

funcmain(){
//关键点5:在初始化阶段，完成缓存的实例化，并依赖注入到客户端
cache:=NewCacheProxy(&memoryDb{tables:sync.Map{}})
client(cache)
}

本例子中，Subject 是Db接口，Proxy 是CacheProxy对象，SubjectImpl 是memoryDb对象：

总结实现代理模式的几个关键点：

定义代理对象，实现被代理对象的接口。本例子中，前者是CacheProxy对象，后者是Db接口。

代理对象组合被代理对象，这里组合的应该是抽象接口，让代理的可扩展性更高些。本例子中，CacheProxy对象组合了Db接口。

代理对象在具体接口实现上，嵌入代理本身的逻辑。本例子中，CacheProxy在Query、Insert等方法中，加入了缓存sync.Map的读写逻辑。

代理对象也可以有自己特有方法，提供一些辅助的功能。本例子中，CacheProxy新增了Hit、Miss等方法用于统计缓存的命中率。

最后，在初始化阶段，完成代理的实例化，并依赖注入到客户端。这要求，客户端依赖抽象接口，而不是具体实现，否则代理就不透明了。

扩展

Go 标准库中的反向代理

代理模式最典型的应用场景是远程代理，其中，反向代理又是最常用的一种。

以 Web 应用为例，反向代理位于 Web 服务器前面，将客户端（例如 Web 浏览器）请求转发后端的 Web 服务器。反向代理通常用于帮助提高安全性、性能和可靠性，比如负载均衡、SSL 安全链接。

Go 标准库的 net 包也提供了反向代理，ReverseProxy，位于net/http/httputil/reverseproxy.go下，实现http.Handler接口。http.Handler提供了处理 Http 请求的能力，也即相当于 Http 服务器。那么，对应到 UML 结构图中，http.Handler就是 Subject，ReverseProxy就是 Proxy：

下面列出ReverseProxy的一些核心代码：

//net/http/httputil/reverseproxy.go
packagehttputil

typeReverseProxystruct{
//修改前端请求，然后通过Transport将修改后的请求转发给后端
Directorfunc(*http.Request)
//可理解为Subject，通过Transport来调用被代理对象的ServeHTTP方法处理请求
Transporthttp.RoundTripper
//修改后端响应，并将修改后的响应返回给前端
ModifyResponsefunc(*http.Response)error
//错误处理
ErrorHandlerfunc(http.ResponseWriter,*http.Request,error)
...
}

func(p*ReverseProxy)ServeHTTP(rwhttp.ResponseWriter,req*http.Request){
//初始化transport
transport:=p.Transport
iftransport==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))
...
}

ReverseProxy就是典型的代理模式实现，其中，远程代理无法直接引用后端的对象引用，因此这里通过引入Transport来远程访问后端服务，可以将Transport理解为 Subject。

可以这么使用ReverseProxy：

funcproxy(c*gin.Context){
remote,err:=url.Parse("https://yrunz.com")
iferr!=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)
}

funcmain(){
r:=gin.Default()
r.Any("/*proxyPath",proxy)
r.Run(":8080")
}

典型应用场景

远程代理（remote proxy），远程代理适用于提供服务的对象处在远程的机器上，通过普通的函数调用无法使用服务，需要经过远程代理来完成。因为并不能直接访问本体对象，所有远程代理对象通常不会直接持有本体对象的引用，而是持有远端机器的地址，通过网络协议去访问本体对象。

虚拟代理（virtual proxy），在程序设计中常常会有一些重量级的服务对象，如果一直持有该对象实例会非常消耗系统资源，这时可以通过虚拟代理来对该对象进行延迟初始化。

保护代理（protection proxy），保护代理用于控制对本体对象的访问，常用于需要给 Client 的访问加上权限验证的场景。

缓存代理（cache proxy），缓存代理主要在 Client 与本体对象之间加上一层缓存，用于加速本体对象的访问，常见于连接数据库的场景。

智能引用（smart reference），智能引用为本体对象的访问提供了额外的动作，常见的实现为 C++ 中的智能指针，为对象的访问提供了计数功能，当访问对象的计数为 0 时销毁该对象。

优缺点

优点

可以在客户端不感知的情况下，控制访问对象，比如远程访问、增加缓存、安全等。

符合开闭原则，可以在不修改客户端和被代理对象的前提下，增加新的代理；也可以在不修改客户端和代理的前提下，更换被代理对象。

缺点

作为远程代理时，因为多了一次转发，会影响请求的时延。

与其他模式的关联

从结构上看，装饰模式和 代理模式 具有很高的相似性，但是两种所强调的点不一样。前者强调的是为本体对象添加新的功能，后者强调的是对本体对象的访问控制。

文章配图

可以在用Keynote画出手绘风格的配图中找到文章的绘图方法。

审核编辑：汤梓红