适配器模式

最新推荐文章于 2023-09-29 09:40:56 发布

刚入门的Rain

最新推荐文章于 2023-09-29 09:40:56 发布

阅读量361

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/weixin_45776349/article/details/119784464

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

适配器模式用于将不同接口的类协同工作，通过类适配器、对象适配器和接口适配器实现。类适配器通过继承被适配类实现目标接口，对象适配器则通过持有被适配类实例并实现目标接口。接口适配器允许不实现接口的所有方法，提供默认实现。适配器模式常用于兼容老版本接口、替换外部系统、统一数据格式以及在日志框架间切换。

摘要由CSDN通过智能技术生成

适配器模式概述

基本介绍

适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
适配器模式属于结构型模式
主要分为三类:类适配器模式、对象适配器模式、接口适配器模式

工作原理

适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容从用户的角度看不到被适配者，是解耦的
用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法用户收到反馈结果，感觉只是和目标接口交互，如图

一、类适配器

基本介绍：Adapter 类，通过继承 src 类，实现 dst 类接口，完成 src->dst 的适配

以生活中充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 src (即被适配者)，我们的目 dst(即目标)是 5V 直流电

在这里插入图片描述

Voltage220V

//被适配的类
public class Voltage220V {
   //输出220V的电压
   public int output220V() {
      int src = 220;
      System.out.println("电压=" + src + "伏");
      return src;
   }
}

IVoltage5V

//适配接口
public interface IVoltage5V {
   public int output5V();
}

Phone

public class Phone {

   //充电
   public void charging(IVoltage5V iVoltage5V) {
      if(iVoltage5V.output5V() == 5) {
         System.out.println("电压为5V, 可以充电~~");
      } else if (iVoltage5V.output5V() > 5) {
         System.out.println("电压大于5V, 不能充电~~");
      }
   }
}

VoltageAdapter

作用就是将220v电压转换成5v

//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

   @Override
   public int output5V() {
      // TODO Auto-generated method stub
      //获取到220V电压
      int srcV = output220V();
      int dstV = srcV / 44 ; //转成 5v
      return dstV;
   }

}

Client

public class Client {

   public static void main(String[] args) {
      // TODO Auto-generated method stub
      System.out.println(" === 类适配器模式 ====");
      Phone phone = new Phone();
      phone.charging(new VoltageAdapter());
   }

}

1）java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性。
2）src类的方法在Adapter中暴露出来，会增加使用的成本。
3）由于其继承了src类，所以他可以根据要求重写src类的方法，使得Adapter的灵活性增强了。

二、对象适配器实现

基本思路和类的适配器模式相同，只是将 Adapter 类作修改，不是继承 src 类，而是持有 src 类的实例，以解决兼容性的问题。即：持有 src 类，实现 dst 类接口，完成 src->dst 的适配

根据组合复用在系统中尽量使用关联关系（聚合，组合）来替代继承关系。

上面的例子代码基本没用什么改变，改变的只有以下两个类

VoltageAdapter

// 适配器类
public class VoltageAdapter implements IVoltage5V {

  private Voltage220V voltage220V; // 关联关系-聚合

  // 通过构造器，传入一个 Voltage220V 实例
  public VoltageAdapter(Voltage220V voltage220v) {

    this.voltage220V = voltage220v;
  }

  @Override
  public int output5V() {

    int dst = 0;
    if (null != voltage220V) {
      int src = voltage220V.output220V(); // 获取220V 电压
      System.out.println("使用对象适配器，进行适配~~");
      dst = src / 44;
      System.out.println("适配完成，输出的电压为=" + dst);
    }

    return dst;
  }
}

Client

public class Client {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println(" === 对象适配器模式 ====");
    Phone phone = new Phone();
    phone.charging(new VoltageAdapter(new Voltage220V()));
  }
}

对象适配器模式注意事项和细节

对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。
根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承src 的局限性问题，也不再要求dst必须是接口。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vUrJe9gY-1629277412306)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20210818113203414.png)]$

