6 『适配器模式』 - 图1

1. 「引例」

人力资源管理项目
分为三大模块：人员信息管理、薪酬管理、 职位管理。人员信息管理的对象是所有员工的所有信息，所有的员工指的是在职的员工，其他的离职的、退休的暂不考虑。

UserInfo存储用户的所有信息，也就是BO（Business Object，业务对象），这个对象设计为贫血对象「Thin Business Object」，不需要存储状态以及相关的关系。本人是反对使用充血对象「Rich Business Object」。
一个对象如果不存储实体状态以及对象之间的关系，该对象就叫做「贫血对象」，对应的领域模型就是贫血领域模型，有实体状态和对象关系的模型就是充血领域模型。
「接口」 ```java public interface IUserInfo { // 用户姓名 public String getUserName(); // 家庭地址 public String getHomeAddress(); // 手机号码 public String getMobileNumber(); // 办公电话 public String getOfficeTelNumber(); // 职位 public String getJobPosition(); // 家庭电话 public String getHomeTelNumber(); }


- 「实现类」
```java
public class UserInfo implements IUserInfo {
    public String getUserName() {
        System.out.println("姓名叫做...");
        return null;
    }
    public String getHomeAddress() {
        System.out.println("这里是员工的家庭地址...");
        return null;
    }
    public String getMobileNumber() {
        System.out.println("这个人的手机号码是0000...");
        return null;
    }
    public String getOfficeTelNumber() {
        System.out.println("办公室电话是...");
        return null;
    }
    public String getJobPosition() {
        System.out.println("这个人的职位是BOSS...");
        return null;
    }
    public String getHomeTelNumber() {
        System.out.println("员工的家庭电话是...");
        return null;
    }
}

现在出现一个劳动外包服务公司要加入到本项目中来，其公司的人员管理系统的业务模式跟本公司的模式并不同。

人员信息分为三部分：基本信息、办公信息和个人家庭信息，并且都放到了HashMap中，比如人员的姓名放到BaseInfo信息中，家庭地址放到HomeInfo中。

「接口」

public interface IOuterUser {
  //基本信息，如名称、性别、手机号码等
  public Map getUserBaseInfo();
  // 工作区域信息
  public Map getUserOfficeInfo();
  // 用户的家庭信息
  public Map getUserHomeInfo();
}

「实现类」

public class OuterUser implements IOuterUser {
  public Map getUserBaseInfo() {
      HashMap baseInfoMap = new HashMap();
      baseInfoMap.put("userName", "这个员工叫混世魔王...");
      baseInfoMap.put("mobileNumber", "这个员工电话是...");
      return baseInfoMap;
  }
  public Map getUserOfficeInfo() {
      HashMap officeInfo = new HashMap();
      officeInfo.put("jobPosition", "这个人的职位是BOSS...");
      officeInfo.put("officeTelNumber", "员工的办公电话是...");
      return officeInfo;
  }
  public Map getUserHomeInfo() {
      HashMap homeInfo = new HashMap();
      homeInfo.put("homeTelNumbner", "员工的家庭电话是...");
      homeInfo.put("homeAddress", "员工的家庭地址是...");
      return homeInfo;
  }
}

现在需要将它们的管理系统与我们的进行交互。思路是先取出对方的数据对象，然后转化为我们的数据对象，中间需要转换。
了解业务需求后，决定采用RMI「Remote Method Invocation，远程对象调用」的方式联机交互。只要有接口，就可以把远程的对象当成本地的对象使用。实现不同系统中的对象互相调用。

📌注：我们之所以能够增加一个OuterUserInfo中转类，是因为在系统设计时严格遵守了依赖倒置原则和里氏替换原则，否则即使增加了中转类也无法解决问题。

public class OuterUserInfo extends OuterUser implements IUserInfo {
    private Map homeInfo = super.getUserHomeInfo();      // 员工的基本信息
    private Map officeInfo = super.getUserOfficeInfo();  // 员工的家庭信息
    private Map baseInfo = super.getUserBaseInfo();      // 工作信息
    public String getUserName() {
        String userName = (String) this.baseInfo.get("userName");
        System.out.println(userName);
        return userName;
    }
    public String getHomeAddress() {
        String homeAddress = (String) this.homeInfo.get("homeAddress");
        System.out.println(homeAddress);
        return homeAddress;
    }
    public String getMobileNumber() {
        String mobileNumber = (String) this.baseInfo.get("mobileNumber");
        System.out.println(mobileNumber);
        return mobileNumber;
    }
    public String getOfficeTelNumber() {
        String officeTelNumber = (String) this.officeInfo.get("officeTelNumber");
        System.out.println(officeTelNumber);
        return officeTelNumber;
    }
    public String getJobPosition() {
        String jobPosition = (String) this.officeInfo.get("jobPosition");
        System.out.println(jobPosition);
        return jobPosition;
    }
    public String getHomeTelNumber() {
        String homeTelNumber = (String) this.homeInfo.get("homeTelNumber");
        System.out.println(homeTelNumber);
        return homeTelNumber;
    }
}

