Young Kbt blog
Young Kbt
2022-03-07
目录

设计模式 - 结构型适配器模式

# 基本介绍

在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑接交流电源时需要一个电源适配器，用计算机访问照相机的 SD 内存卡时需要一个读卡器等。

在软件设计中也可能出现：需要开发的具有某种业务功能的组件在现有的组件库中已经存在，但它们与当前系统的接口规范不兼容，如果重新开发这些组件成本又很高，这时用适配器模式能很好地解决这些问题。

适配器模式（Adapter Pattern）将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器（Wrapper）。

适配器模式属于结构型模式，主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。

主要优点

  • 客户端通过适配器可以透明地调用目标接口
  • 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类
  • 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题
  • 在很多业务场景中符合开闭原则

主要缺点

  • 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性
  • 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱

# 模式的结构

适配器模式（Adapter）包含以下主要角色：

  • 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口
  • 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口
  • 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

# 工作原理

  • 适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容

  • 从用户的角度看不到被适配者，是解耦的

  • 用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法

  • 用户收到反馈结果，感觉只是和目标接口交互，如图

    image-20220307113733499

# 现实生活中的适配器例子

泰国插座用的是两孔的（欧标），可以买个多功能转换插头 (适配器) ，这样就可以使用了。

image-20220307113604066

# 类适配器模式

# 类适配器模式介绍

基本介绍：Adapter 类，通过继承 被适配类，实现 适配接口，完成被适配类到适配接口的适配。

image-20220314150218744

# 类适配器模式应用实例

应用实例说明：以生活中充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 src（即被适配者），我们的目标是 5V 直流电。

思路分析（类图）：

image-20220307113851301

代码实现

// dst 适配接口（充电器需要 5V）
public interface IVoltage5V {
	public int output5V();
}

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

// 适配器类（充电器）需要将插排的 220V 转为实际需要的 5V
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
	@Override
	public int output5V() {
		// 获取到 220V 电压
		int srcV = output220V();
		int dstV = srcV / 44 ; // 转成 5v
		return dstV;
	}
}
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

手机类和测试类

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, 不能充电~~");
		}
	}
}

public class Client {
	public static void main(String[] args) {
		System.out.println(" === 类适配器模式 ====");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 类适配器模式注意事项和细节

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

# 对象适配器模式

# 对象适配器模式介绍

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

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

对象适配器模式是适配器模式常用的一种。

image-20220314150231277

# 对象适配器模式应用实例

应用实例说明

以生活中充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 src (即被适配者)，我们的 dst（即目标）是 5V 直流电，使用对象适配器模式完成。

思路分析（类图）

只需修改适配器即可，如下：

image-20220307153329627

代码实现

// 适配接口（充电器需要 5V）
public interface IVoltage5V {
	public int output5V();
}

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

// 适配器类（充电器）需要将插排的 220V 转为实际需要的 5V
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;
    }
}
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

手机类和测试类

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, 不能充电~~");
		}
	}
}
public class Client {
	public static void main(String[] args) {
		System.out.println(" === 对象适配器模式 ====");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter(new Voltage220V()));
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

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

  • 使用成本更低，更灵活

# 接口适配器模式

# 接口适配器模式介绍

  • 一些书籍称为：适配器模式（Default Adapter Pattern）或缺省适配器模式
  • 核心思路：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
  • 适用于一个接口不想使用其所有的方法的情况

# 接口适配器模式应用实例

  • Android 中的属性动画 ValueAnimator 类可以通过 addListener(AnimatorListener listener) 方法添加监听器，那么常规写法如下：

    ValueAnimator valueAnimator = ValueAnimator.oflnt(0, 100);
valueAnimator.addListener(new Animator.AnimatorListener() {
    @Override
    public void onAnimationStart(Animator animation) {}
    @Override
    public void onAnimationEnd(Animator animation) {}
    @Override
    public void onAnimationCancel(Animator animation) {}
    @Override
    public void onAnimationRepeat(Animator animation) {}
});
valueAnimator.start();
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