适配器模式的原理与实现

顾名思义，这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。对于这个模式，有一个经常被拿来解释它的例子，就是 USB 转接头充当适配器，把两种不兼容的接口，通过转接变得可以一起工作。

原理很简单，我们再来看下它的代码实现。适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现。具体的代码实现如下所示。其中，ITarget 表示要转化成的接口定义。Adaptee 是一组不兼容 ITarget 接口定义的接口，Adaptor 将 Adaptee 转化成一组符合 ITarget 接口定义的接口。

三、接口适配器模式

介绍：核心思路：
1）当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中的每个方法提供一个默认方法（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求。
2）适用于一个接口不想使用其所有的方法的情况

在这里插入图片描述

public interface Interface4 {
    public void m1();
    public void m2();
    public void m3();
    public void m4();
}

//在AbsAdapter 将接口内的方法全部空实现
public class AbsAdapter implements Interface4{
    @Override
    public void m1() {}
    @Override
    public void m2() {}
    @Override
    public void m3() {}
    @Override
    public void m4() {}
}

//使用内部类的方式把抽象类中空实现的方法且需要的方法重写
public class Client {
    public static void main(String[] args) {
        AbsAdapter absAdapter = new AbsAdapter(){
            @Override
            public void m1() {
                System.out.println("使用了m1的方法");
            }
        };
        absAdapter.m1();
    }
}

适配器模式应用场景总结

一、封装有缺陷的接口

假设我们依赖的外部系统在接口设计方面有缺陷（比如包含大量静态方法），引入之后会影响到我们自身代码的可测试性。为了隔离设计上的缺陷，我们希望对外部系统提供的接口进行二次封装，抽象出更好的接口设计，这个时候就可以使用适配器模式了。

public class CD { //这个类来自外部sdk，我们无权修改它的代码
    //...
    public static void staticFunction1() { //... }
        
    public void uglyNamingFunction2() { //... }
        
    public void tooManyParamsFunction3(int paramA, int paramB, ...) { //... }

    public void lowPerformanceFunction4() { //... }

}

// 使用适配器模式进行重构
public class ITarget {

    void function1();
    void function2();
    void fucntion3(ParamsWrapperDefinition paramsWrapper);
    void function4();
    //...
}

// 注意：适配器类的命名不一定非得末尾带Adaptor

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...
    }
}

如果一个类是别人提供的，不便于修改，而我们想要的功能在原有类中并没有提供。（无相应的输入输出的函数），那么就可以使用一个类去继承被适配的类，然后实现一个接口（因为接口是对行为的抽象，我们想适配的功能都放到这个接口里去实现）。

召回率 就是用你查出来的正确的数量除以所有正确的数量，可以跟准确率对比着记忆，
准确率是用你查出来的正确的数量除以所有的数量（包含正确和不正确的数量）

二、统一多个类的接口设计

某个功能的实现依赖多个外部系统（或者说类）。通过适配器模式，将它们的接口适配为统一的接口定义，然后我们就可以使用多态的特性来复用代码逻辑

假设我们的系统要对用户输入的文本内容做敏感词过滤，为了提高过滤的召回率，我们引入了多款第三方敏感词过滤系统，依次对用户输入的内容进行过滤，过滤掉尽可能多的敏感词。但是，每个系统提供的过滤接口都是不同的。这就意味着我们没法复用一套逻辑来调用各个系统。这个时候，我们就可以使用适配器模式，将所有系统的接口适配为统一的接口定义，这样我们可以复用调用敏感词过滤的代码。

import java.util.ArrayList;
import java.util.List;

public class ASensitiveWordsFilter { // A敏感词过滤系统提供的接口
  // text是原始文本，函数输出用***替换敏感词之后的文本
  public String filterSexyWords(String text) {
    // ...
  }

  public String filterPoliticalWords(String text) {
    // ...
  }
}

public class BSensitiveWordsFilter { // B敏感词过滤系统提供的接口
  public String filter(String text) {
    // ...
  }
}

public class CSensitiveWordsFilter { // C敏感词过滤系统提供的接口
  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);
}

public class ASensitiveWordsFilterAdaptor implements ISensitiveWordsFilter {
  private ASensitiveWordsFilter aFilter;