使用强转，完成数据转换。当然，一开始用泛型加以限制可以避免此转换。 ```java @Test public void test1() { // 没有与外系统连接的时候，是这样写的 IUserInfo userInfo = new UserInfo(); // 从数据库中查到10个 for (int i = 0; i < 10; i++) {
```
  userInfo.getMobileNumber();
```
} }

@Test public void test2() { // 没有与外系统连接的时候，是这样写的 IUserInfo userInfo = new OuterUserInfo(); // 仅仅只用改动这里 // 从数据库中查到10个 for (int i = 0; i < 10; i++) { userInfo.getMobileNumber(); } }


- 适配器模式只修改了一句话，其他的业务逻辑都不用修改就解决了系统
对接的问题。
<a name="FTXYU"></a>
# 2. 「定义」
> Convert the interface of a class into another interface clients expect.Adapter lets classes work
together that couldn't otherwise because of incompatible interfaces.
- 将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
- 适配器模式（Adapter）又叫做**变压器模式 | 封装器模式**，也叫做**包装模式**（Wrapper），但是包装模式可不止一个，还包括了**装饰模式。**
**通用类图**<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2860434/1619862720564-1764fbd2-82fe-451a-8c05-f4252838849f.png#clientId=u00992a08-7868-4&from=paste&id=u840264ce&margin=%5Bobject%20Object%5D&name=image.png&originHeight=369&originWidth=518&originalType=binary&size=42936&status=done&style=shadow&taskId=udc4d67bd-4ee4-482d-b1be-2bf0ba2e0e1)<br />形象解释：<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2860434/1619863165976-00f347c8-a67c-41d7-9c66-2e6e948e8e81.png#clientId=u00992a08-7868-4&from=paste&id=u28da630a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=154&originWidth=1058&originalType=binary&size=32637&status=done&style=shadow&taskId=u32de5748-6be7-4aaa-b7e1-fafc5f0387c)
- 「Target目标角色」
   - 该角色定义把其他类转换为何种接口，也就是期望接口，例子中的IUserInfo接口
就是目标角色。
- 「Adaptee源角色」
   - 想把谁转换成目标角色，这个“谁”就是源角色。
   - 它是已经存在的、运行良好的类或对
象，经过适配器角色的包装，它会成为一个崭新、靓丽的角色。
- 「Adapter适配器角色」
   - 适配器模式的核心角色，其他两个角色都是已经存在的角色，而适配器角色是需要新建
立的。
   - 它的职责非常简单：把源角色转换为目标角色，怎么转换？通过继承或是类关联的方式。
**通用源码**
```java
public interface Target {
    public void request(); // 目标角色有自己的方法
}
public class ConcreteTarget implements Target {
    public void request() {
        System.out.println("If you need any help, call me!");
    }
}
public class Adaptee {
    //原有的业务逻辑
    public void doSomething() {
        System.out.println("I'm kind of busy, leave me alone.");
    }
}
public class Adapter extends Adaptee implements Target{
    public void request() {
        super.doSomething();
    }
}
class Client {
    @Test
    public void test() {
        // 原有的业务逻辑
        Target target = new ConcreteTarget();
        target.request();
        // 现在增加了适配器角色后的业务逻辑
        Target target2 = new Adapter();
        target2.request();
    }
}

3. 「应用」

1. 「优点」

适配器模式可以让两个没有任何关系的类在一起运行
- 只要适配器这个角色能够搞定他们就成。
增加了类的透明性
- 访问Target目标角色，但是具体的实现都委托给了源角色，而这些对高层次模块是透明的，也是它不需要关心的。
提高了类的复用度
- 源角色在原有的系统中还是可以正常使用，而在目标角色中也可以充当新的演员。
灵活性非常好
- 某一天，突然不想要适配器，删除掉这个适配器就可以，其他的代码都不用修改，基本上就类似一个灵活的构件，想用就用，不想就卸载。

2. 「使用场景」

你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的模式。
比如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口。使用适配器模式。

3. 「注意事项」

📌

适配器模式最好在详细设计阶段不要考虑它，它不是为了解决还处在开发阶段的问题，而是解决正在服役的项目问题。这个模式使用的主要场景是扩展应用中，系统扩展了，不符合原有设计的时候才考虑通过适配器模式减少代码修改带来的风险。
项目一定要遵守「依赖倒置原则」和「里氏替换原则」，否则即使在适合使用适配器的场合下，也会带来非常大的改造。

4. 「扩展」

刚刚讲的人力资源管理的例子中，如果劳动服务公司提供的人员接口不止一个，用户基本信息是一个接口，工作信息是一个接口，家庭信息是一个接口，总共有三个接口三个实现类，想想看如何处理呢？不能再使用我们上面的方法了。
因为Java是不支持多继承，可以使用类关联的办法嘛。声明一个OuterUserInfo实现类，实现IUserInfo接口，通过再关联其他三个实现类就可以解决。

「接口」

