适配器模式-通过适配器来复用

适配器模式是一种结构型设计模式,适配器模式主要是来解决接口不兼容的问题,使得原本没有关系的类可以协同工作。就好像我们笔记本电脑的电源适配器,在电压110v-220v之间都是可以正常工作的(那么大一坨),这适配器的工作就是把外部不稳定的电压转化成笔记本电脑能稳定使用的直流电压

适配器模式

定义

适配器模式(Adapter Pattern)- 将一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作

使用适配器模式其实就是把一个接口或者类转换成其他的接口和类,使其可以和其他模块一起工作,也可以被称为包装模式(Wrapper),同样有包装的功能还有装饰模式。适配器模式主要应用于想要复用现有的类,但是接口又与复用环境不一致的情况下

经常换手机的人可能会知道,手机的充电接口有几种,安卓的接口现在大多是Type-C了,一些低端机可能还在用Micro USB接口,而苹果则是用Lightining接口,假如我现在买了个新手机是Type-C接口,那我以前的那个Micro USB数据线还能不能继续用呢,是可以用的,只不过需要加上一个转接头,这个转接头便是一个适配器

适配器模式结构

适配器模式角色

  • 目标类(Target):定义客户所需接口,可以是一个抽象类或接口,也可以是具体类
  • 适配者(Adaptee):或者叫源对象,需要被适配的角色,它是已经存在的类或对象,适配者类一般是一个具体类,包含了客户希望使用的业务方法,在某些情况下可能没有适配者类的源代码
  • 适配器(Adapter):它的职责就是要把适配者转换成目标角色,对Adaptee和Target进行适配,在对象适配器中,它通过继承Target并关联一个Adaptee对象使二者产生联系

适配器有两种分类:对象适配器、类(或接口)适配器。在对象适配器模式中,适配器与适配者之间是关联关系;在类适配器模式中,适配器与适配者之间是继承(或实现)关系

对象适配器

类适配器

优点和使用场景

优点

  • 可以让两个没有关系的类在一起运行,引入一个适配器,可以不用修改原有代码
  • 增加类的透明度,客户端只调用Target,不关心具体实现
  • 提高类的复用度,原适配者类的功能还可以正常使用
  • 灵活性和扩展性非常好,符合“开闭原则”

使用场景

  • 系统需要使用一些现有的类,而这些类的接口(如方法名)不符合系统的需要,甚至没有这些类的源代码
  • 修改已投产的接口,可以考虑适配器模式

注意,适配器模式通常是用来解决系统扩展的问题,在系统开发过程中或已经项目维护中,当需要引入第三方的功能或要扩展的内容不符合原有设计的时候,才会考虑通过适配器模式来减少代码修改带来的风险。另外,项目一定要遵守依赖倒置原则里氏替换原则,这样在使用适配器模式时,才不会有太多改动

总的来说,适配器模式属于补偿模式,专门用来在系统后期扩展、修改时使用,但要注意不要过度使用适配器模式

实例

前些天刚入手一台新手机,满心欢喜啊,拿到手就忍不住开始“摩擦“,掂量一圈发现现在的手机是越来越好看、越来越薄了呀,一开心就想着拿出我的耳机想要沉浸在音乐的世界里,可下一秒蒙圈了,泥马没有耳机孔。原来啊,为了把手机做的更薄、更美,手机厂家牺牲了传统的3.mm耳机插孔,而使用复用充电接口Type-C,这下难道我又要去再搞一条Type-C接口的耳机吗?答案是可以不用,可以买一个接口转换器

Target目标类 - 要求使用Type-C接口

1
2
3
public interface TypeC {
void useTypeCPort();
}

Adaptee适配者 - 被适配的对象

1
2
3
4
5
6
7
8
9
10
11
public interface Headset {
void listen();
}

public class CommonHeadset implements Headset {

@Override
public void listen() {
System.out.println("使用3.5mm耳机享受音乐...");
}
}

Adapter适配器 - 把适配对象和目标类关联起来,达到转换的目的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class CommonHeadsetAdapter implements TypeC {

private CommonHeadset headset;

public CommonHeadsetAdapter(CommonHeadset headset){
this.headset = headset;
}

@Override
public void useTypeCPort() {
System.out.println("使用Type-C转接头");
this.headset.listen();
}
}

测试