  public String filter(String text) {
    String maskedText = aFilter.filterSexyWords(text);
    maskedText = aFilter.filterPoliticalWords(maskedText);
    return maskedText;
  }
}

// ...省略BSensitiveWordsFilterAdaptor、CSensitiveWordsFilterAdaptor...
// 扩展性更好，更加符合开闭原则，如果添加一个新的敏感词过滤系统，
// 这个类完全不需要改动；而且基于接口而非实现编程，代码的可测试性更好。
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;
  }
}

其实这里就是对对象适配器的应用场景

为每个过滤器都设置了一个适配器。

思想还是那样

抽象出一个接口，该接口内的方法就是我们想要的功能。比如对于我们想要的过滤功能来说，就是很简单的一个函数String filter(String text);输入未过滤的字符串，输出过滤后的字符串。
再实现相应的适配器类，适配器类使用组合的方式(实际上就是拥有一个原来过滤系统的对象)，且继承接口。这样我们就可以在该适配器中实现该接口的方法，得到我们适配后的输入输出

三、兼容老版本接口

在做版本升级的时候，对于一些要废弃的接口，我们不直接将其删除，而是暂时保留，并且标注为 deprecated，并将内部实现逻辑委托为新的接口实现。

好处：让使用它的项目有个过渡期，而不是强制进行代码修改。这也可以粗略地看作适配器模式的一个应用场景。
JDK1.0 中包含一个遍历集合容器的类 Enumeration（只支持遍历，不支持移除）。JDK2.0 对这个类进行了重构，将它改名为 Iterator 类，并且对它的代码实现做了优化。但是考虑到如果将 Enumeration 直接从 JDK2.0 中删除，那使用 JDK1.0 的项目如果切换到 JDK2.0，代码就会编译不通过。为了避免这种情况的发生，我们必须把项目中所有使用到 Enumeration 的地方，都修改为使用 Iterator 才行
单独一个项目做 Enumeration 到 Iterator 的替换，勉强还能接受。但是，使用 Java 开发的项目太多了，一次 JDK 的升级，导致所有的项目不做代码修改就会编译报错，这显然是不合理的。这就是我们经常所说的不兼容升级。为了做到兼容使用低版本 JDK 的老代码，我们可以暂时保留 Enumeration 类，并将其实现替换为直接调用 Itertor。代码示例如下所示：
```
public  class  Collections  {
  public  static Emueration emumeration(final Collection c)  {
    return  new Enumeration() {
      Iterator i = c.iterator();

      public boolean hasMoreElments()  {
        return i.hashNext();
      }

      public Object nextElement()  {
        return i.next():
      }
    }
  }
}
```

四、替换依赖的外部系统

当我们把项目中依赖的一个外部系统替换为另一个外部系统的时候，利用适配器模式，可以减少对代码的改动。具体的代码示例如下所示：

// 外部系统A
public  interface  IA  {
//...
  void  fa();
}
public  class  A  implements  IA  {
//...
  public  void  fa()  { 
    //... 
  }
}

// 在我们的项目中，外部系统A的使用示例
public  class  Demo  {
  private IA a;
  public  Demo(IA a)  {
    this.a = a;
  }
  //... 

}

Demo d = new Demo(new A());

// 将外部系统A替换成外部系统B
public  class  BAdaptor  implemnts  IA  {
  private B b;
  public  BAdaptor(B b)  {
    this.b= b;
  }

  public  void  fa()  {
  //...
    b.fb();
  }
}

// 借助BAdaptor，Demo的代码中，调用IA接口的地方都无需改动，
// 只需要将BAdaptor如下注入到Demo即可。
Demo d = new Demo(new BAdaptor(new B()));

