第十三章：适配器模式

一、情景

中国香港使用的英标插座，Tony从内地来到了香港，那么就要把英标插座转换成国标插座才能给电子产品充电。

二、代码模拟

package main

import "fmt"

type SocketEntity struct {
    numOfPin  int
    typeOfPin string
}

func (s *SocketEntity) GetNumOfPin() int {
    return s.numOfPin
}

func (s *SocketEntity) SetNumOfPin(numOfPin int) {
    s.numOfPin = numOfPin
}

func (s *SocketEntity) GetTypeOfPin() string {
    return s.typeOfPin
}

func (s *SocketEntity) SetTypeOfPin(typeOfPin string) {
    s.typeOfPin = typeOfPin
}

func NewSocketEntity(numOfPin int, typeOfPin string) *SocketEntity {
    return &SocketEntity{
        numOfPin:  numOfPin,
        typeOfPin: typeOfPin,
    }
}

type ISocket interface {
    GetName() string
    GetSocket() *SocketEntity
}

type ChineseSocket struct {
}

func (c *ChineseSocket) GetName() string {
    return "国标插座"
}

func (c *ChineseSocket) GetSocket() *SocketEntity {
    return NewSocketEntity(3, "八字扁型")
}

func NewChineseSocket() ISocket {
    return &ChineseSocket{}
}

type BritishSocket struct {
}

func (b *BritishSocket) name() string {
    return "英标插座"
}

func (b *BritishSocket) socketInterface() *SocketEntity {
    return NewSocketEntity(3, "T字方型")
}

func NewBritishSocket() *BritishSocket {
    return &BritishSocket{}
}

type AdapterSocket struct {
    /*插座转换器*/
    britishSocket *BritishSocket
}

func (a *AdapterSocket) GetName() string {
    return a.britishSocket.name() + "转换器"
}

func (a *AdapterSocket) GetSocket() *SocketEntity {
    socket := a.britishSocket.socketInterface()
    socket.SetTypeOfPin("八字扁型")
    return socket
}

func NewAdapterSocket(britishSocket *BritishSocket) ISocket {
    return &AdapterSocket{
        britishSocket: britishSocket,
    }
}

func CanChargeForDigitalDevice(name string, socket *SocketEntity) {
    var isStandard string
    var canCharge string
    if socket.GetNumOfPin() == 3 && socket.GetTypeOfPin() == "八字扁型" {
        isStandard = "符合"
        canCharge = "可以"
    } else {
        isStandard = "不符合"
        canCharge = "不可以"
    }
    fmt.Printf("[%s]：\n针脚数量：%d，针脚类型：%s；%s中国标准，%s给中国内地的电子设备充电！\n", name, socket.GetNumOfPin(), socket.GetTypeOfPin(), isStandard, canCharge)
}

func testSocket() {
    chineseSocket := NewChineseSocket()
    CanChargeForDigitalDevice(chineseSocket.GetName(), chineseSocket.GetSocket())

    britishSocket := NewBritishSocket()
    CanChargeForDigitalDevice(britishSocket.name(), britishSocket.socketInterface())

    adapterSocket := NewAdapterSocket(britishSocket)
    CanChargeForDigitalDevice(adapterSocket.GetName(), adapterSocket.GetSocket())
}

func main() {
    testSocket()
}

输出结果：

[国标插座]：
针脚数量：3，针脚类型：八字扁型；符合中国标准，可以给中国内地的电子设备充电！
[英标插座]：
针脚数量：3，针脚类型：T字方型；不符合中国标准，不可以给中国内地的电子设备充电！
[英标插座转换器]：
针脚数量：3，针脚类型：八字扁型；符合中国标准，可以给中国内地的电子设备充电！

Process finished with exit code 0

三、什么是适配器模式以及其设计思想

1.定义

将一个类的接口变成客户端所期望的另外一种接口，从而使原本因接口不匹配而无法一起工作的两个类能够在一起工作。

适配器模式的作用：
（1）接口转换，将原有接口（或方法）转换成另外一种接口。
（2）用新的接口包装一个已有的类。
（3）匹配一个老的组件到一个新的接口。
2.设计思想

适配器模式又叫做变压器模式，也叫包装模式，它的核心思想是：将一个对象经过包装或转换后使它符合指定的接口，使得调用方可以像使用接口的一般对象一样使用它。

四、模型抽象

4.1 适配器模式的框架模型

type Target struct {
    //目标类
}

func (t Target) function() {

}

type Adaptee struct {
    //原对象类
}

func (a Adaptee) specificFunction() {

}

type Adapter struct {
    //适配器
    adaptee Adaptee
}

func (Adapter) function() {
    
}

场景模拟中的ISoket师提供给客户端调用的抽象接口，BritishSocket是进行适配的对象类，AdapterSocket是适配器，将BritishSocket包装成符合ISocket接口的对象。

4.2设计要点：

适配器模式中主要有三个角色：
（1）目标(Target)：即你期望的目标接口，要转换成的接口。
（2）源对象(Adaptee)：即要被转换的角色，要把谁转换成目标对象。
（3）适配器(Adapter)：适配器模式的核心角色，负责把源对象转换和包装成目标对象。

4.3优缺点

优点：
（1）可以让两个没有关联的类一起运行，起中间转换的作用。
（2）提高了类的复用率。
（3）灵活性好，不会破坏原有系统。
缺点：
（1）如果原有系统没有设计好（如Target不是抽象类或接口，而是一个实体类），适配模式将很难实现。
（2）过多地使用适配器，容易使代码结构混乱，如明明看到调用的是 A 接口，内部调用的却是B接口的实现。

五、应用场景

（1）系统需要使用现有的类，而这些类的接口不符合现有系统的要求。
（2）对已有的系统拓展新功能，尤其适用于在设计良好的系统框架下增加接入第三方的接口或第三方的SDK。

摘录来自
人人都懂设计模式：从生活中领悟设计模式：Python实现