上一篇:【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画出手绘风格的配图中找到文章的绘图方法。
-
代码
+关注
关注
30文章
4847浏览量
69308 -
设计模式
+关注
关注
0文章
53浏览量
8658 -
Client
+关注
关注
0文章
10浏览量
8848 -
代理模式
+关注
关注
0文章
4浏览量
1795
原文标题:【Go实现】实践GoF的23种设计模式:代理模式
文章出处:【微信号:yuanrunzi,微信公众号:元闰子的邀请】欢迎添加关注!文章转载请注明出处。
发布评论请先 登录
相关推荐
适配器模式和代理模式的区别
23种基本的设计模式总结
Command模式与动态语言

适配器模式和代理模式的区别

GoF设计模式之观察者模式
实践GoF的23种设计模式:命令模式简介
设计模式中代理模式的使用场景

评论