笔记来源：尚硅谷Java设计模式（图解+框架源码剖析）

适配器模式

泰国旅游使用插座问题

现实生活中的适配器例子

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

基本介绍

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

工作原理

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

1、类适配器模式

案例

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

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

UML 类图

核心代码

// 被适配的类
public class Voltage220V {
    public Integer output220V() {
        int src = 220;
        System.out.println("电压=" + src + "伏");
        return src;
    }
}
// 适配接口
public interface IVoltage5V {
    Integer output5V();
}
// 适配器
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    @Override
    public Integer output5V() {
        int src = output220V();
        int dst = src / 44;
        System.out.println("电压=" + dst + "伏");
        return dst;
    }
}
// 使用适配器方法
public class Phone {
    public void charing(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压=5伏，正在充电~");
        } else {
            System.out.println("电压!=5伏，无法充电~");
        }
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.charing(new VoltageAdapter());
    }
}

注意事项和细节

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

2、对象适配器模式

• 1）基本思路和类的适配器模式相同，只是将 Adapter 类作修改，不是继承 src 类，而是持有 src 类的实例，以解决兼容性的问题。即：持有 src 类，实现 dst 类接口，完成 src->dst 的适配
• 2）根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系
• 3）对象适配器模式是适配器模式常用的一种

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

UML 类图

核心代码

只需修改 Adapter 类即可

public class VoltageAdapter implements IVoltage5V {
    private Voltage220V voltage220V;
    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }
    @Override
    public Integer output5V() {
        if (voltage220V == null) {
            return 0;
        }
        int src = voltage220V.output220V();
        int dst = src / 44;
        System.out.println("电压=" + dst + "伏");
        return dst;
    }
}
public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.charing(new VoltageAdapter(new Voltage220V()));
    }
}

注意事项和细节

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

3、接口适配器模式

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

实例

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

ValueAnimator valueAnimator = ValueAnimator.ofInt(0, 100);
valueAnimator.addListener(new Animator.AnimatorListener() {
    @Override
    public void onAnimatorStart(Animator animation) {
    }
    @Override
    public void onAnimatorEnd(Animator animation) {
    }
    @Override
    public void onAnimatorCancel(Animator animation) {
    }
    @Override
    public void onAnimatorRepeat(Animator animation) {
    }
});
valueAnimator.start();

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

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

3）AnimatorListenerAdapter 类就是一个接口适配器，它空实现了 Animator.AnimatorListener 类（src）的所有方法

public abstract class AnimatorListenerAdapter implements Animator.AnimatorListener, 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) {
    }
}

4）AnimatorListener 是一个接口

public static interface AnimatorListener {
    void onAnimationStart(Animator animation);
    void onAnimationEnd(Animator animation);
    void onAnimationCancel(Animator animation);
    void onAnimationRepeat(Animator animation);
}

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

new AnimatorListenerAdapter() {
    @Override
    public void onAnimationStart(Animator animation){
        // xxxx具体实现
    }
}

现在我们按照上述步骤，自己去实现一下

UML 类图

核心代码

public interface Interface4 {
    void operation1();
    void operation2();
    void operation3();
    void operation4();
}
public abstract class AbsAdapter implements Interface4 {
    @Override
    public void operation1() {
    }
    @Override
    public void operation2() {
    }
    @Override
    public void operation3() {
    }
    @Override
    public void operation4() {
    }
}
public class Client {
    public static void main(String[] args) {
        AbsAdapter absAdapter = new AbsAdapter() {
            @Override
            public void operation1() {
                System.out.println("调用operation1方法");
            }
        };
        absAdapter.operation1();
    }
}

4、SpringMVC 框架源码分析

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

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

3）使用 HandlerAdapter 的原因分析

在 DispatcherServlet 中，有一个 doDispatch 方法，其中便使用到了 HandlerAdapter 适配器

通过 request 可以获得一个 Handler，再根据这个 Handler 获得不同的 HandlerAdapter 进行处理

HandlerAdapter 本质上是一个适配器接口，具体的适配器实现类有多种，其中有我们较为熟悉的 HttpRequestHandlerAdapter 和 RequestMappingHandlerAdapter

HandlerAdapter 的实现子类是的每一种 Controller 有一种对应的适配器实现类，每种 Controller 有不同的实现方式

