引言
适配器设计模式是一种结构设计模式，它允许将一个类的接口转换成客户端期望的另一个接口。适配器让那些接口不兼容的类可以一起工作。这种模式在系统集成、插件开发和第三方库集成中尤为重要。
核心组件：
- 目标接口（ITarget）：期望的接口，要转化成的接口定义，客户端将使用这个接口；
- 适配者（Adaptee）：已存在的类，具有不兼容
Target定义的接口； - 适配器（Adaptor）：将适配者
Adaptee的接口转换成目标ITarget的接口。
实现方式
类适配器
类适配器基于继承实现
// 目标接口
public interface ITarget {
void f1();
void f2();
void fc();
}
// 适配者
public class Adaptee {
public void fa() { //... }
public void fb() { //... }
public void fc() { //... }
}
//适配器
public class Adaptor extends Adaptee implements ITarget {
public void f1() {
super.fa();
}
public void f2() {
//...重新实现f2()...
}
//fc()不需要实现，直接继承自Adaptee，这是跟对象适配器最大的不同点
}
对象适配器
对象适配器基于组合实现
// 目标接口
public interface ITarget {
void f1();
void f2();
void fc();
}
//适配者
public class Adaptee {
public void fa() { ... }
public void fb() { ... }
public void fc() { ... }
}
//适配器
public class Adaptor implements ITarget {
private Adaptee adaptee;
public Adaptor(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void f1() {
adaptee.fa(); //委托给Adaptee
}
public void f2() {
//...重新实现f2()...
}
public void fc() {
adaptee.fc();
}
}
方案选择
类适配器和对象适配器在实际工作中该怎么选择呢？有以下两个维度
Adaptee接口的个数Adaptee和ITarget接口的契合程度
1）若Adaptee接口不多，则两种方式都可以；
2）若Adaptee接口很多，且Adaptee和ITarget接口定义大部分都相同，推荐使用类适配器，因为Adaptor复用父类Adaptee的接口，比起对象适配器的实现方式，Adaptor的代码量要少一些；
3）若Adaptee接口很多，且Adaptee和ITarget接口定义大部分都不相同，推荐使用对象适配器，因为组合结构相对于继承更加灵活。
应用场景
适配器模式可以看作一种“补偿模式”，用来补救设计上的缺陷，属于无奈之举。如果在设计初期，就能协调规避接口不兼容的问题，那么这种模式就没有应用的机会了。
那么在实际开发中，什么情况下会出现接口不兼容呢？
封装有缺陷的接口设计
假如我们依赖的外部系统在接口设计上有缺陷（比如包含大量静态方法），引入之后会影响到我们自身代码的可测试性。为了隔离设计上的缺陷，我们希望对外部系统提供的接口进行二次封装，抽象出更好的接口设计。
//假设这个类来自外部sdk，我们无权修改它的代码
public class CD {
public static void staticFunction1() { //... }
public void uglyNamingFunction2() { //... }
public void tooManyParamsFunction3(int paramA, int paramB, ...) { //... }
public void lowPerformanceFunction4() { //... }
}
// 使用适配器模式进行重构
// 目标接口
public interface ITarget {
void function1();
void function2();
void fucntion3(ParamsWrapperDefinition paramsWrapper);
void function4();
//...
}
//适配器
public class CDAdaptor extends CD implements ITarget {
public void function1() {
super.staticFunction1();
}
public void function2() {
super.uglyNamingFucntion2();
}
public void function3(ParamsWrapperDefinition paramsWrapper) {
super.tooManyParamsFunction3(paramsWrapper.getParamA(), ...);
}
public void function4() {
//...reimplement it...
}
}
统一多个类的接口设计
某个功能的实现依赖多个外部系统或者多个类，通过适配器模式，将它们的接口适配为统一的接口定义，然后就可以使用多态特性来复用代码逻辑。
假如系统 A 要对用户输入的文本进行敏感词过滤，为了提高过滤的召回率，引入了多款第三方敏感词过滤系统，依次对用户输入的内容进行过滤，过滤掉尽可能多的敏感词。
但是，每个系统提供的过滤接口都是不同的。意味着我们无法复用一套逻辑来调用各个系统。此时，我们可以使用适配器模式，将所有系统的接口适配为统一的接口定义，这样我们可以复用调用敏感词过滤的代码。
未使用适配器模式
// A敏感词过滤系统提供的接口
public class ASensitiveWordsFilter {
//text是原始文本，函数输出用***替换敏感词之后的文本
public String filterSexyWords(String text) {
// ...
}
public String filterPoliticalWords(String text) {
// ...
}
}
// B敏感词过滤系统提供的接口
public class BSensitiveWordsFilter {
public String filter(String text) {
//...
}
}
// C敏感词过滤系统提供的接口
public class CSensitiveWordsFilter {
public String filter(String text, String mask) {
//...
}
}
// 未使用适配器模式之前的代码：代码的可测试性、扩展性不好
public class RiskManagement {
private ASensitiveWordsFilter aFilter = new ASensitiveWordsFilter();
private BSensitiveWordsFilter bFilter = new BSensitiveWordsFilter();
private CSensitiveWordsFilter cFilter = new CSensitiveWordsFilter();
public String filterSensitiveWords(String text) {
String maskedText = aFilter.filterSexyWords(text);
maskedText = aFilter.filterPoliticalWords(maskedText);
maskedText = bFilter.filter(maskedText);
maskedText = cFilter.filter(maskedText, "***");
return maskedText;
}
}
适配器模式改造
// 统一接口定义
public interface ISensitiveWordsFilter {
String filter(String text);
}
// A 适配器
public class ASensitiveWordsFilterAdaptor implements ISensitiveWordsFilter {
private ASensitiveWordsFilter aFilter;
public String filter(String text) {
String maskedText = aFilter.filterSexyWords(text);
maskedText = aFilter.filterPoliticalWords(maskedText);
return maskedText;
}
}
// B 适配器
public class BSensitiveWordsFilterAdaptor implements ISensitiveWordsFilter {
private BSensitiveWordsFilter bFilter;
public String filter(String text) {
String maskedText = bFilter.filter(text);
return maskedText;
}
}
// C 适配器
public class CSensitiveWordsFilterAdaptor implements ISensitiveWordsFilter {
private CSensitiveWordsFilter cFilter;
public String filter(String text) {
String maskedText = cFilter.filter(text,"");
return maskedText;
}
}
// 扩展性更好，更加符合开闭原则，如果添加一个新的敏感词过滤系统，
// 这个类完全不需要改动；而且基于接口而非实现编程，代码的可测试性更好。
public class RiskManagement {
private List<ISensitiveWordsFilter> filters = new ArrayList<>();
public void addSensitiveWordsFilter(ISensitiveWordsFilter filter) {
filters.add(filter);
}
public String filterSensitiveWords(String text) {
String maskedText = text;
for (ISensitiveWordsFilter filter : filters) {
maskedText = filter.filter(maskedText);
}
return maskedText;
}
}
替换依赖的外部系统
当我们把项目中依赖的一个外部系统替换为另一个外部系统时，利用适配器模式，可以减少对代码的改动。
假设我们有一个外部系统 A 的接口和实现。
public interface IA {
void fa();
}
public class A implements IA {
public void fa() {
System.out.println("Implementation of fa in System A");
}
}
还有一个使用外部系统 A 的 Demo 类
public class Demo {
private IA a;
public Demo(IA a) {
this.a = a;
}
public void doSomething() {
a.fa();
}
}
现在，我们引入外部系统B以及适配器BAdaptor
public class B {
public void fb() {
System.out.println("Implementation of fb in System B");
}
}
// B的适配器
public class BAdaptor implements IA {
private B b;
public BAdaptor(B b) {
this.b = b;
}
public void fa() {
// 适配B的fb方法
b.fb();
}
}
最后，我们可以在Demo中无缝替换A为B，而不影响Demo的代码
public class Client {
public static void main(String[] args) {
// 使用外部系统A
Demo demoWithA = new Demo(new A());
demoWithA.doSomething();
// 替换为外部系统B，借助适配器
Demo demoWithB = new Demo(new BAdaptor(new B()));
demoWithB.doSomething();
}
}
通过引入适配器，我们在替换外部系统时只需修改实例的创建，而不需要修改Demo中的代码。这符合适配器模式的核心思想，实现了对项目代码的最小侵入性。
适配不同格式的数据
Java 中的 Arrays.asList() 也可以看作一种数据适配器，将数组类型的数据转化为集合容器类型。
List<String> stooges = Arrays.asList("A", "B", "C");
总结
适配器设计模式是一种强大的工具，它允许不兼容的接口协同工作。通过创建适配器，我们可以将现有的类集成到新系统中，而无需修改它们的代码。这种模式提高了代码的可重用性和系统的灵活性。
参考资料：
《极客时间-设计模式之美》