五、适配不同格式的数据

前面我们讲到，适配器模式主要用于接口的适配，实际上，它还可以用在不同格式的数据之间的适配。比如，把从不同征信系统拉取的不同格式的征信数据，统一为相同的格式，以方便存储和使用。再比如，Java 中的 Arrays.asList() 也可以看作一种数据适配器，将数组类型的数据转化为集合容器类型。

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

适配器模式在java日志中应用

java中有很多日志框架，常用的就是log4j和logbacj之类的
大部分日志框架都提供类似的功能，比如按照什么级别打印日志
如果只是自己的一个项目，那使用任何日志框架都可以了
但是如果我们开发的是一个继承到其他系统的组件的话，如果该组件和系统使用的日志框架不一样，那整个系统就有两套日志框架了，日志的管理工作就变得比较复杂
为了解决这个问题，就需要统一日志打印框架
对于java开发来说， Slf4j 这个日志框架你肯定不陌生，它相当于规范，提供了一套打印日志的统一接口规范。不过，它只定义了接口，并没有提供具体的实现，需要配合其他日志框架（log4j、logback……）来使用。
而Slf4j还提供了针对不同日志框架的适配器。对不同日志框架的接口进行二次封装，适配成统一的 Slf4j 接口定义。具体的代码示例如下所示。

实际上这里的思想就是可以使用适配器思想。

还是之前提到的

Slf4j提供了接口，接口中有我们想要的一系列打印日志的规范，即我们想要的输入和输出
可以实现若干个适配器。对相应的日志框架进行适配，原理还是去实现该接口，再继承一个相应的日志框架，通过日志框架中的一些方法实现接口。
在使用的时候可以将适配器类型定义为接口（依赖倒置，不依赖于具体实现而依赖于抽象）
那直接使用适配器里面的方法就可以了

/ slf4j统一的接口定义
package org.slf4j;
public  interface Logger {
  public  boolean isTraceEnabled();
  public  void trace(String msg);
  public  void trace(String format, Object arg);
  public  void trace(String format, Object arg1, Object arg2);
  public  void trace(String format, Object[] argArray);
  public  void trace(String msg, Throwable t);
  public  boolean isDebugEnabled();
  public  void debug(String msg);
  public  void debug(String format, Object arg);
  public  void debug(String format, Object arg1, Object arg2);
  public  void debug(String format, Object[] argArray);
  public  void debug(String msg, Throwable t);

//...省略info、warn、error等一堆接口
}


// log4j日志框架的适配器
// Log4jLoggerAdapter实现了LocationAwareLogger接口，
// 其中LocationAwareLogger继承自Logger接口，
// 也就相当于Log4jLoggerAdapter实现了Logger接口。
package org.slf4j.impl;
public final class Log4jLoggerAdapter extends MarkerIgnoringBase
        implements LocationAwareLogger, Serializable {

  final transient org.apache.log4j.Logger logger; // log4j

  public  boolean isDebugEnabled() {
    return logger.isDebugEnabled();
  }

  public  void debug(String msg) {
    logger.log(FQCN, Level.DEBUG, msg, null);
  }

  public  void debug(String format, Object arg) {
    if (logger.isDebugEnabled()) {
      FormattingTuple ft = MessageFormatter.format(format, arg);
      logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
    }
  }

  public  void debug(String format, Object arg1, Object arg2) {
    if (logger.isDebugEnabled()) {
      FormattingTuple ft = MessageFormatter.format(format, arg1, arg2);
      logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
    }
  }

  public  void debug(String format, Object\[\] argArray) {
    if (logger.isDebugEnabled()) {
      FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
      logger.log(FQCN, Level.DEBUG, ft.getMessage(), ft.getThrowable());
    }
  }

  public  void debug(String msg, Throwable t) {
    logger.log(FQCN, Level.DEBUG, msg, t);
  }

//...省略一堆接口的实现...
}