言归正传，拿到 HandlerAdapter 适配器之后，便会调用其中的 handle 方法， 此方法便是具体的适配器实现类需要实现的方法

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

4）为了更深刻地理解其中运用的模式思想，我们自己动手写 SpringMVC，通过适配器设计模式获取到对应的 Controller 的源码

5、自己动手写 SpringMVC

UML 类图

核心代码

public interface Controller {
}
public class AnnotationController implements Controller {
    public void doAnnotationHandler() {
        System.out.println("annotation...");
    }
}
public class HttpController implements Controller {
    public void doHttpHandler() {
        System.out.println("http...");
    }
}
public class SimpleController implements Controller {
    public void doSimplerHandler() {
        System.out.println("simple...");
    }
}
//定义一个Adapter接口
public interface HandlerAdapter {
    boolean supports(Object handler);
    void handle(Object handler);
}
public class AnnotationHandlerAdapter implements HandlerAdapter {
    @Override
    public void handle(Object handler) {
        ((AnnotationController) handler).doAnnotationHandler();
    }
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof AnnotationController);
    }
}
public class HttpHandlerAdapter implements HandlerAdapter {
    @Override
    public void handle(Object handler) {
        ((HttpController) handler).doHttpHandler();
    }
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof HttpController);
    }
}
public class SimpleHandlerAdapter implements HandlerAdapter {
    @Override
    public void handle(Object handler) {
        ((SimpleController) handler).doSimplerHandler();
    }
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof SimpleController);
    }
}
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();
        SimpleController controller = new SimpleController();
        //AnnotationController controller = new AnnotationController();
        // 得到对应适配器
        HandlerAdapter adapter = getHandler(controller);
        //通过适配器执行对应的controller对应方法
        adapter.handle(controller);
    }
    public HandlerAdapter getHandler(Controller controller) {
        //遍历：根据得到的controller（handler），返回对应适配器
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(controller)) {
                return adapter;
            }
        }
        return null;
    }
}

说明

• Spring 定义了一个适配接口，使得每一种 Controller 有一种对应的适配器实现类
• 适配器代替 Controller 执行相应的方法
• 扩展 Controller 时，只需要增加一个适配器类就完成了 SpringMVC 的扩展了
• 这就是设计模式的力量

注意事项和细节

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

笔记来源：尚硅谷Java设计模式（图解+框架源码剖析）

桥接模式

1、传统方式解决手机操作问题

现在对不同手机类型的不同品牌实现操作编程（比如：开机、关机、上网，打电话等），如图：

UML 类图

问题分析

1. 扩展性问题（类爆炸）：如果我们再增加手机的样式（旋转式），就需要增加各个品牌手机的类；同样如果我们增加一个手机品牌，也要在各个手机样式类下增加
2. 违反了单一职责原则：当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本
3. 解决方案——使用桥接模式

2、桥接模式基本介绍

1. 桥接模式（Bridge模式）：一种结构型设计模式：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变
2. Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责
3. 它的主要特点是把抽象（Abstraction）与行为实现（Implementation）分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展

原理类图

原理类图说明

• Client：桥接模式的调用者
• Abstraction：Abstraction 充当桥接类，维护了 Implementor，即 ConcreteImplementorA / ConcreteImplementorB
• RefinedAbstraction：Abstraction 抽象类的子类
• Implementor：行为实现类的接口
• ConcreteImplementorA / ConcreteImplementorB：行为的具体实现类
• 这里的抽象类和接口是聚合的关系，也是调用者和被调用者的关系

3、桥接模式解决手机操作问题

UML 类图

核心代码

