ToB企服应用市场:ToB评测及商务社交产业平台

标题: Go语言实现GoF设计模式：适配器模式 [打印本页]
作者: 梦见你的名字    时间: 2024-2-15 22:47
标题: Go语言实现GoF设计模式：适配器模式
本文分享自华为云社区《【Go实现】实践GoF的23种设计模式：适配器模式》，作者：元闰子。
简介

适配器模式（Adapter）是最常用的结构型模式之一，在现实生活中，适配器模式也是处处可见，比如电源插头转换器，它可以让英式的插头工作在中式的插座上。
GoF 对它的定义如下：
Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
简单来说，就是适配器模式让原本因为接口不匹配而无法一起工作的两个类/结构体能够一起工作。
适配器模式所做的就是将一个接口 Adaptee，通过适配器 Adapter 转换成 Client 所期望的另一个接口 Target 来使用，实现原理也很简单，就是 Adapter 通过实现 Target 接口，并在对应的方法中调用 Adaptee 的接口实现。

UML 结构


场景上下文

在 简单的分布式应用系统（示例代码工程）中，db 模块用来存储服务注册信息和系统监控数据，它是一个 key-value 数据库。在 访问者模式 中，我们为它实现了 Table 的按列查询功能；同时，我们也为它实现了简单的 SQL 查询功能（将会在 解释器模式 中介绍），查询的结果是 SqlResult 结构体，它提供一个 toMap 方法将结果转换成 map 。
为了方便用户使用，我们将实现在终端控制台上提供人机交互的能力，如下所示，用户输入 SQL 语句，后台返回查询结果：

终端控制台的具体实现为 Console，为了提供可扩展的查询结果显示样式，我们设计了 ConsoleRender 接口，但因 SqlResult 并未实现该接口，所以 Console 无法直接渲染 SqlResult 的查询结果。

为此，我们需要实现一个适配器，让 Console 能够通过适配器将 SqlResult 的查询结果渲染出来。示例中，我们设计了适配器 TableRender，它实现了 ConsoleRender 接口，并以表格的形式渲染出查询结果，如前文所示。

代码实现
  1. // demo/db/sql.go
  2. package db
  4. // Adaptee SQL语句执行返回的结果，并未实现Target接口
  5. type SqlResult struct {
  6.     fields []string
  7.     vals   []interface{}
  8. }
  10. func (s *SqlResult) Add(field string, record interface{}) {
  11.     s.fields = append(s.fields, field)
  12.     s.vals = append(s.vals, record)
  13. }
  15. func (s *SqlResult) ToMap() map[string]interface{} {
  16.     results := make(map[string]interface{})
  17.     for i, f := range s.fields {
  18.         results[f] = s.vals[i]
  19.     }
  20.     return results
  21. }
  23. // demo/db/console.go
  24. package db
  26. // Client 终端控制台
  27. type Console struct {
  28.     db Db
  29. }
  31. // Output 调用ConsoleRender完成对查询结果的渲染输出
  32. func (c *Console) Output(render ConsoleRender) {
  33.     fmt.Println(render.Render())
  34. }
  36. // Target接口，控制台db查询结果渲染接口
  37. type ConsoleRender interface {
  38.     Render() string
  39. }
  41. // TableRender表格形式的查询结果渲染Adapter
  42. // 关键点1: 定义Adapter结构体/类
  43. type TableRender struct {
  44.     // 关键点2: 在Adapter中聚合Adaptee，这里是把SqlResult作为TableRender的成员变量
  45.     result *SqlResult
  46. }
  48. // 关键点3: 实现Target接口，这里是实现了ConsoleRender接口
  49. func (t *TableRender) Render() string {
  50.     // 关键点4: 在Target接口实现中，调用Adaptee的原有方法实现具体的业务逻辑
  51.     vals := t.result.ToMap()
  52.     var header []string
  53.     var data []string
  54.     for key, val := range vals {
  55.         header = append(header, key)
  56.         data = append(data, fmt.Sprintf("%v", val))
  57.     }
  58.     builder := &strings.Builder{}
  59.     table := tablewriter.NewWriter(builder)
  60.     table.SetHeader(header)
  61.     table.Append(data)
  62.     table.Render()
  63.     return builder.String()
  64. }
  66. // 这里是另一个Adapter，实现了将error渲染的功能
  67. type ErrorRender struct {
  68.     err error
  69. }
  71. func (e *ErrorRender) Render() string {
  72.     return e.err.Error()
  73. }