1
2
3
4
5
6
@Test
public void adapterTest(){
CommonHeadset headset = new CommonHeadset();
CommonHeadsetAdapter headsetAdapter = new CommonHeadsetAdapter(headset);
headsetAdapter.useTypeCPort();
}

测试结果

1
2
使用Type-C转接头
使用3.5mm耳机享受音乐...

上面的是对象适配器,下面的是类适配器的做法

1
2
3
4
5
6
7
8
public class CommonHeadsetAdapter2 extends CommonHeadset implements TypeC {

@Override
public void useTypeCPort() {
System.out.println("使用Type-C转接头");
super.listen();
}
}

适配器模式应用

在我看来适配器模式主要是用在系统的扩展,或接入第三方接口。我们都不想破坏原有的设计和结构,为了适应新的需求,在它们之间增加一个适配层,这个适配器角色为我们转换数据或做连接。这样新的接口就能流畅调用旧的接口,达到复用的目的,符合开闭原则

要想理解适配器模式的应用或自己使用适配器,只要理清角色分工就很容易了。需要扩展一个怎样的新需求 (目标角色),但不改变原有的设计结构 (被适配角色),这个被适配角色可以是现有的接口、对象、类或第三方API,然后使用一个中间角色 (适配器)做数据转换或功能调用,使其满足新需求

JDBC - 驱动程序 - 数据库引擎API

Java程序是通过JDBC来跟数据库连接的,JDBC给出了一套抽象的接口,即目标接口。而各种数据库就是我们要适配的对象的,在JDBC接口和数据库引擎API之间需要一个适配器,而这个适配器就是驱动程序。(比如MySql的连接程序就是一个适配器,它把数据库的API操作适配成JDBC的Java操作)

Java I/O 库使用了适配器模式

ByteArrayInputStream是一个适配器类,它继承了InputStream的接口,并且封装了一个 byte 数组。它将一个 byte 数组的接口适配成InputStream流处理器的接口;

FileOutputStream 继承了 OutputStream 类型,同时持有一个对 FileDiscriptor 对象的引用。这是一个将 FileDiscriptor 接口适配成 OutputStream 接口形式的对象适配器模式;

Reader类型的原始流处理器都是适配器模式的应用。StringReader是一个适配器类,StringReader类继承了Reader类型,持有一个对String对象的引用。它将String的接口适配成 Reader 类型的接口

Spring AOP中的适配器模式

在Spring的Aop中,使用Advice(通知)来增强被代理类的功能。

Advice的类型有:MethodBeforeAdviceAfterReturningAdviceThrowsAdvice,而每个类型的Advice都有对应的拦截器:MethodBeforeAdviceInterceptorAfterReturningAdviceInterceptorThrowsAdviceInterceptor。Spring需要将每个Advice都封装成对应的拦截器类型,返回给容器,所以需要使用适配器模式对Advice进行转换

在这个应用中,Advice增强类其实只是普通的对象(被适配角色),而我们的目标是通过拦截器对切入点增强功能,所以通过适配器将我们的Advice适配成拦截器达到增强切入点的目的

Adaptee适配者类

1
2
3
4
5
6
7
8
9
10
public interface MethodBeforeAdvice extends BeforeAdvice {
void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

public interface AfterReturningAdvice extends AfterAdvice {
void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}

public interface ThrowsAdvice extends AfterAdvice {
}

Target目标接口

1
2
3
4
5
6
public interface AdvisorAdapter {
// 判断是否支持该增强,即是否匹配
boolean supportsAdvice(Advice advice);
// 获取对应的拦截器
MethodInterceptor getInterceptor(Advisor advisor);
}

Adapter适配器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

@Override
public boolean supportsAdvice(Advice advice) {
return (advice instanceof MethodBeforeAdvice);
}

@Override
public MethodInterceptor getInterceptor(Advisor advisor) {
MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
return new MethodBeforeAdviceInterceptor(advice);
}
}

class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {

@Override
public boolean supportsAdvice(Advice advice) {
return (advice instanceof AfterReturningAdvice);
}

@Override
public MethodInterceptor getInterceptor(Advisor advisor) {
AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
return new AfterReturningAdviceInterceptor(advice);
}
}

class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {

@Override
public boolean supportsAdvice(Advice advice) {
return (advice instanceof ThrowsAdvice);
}

@Override
public MethodInterceptor getInterceptor(Advisor advisor) {
return new ThrowsAdviceInterceptor(advisor.getAdvice());
}
}