// 行为接口——品牌接口
public interface Branch {
    void open();
    void call();
    void close();
}
// 行为实现类——华为品牌
public class Huawei implements Branch {
    @Override
    public void open() {
        System.out.println("华为手机开机");
    }
    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }
    @Override
    public void close() {
        System.out.println("华为手机关机");
    }
}
// 行为实现类——小米品牌
public class Xiaomi implements Branch {
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }
    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }
    @Override
    public void close() {
        System.out.println("小米手机关机");
    }
}
// 行为实现类——苹果品牌
public class iPhone implements Branch {
    @Override
    public void open() {
        System.out.println("苹果手机开机");
    }
    @Override
    public void call() {
        System.out.println("苹果手机打电话");
    }
    @Override
    public void close() {
        System.out.println("苹果手机关机");
    }
}
// 桥接类——手机抽象类
public abstract class Phone {
    private Branch branch;
    public Phone(Branch branch) {
        this.branch = branch;
    }
    public void open() {
        branch.open();
    }
    public void call() {
        branch.call();
    }
    public void close() {
        branch.close();
    }
}
// 桥接子类——翻盖式手机
public class FlipPhone extends Phone {
    public FlipPhone(Branch branch) {
        super(branch);
        System.out.println("翻盖式手机");
    }
    @Override
    public void open() {
        super.open();
    }
    @Override
    public void call() {
        super.call();
    }
    @Override
    public void close() {
        super.close();
    }
}
// 桥接子类——滑盖式手机
public class SlidePhone extends Phone {
    public SlidePhone(Branch branch) {
        super(branch);
        System.out.println("滑盖式手机");
    }
    @Override
    public void open() {
        super.open();
    }
    @Override
    public void call() {
        super.call();
    }
    @Override
    public void close() {
        super.close();
    }
}
// 桥接子类——直立式手机
public class UprightPhone extends Phone {
    public UprightPhone(Branch branch) {
        super(branch);
        System.out.println("直立式手机");
    }
    @Override
    public void open() {
        super.open();
    }
    @Override
    public void call() {
        super.call();
    }
    @Override
    public void close() {
        super.close();
    }
}
public class Client {
  public static void main(String[] args) {
    //获取折叠式手机(样式+品牌)
    FoldPhone foldPhone = new FoldPhone(new xiaomi());
    foldPhone.open();
    foldPhone.call();
    foldPhone.close();
    System.out.println("===========");
    foldPhone=new FoldPhone(new vivo());
    foldPhone.open();
    foldPhone.call();
    foldPhone.close();
    System.out.println("=======调用直立式手机====");
    UpRighrPhone phone = new UpRighrPhone(new vivo());
    phone.open();
    phone.call();
    phone.close();
    phone=new UpRighrPhone(new xiaomi());
    phone.open();
    phone.call();
    phone.close();
  }
}

4、JDK 源码分析

JDBC 的 Driver 接口：如果从桥接模式来看，Driver 就是一个接口，下面可以有 MySQL 的 Driver、Oracle 的 Driver，这些就可以当做实现接口类

Connection 继承体系

Driver源码

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

DriverManager 结构

说明

• MySQL 有自己的 Connectionlmpl 类，同样 Oracle 也有对应的实现类
• Driver 和 Connection 之间是通过 DriverManager 类进行桥连接的

5、注意事项和细节

1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来。这有助于系统进行分层设计，从而产生更好的结构化系统
2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成
3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本
4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程
5. 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围有一定的后限性，即需要有这样的应用场景

6、桥接模式其他应用场景

对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用

常见的应用场景

1. JDBC 驱动程序
2. 银行转账系统
   • 转账分类：网上转账、柜台转账、AMT 转账
   • 转账用户类型：普通用户、银卡用户、金卡用户
3. 消息管理
   • 消息类型：即时消息、延时消息
   • 消息分类：手机短信、邮件消息、QQ消息…

     装饰者模式

1、星巴克咖啡订单项目

星巴克咖啡订单项目（咖啡馆）：

• 1）咖啡种类/单品咖啡：Espresso（意大利浓咖）、ShortBlack、LongBlack（美式咖啡）、Decaf（无因咖啡）
• 2）调料：Mik、Soy（豆浆）、Chocolate
• 3）要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
• 4）使用 OO 的来计算不同种类咖啡的费用：客户可以点单品咖啡，也可以单品咖啡+调料组合

2、方案 1-解决星巴克咖啡订单项目（较差的方案）

方案 1-解决星巴克咖啡订单问题分析

• 1）Drink 是一个抽象类，表示饮料
• 2）description 就是对咖啡的描述，比如咖啡的名字
• 3）cost 方法就是计算费用，Drink 类中做成一个抽象方法
• 4）Decaf 就是单品咖啡，继承 Drink，并实现 cost
• 5）Espresso && Milk 就是单品咖啡+调料，这个组合很多
• 6）问题：这样设计，会有很多类。当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，出现类爆炸

