适配器模式(结构型)
一、适配器介绍
1). 相关概念
- 适配器模式：Adapter Pattern, 别名包装器(Wrapper),将一个接口转换成客户希望的另一个接口，使接口不兼容的哪些类可以一起工作.
-
适配器模式分类：
- 对象适配器：适配器与是适配者之间为关联关系
- 类适配器：适配器与是适配者之间为继承关系(Java、C#由于单继承语法特性，此类型几乎不用)
2). 对象适配器模式角色
对象适配器模式结构图.png
- Target 目标抽象类：目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。
- Adapter 适配器类：适配器可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，适配器类是适配器模式的核心，在对象适配器中，它通过继承Target并关联一个Adaptee对象使二者产生联系。
- Adaptee 适配者类：适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码。
典型的对象适配器代码
class Adapter extends Target {
/**
* 维持一个对适配者对象的引用
*/
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee=adaptee;
}
/**
* 转发调用
*/
@Override
public void request() {
adaptee.specificRequest();
}
}
二、对象适配器模式案例
假设业务需求需要使用算法库(假设已经没有了源码)中的快速排序和二分查找，业务中的数据是双精度，而算法库是整型，请使用对象适配器模式进行设计。
对象适配器模式案例.png
- 目标类Target
/**
* 抽象成绩操作类：目标接口
*/
interface ScoreOperation {
/**
* 成绩排序
* @param array
* @return
*/
public double[] sort(double array[]);
/**
* 成绩查找,返回索引
* @param array
* @param key
* @return
*/
public int search(double array[], double key);
}
- 适配者adaptee
/**
* 快速排序类：适配者
*/
class QuickSort {
public int[] quickSort(int array[]) {
sort(array, 0, array.length - 1);
return array;
}
public void sort(int array[], int p, int r) {
int q = 0;
if (p < r) {
q = partition(array, p, r);
sort(array, p, q - 1);
sort(array, q + 1, r);
}
}
public int partition(int[] a, int p, int r) {
int x = a[r];
int j = p - 1;
for (int i = p; i <= r - 1; i ++) {
if (a[i] <= x) {
j ++;
swap(a, j, i);
}
}
swap(a, j + 1, r);
return j + 1;
}
public void swap (int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
/**
* 二分查找类：适配者
*/
class BinarySearch {
public int binarySearch(int array[], int key) {
int low = 0;
int high = array.length - 1;
while (low <= high) {
int mid = low / 2 + high / 2;
int midVal = array[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
// 找到了元素，并返回对应的索引
return mid;
}
}
// 未找到索引
return -1;
}
}
- 适配器 Adapter
/**
* 操作适配器：适配器
*/
class OperationAdapter implements ScoreOperation {
/**
* 格式化工具，拓展功能
*/
private static DecimalFormat format = new DecimalFormat("#.00");
// 定义适配者QuickSort对象
private QuickSort quickSort;
// 定义是配置者BinarySearch对象
private BinarySearch binarySearch;
public OperationAdapter() {
quickSort = new QuickSort();
binarySearch = new BinarySearch();
}
// TODO
@Override
public double[] sort(double[] array) {
int[] arrayModify = new int[array.length];
for (int i = 0; i < array.length; i++) {
arrayModify[i] = (int)(array[i] * 100);
}
this.quickSort.quickSort(arrayModify);
double[] arrayNew = new double[arrayModify.length];
for (int i = 0; i < arrayNew.length; i++) {
arrayNew[i] = arrayModify[i] / 100.0;
}
return arrayNew;
}
@Override
public int search(double[] array, double key) {
int[] arrayModify = new int[array.length];
for (int i = 0; i < array.length; i++) {
arrayModify[i] = (int)(array[i] * 100);
}
return this.binarySearch.binarySearch(arrayModify, (int) (key * 100));
}
}
- Client 测试类
/**
* 客户端，
* @author Liucheng
* @since 2019-07-17
*/
public class Client {
public static void main(String[] args) {
// 针对抽象目标接口编程,为了更好的支持拓展，建议使用xml进行配置,通过反射生成bean
ScoreOperation operation = new OperationAdapter();
double scores[] = {84.5,76,50,69,90.5,91,88.5,96}; //定义成绩数组
// 排序
scores = operation.sort(scores);
for (double score : scores) {
System.out.print(score + " ");
}
System.out.println();
// 查找
System.out.println("90.5 分的位置：" + (operation.search(scores, 90.5) + 1));
}
}
测试结果
50.0 69.0 76.0 84.5 88.5 90.5 91.0 96.0
90.5 分的位置：6
三、其他适配器介绍
1). 缺省适配器
缺省适配器模式是适配器模式的一种变体，其应用也较为广泛
缺省适配器模式(Default Adapter Pattern)：当不需要实现一个接口所提供的所有方法时，可先设计一个抽象类实现该接口，并为接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可以选择性地覆盖父类的某些方法来实现需求，它适用于不想使用一个接口中的所有方法的情况，又称为单接口适配器模式。
缺省适配器模式.png
- ServiceInterface（适配者接口）：它是一个接口，通常在该接口中声明了大量的方法。
- AbstractServiceClass（缺省适配器类）：它是缺省适配器模式的核心类，使用空方法的形式实现了在ServiceInterface接口中声明的方法。通常将它定义为抽象类，因为对它进行实例化没有任何意义。
- ConcreteServiceClass（具体业务类）：它是缺省适配器类的子类，在没有引入适配器之前，它需要实现适配者接口，因此需要实现在适配者接口中定义的所有方法，而对于一些无须使用的方法也不得不提供空实现。在有了缺省适配器之后，可以直接继承该适配器类，根据需要有选择性地覆盖在适配器类中定义的方法。
2). 双向适配器(实现复杂，使用较少)
在适配器中同时包含对目标类和适配者类的引用，适配者可以通过它调用目标类中的方法，目标类也可以通过它调用适配者类中的方法。
双向适配器.png
- 典型代码
class Adapter implements Target,Adaptee {
//同时维持对抽象目标类和适配者的引用
private Target target;
private Adaptee adaptee;
public Adapter(Target target) {
this.target = target;
}
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
public void specificRequest() {
target.request();
}
}
3). 类适配器（使用比较少）
类适配器模式和对象适配器模式最大的区别在于适配器和适配者之间的关系不同，对象适配器模式中适配器和适配者之间是关联关系，而类适配器模式中适配器和适配者是继承关系。
类适配器.png
- 典型的类适配器代码
class Adapter extends Adaptee implements Target {
public void request() {
specificRequest();
}
}
- 局限性：单继承体系语言受到限制，如下情况
- 目标类Target为类
- Adaptee为最终类
- 适配多个适配者实现复杂(需要额外的类进行继承操作)
四、适配器模式总结
1). 优点
类/对象适配器共有
- 将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。
- 增加了类的透明性和复用性，将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者的复用性，同一个适配者类可以在多个不同的系统中复用。
- 灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。
对象适配器优点
- 一个对象适配器可以把多个不同的适配者适配到同一个目标；
- 可以适配一个适配者的子类，由于适配器和适配者之间是关联关系，根据“里氏代换原则”，适配者的子类也可通过该适配器进行适配。
2). 缺点
类适配器对于单继承语法特性支持性不哈
3). 适用场景
- 系统需要使用一些现有的类，而这些类的接口（如方法名）不符合系统的需要，甚至没有这些类的源代码。
- 想创建一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。