  • 有时候我们不想实现 Animator.AnimatorListener 接口的全部方法，我们只想监听 onAnimationStart，我们会如下写：

    ValueAnimator valueAnimator = ValueAnimator.oflnt(0,100);
valueAnimator.addListener(new AnimatorListenerAdapter(){
    @Override
    public void onAnimationStart(Animator animation) {
        // xxxx 具体实现
    }
});
valueAnimator.start(;
    1
    2
    3
    4
    5
    6
    7
    8

  • AnimatorListenerAdapter 类，就是一个接口适配器，代码如下：它空实现了 Animator.AnimatorListener 类(src)的所有方法

    public abstract class AnimatorListenerAdapter implements Animator.Animator extends Animator.AnimatorPauseListener {
    @Override // 默认实现
    public void onAnimationCancel(Animator animation) {}
    @Override
    public void onAnimationEnd(Animator animation) {}
    @Override
    public void onAnimationRepeat(Animator animation) {}
    @Override
    public void onAnimationStart(Animator animation) {}
    @Override
    public void onAnimationPause(Animator animation) {}
    @Override
    public void onAnimationResume(Animator animation) {}
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

  • AnimatorListener 是一个接口：

    public static interface AnimatorListener {
    void onAnimationStart(Animator animation);
    void onAnimationEnd(Animator animation);
    void onAnimationCancel(Animator animation);
    void onAnimationRepeat(Animator animation);
}
    1
    2
    3
    4
    5
    6

  • 程序里的匿名内部类就是 Listener 具体实现类

    new AnimatorListenerAdapter(){
    @Override
    public void onAnimationStart(Animator animation) {
        // xxxx 具体实现
    }
}
    1
    2
    3
    4
    5
    6

案例说明

image-20220307154814117

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

// 在 AbsAdapter 我们将 Interface4 的方法进行默认实现
public abstract class AbsAdapter implements Interface4 {
    // 默认实现
    public void m1() {

    }

    public void m2() {

    }

    public void m3() {

    }

    public void m4() {

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

测试类：

public class Client {
    public static void main(String[] args) {
        AbsAdapter absAdapter = new AbsAdapter() {
            // 只需要去覆盖我们 需要使用 接口方法
            @Override
            public void m1() {
                System.out.println("使用了m1的方法");
            }
        };
        absAdapter.m1();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

# SpringMVC 的适配器模式剖析

  • SpringMVC 中的 HandlerAdapter, 就使用了适配器模式

  • SpringMVC 处理请求的流程回顾

  • 使用 HandlerAdapter 的原因分析：

    可以看到处理器的类型不同，有多重实现方式，那么调用方式就不是确定的，如果需要直接调用 Controller 方法，需要调用的时候就得不断是使用 if-else 来进行判断是哪一种子类然后执行。那么如果后面要扩展 Controller，就得修改原来的代码，这样违背了 OCP 原则。

image-20220307155052736

# 适配器模式的注意事项和细节

  • 三种命名方式，是根据 src 是以怎样的形式给到 Adapter（在 Adapter 里的形式）来命名的
  • 类适配器：以类给到，在 Adapter 里，就是将 src 当做类，继承
    • 对象适配器：以对象给到，在 Adapter 里，将 src 作为一个对象，持有
    • 接口适配器：以接口给到，在 Adapter 里，将 src 作为一个接口，实现
  • Adapter 模式最大的作用还是将原本不兼容的接口融合在一起工作
  • 实际开发中，实现起来不拘泥于我们讲解的三种经典形式

# 适配器模式的应用场景

适配器模式（Adapter）通常适用于以下场景：

  • 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致
  • 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同
编辑此页 (opens new window)
#设计模式
更新时间: 2023/10/23, 10:58:52
设计模式 - 创建型建造者模式
设计模式 - 结构型桥接模式

← 设计模式 - 结构型桥接模式→

最近更新
01
技术随笔 - Element Plus 修改包名 原创
11-02
02
Reactor - 扩展性
11-02
03
Reactor - 最佳实践
11-02
更多文章>
Theme by Vdoing | Copyright © 2021-2024 Young Kbt | blog
桂ICP备2021009994号