3、方案 2-解决星巴克咖啡订单项目（好点的方案）

前面分析到方案 1 因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到 Drink 类，这样就不会造成类数量过多。从而提高项目的维护性（如图）

说明：Milk、Soy、Chocolate 可以设计为 Boolean，表示是否要添加相应的调料

方案 2-解决星巴克咖啡订单问题分析

• 1）方案 2 可以控制类的数量，不至于造成很多的类
• 2）在增加或者删除调料种类时，代码的维护量很大
• 3）考虑到用户可以添加多份调料时，可以将 hasMilk 返回一个对应 int
• 4）考虑使用装饰者模式

4、装饰者模式

定义

1）装饰者模式：动态地将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式体现了开闭原则（OCP）

2）这里提到的动态的将新功能附加到对象和 OCP 原则，在后面的应用实例上会以代码的形式体现，请同学们注意体会

原理

• 1）装饰者模式就像打包一个快递
  • 主体：比如陶瓷、衣服（Component）
  • 包装：比如报纸填充、塑料泡沫、纸板、木板（Decorator）
• 2）主体（Component）：比如前面的 Drink
• 3）具体的主体（ConcreteComponent）：比如前面的各个单品咖啡
• 4）装饰者（Decorator）：比如各调料
• 4）Component 与 ConcreteComponent 之间，如果 ConcreteComponent 类很多，还可以设计一个缓冲层，将共有的部分提取出来，抽象成一个类

5、装饰者模式解决星巴克咖啡订单项目

说明

• 1）Drink 就是抽象类 Component
• 2）ShortBlack 单品咖啡就是具体的主体
• 3）Decorator 是一个装饰类，含有一个被装饰的对象（Drink）
• 4）Decorator 的 cost 方法进行一个费用的叠加，递归地计算价格

装饰者模式下的订单：2份巧克力 + 一份牛奶的 LongBlack

说明

• 1）Milk 包含了 LongBlack
• 2）一份 Chocolate 包含了 Milk + LongBlack
• 3）一份 Chocolate 包含了 Chocolate + Milk + LongBlack
• 4）这样不管是什么形式的单品咖啡 + 调料组合，通过递归方式可以方便的组合和维护

UML类图

核心代码

// 抽象主体
public abstract class Drink {
    private String desc;
    private Float price;
    public String getDesc() {
        return desc;
    }
    protected void setDesc(String desc) {
        this.desc = desc;
    }
    public Float getPrice() {
        return price;
    }
    protected void setPrice(Float price) {
        this.price = price;
    }
    public abstract Float cost();
}
// 具体主体
public class Coffee extends Drink {
    @Override
    public Float cost() {
        return super.getPrice();
    }
}
public class Decaf extends Coffee {
    public Decaf() {
        setDesc("无因咖啡");
        setPrice(20.0f);
    }
}
public class Espresso extends Coffee {
    public Espresso() {
        setDesc("意大利浓咖");
        setPrice(30.0f);
    }
}
public class ShortBlack extends Coffee {
    public ShortBlack() {
        setDesc("短黑咖啡");
        setPrice(40.0f);
    }
}
public class LongBlack extends Coffee {
    public LongBlack() {
        setDesc("美式咖啡");
        setPrice(50.0f);
    }
}
//装饰者
public class Decorator extends Drink {
    private Drink drink;
    public Decorator(Drink drink) {
        this.drink = drink;
    }
    @Override
    public Float cost() {
        return super.getPrice() + drink.cost();
    }
}
public class Milk extends Decorator {
    public Milk(Drink drink) {
        super(drink);
        setDesc("牛奶");
        setPrice(3.0f);
    }
}
public class Soy extends Decorator {
    public Soy(Drink drink) {
        super(drink);
        setDesc("豆浆");
        setPrice(4.0f);
    }
}
public class Chocolate extends Decorator {
    public Chocolate(Drink drink) {
        super(drink);
        setDesc("巧克力");
        setPrice(5.0f);
    }
}
// 调用者
public class CoffeeBar {
    public static void main(String[] args) {
        Drink drink = new Espresso();
        System.out.println("意大利浓咖：" + drink.cost() + "美元"); // 意大利浓咖：30.0美元
        drink = new Milk(drink);
        System.out.println("意大利浓咖 + 1份牛奶：" + drink.cost() + "美元"); // 意大利浓咖 + 1份牛奶：33.0美元
        drink = new Chocolate(drink);
        System.out.println("意大利浓咖 + 1份牛奶 + 1份巧克力：" + drink.cost() + "美元"); // 意大利浓咖...：38.0美元
        drink = new Chocolate(drink);
        System.out.println("意大利浓咖 + 1份牛奶 + 2份巧克力：" + drink.cost() + "美元"); // 意大利浓咖...：43.0美元
    }
}

