设计模式 -- 适配器模式 (Adapter Pattern)

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

适配器模式通用类图：

IInfo与IOuterInfo两个接口的并不匹配，但是可以通过AdapterInfo（适配器）可以将IOuterInfo接口的信息转化为IInfo接口所需要的信息，这样两个匹配的接口就可以一起工作了。

问题重现
IInfo接口可以查询数据，返回类型是String类型；IOuterInfo接口也可以查询数据，但是返回的是Map<String,String>类型，那么怎么将这两个接口结合在一起呢？

代码重现：

public interface IInfo {
   public String request();
}

public class Info implements IInfo {
   @Override
   public String request() {
      String a = "这是 Info 的数据";
      return a;
   }
}

public interface IOuterInfo {
   public Map<String,String> doSomething();
}

public class OuterInfo implements IOuterInfo {
   @Override
   public Map<String,String> doSomething() {
      Map<String,String> map = new HashMap<>();
      map.put("abc","def");
      return map;
   }
}

在IInfo接口与IOuterInfo接口间可以增加一个适配类，将IOuterInfo接口的数据转换为IInfo接口所需要的数据，这就是适配器模式。
增加代码如下：

public class AdapterInfo extends OuterInfo implements IInfo {
   @Override
   public String request() {
      Map<String,String> map = new HashMap<>();
      map = super.doSomething();
      return map.get("abc");
   }
}

public class Client {
   public static void main(String[] args) {
      IInfo info = new Info();
      System.out.println(info.request());
      
      //适配器接受外部数据
      IInfo Adapterinfo = new AdapterInfo();
      System.out.println(Adapterinfo.request());
   }
}

这样就可以将两个接口的数据互通，从而使得不匹配的接口能正常工作，其中AdapterInfo起到了角色转换的作用。

适配器的优点
①适配器模式能将两个不相关的接口在一起运行。
②我们在访问IInfo接口的数据时，具体的实现都委托给了IOuterInfo接口的实现类，对于高层模块而言是透明的。
③源角色在原系统中可以继续使用，在目标角色中则扮演新的角色，提高类的复用性。
④灵活性强，可以随时切换适配器。

适配器的使用场景
如果要更改一个已经投产的正常运行的接口时，使用适配器模式是最好的选择。

适配器模式注意事项
适配器模式不是为了解决还处于开发阶段的问题，而是解决正在服役的项目问题，因此在项目处于详细开发设计阶段，不建议使用此模式。项目一定要遵循依赖倒置原则与里氏替换原则，否则使用适配器模式时将带来较大的变动。

适配器模式的扩展
在上述问题中，与IInfo接口适配的只有一个IOuterInfo接口。若假如不止一个IOuterInfo接口，比如有IOuterInfo1，IOuterInfo2接口呢，Java是不可以多继承的，那该怎么将多个接口一起关联呢？
思路：在AdapterInfo（适配器）实现目标角色后，再关联外部IOuterInfo1，IOuterInfo2接口的实现类
修改部分代码如下：

public interface IOuterInfo1 {
   public Map<String,String> doSomething();
}

public interface IOuterInfo2 {
   public Map<String,String> doSomething();
}

public class OuterInfo1 implements IOuterInfo1 {
   @Override
   public Map<String,String> doSomething() {
      Map<String,String> map = new HashMap<>();
      map.put("abc","def");
      return map;
   }
}

public class OuterInfo2 implements IOuterInfo2 {
   @Override
   public Map<String, String> doSomething() {
      Map<String,String> map = new HashMap<>();
      map.put("123","456");
      return map;
   }
}

//实现目标角色接口，再引入外部源目标实现类
public class AdapterInfo implements IInfo {
   //源目标对象
   private IOuterInfo1 outerInfo1 = null;
   private IOuterInfo2 outerInfo2 = null;
   //数据处理
   private Map<String,String> map1 = null;
   private Map<String,String> map2 = null;
   
   //构造函数传递对象
   public AdapterInfo(IOuterInfo1 _outerInfo1, IOuterInfo2 _outerInfo2) {
      this.outerInfo1 = _outerInfo1;
      this.outerInfo2 = _outerInfo2;
      //数据处理
      this.map1 = outerInfo1.doSomething();
      this.map2 = outerInfo2.doSomething();
      
   }
   
   @Override
   public String request() {
      String demo1 = map1.get("abc");
      String demo2 = map2.get("123");
      System.out.println("demo1: "+demo1+" demo2: "+demo2);
      return null;
   }
}

public class Client {
   public static void main(String[] args) {
      IInfo info = new Info();
      System.out.println(info.request());
      
      //适配器接受外部数据
      IOuterInfo1 info1 = new OuterInfo1();
      IOuterInfo2 info2 = new OuterInfo2();
      IInfo Adapterinfo = new AdapterInfo(info1,info2);
      Adapterinfo.request();
   }
}
----------------output---------------
这是 Info 的数据
demo1: def demo2: 456

这种通过类间的关联关系进行耦合的适配叫做对象适配器，灵活性较强。

通过类的继承进行适配叫做类适配器，通过覆盖源角色的方法进行扩展。

在实际项目中，对象适配器的使用场景较多。

参考书籍：设计模式之禅 --- 秦小波 著