0、结构型模式

结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。

由于组合关系或聚合关系比继承关系耦合度低，满足”合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

结构型模式分为以下7种：

代理模式
适配器模式
装饰者模式
桥接模式
外观模式
组合模式
享元模式

适配器设计模式

1、旅游使用插座问题

不同国家所使用的插座国标是不同的，所以去国外旅游可以买个多功能转换插头（适配器），这样就可以使用了。

2、适配器模式——基本介绍

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

2）适配器模式属于结构型模式。

3）主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。类适配器模式比对象适配器模式的耦合度高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

3、适配器模式——工作原理

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

2）从用户的角度看不到被适配者，是解耦合的。

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

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

(目标)最终需要的输出，dst <———— 适配器 <———— (被适配者)需要被适配的类、接口等src

4、结构

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

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

5、类适配器模式

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

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

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

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

// 适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    @Override
    public int output5V() {
        // 获取220V电压
        int src = output220V();
        int dst = src / 44;
        return dst;
    }
}

// 手机
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，不能充电~");
        }
    }
}

【2】类适配器模式的注意事项和细节

1）Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性。

2）src类的方法在Adapter中都会暴露出来，也增加了使用的成本。

3）类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可用。

4）由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了。

6、对象适配器模式

【1】对象适配器模式介绍

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

2）根据 “合成复用原则”，在系统中尽量使用关联关系来替代继承关系。

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

【2】对象适配器模式应用实例（使用前述充电器例子）

public class VoltageAdapter implements IVoltage5 {
    public Voltage220 voltage; // 持有对象，而不是继承。
    
    public VoltageAdapter(Voltage220 voltage) {
        this.voltage = voltage;
    }
    
    @Override
    public int output5V() {
        // 获取220V电压
        int dst = 0;
        if (null != voltage) {
            int src = voltage.output220V();
            dst = src / 44;              
        }
		return dst; 
    }
}

【3】对象适配器注意事项

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

2）使用成本更低，更灵活。

7、接口适配器模式

【1】接口适配器模式介绍

1）一些书籍称为：适配器模式（Default Adapter Pattern）或缺省适配器模式。

2）当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并未该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求。

3）适用于一个接口不想使用其所有的方法的情况。

【2】接口适配器模式实例

1）Android中的属性动画ValueAnimator类可以通过addListener（AnimatorListener listener）方法添加监听器，常规写法如下：

ValueAnimator valueAnimator = ValueAnimator.ofInt(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();

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

ValueAnimator valueAnimator = ValueAnimator.ofInt(0, 100);
valueAnimator.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationStart(Animator animation) {
        // 具体实现
    }
});
valueAnimator.start();

8、应用场景

以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

9、适配器模式在JDK中的使用

Reader（字符流）、InputStream（字节流）的适配使用的是InputStreamReader。

InputStreamReader继承自java.io包中的Reader，对他中的抽象的未实现的方法给出实现。如：

public int read() throws IOException {
    return sd.read();
}

public int read(char cbuf[], int offset, int length) throws IOException {
    return sd.read(cbuf, offset, length);
}

如上代码中的sd（StreamDecoder类对象），在Sun的JDK实现中，实际的方法实现是对sun.nio.cs.StreamDecoder类的同名方法的调用封装。类结构如下：

从上图可以看出：

InputStreamReader是对同样实现了Reader的StreamDecoder的封装。
StreamDecoder不是Java SE API中的内容，是Sun JDK给出的自身实现。但我们知道他们对构造方法中的字节流类（InputStream）进行封装，并通过该类进行了字节流和字符流之间的解码转换。

结论：

从表层来看，InputStreamReader做了InputStream字节流类到Reader字符流之间的转换。而从如上Sun JDK中的实现类关系结构中可以看出，是StreamDecoder的设计实现在实际上采用了适配器模式。

10、适配器模式在SpringMVC中的应用

1）SpringMVC中的HandlerAdapter，就使用了适配器模式。

2）SpringMVC处理请求的流程回顾。

DispatcherServlet类中有getHandlerAdapter方法。

3）使用HandlerAdapter的原因分析：

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

4）动手写SpringMVC通过适配器设计模式获取到对应的Controller的源码

说明：

Spring定义了一个适配接口，使得每一种Controller有一种对应的适配器实现类。
适配器代替controller执行相应的方法。
扩展Controller时，只需要增加一个适配器类就完成了SpringMVC的扩展了。

// 多种Controller实现
public interface Controller {
    
}

class HttpController implements Controller {
    public void doHttpHandler() {
        System.out.println("http...");
    }
}

class SimpleController implements Controller {
    public void doSimplerHandler() {
        System.out.println("simple...");
    }
}

class AnnotationController implements Controller {
    public void doAnnotationHandler() {
        System.out.println("annotation...");
    }
}

// 定义一个Adapter接口
public interface HandlerAdapter {
    boolean supports(Object handler);
    void handle(Object handler);
}

// 多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter {
    public void handle(Object handler) {
        ((SimpleController) handler).doSimplerHandler();
    }
    
    public boolean supports(Object handler) {
        return (handler instanceof SimpleController);
    }
}

class HttpHandlerAdapter implements HandlerAdapter {
    public void handle(Object handler) {
        ((HttpController) handler).doHttpHandler();
    }
    
    public boolean supports(Object handler) {
        return (handler instanceof HttpController);
    }
}

class AnnotationHandlerAdapter implements HandlerAdapter {
    public void handle(Object handler) {
        ((AnnotationController) handler).doAnnotationHandler();
    }
    
    public boolean supports(Object handler) {
        return (handler instanceof AnnotationController);
    }
}

public class DispatchServlet {
    public static List<HandlerAdapter> handlerAdapters = new ArrayList<>();
    
    public DispatchServlet() {
        handlerAdapters.add(new AnnotationHandlerAdapter());
        handlerAdapters.add(new HttpHandlerAdapter());
        handlerAdapters.add(new SimpleHandlerAdapter());
    }
    
    public void doDispatch() {
        // 此处模拟SpringMVC从request取handler的对象
        // 适配器可以获取到希望的Controller
        // HttpController controller = new HttpController();
        AnnotationController controller = new AnnotationController();
        // SimpleController controller = new SimpleController();
        // 得到对应适配器
        HandlerAdapter adapter = getHandler(controller);
        // 通过适配器执行对应的controller对应方法
        adapter.handle(controller);
    }
    
    public HandlerAdapter getHandler(Controller controller) {
        for (HandlerAdapter adapter: this.handlerAdapters) {
            if (adapter.supports(controller)) {
                return adapter;
            }
        }
        return null;
    }
}