6、JDK 源码分析

Java 的 IO 结构，FilterlnputStream 就是一个装饰者

核心代码

// 是一个抽象类，即Component
public abstract class InputStream implements Closeable {} 
// 是一个装饰类，即Decorator
public class FilterInputStream extends InputStream { 
    protected volatile InputStream in;
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
}
// FilterInputStream子类，也继承了被装饰的对象 in
public class DataInputStream extends FilterInputStream implements DataInput { 
    public DataInputStream(InputStream in) {
        super(in);
    }

分析

• 1）InputStream 是抽象类，类似我们前面讲的 Drink
• 2）FileInputStream 是 InputStream 子类，类似我们前面的 DeCaf、LongBlack
• 3）FilterInputStream 是 InputStream 子类，类似我们前面的 Decorator，修饰者
• 4）DataInputStream 是 FilterInputStream 子类，类似前面的Milk，Soy等，具体的修饰者
• 5）FilterInputStream 类有protected volatile InputStream in;，即含被装饰者
• 6）分析得出在 JDK 的 IO 体系，就是使用装饰者模式

笔记来源：尚硅谷Java设计模式（图解+框架源码剖析）

组合模式

1、学校院系展示需求

编写程序展示一个学校院系结构：

需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图：

传统方式解决学校院系展示（类图）

问题分析

• 1）将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的
• 2）实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。因此这种方案，不能很好实现的 管理 的操作，比如对学院、系的添加、删除、遍历等
• 3）解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作 ==> 组合模式

2、组合模式基本介绍

• 1）组合模式（Composite Pattern），又叫部分整体模式。它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系
• 2）组合模式依据树形结构来组合对象，用来表示部分以及整体层次
• 3）这种类型的设计模式属于结构型模式
• 4）组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

原理类图

对原理结构图的说明一即组合模式的角色及职责

• 1）Component：这是组合中对象声明接口。在适当情况下，实现所有类共有的接口默认行为，用于访问和管理 Component子部件。Component可以是抽象类或者接口
• 2）Leaf：在组合中表示叶子结点，叶子结点没有子节点
• 3）Composite：非叶子结点，用于存储子部件，在Component接口中实现子部件的相关操作。比如增加、删除

解决的问题

组合模式解决这样的问题，当我们的要处理的对象可以生成一棵树形结构，而我们要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子

3、组合模式解决学校院系展示

UML 类图

核心代码

// Component 抽象类
public abstract class OrganizationComponent {
    private String name;
    public OrganizationComponent(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void add(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }
    public void remove(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }
    public abstract void print();
}
// Composite 非叶子节点
public class University extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    public University(String name) {
        super(name);
    }
    @Override
    public void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    @Override
    public void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    public void print() {
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
}
public class College extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    public College(String name) {
        super(name);
    }
    @Override
    public void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    @Override
    public void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    public void print() {
        System.out.println("=============" + getName() + "=============");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
}
// Leaf 叶子结点
public class Major extends OrganizationComponent {
    public Major(String name) {
        super(name);
    }
    @Override
    public void print() {
        System.out.println(getName());
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        //大学
        OrganizationComponent university = new University("清华大学");
        //学院
        OrganizationComponent computerCollege = new College("计算机学院");
        OrganizationComponent infoEngineerCollege = new College("信息工程学院");
        //专业
        computerCollege.add(new Major("软件工程"));
        computerCollege.add(new Major("网络工程"));
        computerCollege.add(new Major("计算机科学与技术"));
        infoEngineerCollege.add(new Major("通信工程"));
        infoEngineerCollege.add(new Major("信息工程"));
        university.add(computerCollege);
        university.add(infoEngineerCollege);
        university.print();
        //=============计算机学院=============
        //软件工程
        //网络工程
        //计算机科学与技术
        //=============信息工程学院=============
        //通信工程
        //信息工程
    }
}

4、JDK 源码分析

Java 的集合类—— HashMap 就使用了组合模式

UML 类图

核心代码

// Component
public interface Map<K,V> {
    interface Entry<K,V> {}
}
public abstract class AbstractMap<K,V> implements Map<K,V> {}
// Composite
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // Leaf
    static class Node<K,V> implements Map.Entry<K,V> {}
}

说明

• 1）Map 就是一个抽象的构建，类似Component
• 2）HashMap 是一个中间的构建，类似Composite，实现 / 继承了相关方法 put、putAll
• 3）Node 是 HashMap 的静态内部类，类似Leaf叶子节点，这里就没有 put

5、注意事项和细节

• 1）简化客户端操作：客户端只需要面对一致的对象，而不用考虑整体部分或者节点叶子的问题
• 2）具有较强扩展性：当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动
• 3）方便创建复杂的层次结构：客户端不用理会组合里面的组成细节，容易添加节点或者叶子，从而创建出复杂的树形结构
• 4）需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式
• 5）要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式

外观模式

1、影院管理项目

组建一个家庭影院：

DVD 播放器、投影仪、自动屏幕、环绕立体声、爆米花机，要求完成使用家庭影院的功能，其过程为：

• 直接用遥控器：统筹各设备开关
• 开爆米花机
• 放下屏幕
• 开投影仪
• 开音响
• 开DVD，选dvd
• 去拿爆米花
• 调暗灯光
• 播放
• 观影结束后，关闭各种设备

传统方式解决影院管理

ClientTest{
    public static void main(String[] args){
        // 1、创建相关的对象
        // 2、调用创建的各个对象的一系列方法
        // 3、调用DVDPlayer对象的play方法
    }
}

传统方式解决影院管理问题分析

• 1）在 ClientTest 的 main 方法中，创建各个子系统的对象，并直接去调用子系统（对象）相关方法，会造成调用过程混乱，没有清晰的过程
• 2）不利于在 ClientTest 中去维护对子系统的操作
• 3）解决思路：定义一个高层接口，给子系统中的一组接口提供一个一致的界面（比如在高层接口提供四个方法ready，play，pause，end），用来访问子系统中的一群接口
• 4）也就是说就是通过定义一个一致的接口（界面类），用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节 ==》外观模式

2、外观模式基本介绍

外观模式（Facade），也叫过程模式

外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节，这个接口使得这一子系统更加容易使用

原理类图

原理类图的说明（外观模式的角色）

• 1）外观类（Facade）：为调用端提供统一的调用接口，外观类知道哪些子系统负责处理请求，从而将调用端的请求代理给适当子系统对象
• 2）调用者（Client）：外观接口的调用者
• 3）子系统的集合：指模块或者子系统，处理 Facade 对象指派的任务，是功能的实际提供者

3、外观模式解决影院管理

• 1）外观模式可以理解为转换一群接口，客户只要调用一个接口，而不用调用多个接口才能达到目的，比如：
  • 在 PC 上安装软件的时候经常有一键安装选项（省去选择安装目录、安装的组件等等）
  • 手机的重启功能（把关机和启动合为一个操作）
• 2）外观模式就是解决多个复杂接口带来的使用困难，起到简化用户操作的作用

使用外观模式来完成家庭影院项目

UML 类图

核心代码

【投影仪】

public class Projector {
    private static Projector projector = new Projector();
    public static Projector getInstance() {
        return projector;
    }
    public void on() {
        System.out.println("打开投影仪...");
    }
    public void off() {
        System.out.println("关闭投影仪...");
    }
    public void focus() {
        System.out.println("投影仪聚焦...");
    }
    public void zoom() {
        System.out.println("投影仪放大...");
    }
}

【DVD 播放器】

public class DVDPlayer {
    private static DVDPlayer player = new DVDPlayer();
    public static DVDPlayer getInstance() {
        return player;
    }
    public void on() {
        System.out.println("打开DVD播放器...");
    }
    public void off() {
        System.out.println("关闭DVD播放器...");
    }
    public void play() {
        System.out.println("播放DVD播放器...");
    }
    public void pause() {
        System.out.println("暂停DVD播放器...");
    }
    public void setDvd(String dvd) {
        System.out.println("选dvd：" + dvd + "...");
    }
}

【荧幕】

public class Screen {
    private static Screen screen = new Screen();
    public static Screen getInstance() {
        return screen;
    }
    public void up() {
        System.out.println("升起荧幕...");
    }
    public void down() {
        System.out.println("拉下荧幕...");
    }
}

【立体声】

public class Stereo {
    private static Stereo stereo = new Stereo();
    public static Stereo getInstance() {
        return stereo;
    }
    public void on() {
        System.out.println("打开立体声...");
    }
    public void off() {
        System.out.println("关闭立体声...");
    }
    public void setVolume(Integer volume) {
        System.out.println("立体声音量+" + volume + "...");
    }
}

【灯光】

public class TheaterLights {
    private static TheaterLights lights = new TheaterLights();
    public static TheaterLights getInstance() {
        return lights;
    }
    public void on() {
        System.out.println("打开灯光...");
    }
    public void off() {
        System.out.println("关闭灯光...");
    }
    public void dim() {
        System.out.println("调暗灯光...");
    }
    public void bright() {
        System.out.println("调亮灯光...");
    }
}

【爆米花机器】

public class Popcorn {
    private static Popcorn popcorn = new Popcorn();
    public static Popcorn getInstance() {
        return popcorn;
    }
    public void on() {
        System.out.println("打开爆米花机器...");
    }
    public void off() {
        System.out.println("关闭爆米花机器...");
    }
    public void pop() {
        System.out.println("取出爆米花...");
    }
}

【家庭影院 Facade】

public class HomeTheaterFacade {
    private Popcorn popcorn;
    private Screen screen;
    private Stereo stereo;
    private TheaterLights lights;
    private Projector projector;
    private DVDPlayer player;
    public HomeTheaterFacade() {
        this.popcorn = Popcorn.getInstance();
        this.screen = Screen.getInstance();
        this.stereo = Stereo.getInstance();
        this.lights = TheaterLights.getInstance();
        this.projector = Projector.getInstance();
        this.player = DVDPlayer.getInstance();
    }
    public void ready() {
        lights.on(); // 打开灯光
        popcorn.on(); // 开爆米花机
        screen.down(); // 放下屏幕
        projector.on(); // 开投影仪
        projector.focus();
        projector.zoom();
        stereo.on(); // 开音响，设置音量
        stereo.setVolume(8);
        player.on(); // 开DVD，选dvd
        player.setDvd("坦塔尼克号");
        popcorn.pop(); // 去拿爆米花，关闭机器
        popcorn.off();
        lights.dim(); // 调暗灯光
    }
    public void play() {
        player.play();
    }
    public void pause() {
        player.pause();
    }
    public void end() {
        player.off();
        projector.off();
        stereo.off();
        lights.bright();
        screen.up();
    }
}

【客户端】

public class Client {
    public static void main(String[] args) throws InterruptedException {
        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
        System.out.println("===========家庭影院初始化============");
        homeTheaterFacade.ready();
        System.out.println("===========家庭影院沉浸式播放============");
        homeTheaterFacade.play();
        Thread.sleep(1000);
        System.out.println("===========家庭影院暂停============");
        homeTheaterFacade.pause();
        Thread.sleep(1000);
        System.out.println("===========家庭影院沉浸式播放============");
        homeTheaterFacade.play();
        Thread.sleep(1000);
        System.out.println("===========家庭影院结束============");
        homeTheaterFacade.end();
    }
}

4、MyBatis 框架源码分析

MyBatis 中 Configuration 去创建 MetaObject 对象时使用到了外观模式

代码分析

private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
    this.originalObject = object;
    this.objectFactory = objectFactory;
    this.objectWrapperFactory = objectWrapperFactory;
    this.reflectorFactory = reflectorFactory;
    if (object instanceof ObjectWrapper) {
      this.objectWrapper = (ObjectWrapper)object;
    } else if (objectWrapperFactory.hasWrapperFor(object)) {
      this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    } else if (object instanceof Map) {
      this.objectWrapper = new MapWrapper(this, (Map)object);
    } else if (object instanceof Collection) {
      this.objectWrapper = new CollectionWrapper(this, (Collection)object);
    } else {
      this.objectWrapper = new BeanWrapper(this, object);
    }
  }