public interface IOuterUserBaseInfo {
  public Map getUserBaseInfo(); //基本信息，比如名称、性别、手机号码等
}
public interface IOuterUserHomeInfo {
   public Map getUserHomeInfo(); //用户的家庭信息
}
public interface IOuterUserOfficeInfo {
  public Map getUserOfficeInfo(); //工作区域信息
}

「实现类」

public class OuterUserBaseInfo implements IOuterUserBaseInfo {
  public Map getUserBaseInfo() {
      HashMap baseInfoMap = new HashMap();
      baseInfoMap.put("userName", "这个员工叫混世魔王...");
      baseInfoMap.put("mobileNumber", "这个员工电话是...");
      return baseInfoMap;
  }
}
public class OuterUserHomeInfo implements IOuterUserHomeInfo {
  public Map getUserHomeInfo() {
      HashMap homeInfo = new HashMap();
      homeInfo.put("homeTelNumbner", "员工的家庭电话是...");
      homeInfo.put("homeAddress", "员工的家庭地址是...");
      return homeInfo;
  }
}
public class OuterUserOfficeInfo implements IOuterUserOfficeInfo {
  public Map getUserOfficeInfo() {
      HashMap officeInfo = new HashMap();
      officeInfo.put("jobPosition", "这个人的职位是BOSS...");
      officeInfo.put("officeTelNumber", "员工的办公电话是...");
      return officeInfo;
  }
}

「适配器」

public class OuterUserInfo implements IUserInfo {
  //源目标对象
  private IOuterUserBaseInfo baseInfo = null;    //员工的基本信息
  private IOuterUserHomeInfo homeInfo = null;    //员工的家庭信息
  private IOuterUserOfficeInfo officeInfo = null; //工作信息
  //数据处理
  private Map baseMap = null;
  private Map homeMap = null;
  private Map officeMap = null;
  public OuterUserInfo(IOuterUserBaseInfo _baseInfo, IOuterUserHomeInfo _homeInfo, IOuterUserOfficeInfo _officeInfo) {
      this.baseInfo = _baseInfo;
      this.homeInfo = _homeInfo;
      this.officeInfo = _officeInfo;
      //数据处理
      this.baseMap = this.baseInfo.getUserBaseInfo();
      this.homeMap = this.homeInfo.getUserHomeInfo();
      this.officeMap = this.officeInfo.getUserOfficeInfo();
  }
  public String getUserName() {
      String userName = (String) this.baseMap.get("userName");
      System.out.println(userName);
      return userName;
  }
  public String getHomeAddress() {
      String homeAddress = (String) this.homeMap.get("homeAddress");
      System.out.println(homeAddress);
      return homeAddress;
  }
  public String getMobileNumber() {
      String mobileNumber = (String) this.baseMap.get("mobileNumber");
      System.out.println(mobileNumber);
      return mobileNumber;
  }
  public String getOfficeTelNumber() {
      String officeTelNumber = (String) this.officeMap.get("officeTelNumber");
      System.out.println(officeTelNumber);
      return officeTelNumber;
  }
  public String getJobPosition() {
      String jobPosition = (String) this.officeMap.get("jobPosition");
      System.out.println(jobPosition);
      return jobPosition;
  }
  public String getHomeTelNumber() {
      String homeTelNumber = (String) this.homeMap.get("homeTelNumber");
      System.out.println(homeTelNumber);
      return homeTelNumber;
  }
}

「测试」

class Client {
  @Test
  public void test() {
      //外系统的人员信息
      IOuterUserBaseInfo baseInfo = new OuterUserBaseInfo();
      IOuterUserHomeInfo homeInfo = new OuterUserHomeInfo();
      IOuterUserOfficeInfo officeInfo = new OuterUserOfficeInfo();
      // 传递三个对象
      IUserInfo iUserInfo = new OuterUserInfo(baseInfo, homeInfo, officeInfo);
      //从数据库中查到10个
      for (int i = 0; i < 10; i++) {
          iUserInfo.getMobileNumber();
      }
  }
}

OuterUserInfo变成了委托服务，把IUserInfo接口需要的所有的操作都委托给其他三个接口下的实现类，它的委托是通过对象层次的关联关系进行委托的，而不是继承关系。
「拓展」里的这种通过关联类的方式实现适配器叫做「对象适配器」，通过继承进行适配的叫做「类适配器」

对象适配器通用类图

对象适配器和类适配器的区别是：类适配器是类间继承，对象适配器是对象的合成关系，也可以说是类的关联关系，这是两者的根本区别。
二者在实际项目中都会经常用到，由于对象适配器是通过类间的关联关系进行耦合的，因此在设计时就可以做到比较灵活，比如修补源角色的隐形缺陷，关联其他对象等，而类适配器就只能通过覆写源角色的方法进行扩展，在实际项目中，对象适配器使用到场景相对较多。

5. 「最佳实践」

在绝对完美的设计下，适配器模式根本用不到，如有设计上的疏漏，可以用适配器来修补。
技术只是业务的实现工具，业务更替，技术的迭代也是难免的。用适配器就可以“弥补”这一需求。