复制代码
客户端这么使用：
  1. func (c *Console) Start() {
  2.     fmt.Println("welcome to Demo DB, enter exit to end!")
  3.     fmt.Println("> please enter a sql expression:")
  4.     fmt.Print("> ")
  5.     scanner := bufio.NewScanner(os.Stdin)
  6.     for scanner.Scan() {
  7.         sql := scanner.Text()
  8.         if sql == "exit" {
  9.             break
  10.         }
  11.         result, err := c.db.ExecSql(sql)
  12.         if err == nil {
  13.             // 关键点5：在需要Target接口的地方，传入适配器Adapter实例，其中创建Adapter实例时需要传入Adaptee实例
  14.             c.Output(NewTableRender(result))
  15.         } else {
  16.             c.Output(NewErrorRender(err))
  17.         }
  18.         fmt.Println("> please enter a sql expression:")
  19.         fmt.Print("> ")
  20.     }
  21. }
复制代码
在已经有了 Target 接口（ConsoleRender）和 Adaptee（SqlResult）的前提下，总结实现适配器模式的几个关键点：
扩展

适配器模式在 Gin 中的运用

Gin 是一个高性能的 Web 框架，它的常见用法如下：
  1. // 用户自定义的请求处理函数，类型为gin.HandlerFunc
  2. func myGinHandler(c *gin.Context) {
  3.     ... // 具体处理请求的逻辑
  4. }
  6. func main() {
  7.     // 创建默认的route引擎,类型为gin.Engine
  8.     r := gin.Default()
  9.     // route定义
  10.     r.GET("/my-route", myGinHandler)
  11.     // route引擎启动
  12.     r.Run()
  13. }
复制代码
在实际运用场景中，可能存在这种情况。用户起初的 Web 框架使用了 Go 原生的 net/http，使用场景如下：
  1. // 用户自定义的请求处理函数，类型为http.Handler
  2. func myHttpHandler(w http.ResponseWriter, r *http.Request) {
  3.     ... // 具体处理请求的逻辑
  4. }
  6. func main() {
  7.     // route定义
  8.     http.HandleFunc("/my-route", myHttpHandler)
  9.     // route启动
  10.     http.ListenAndServe(":8080", nil)
  11. }
复制代码
因性能问题，当前客户准备切换至 Gin 框架，显然，myHttpHandler 因接口不兼容，不能直接注册到 gin.Default() 上。为了方便用户，Gin 框架提供了一个适配器 gin.WrapH，可以将 http.Handler 类型转换成 gin.HandlerFunc 类型，它的定义如下：
  1. // WrapH is a helper function for wrapping http.Handler and returns a Gin middleware.
  2. func WrapH(h http.Handler) HandlerFunc {
  3.       return func(c *Context) {
  4.           h.ServeHTTP(c.Writer, c.Request)
  5.       }
  6. }
复制代码
使用方法如下：
  1. // 用户自定义的请求处理函数，类型为http.Handler
  2. func myHttpHandler(w http.ResponseWriter, r *http.Request) {
  3.     ... // 具体处理请求的逻辑
  4. }
  6. func main() {
  7.     // 创建默认的route引擎
  8.     r := gin.Default()
  9.     // route定义
  10.     r.GET("/my-route", gin.WrapH(myHttpHandler))
  11.     // route引擎启动
  12.     r.Run()
  13. }
复制代码
在这个例子中，gin.Engine 就是 Client，gin.HandlerFunc 是 Target 接口，http.Handler 是 Adaptee，gin.WrapH 是 Adapter。这是一个 Go 风格的适配器模式实现，以更为简洁的 func 替代了 struct。
典型应用场景

优缺点

优点

缺点

与其他模式的关联

适配器模式 和 装饰者模式、代理模式 在 UML 结构上具有一定的相似性。但适配器模式改变原有对象的接口，但不改变原有功能；而装饰者模式和代理模式则在不改变接口的情况下，增强原有对象的功能。
文章配图

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

[1] 【Go实现】实践GoF的23种设计模式：SOLID原则, 元闰子
[2] Design Patterns, Chapter 4. Structural Patterns, GoF
[3] 适配器模式, refactoringguru.cn
[4] Gin Web Framework, Gin
 
点击关注，第一时间了解华为云新鲜技术~
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4