示意图

5、外观模式的注意事项和细节

• 1）外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
• 2）外观模式对客户端与子系统的耦合关系，让子系统内部的模块更易维护和扩展
• 3）通过合理的使用外观模式，可以帮我们更好的划分访问的层次
• 4）当系统需要进行分层设计时，可以考虑使用 Facade 模式
• 5）在维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个 Facade 类，来提供遗留系统的比较清晰简单的接口，让新系统与 Facade 类交互，提高复用性
• 6）不能过多的或者不合理的使用外观模式，使用外观模式好，还是直接调用模块好。要以让系统有层次，利于维护为目的

享元模式

1、展示网站项目需求

小型的外包项目，给客户 A 做一个产品展示网站，客户 A 的朋友感觉效果不错，也希望做这样的产品展示网站，但是要求都有些不同：

• 1）有客户要求以新闻的形式发布
• 2）有客户人要求以博客的形式发布
• 3）有客户希望以微信公众号的形式发布

传统方案解决网站展现项目

• 1）直接复制粘贴一份，然后根据客户不同要求，进行定制修改
• 2）给每个网站租用一个空间
• 3）方案设计示意图

传统方案解决网站展现项目-问题分析

• 1）需要的网站结构相似度很高，而且都不是高问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，造成服务器的资源浪费
• 2）解决思路：整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源
• 3）对于代码来说，由于是一份实例，维护和扩展都更加容易
• 4）上面的解决思路就可以使用享元模式来解决

2、享元模式基本介绍

• 1）享元模式（Flyweight Pattern）也叫蝇量模式：运用共享技术有效地支持大量细粒度的对象
• 2）常用于系统底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则创建一个
• 3）享元模式能够解决重复对象的内存浪费的问题。当系统中有大量相似对象，需要缓冲池时，不需总是创建新对象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率
• 4）享元模式经典的应用场景就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，享元模式是池技术的重要实现方式

3、享元模式的原理类图

对原理图的说明——即模式的角色和职责

• 1）Flyweight：抽象的享元角色，是抽象的产品类，同时定义出对象的外部状态和内部状态的接口和实现
• 2）ConcreteFlyweight：具体的享元角色，是具体的产品类，实现抽象角色定义的相关业务
• 3）UnsharedConcreteFlyweight：不可共享的角色，一般不会出现在享元工厂中
• 4）FlyweightFactory：享元工厂类，用于构建一个池容器（集合），同时提供从池中获取对象的方法

4、内部状态和外部状态

比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一点。所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同。当我们落子后，落子颜色是定的，但位置是变化的，所以棋子坐标就是棋子的外部状态

• 1）享元模式提出了两个要求：细粒度和共享对象。即将对象的信息分为两个部分：内部状态和外部状态
• 2）内部状态：指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
• 3）外部状态：指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态

举个例子：围模理论上有 361 个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生。因为内存空间有限，一台服务器很难支持更多的玩家玩围模游戏。如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题

5、享元模式解决网站展现项目

原理类图

UML 类图

核心代码

/**
 * 内部状态，共享角色
 */
public enum Type {
    新闻,
    博客,
    微信公众号
}
/**
 * 外部状态，非共享角色
 */
public class User {
    private String name;
    public User(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
/**
 * 抽象的享元角色
 */
public abstract class Website {
    public abstract void use(User user);
}
/**
 * 具体的享元角色
 */
public class ConcreteWebsite extends Website {
    private Type type;
    public ConcreteWebsite(Type type) {
        this.type = type;
    }
    @Override
    public void use(User user) {
        System.out.println("网站正在使用中：类型为" + type.name() + "，使用者为" + user.getName());
    }
}
/**
 * 享元工厂类
 */
public class WebsiteFactory {
    private static Map<Type, Website> pool = new HashMap<>();
    public static Website getWebsiteCategory(Type type) {
        if (pool.get(type) == null) {
            pool.put(type, new ConcreteWebsite(type));
        }
        return pool.get(type);
    }
    public static Integer getSize() {
        return pool.size();
    }
}