23种设计模式

计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

一、创建型模式

1、单例模式

1.1、介绍

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

1.2、单例模式的类型

单例模式有两种类型：

懒汉式：在真正需要使用对象时才去创建该单例类对象

饿汉式：在类加载时已经创建好该单例对象，等待被程序使用

1.3、饿汉式创建单例对象

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

public class Singleton{
    
    private static final Singleton singleton = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

1.4、懒汉式创建单例对象

我们再来回顾懒汉式的核心方法

public static Singleton getInstance() {
    if (singleton == null) {
        singleton = new Singleton();
    }
    return singleton;
}

这个方法其实是存在问题的，试想一下，如果两个线程同时判断singleton为空，那么它们都会去实例化一个Singleton对象，这就变成双例了。所以，我们要解决的是线程安全问题。

最容易想到的解决方法就是在方法上加锁，或者是对类对象加锁，程序就会变成下面这个样子

public static synchronized Singleton getInstance() {
    if (singleton == null) {
        singleton = new Singleton();
    }
    return singleton;
}
// 或者
public static Singleton getInstance() {
    synchronized(Singleton.class) {   
        if (singleton == null) {
            singleton = new Singleton();
        }
    }
    return singleton;
}

这样就规避了两个线程同时创建Singleton对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。

接下来要做的就是优化性能，目标是：如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例。所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁

public static Singleton getInstance() {
    if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
            if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                singleton = new Singleton();
            }
        }
    }
    return singleton;
}

上面的代码已经完美地解决了并发安全+性能低效问题：

（1）第2行代码，如果singleton不为空，则直接返回对象，不需要获取锁；而如果多个线程发现singleton为空，则进入分支；

（2）第3行代码，多个线程尝试争抢同一个锁，只有一个线程争抢成功，第一个获取到锁的线程会再次判断singleton是否为空，因为singleton有可能已经被之前的线程实例化;

（3）其它之后获取到锁的线程在执行到第4行校验代码，发现singleton已经不为空了，则不会再new一个对象，直接返回对象即可;

（4）之后所有进入该方法的线程都不会去获取锁，在第一次判断singleton对象时已经不为空了;

因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁）

完整的代码如下所示：

public class Singleton {
    
    private static Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

上面这段代码已经近似完美了，但是还存在最后一个问题：指令重排

1.5、使用volatile防止指令重排

创建一个对象，在JVM中会经过三步：

（1）为singleton分配内存空间

（2）初始化singleton对象

（3）将singleton指向分配好的内存空间

指令重排序是指：JVM在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能

在这三步中，第2、3步有可能会发生指令重排现象，创建对象的顺序变为1-3-2，会导致多个线程获取对象时，有可能线程A创建对象的过程中，执行了1、3步骤，线程B判断singleton已经不为空，获取到未初始化的singleton对象，就会报NPE异常。文字较为晦涩，可以看流程图：

使用volatile关键字可以防止指令重排序，其原理较为复杂，这篇博客不打算展开，可以这样理解：使用volatile关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换，这样在多线程环境下就不会发生NPE异常了。

volatile还有第二个作用：使用volatile关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

最终的代码如下所示：

public class Singleton {
    
    private static volatile Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

2、工厂模式

2.1、介绍

工厂模式是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂、具体工厂、抽象产品、具体产品。

四个角色：

（1）抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。

（2）具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

（3）抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

（4）具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

2.2、关系依赖图

2.3、代码实现

产品接口类

Shape

public interface Shape {
    void draw();
}

产品实现类

Rectangle

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle：绘制长方形");
    }
}

Square

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square：绘制正方形");
    }
}

Circle

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle：绘制圆形");
    }
}

工厂类

ShapeFactory

public class ShapeFactory {
    public static Shape createShape(String shapeType) {
        if ("Rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        }
        if ("Square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }
        if ("Circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        }
        return null;
    }
}

工厂类测试

ShapeFactoryTest

public class ShapeFactoryTest {
    public static void main(String[] args) {
        Shape rectangle = ShapeFactory.createShape("Rectangle");
        rectangle.draw();

        Shape square = ShapeFactory.createShape("Square");
        square.draw();

        Shape crcle = ShapeFactory.createShape("Circle");
        crcle.draw();
    }
}

结果：

Rectangle：绘制长方形

Square：绘制正方形

Circle：绘制圆形

2.4、应用

最佳实践：java.util.Calendar

Calendar 类的相关代码如下所示，大部分代码都已经省略，我只给出了 getInstance() 工厂方法的代码实现。从代码中，我们可以看出，getInstance() 方法可以根据不同 TimeZone 和 Locale，创建不同的 Calendar 子类对象，比如 BuddhistCalendar、JapaneseImperialCalendar、GregorianCalendar，这些细节完全封装在工厂方法中，使用者只需要传递当前的时区和地址，就能够获得一个 Calendar 类对象来使用，而获得的对象具体是哪个 Calendar 子类的对象，使用者在使用的时候并不关心。

public abstract class Calendar implements Serializable, Cloneable, Comparable {
  //...
  public static Calendar getInstance(TimeZone zone, Locale aLocale){
    return createCalendar(zone, aLocale);
  }

  private static Calendar createCalendar(TimeZone zone,Locale aLocale) {
    CalendarProvider provider = LocaleProviderAdapter.getAdapter(
        CalendarProvider.class, aLocale).getCalendarProvider();
    if (provider != null) {
      try {
        return provider.getInstance(zone, aLocale);
      } catch (IllegalArgumentException iae) {
        // fall back to the default instantiation
      }
    }

    Calendar cal = null;
    if (aLocale.hasExtensions()) {
      String caltype = aLocale.getUnicodeLocaleType("ca");
      if (caltype != null) {
        switch (caltype) {
          case "buddhist":
            cal = new BuddhistCalendar(zone, aLocale);
            break;
          case "japanese":
            cal = new JapaneseImperialCalendar(zone, aLocale);
            break;
          case "gregory":
            cal = new GregorianCalendar(zone, aLocale);
            break;
        }
      }
    }
    if (cal == null) {
      if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
        cal = new BuddhistCalendar(zone, aLocale);
      } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja" && aLocale.getCountry() == "JP") {
        cal = new JapaneseImperialCalendar(zone, aLocale);
      } else {
        cal = new GregorianCalendar(zone, aLocale);
      }
    }
    return cal;
  }
  
}

3、抽象工厂模式

3.1、介绍

抽象工厂模式（Abstract Factory）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。

3.2、关系依赖图

3.3、代码实现

图形产品接口类

Shape

public interface Shape {
    void draw();
}

图形产品实现类

Rectangle

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle：绘制长方形");
    }
}

Square

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square：绘制正方形");
    }
}

Circle

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle：绘制圆形");
    }
}

图形工厂类编写

ShapeFactory

public class ShapeFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        if ("Rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        }
        if ("Square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }
        if ("Circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        }
        return null;
    }

    @Override
    public Color createColor(String color) {
        return null;
    }
}

颜色产品接口类

Color

public interface Color {
    void fill();
}

颜色产品实现类

Red

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Red：填充红色");
    }
}

Green

public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Green：填充绿色");
    }
}

Blue

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Blue：填充蓝色");
    }
}

颜色工厂类编写

ColorFactory

public class ColorFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        if ("Red".equalsIgnoreCase(colorType)) {
            return new Red();
        }
        if ("Green".equalsIgnoreCase(colorType)) {
            return new Green();
        }
        if ("Blue".equalsIgnoreCase(colorType)) {
            return new Blue();
        }
        return null;
    }
}

产品家族抽象类

AbstractFactory

public abstract class AbstractFactory {
    public abstract Shape createShape(String shapeType);
    public abstract Color createColor(String colorType);
}

抽象类的工厂类

AbstractFactoryProducer

public class AbstractFactoryProducer {
    public static AbstractFactory createFactory(String choice) {
        if ("Shape".equalsIgnoreCase(choice)) {
            return new ShapeFactory();
        }
        if ("Color".equalsIgnoreCase(choice)) {
            return new ColorFactory();
        }
        return null;
    }
}

抽象工厂类测试

AbstractFactoryProducerTest

public class AbstractFactoryProducerTest {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = AbstractFactoryProducer.createFactory("Shape");
        Shape rectangle = shapeFactory.createShape("Rectangle");
        rectangle.draw();
        Shape square = shapeFactory.createShape("Square");
        square.draw();
        Shape circle = shapeFactory.createShape("Circle");
        circle.draw();

        AbstractFactory colorFactory = AbstractFactoryProducer.createFactory("Color");
        Color red = colorFactory.createColor("Red");
        red.fill();
        Color green = colorFactory.createColor("Green");
        green.fill();
        Color blue = colorFactory.createColor("Blue");
        blue.fill();
    }
}

结果：

Rectangle：绘制长方形

Square：绘制正方形

Circle：绘制圆形

Red：填充红色

Green：填充绿色

Blue：填充蓝色

3.4、应用

最佳实践：java.sql.Connection

Connection接口源码如下所示，其定义了Statement、PreparedStatement、CallableStatement三个产品等级结构。

public interface Connection extends Wrapper, AutoCloseable {
    Statement createStatement() throws SQLException;
    PreparedStatement prepareStatement(String sql) throws SQLException;
    CallableStatement prepareCall(String sql) throws SQLException;
}

4、原型模式

4.1、介绍

原型模式属于创建型设计模式。通过复制现有的实例来创建新的实例，无需知道相应类的信息。简单的讲就是当我需要创建一个指定的对象时，刚好现在就有这个对象，但又不能直接使用，所以简单的方式就是克隆一个一摸一样的对象来使用。

4.2、代码实现

（1）原型模式实现（浅克隆）

IdCard

//身份证对象
class IdCard {
    private String id;

    public IdCard(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return id;
    }
}

Person

//代表人对象
public class Person implements Cloneable {
    private String name;
    private int age;
    private IdCard idCard;

    public Person(String name, int age, IdCard idCard) {
        this.name = name;
        this.age = age;
        this.idCard = idCard;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "personHashCode=" + this.hashCode() +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", idCard=" + idCard +
                ", idCardHashCode=" + idCard.hashCode() +
                '}';
    }

    //浅克隆已经帮我们实现了
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

PersonTest

public class PersonTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建一个对象
        Person person = new Person("张三", 20, new IdCard("10086"));

        //克隆两个对象
        Person person1 = (Person) person.clone();
        Person person2 = (Person) person.clone();

        //打印三人信息
        System.out.println(person);
        System.out.println(person1);
        System.out.println(person2);
    }
}

运行效果：

Person{personHashCode=460141958, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}

Person{personHashCode=1956725890, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}

Person{personHashCode=356573597, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}

解释说明：

我们发现可以通过实现implements Cloneable来完成浅拷贝，基本变量是值传递克隆，而引用对象IdCard则是引用传递，这不符合我们面向对象思想，每一个Person应该都有一个独立的IdCard，而不是共用一个，而要解决这种问题，我们需要使用深克隆。

（2）原型模式实现（深克隆：第一种）

IdCard

//身份证对象
class IdCard implements Cloneable {
    private String id;

    public IdCard(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return id;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Person

//代表人对象
public class Person implements Cloneable {
    private String name;
    private int age;
    private IdCard idCard;

    public Person(String name, int age, IdCard idCard) {
        this.name = name;
        this.age = age;
        this.idCard = idCard;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "personHashCode=" + this.hashCode() +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", idCard=" + idCard +
                ", idCardHashCode=" + idCard.hashCode() +
                '}';
    }

    //深克隆我们需要自己手动实现，在引用对象中也需要实现clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //完成对当前基本数据类型
        //注：String类型通过常量赋值时相当于基本数据类型，通过new关键字创建对象时便是引用数据类型
        Object person = super.clone();

        //对引用类型进行单独处理
        Person p = (Person) person;
        IdCard idCard = (IdCard) p.getIdCard().clone();//实现自己的克隆
        p.setIdCard(idCard);

        return p;
    }
}

PersonTest

public class PersonTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建一个对象
        Person person = new Person("张三", 20, new IdCard("10086"));

        //克隆两个对象
        Person person1 = (Person) person.clone();
        Person person2 = (Person) person.clone();

        //打印三人信息
        System.out.println(person);
        System.out.println(person1);
        System.out.println(person2);
    }
}

运行效果：

Person{personHashCode=460141958, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}

Person{personHashCode=1956725890, name='张三', age=20, idCard=10086, idCardHashCode=356573597}

Person{personHashCode=1735600054, name='张三', age=20, idCard=10086, idCardHashCode=21685669}

解释说明：

使用这种深克隆的方式，完美的解决了当数据类型为引用类型时，只是拷贝原引用对象地址而不是一个全新的引用对象的引用，但是这种实现有一个很大的弊端，需要在每一个对象中都实现clone方法，如果类全是你自己写的，那自然没问题，实现一下就行了，不过有点麻烦。但是，如果你引用的是第三方的一个类，无法修改源代码，这种方式，显然就无法实现深克隆了。

（3）原型模式实现（深克隆：第二种）

IdCard

//身份证对象
class IdCard implements Serializable {
    private String id;

    public IdCard(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return id;
    }
}

Person

//代表人对象
public class Person implements Serializable {
    private String name;
    private int age;
    private IdCard idCard;

    public Person(String name, int age, IdCard idCard) {
        this.name = name;
        this.age = age;
        this.idCard = idCard;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "personHashCode=" + this.hashCode() +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", idCard=" + idCard +
                ", idCardHashCode=" + idCard.hashCode() +
                '}';
    }

    //手动实现深克隆方法
    public Person deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            return (Person) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                ois.close();
                bis.close();
                oos.close();
                bos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

PersonTest

public class PersonTest {
    public static void main(String[] args) {
        //创建一个对象
        Person person = new Person("张三", 20, new IdCard("10086"));

        //克隆两个对象
        Person person1 = person.deepClone();
        Person person2 = person.deepClone();

        //打印三人信息
        System.out.println(person);
        System.out.println(person1);
        System.out.println(person2);
    }
}

运行效果：

Person{personHashCode=1300109446, name='张三', age=20, idCard=10086, idCardHashCode=1020371697}

Person{personHashCode=20132171, name='张三', age=20, idCard=10086, idCardHashCode=186370029}

Person{personHashCode=2094548358, name='张三', age=20, idCard=10086, idCardHashCode=51228289}

解释说明：

这种方式我们需要手动编写deepClone方法，使用Java流中的序列化与反序列化来实现深克隆，但是这种实现，需要在每一个类中都继承序列化Serializable接口，这种方式，如果你调用的是第三方类，也有可能第三方类上没有实现Serializable序列化接口，但是一般来说，大多都会实现，总的来说，这种比较推荐使用，而且效率也高，要是真的第三方类没有实现Serializable序列化接口，这里可以再提供一种思路，但是不具体实现了，可以借助第三方工具包fastjson先将对象转换为json字符串，然后再把json字符串转为对象，这样也是可以的。

4.3、应用

最佳实践：java.util.ArrayList

5、建造者模式

5.1、介绍

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

5.2、关系依赖图

我们都知道盖房子是一个模式化的过程：打地基 -》砌墙面 -》盖楼顶，只不过不同类型的房子，具体的要求也会不尽相同，比如地基大小、楼的高度等等，但是大致的过程都是相似的，HouseDirector是整个工程的指挥者，由他指挥VillaHouse（别墅建造者）、HighHouse（高楼建造者）来建筑不同类型的House产品。而使用端只需要和指挥者打交道就可以了，屏蔽了产品实现的细节，构建和表示分离，有利于系统的拓展和解耦。

5.3、代码实现

产品实现类

House

public class House {
    private String ground;
    private String wall;
    private String roofed;

    public String getGround() {
        return ground;
    }

    public void setGround(String ground) {
        this.ground = ground;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "ground='" + ground + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

抽象建造者

HouseBuilder

public abstract class HouseBuilder {
    //创建产品对象
    protected House house = new House();

    //生产产品流程
    public abstract void buildGround(); //1.打地基
    public abstract void buildWall();   //2.砌墙面
    public abstract void buildRoofed(); //3.盖楼顶

    //返回产品对象
    public House getResult() {
        return house;
    }
}

工程指挥者

HouseDirector

public class HouseDirector {
    private HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public House build(){
        houseBuilder.buildGround();
        houseBuilder.buildWall();
        houseBuilder.buildRoofed();
        return houseBuilder.getResult();
    }
}

具体建造者：别墅

VillaHouse

public class VillaHouse extends HouseBuilder {
    @Override
    public void buildGround() {
        house.setGround("100平");
        System.out.println("别墅：打地基");
    }

    @Override
    public void buildWall() {
        house.setWall("每面墙高三米");
        System.out.println("别墅：砌墙面");
    }

    @Override
    public void buildRoofed() {
        house.setRoofed("欧式风格屋顶");
        System.out.println("别墅：盖楼顶");
    }
}

具体建造者：高楼

HighHouse

public class HighHouse extends HouseBuilder{
    @Override
    public void buildGround() {
        house.setGround("200平");
        System.out.println("高楼：打地基");
    }

    @Override
    public void buildWall() {
        house.setWall("每面墙高四米");
        System.out.println("高楼：砌墙面");
    }

    @Override
    public void buildRoofed() {
        house.setRoofed("中国复古屋顶");
        System.out.println("高楼：盖楼顶");
    }
}

产品使用端

Client

public class Client {
    public static void main(String[] args) {
        House house1 = new HouseDirector(new VillaHouse()).build();
        System.out.println(house1);

        System.out.println("====================");

        House house2 = new HouseDirector(new HighHouse()).build();
        System.out.println(house2);
    }
}

结果：

别墅：打地基

别墅：砌墙面

别墅：盖楼顶

House{ground='100平', wall='每面墙高三米', roofed='欧式风格屋顶'}

====================

高楼：打地基

高楼：砌墙面

高楼：盖楼顶

House{ground='200平', wall='每面墙高四米', roofed='中国复古屋顶'}

5.4、应用

最佳实践：org.apache.ibatis.builder.xml.XMLConfigBuilder（mybatis 3.5.6框架源码）

产品实现类

org.apache.ibatis.session.Configuration

public class Configuration {
    protected Environment environment;
    protected boolean safeRowBoundsEnabled;
    protected boolean safeResultHandlerEnabled;
    protected boolean mapUnderscoreToCamelCase;
    protected boolean aggressiveLazyLoading;
    protected boolean multipleResultSetsEnabled;
    protected boolean useGeneratedKeys;
    protected boolean useColumnLabel;
    protected boolean cacheEnabled;
    protected boolean callSettersOnNulls;
    protected boolean useActualParamName;
    protected boolean returnInstanceForEmptyRow;
    protected boolean shrinkWhitespacesInSql;
    protected String logPrefix;
    protected Class logImpl;
    protected Class vfsImpl;
    protected Class defaultSqlProviderType;
    protected LocalCacheScope localCacheScope;
    protected JdbcType jdbcTypeForNull;
    protected Set lazyLoadTriggerMethods;
    protected Integer defaultStatementTimeout;
    protected Integer defaultFetchSize;
    protected ResultSetType defaultResultSetType;
    protected ExecutorType defaultExecutorType;
    protected AutoMappingBehavior autoMappingBehavior;
    protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior;
    protected Properties variables;
    protected ReflectorFactory reflectorFactory;
    protected ObjectFactory objectFactory;
    protected ObjectWrapperFactory objectWrapperFactory;
    protected boolean lazyLoadingEnabled;
    protected ProxyFactory proxyFactory;
    protected String databaseId;
    protected Class configurationFactory;
    protected final MapperRegistry mapperRegistry;
    protected final InterceptorChain interceptorChain;
    protected final TypeHandlerRegistry typeHandlerRegistry;
    protected final TypeAliasRegistry typeAliasRegistry;
    protected final LanguageDriverRegistry languageRegistry;
    protected final Map mappedStatements;
    protected final Map caches;
    protected final Map resultMaps;
    protected final Map parameterMaps;
    protected final Map keyGenerators;
    protected final Set loadedResources;
    protected final Map sqlFragments;
    protected final Collection incompleteStatements;
    protected final Collection incompleteCacheRefs;
    protected final Collection incompleteResultMaps;
    protected final Collection incompleteMethods;
    protected final Map cacheRefMap;
    
    //...此处省略很多代码
}

抽象建造者

org.apache.ibatis.builder.BaseBuilder

public abstract class BaseBuilder {
    protected final Configuration configuration;
    protected final TypeAliasRegistry typeAliasRegistry;
    protected final TypeHandlerRegistry typeHandlerRegistry;

    public BaseBuilder(Configuration configuration) {
        this.configuration = configuration;
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
    }

    public Configuration getConfiguration() {
        return this.configuration;
    }
    
    //...此处省略很多代码
}

具体建造者

org.apache.ibatis.builder.xml.XMLConfigBuilder

public class XMLConfigBuilder extends BaseBuilder {
    private boolean parsed;
    private final XPathParser parser;
    private String environment;
    private final ReflectorFactory localReflectorFactory;
    
    //...此处省略很多代码
    
    public Configuration parse() {
        if (this.parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
            this.parsed = true;
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }

    private void parseConfiguration(XNode root) {
        try {
            this.propertiesElement(root.evalNode("properties"));
            Properties settings = this.settingsAsProperties(root.evalNode("settings"));
            this.loadCustomVfs(settings);
            this.loadCustomLogImpl(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
            this.settingsElement(settings);
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }
    
    //...此处省略很多代码
}

parse方法最终要返回一个Configuration对象，构建Configuration对象的建造过程都在parseConfiguration方法中，这也就是mybatis解析XML配置文件 来构建Configuration对象的主要过程，所以XMLConfigBuilder是具体建造者，复杂产品对象是Configuration，至于指挥者这里好像并没有用到。

二、结构型模式

1、适配器模式

1.1、介绍

适配器模式（Adapter Pattern）是作为两个不兼容接口之间的桥梁，这种类型的设计模式属于结构型模式。一些书籍也称适配器模式为缺省适配器模式（Default Adapter Pattern）。适配器模式主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。以生活中手机充电为例来讲解适配器模式，手机本身并不能直接用220V交流电，需要将220V的交流电转换为5V的直流电，在这个过程中，充电器本身相当于Adapter（适配器），220V交流电相当于Adaptee (适配者)，5V直流电则是我们的Target（目标）

1.2、关系依赖图

适配器模式实现（类适配器）

适配器模式实现（对象适配器）

1.3、代码实现

（1）适配器模式实现（类适配器）

创建交流电

Voltage220V

public class Voltage220V {
    public int output220V() {
        System.out.println("Voltage220V output220V ...");
        return 220;
    }
}

定义直流电

Voltage5V

public interface Voltage5V {
    //定义一个标准，充电器来实现
    public int output5V();
}

创建充电器

VoltageAdapter

public class VoltageAdapter extends Voltage220V implements Voltage5V {
    @Override
    public int output5V() {
        //获取220V交流电
        int output220V = output220V();
        //转换为5V直流电
        int output5V = output220V / 44;

        System.out.println("VoltageAdapter output5V ...");
        return output5V;
    }
}

创建手机类

Phone

public class Phone {
    //充电
    public void charging(Voltage5V voltage5V) {
        if (voltage5V.output5V() == 5) {
            System.out.println("电压刚好5V, 可以充电");
        } else if (voltage5V.output5V() > 5) {
            System.out.println("电压大于5V, 不能充电");
        }
    }
}

测试充电器

PhoneTest

public class PhoneTest {
    public static void main(String[] args) {
        //创建一部手机
        Phone phone = new Phone();
        //用充电器充电
        phone.charging(new VoltageAdapter());
    }
}

结果：

Voltage220V output220V ...

VoltageAdapter output5V ...

电压刚好5V, 可以充电

点评：

Java是单继承机制，所以类适配器需要继承适配者（Adaptee，指Voltage220V）类，这点算是一个缺点，除此之外还必须要求目标（Target，指Voltage5V）必须是接口，有一定局限性；

适配者Voltage220V类的方法在适配器VoltageAdapter类中都会暴露出来，也增加了使用的成本。但是由于其继承了适配者Voltage220V类，所以它可以根据需求重写该类的方法，使得适配器VoltageAdapter类的灵活性增强了。

（2）适配器模式实现（对象适配器）

创建交流电

Voltage220V

public class Voltage220V {
    public int output220V() {
        System.out.println("Voltage220V output220V ...");
        return 220;
    }
}

定义直流电

Voltage5V

public interface Voltage5V {
    //定义一个标准，充电器来实现
    public int output5V();
}

创建充电器

VoltageAdapter

public class VoltageAdapter implements Voltage5V {
    private Voltage220V voltage220V;

    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
        //获取220V交流电
        int output220V = voltage220V.output220V();
        //转换为5V直流电
        int output5V = output220V / 44;

        System.out.println("VoltageAdapter output5V ...");
        return output5V;
    }
}

创建手机类

Phone

public class Phone {
    //充电
    public void charging(Voltage5V voltage5V) {
        if (voltage5V.output5V() == 5) {
            System.out.println("电压刚好5V, 可以充电");
        } else if (voltage5V.output5V() > 5) {
            System.out.println("电压大于5V, 不能充电");
        }
    }
}

测试充电器

PhoneTest

public class PhoneTest {
    public static void main(String[] args) {
        //创建一部手机
        Phone phone = new Phone();
        //用充电器充电（传入220V交流电，传出5V直流电）
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

结果：

Voltage220V output220V ...

VoltageAdapter output5V ...

电压刚好5V, 可以充电

点评：

对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。

根据合成复用原则，使用组合替代继承， 所以它解决了类适配器中VoltageAdapter必须继承Voltage220V的局限性问题，也不再强制要求Voltage5V必须是接口。使用成本更低，更灵活。因此，对象适配器模式是适配器模式常用的一种。

1.4、应用

最佳实践：适配器模式在 SpringMVC 框架应用

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

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

org.springframework.web.servlet.HandlerAdapter，相当于适配器模式中的目标（Target）

public interface HandlerAdapter {
	boolean supports(Object handler);

	@Nullable
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

	long getLastModified(HttpServletRequest request, Object handler);
}

org.springframework.web.servlet.DispatcherServlet

public class DispatcherServlet extends FrameworkServlet {
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //通过request可以得到请求对应的控制器handler
        mappedHandler = getHandler(processedRequest);
        //根据handler得到对应的适配器 
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        //通过适配器去调用对应controller的方法，并返回ModelAndView
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    }
}

getHandlerAdapter：

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
    throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

我们随便找一个HandlerAdapter的实现类，相当于适配器模式中的适配器（Adapter），其中Object handler为适配者（Adaptee）

public class HttpRequestHandlerAdapter implements HandlerAdapter {
	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		((HttpRequestHandler) handler).handleRequest(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}
}

2、桥接模式

2.1、介绍

在现实生活中，某些类具有两个或多个维度的变化，如图形既可按形状分，又可按颜色分。如何设计类似于 Photoshop 这样的软件，能画不同形状和不同颜色的图形呢？如果用继承方式，m 种形状和 n 种颜色的图形就有 m×n 种，不但对应的子类很多，而且扩展困难。

当然，这样的例子还有很多，如不同颜色和字体的文字、不同品牌和功率的汽车，如果用桥接模式就能很好地解决这些问题，那么桥接模式到底是什么呢？

桥接模式（Bridge Pattern）的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。桥接模式遵循了里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放。

2.2、关系依赖图

2.3、代码实现

业务逻辑场景 : 开发跨平台的视频播放器 , 平台有 Android , iOS , Windows , Linux , Mac , 播放器支持的格式有 MP4 , AVI , RMVB , FLV 格式 ; 这种情况下 , 适合使用桥接模式 ;

平台 : 播放器支持 Linux , Android 平台 ;

视频格式 : 播放器支持 MP4 , FLV 视频格式 ;

这里分为两块 , 一块是平台 , 一块是视频格式 ;

平台可以不断的扩展 , 如 : Windows , iOS , MAC , 嵌入式平台 ;

视频类型也可以不断的扩展 , 如 : H264 , H265 , MPEG 等 ;

二者可以随着自己的层级进行扩展 ;

桥接模式 最重要的是 将 抽象 与 实现 解耦 , 通过组合 在 抽象 与 实现 之间搭建桥梁 ;

视频格式抽象

package bridge;

public interface Vedio {
    /**
     * 打开视频
     *      可以打开 MP4 / FLV 格式视频
     *      视频 ( 格式 ) 是个 抽象
     * @return
     */
    Vedio openVedio();

    /**
     * 查看视频信息
     */
    void showVedio();
}

FLV 视频格式实现

package bridge;

/**
 * FLV 视频格式
 */
public class FlvVedio implements Vedio {
    @Override
    public Vedio openVedio() {
        System.out.println("打开 FLV 格式视频");
        return new FlvVedio();
    }

    @Override
    public void showVedio() {
        System.out.println("当前视频格式是 FLV");
    }
}

MP4 视频格式实现

package bridge;

/**
 * MP4 格式
 */
public class MP4Vedio implements Vedio {
    @Override
    public Vedio openVedio() {
        System.out.println("打开 MP4 格式视频");
        return new MP4Vedio();
    }

    @Override
    public void showVedio() {
        System.out.println("当前视频格式是 MP4");
    }
}

系统平台抽象

package bridge;

/**
 * 平台操作系统 抽象类
 */
public abstract class Platform {
    /**
     * 这是桥接模式最核心的代码
     *      在 Platform 中通过组合方式关联 Vedio
     *      Platform 的子类也可以关联 Vedio 子类
     */
    protected Vedio account;

    public Platform(Vedio account) {
        this.account = account;
    }

    /**
     * 该方法与 Vedio 中的方法名相同
     *      方法名相同不是强制的
     * @return
     */
    abstract Vedio openVedio();
}

Linux 系统平台实现

package bridge;

public class LinuxPlatform extends Platform {
    public LinuxPlatform(Vedio account) {
        super(account);
    }

    @Override
    Vedio openVedio() {
        System.out.println("在 Linux 平台播放视频");
        return account;
    }
}

Android 系统平台实现

package bridge;

public class AndroidPlatform extends Platform {
    public AndroidPlatform(Vedio account) {
        super(account);
    }

    @Override
    Vedio openVedio() {
        System.out.println("在 Android 平台打开视频");
        return account;
    }
}

测试类

package bridge;

public class Main {
    public static void main(String[] args) {
        // 在 Linux 平台打开 FLV 视频
        Platform linuxPlatform = new LinuxPlatform(new FlvVedio());
        Vedio linuxFlv = linuxPlatform.openVedio();
        linuxFlv.showVedio();

        System.out.println();

        // 在 Android 平台打开 MP4 视频
        Platform androidPlatform = new AndroidPlatform(new MP4Vedio());
        Vedio androidMp4 = androidPlatform.openVedio();
        androidMp4.showVedio();
    }
}

执行结果：

在 Linux 平台播放视频

当前视频格式是 FLV

在 Android 平台打开视频

当前视频格式是 MP4

3、装饰器模式

3.1、介绍

在软件开发过程中，有时想用一些现存的组件，这些组件可能只是完成了一些核心功能，但在不改变其结构的情况下，可以动态地扩展其功能，所有这些都可以釆用装饰器模式来实现。装饰器模式（Decorator Pattern）的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

3.2、关系依赖图

3.3、代码实现

图形接口类

Shape

public interface Shape {
    void draw();
}

图形实现类

Circle

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}

Rectangle

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}

图形修饰者接口类

ShapeDecorator

public abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    public void draw() {
        decoratedShape.draw();
    }
}

图形修饰者实现类

RedShapeDecorator

public class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape) {
        System.out.println("Add Shape Border Color: Red");
    }
}

最终测试类

DecoratorPatternDemo

public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();
        System.out.println("====================");

        ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
        redCircle.draw();
        System.out.println("====================");

        Shape rectangle = new Rectangle();
        rectangle.draw();
        System.out.println("====================");

        ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
        redRectangle.draw();
    }
}

结果：

Shape: Circle

====================

Shape: Circle

Add Shape Border Color: Red

====================

Shape: Rectangle

====================

Shape: Rectangle

Add Shape Border Color: Red

3.4、应用

在java.io包中的FilterInputStream就是一个装饰者类，InputStream in即被装饰者。

public class FilterInputStream extends InputStream {
    protected volatile InputStream in;

    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
    //...
}

DataInputStream是FilterInputStream子类，则是具体的装饰者类。

public class DataInputStream extends FilterInputStream implements DataInput {
    public DataInputStream(InputStream in) {
        super(in);
    }
    //...
}

4、组合模式

4.1、介绍

组合模式（Composite Pattern）又叫“整体-部分”模式，是用于把一组相似的对象当作一个单一的对象。它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性，属于结构型设计模式。组合模式分为透明式的组合模式和安全式的组合模式。

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下：

由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用，而叶子节点与树枝节点在语义上不属于同一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。

4.2、代码实现

（1）组合模式实现（透明式）

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构如下图：

抽象构件

Component

public interface Component {
    public void add(Component c);

    public void remove(Component c);

    public Component getChild(int i);

    public void operation();
}

树叶构件

Leaf

public class Leaf implements Component {
    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    public void add(Component c) {
    }

    public void remove(Component c) {
    }

    public Component getChild(int i) {
        return null;
    }

    public void operation() {
        System.out.println("树叶" + name + "：被访问！");
    }
}

树枝构件

Composite

public class Composite implements Component {
    private ArrayList children = new ArrayList<>();

    public void add(Component c) {
        children.add(c);
    }

    public void remove(Component c) {
        children.remove(c);
    }

    public Component getChild(int i) {
        return children.get(i);
    }

    public void operation() {
        for (Object obj : children) {
            ((Component) obj).operation();
        }
    }
}

客户端测试

CompositePattern

public class CompositePattern {
    public static void main(String[] args) {
        Component c0 = new Composite();
        Component c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();
    }
}

（2）组合模式实现（安全式）

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构如下图：

抽象构件

Component

public interface Component {
    public void operation();
}

树叶构件

Leaf

public class Leaf implements Component {
    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    public void operation() {
        System.out.println("树叶" + name + "：被访问！");
    }
}

树枝构件

Composite

public class Composite implements Component {
    private ArrayList children = new ArrayList<>();

    public void add(Component c) {
        children.add(c);
    }

    public void remove(Component c) {
        children.remove(c);
    }

    public Component getChild(int i) {
        return children.get(i);
    }

    public void operation() {
        for (Object obj : children) {
            ((Component) obj).operation();
        }
    }
}

客户端测试

CompositePattern

public class CompositePattern {
    public static void main(String[] args) {
        Composite c0 = new Composite();
        Composite c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();
    }
}

4.3、应用

HashMap中有一个putAll方法，参数是一个Map，这就是一种组合模式的体现：

ArrayList中有一个addAll方法，参数是一个Collection，这就是一种组合模式的体现：

5、外观模式

5.1、介绍

在现实生活中，常常存在办事较复杂的例子，如办房产证或注册一家公司，有时要同多个部门联系，这时要是有一个综合部门能解决一切手续问题就好了。

软件设计也是这样，当一个系统的功能越来越强，子系统会越来越多，客户对系统的访问也变得越来越复杂。这时如果系统内部发生改变，客户端也要跟着改变，这违背了“开闭原则”，也违背了“迪米特法则”，所以有必要为多个子系统提供一个统一的接口，从而降低系统的耦合度，这就是外观模式的目标。

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

5.2、关系依赖图

5.3、代码实现

图形接口类

Shape

public interface Shape {
    void draw();
}

图形实现类

Circle

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}

Rectangle

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}

Square

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square::draw()");
    }
}

外观角色类

ShapeMaker

public class ShapeMaker {
    private Shape circle;
    private Shape rectangle;
    private Shape square;

    public ShapeMaker() {
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }

    public void drawCircle() {
        circle.draw();
    }

    public void drawRectangle() {
        rectangle.draw();
    }

    public void drawSquare() {
        square.draw();
    }
}

最终测试类

FacadePatternDemo

public class FacadePatternDemo {
    public static void main(String[] args) {
        ShapeMaker shapeMaker = new ShapeMaker();

        shapeMaker.drawCircle();
        shapeMaker.drawRectangle();
        shapeMaker.drawSquare();
    }
}

结果：

Circle::draw()

Rectangle::draw()

Square::draw()

5.4、应用

在Mybatis源码org.apache.ibatis.session.Configuration类中以 new 开头的方法，下图以newExecutor方法为例：

6、享元模式

6.1、介绍

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。例如，围棋和五子棋中的黑白棋子，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式（Flyweight Pattern）也叫蝇量模式，主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

内部状态指对象共享出来的信息，存储在享元信息内部，并且不会随环境的改变而改变。例如围棋的棋子颜色：黑色、白色。

外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。例如围棋的棋子位置：x横坐标、y纵坐标。

6.2、关系依赖图

6.3、代码实现

非享元对象

Point

public class Point {
    private int x;  //外部状态：代表棋子横坐标
    private int y;  //外部状态：代表棋子纵坐标

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

抽象享元对象

ChessPieces

public interface ChessPieces {
    void downPieces(Point p); //落子方法
}

具体享元对象

WhiteChessPieces

public class WhiteChessPieces implements ChessPieces {
    private String color;   //内部状态：代表棋子颜色

    public WhiteChessPieces() {
        this.color = "白";
    }

    @Override
    public void downPieces(Point p) {
        System.out.println(color + "子落入横坐标" + p.getX() + "，纵坐标" + p.getY());
    }
}

BlackChessPieces

public class BlackChessPieces implements ChessPieces {
    private String color;   //内部状态：代表棋子颜色

    public BlackChessPieces() {
        this.color = "黑";
    }

    @Override
    public void downPieces(Point p) {
        System.out.println(color + "子落入横坐标" + p.getX() + "，纵坐标" + p.getY());
    }
}

享原工厂对象

ChessPiecesFactory

public class ChessPiecesFactory {
    private HashMap pools = new HashMap<>();

    public ChessPieces getChessPieces(String color) {
        if (!pools.containsKey(color)) {
            if ("白".equals(color)) {
                pools.put(color, new WhiteChessPieces());
            }
            if ("黑".equals(color)) {
                pools.put(color, new BlackChessPieces());
            }
        }
        return pools.get(color);
    }
}

最终测试类

Client

public class Client {
    public static void main(String[] args) {
        ChessPiecesFactory chessPiecesFactory = new ChessPiecesFactory();

        ChessPieces cp1 = chessPiecesFactory.getChessPieces("白");
        ChessPieces cp2 = chessPiecesFactory.getChessPieces("白");
        ChessPieces cp3 = chessPiecesFactory.getChessPieces("黑");
        ChessPieces cp4 = chessPiecesFactory.getChessPieces("黑");

        Point p1 = new Point(1, 1);
        Point p2 = new Point(2, 2);
        Point p3 = new Point(3, 3);
        Point p4 = new Point(4, 4);

        cp1.downPieces(p1);
        cp2.downPieces(p2);
        cp3.downPieces(p3);
        cp4.downPieces(p4);

        System.out.println("====================");

        System.out.println(cp1 == cp2);
        System.out.println(cp3 == cp4);
    }
}

6.4、应用

如果 Integer.valueOf(x) 中的x在 -128 ~ 127 之间，就是使用享元模式返回，如果不在该范围，则仍然 new。

我们可以单独使用一个测试类来进行测试：

Integer a1 = Integer.valueOf(12);
Integer a2 = Integer.valueOf(12);
System.out.println(a1 == a2);

Integer b1 = Integer.valueOf(128);
Integer b2 = Integer.valueOf(128);
System.out.println(b1 == b2);

结果：

true

false

7、代理模式

7.1、介绍

在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站购买。

代理模式（Proxy Pattern）中，由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。这种类型的设计模式属于结构型模式。

根据代理的创建时期，代理模式分为静态代理和动态代理。

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。

动态：在程序运行时，运用反射机制动态创建而成。

7.2、关系依赖图

7.3、代码实现

7.3.1、代理模式实现（静态代理）

抽象主题类

UserDao

public interface UserDao {
    public void save();

    public void delete();

    public void update();

    public void find();
}

真实主题类

UserDaoImpl

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDaoImpl save ...");
    }

    @Override
    public void delete() {
        System.out.println("UserDaoImpl delete ...");
    }

    @Override
    public void update() {
        System.out.println("UserDaoImpl update ...");
    }

    @Override
    public void find() {
        System.out.println("UserDaoImpl find ...");
    }
}

代理类

UserDaoProxy

public class UserDaoProxy implements UserDao {
    private UserDao userDao;

    public UserDaoProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }

    @Override
    public void delete() {
        System.out.println("UserDaoProxy 权限校验 ...");
        userDao.delete();
        System.out.println("UserDaoProxy 日志记录 ...");
    }

    @Override
    public void update() {
        userDao.update();
    }

    @Override
    public void find() {
        userDao.find();
    }
}

测试类

Client

public class Client {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
        UserDao userDaoProxy = new UserDaoProxy(userDao);
        userDaoProxy.save();
        userDaoProxy.delete();
        userDaoProxy.update();
        userDaoProxy.find();
    }
}

结果：

UserDaoImpl save ...

UserDaoProxy 权限校验 ...

UserDaoImpl delete ...

UserDaoProxy 日志记录 ...

UserDaoImpl update ...

UserDaoImpl find ...

7.3.2、代理模式实现（JDK动态代理）

抽象主题类

UserDao

public interface UserDao {
    public void save();

    public void delete();

    public void update();

    public void find();
}

真实主题类

UserDaoImpl

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDaoImpl save ...");
    }

    @Override
    public void delete() {
        System.out.println("UserDaoImpl delete ...");
    }

    @Override
    public void update() {
        System.out.println("UserDaoImpl update ...");
    }

    @Override
    public void find() {
        System.out.println("UserDaoImpl find ...");
    }
}

代理类

UserDaoProxy

public class UserDaoProxy {
    private UserDao userDao;

    public UserDaoProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserDao createUserDao() {
        Class clazz = userDao.getClass();
        UserDao ud = (UserDao) Proxy.newProxyInstance(
                clazz.getClassLoader(),
                clazz.getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result;
                        if ("delete".equals(method.getName())) {
                            System.out.println("UserDaoProxy 权限校验 ...");
                            result = method.invoke(userDao, args);
                            System.out.println("UserDaoProxy 日志记录 ...");
                        } else {
                            result = method.invoke(userDao, args);
                        }
                        return result;
                    }
                });
        return ud;
    }
}

测试类

Client

public class Client {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
        UserDao userDaoProxy = new UserDaoProxy(userDao).createUserDao();
        userDaoProxy.save();
        userDaoProxy.delete();
        userDaoProxy.update();
        userDaoProxy.find();
    }
}

结果：

UserDaoImpl save ...

UserDaoProxy 权限校验 ...

UserDaoImpl delete ...

UserDaoProxy 日志记录 ...

UserDaoImpl update ...

UserDaoImpl find ...

7.3.3、代理模式实现（CGLIB动态代理）CGLib 动态代理方式可以无需使用抽象主题类。

真实主题类

UserDaoImpl

public class UserDaoImpl {
    public void save() {
        System.out.println("UserDaoImpl save ...");
    }

    public void delete() {
        System.out.println("UserDaoImpl delete ...");
    }

    public void update() {
        System.out.println("UserDaoImpl update ...");
    }

    public void find() {
        System.out.println("UserDaoImpl find ...");
    }
}

代理类

UserDaoImplProxy

public class UserDaoImplProxy {
    public UserDaoImpl createUserDaoImpl() {
        //创建增强对象
        Enhancer enhancer = new Enhancer();
        //设置父类对象
        enhancer.setSuperclass(UserDaoImpl.class);
        //设置回调方法
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Object result;
                if ("delete".equals(method.getName())) {
                    System.out.println("UserDaoImplProxy 权限校验 ...");
                    result = methodProxy.invokeSuper(proxy, args);
                    System.out.println("UserDaoImplProxy 日志记录 ...");
                } else {
                    result = methodProxy.invokeSuper(proxy, args);
                }
                return result;
            }
        });
        //返回代理对象
        return (UserDaoImpl) enhancer.create();
    }
}

测试类

Client

public class Client {
    public static void main(String[] args) {
        UserDaoImpl userDaoImplProxy = new UserDaoImplProxy().createUserDaoImpl();
        userDaoImplProxy.save();
        userDaoImplProxy.delete();
        userDaoImplProxy.update();
        userDaoImplProxy.find();
    }
}

结果：

UserDaoImpl save ...

UserDaoProxy 权限校验 ...

UserDaoImpl delete ...

UserDaoProxy 日志记录 ...

UserDaoImpl update ...

UserDaoImpl find ...

7.4、应用

Spring 使用动态代理实现 AOP 时有两个非常重要的类，即 JdkDynamicAopProxy 类和 CglibAopProxy 类，其类图如下：

Spring 中的代理选择如下：

当 Bean 有实现接口时，Spring 会用 JDK 动态代理方式。

当 Bean 没有实现接口时，Spring 会选择 CGLib 动态代理方式。

Spring 可以通过配置强制使用 CGLib 动态代理，只需在 Spring 的配置文件中加入如下代码即可。

三、行为模式

1、模板模式

1.1、介绍

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

这样的例子在生活中还有很多，例如，一个人每天会起床、吃饭、做事、睡觉等，其中“做事”的内容每天可能不同。我们把这些规定了流程或格式的实例定义成模板，允许使用者根据自己的需求去更新它，例如，简历模板、论文模板、Word 中模板文件等。

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板，它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

1.2、关系依赖图

1.3、代码实现

抽象父类

Game

public abstract class Game {
    abstract void initialize();

    abstract void startPlay();

    abstract void endPlay();

    //模板
    public final void play() {
        //初始化游戏
        initialize();

        //开始游戏
        startPlay();

        //结束游戏
        endPlay();
    }
}

具体子类

Football

public class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football Game Initialized.");
    }

    @Override
    void startPlay() {
        System.out.println("Football Game Started.");
    }

    @Override
    void endPlay() {
        System.out.println("Football Game Finished.");
    }
}

Basketball

public class Basketball extends Game {
    @Override
    void initialize() {
        System.out.println("Basketball Game Initialized.");
    }

    @Override
    void startPlay() {
        System.out.println("Basketball Game Started.");
    }

    @Override
    void endPlay() {
        System.out.println("Basketball Game Finished.");
    }
}

测试类

Client

public class Client {
    public static void main(String[] args) {
        Game g1 = new Football();
        g1.play();

        Game g2 = new Basketball();
        g2.play();
    }
}

结果：

Football Game Initialized.

Football Game Started.

Football Game Finished.

Basketball Game Initialized.

Basketball Game Started.

Basketball Game Finished.

1.4、应用

在 Servlet 中，每一个 Servlet 类都必须要实现 HttpServlet 接口。GenericServlet 是个通用的、不特定于任何协议的 Servlet，它实现了 Servlet 接口。而 HttpServlet 继承于 GenericServlet，为 Servlet 接口提供了处理 HTTP 协议的通用实现，所以我们定义 Servlet 时只需要继承 HttpServlet 即可。

public abstract class HttpServlet extends GenericServlet {
    //以上代码部分省略...
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException
    {
        //省略...
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }


    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }

    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        //省略...
    }


    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException 
    {

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    
    //以下部分代码省略...
}

在 HttpServlet 的 service 方法中，首先获取请求的方法名，然后根据方法名调用对应的 doXXX 方法，比如说请求方法为 GET，那么就去调用 doGet 方法；请求方法为 POST，那么就去调用 doPost 方法。

这里，HttpServlet 就相当于定义了一套处理 HTTP 请求的模板。service 方法为模板方法，定义了处理 HTTP 请求的基本流程；doXXX 等方法为基本方法，根据请求方法做相应的处理，子类可重写这些方法。HttpServletRequest 中的 Method 则起到钩子方法的作用。

比如实现一个输出 Hello World 的简单 Servlet，代码如下：

public class HelloWorld extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response) 
        throws ServletException, IOException 
    {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("
Hello World!
");
    }
}

2、命令模式

2.1、介绍

在软件开发系统中，“方法的请求者”与“方法的实现者”之间经常存在紧密的耦合关系，这不利于软件功能的扩展与维护。例如，想对方法进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与实现者解耦”变得很重要，命令模式就能很好地解决这个问题。

在现实生活中，命令模式的例子也很多。比如看电视时，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者）。

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

2.2、关系依赖图

2.3、代码实现

抽象命令类

Command

public interface Command {
    //执行动作(操作)
    public void execute();

    //撤销动作(操作)
    public void undo();
}

具体命令类

NoCommand

public class NoCommand implements Command {
    @Override
    public void execute() {

    }

    @Override
    public void undo() {

    }
}

TVOnCommand

public class TVOnCommand implements Command {
    TVReceiver tv;

    public TVOnCommand(TVReceiver tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.on();
    }

    @Override
    public void undo() {
        tv.off();
    }
}

TVOffCommand

public class TVOffCommand implements Command {
    TVReceiver tv;

    public TVOffCommand(TVReceiver tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.off();
    }

    @Override
    public void undo() {
        tv.on();
    }
}

命令接收者

TVReceiver

public class TVReceiver {
    public void on() {
        System.out.println(" 电视机打开了... ");
    }

    public void off() {
        System.out.println(" 电视机关闭了... ");
    }
}

命令请求者

RemoteController

public class RemoteController {
    Command[] onCommands;   //开命令集合
    Command[] offCommands;  //关命令集合
    Command undoCommand;    //撤销命令

    public RemoteController() {
        onCommands = new Command[5];
        offCommands = new Command[5];

        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }

    //设置命令按钮
    public void setCommand(int no, Command onCommand, Command offCommand) {
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }

    //按下开按钮
    public void onButtonWasPushed(int no) {
        //找到你按下的开的按钮，并调用对应方法
        onCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = onCommands[no];
    }

    //按下关按钮
    public void offButtonWasPushed(int no) {
        //找到你按下的关的按钮，并调用对应方法
        offCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = offCommands[no];
    }

    //按下撤销按钮
    public void undoButtonWasPushed() {
        undoCommand.undo();
    }
}

最终测试类

Client

public class Client {
    public static void main(String[] args) {
        //创建远程遥控器
        RemoteController remoteController = new RemoteController();
        //创建电视机接收者
        TVReceiver tvReceiver = new TVReceiver();
        TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);
        TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);
        remoteController.setCommand(0, tvOnCommand, tvOffCommand);
        //调用电视机的操作
        remoteController.onButtonWasPushed(0);
        remoteController.offButtonWasPushed(0);
        remoteController.undoButtonWasPushed();
    }
}

结果：

电视机打开了...

电视机关闭了...

电视机打开了...

2.4、应用

Spring 框架的 JdbcTemplate 就使用到了命令模式，不过并不是命令模式的标准实现，只是用到了命令模式的思想。

StatementCallback充当了抽象命令类。

@FunctionalInterface
public interface StatementCallback {
	@Nullable
	T doInStatement(Statement stmt) throws SQLException, DataAccessException;
}

以下图片中是实现了StatementCallback的所有具体命令类。

这里QueryStatementCallback使用到了匿名内部类而不是单独写成一个类文件，它实现了命令接口， 同时也充当命令接收者。

@Nullable
public  T query(final String sql, final ResultSetExtractor rse) throws DataAccessException {
    Assert.notNull(sql, "SQL must not be null");
    Assert.notNull(rse, "ResultSetExtractor must not be null");
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Executing SQL query [" + sql + "]");
    }

    class QueryStatementCallback implements StatementCallback, SqlProvider {
        QueryStatementCallback() {}

        @Nullable
        public T doInStatement(Statement stmt) throws SQLException {
            ResultSet rs = null;

            Object var3;
            try {
                rs = stmt.executeQuery(sql);
                var3 = rse.extractData(rs);
            } finally {
                JdbcUtils.closeResultSet(rs);
            }

            return var3;
        }

        public String getSql() {
            return sql;
        }
    }

    return this.execute(new QueryStatementCallback(), true);
}

命令调用者是 JdbcTemplate，其中 execute(StatementCallback action, boolean closeResources) 方法中，调用 action.doInStatement(stmt) 方法，不同的实现 StatementCallback 接口的对象，对应不同的 doInStatemnt 实现逻辑。

@Nullable
private  T execute(StatementCallback action, boolean closeResources) throws DataAccessException {
    Assert.notNull(action, "Callback object must not be null");
    Connection con = DataSourceUtils.getConnection(this.obtainDataSource());
    Statement stmt = null;

    Object var12;
    try {
        stmt = con.createStatement();
        this.applyStatementSettings(stmt);
        T result = action.doInStatement(stmt);
        this.handleWarnings(stmt);
        var12 = result;
    } catch (SQLException var10) {
        String sql = getSql(action);
        JdbcUtils.closeStatement(stmt);
        stmt = null;
        DataSourceUtils.releaseConnection(con, this.getDataSource());
        con = null;
        throw this.translateException("StatementCallback", sql, var10);
    } finally {
        if (closeResources) {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, this.getDataSource());
        }

    }

    return var12;
}

3、访问者模式

3.1、介绍

在现实生活中，有些集合对象存在多种不同的元素，且每种元素也存在多种不同的访问者和处理方式。例如，公园中存在多个景点，也存在多个游客，不同的游客对同一个景点的评价可能不同；医院医生开的处方单中包含多种药元素，査看它的划价员和药房工作人员对它的处理方式也不同，划价员根据处方单上面的药品名和数量进行划价，药房工作人员根据处方单的内容进行抓药。

访问者模式（Visitor Pattern）主要将数据结构与数据操作分离，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

3.2、关系依赖图

3.3、代码实现

抽象访问者类

ComputerPartVisitor

public interface ComputerPartVisitor {
    void visit(Mouse mouse);

    void visit(Keyboard keyboard);
}

具体访问者类

MIComputerPartVisitor

public class MIComputerPartVisitor implements ComputerPartVisitor {
    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying XiaoMi Mouse ...");
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying XiaoMi Keyboard ...");
    }
}

HPComputerPartVisitor

public class HPComputerPartVisitor implements ComputerPartVisitor {
    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying HuiPu Mouse ...");
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying HuiPu Keyboard ...");
    }
}

抽象元素类

ComputerPart

public interface ComputerPart {
    void accept(ComputerPartVisitor computerPartVisitor);
}

具体元素类

Mouse

public class Mouse implements ComputerPart {
    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

Keyboard

public class Keyboard implements ComputerPart {
    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }
}

对象结构类

ObjectStructure

public class ObjectStructure {
    private List computerParts = new ArrayList<>();

    public void attach(ComputerPart computerPart) {
        computerParts.add(computerPart);
    }

    public void detach(ComputerPart computerPart) {
        computerParts.remove(computerPart);
    }

    public void display(ComputerPartVisitor computerPartVisitor) {
        for (ComputerPart computerPart : computerParts) {
            computerPart.accept(computerPartVisitor);
        }
    }
}

最终测试类

Client

public class Client {
    public static void main(String[] args) {
        ObjectStructure os = new ObjectStructure();
        os.attach(new Mouse());
        os.attach(new Keyboard());
        os.display(new MIComputerPartVisitor());
        os.display(new HPComputerPartVisitor());
    }
}

结果：

Displaying XiaoMi Mouse ...

Displaying XiaoMi Keyboard ...

Displaying HuiPu Mouse ...

Displaying HuiPu Keyboard ...

3.4、应用

在早期的 Java 版本中，如果要对指定目录下的文件进行遍历，必须用递归的方式来实现，这种方法复杂且灵活性不高。

Java 7 版本后，Files 类提供了 walkFileTree() 方法，该方法可以很容易的对目录下的所有文件进行遍历，需要 Path、FileVisitor 两个参数。其中，Path 是要遍历文件的路径，FileVisitor 则可以看成一个文件访问器。源码如下：

public final class Files {
    //以上代码部分省略...
    
    public static Path walkFileTree(Path start, FileVisitor visitor)
        throws IOException
    {
        return walkFileTree(start,
                            EnumSet.noneOf(FileVisitOption.class),
                            Integer.MAX_VALUE,
                            visitor);
    }
    
    //以下代码部分省略...
}

FileVisitor 提供了递归遍历文件树的支持，这个接口的方法表示了遍历过程中的关键过程，允许在文件被访问、目录将被访问、目录已被访问、发生错误等过程中进行控制。换句话说，这个接口在文件被访问前、访问中和访问后，以及产生错误的时候都有相应的钩子程序进行处理。FileVisitor 主要提供了 4 个方法，且返回结果的都是 FileVisitResult 对象值，用于决定当前操作完成后接下来该如何处理。FileVisitResult 是一个枚举类，代表返回之后的一些后续操作。源码如下：

public interface FileVisitor {
    FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) throws IOException;

    FileVisitResult visitFile(T file, BasicFileAttributes attrs) throws IOException;

    FileVisitResult visitFileFailed(T file, IOException exc) throws IOException;

    FileVisitResult postVisitDirectory(T dir, IOException exc) throws IOException;
}

FileVisitResult 主要包含 4 个常见的操作：

FileVisitResult.CONTINUE：这个访问结果表示当前的遍历过程将会继续。

FileVisitResult.SKIP_SIBLINGS：这个访问结果表示当前的遍历过程将会继续，但是要忽略当前文件/目录的兄弟节点。

FileVisitResult.SKIP_SUBTREE：这个访问结果表示当前的遍历过程将会继续，但是要忽略当前目录下的所有节点。

FileVisitResult.TERMINATE：这个访问结果表示当前的遍历过程将会停止。

public enum FileVisitResult {
    CONTINUE,
    TERMINATE,
    SKIP_SUBTREE,
    SKIP_SIBLINGS;
}

通过访问者去遍历文件树会比较方便，比如查找文件夹内符合某个条件的文件或者某一天内所创建的文件，这个类中都提供了相对应的方法。它的实现也非常简单，代码如下：

public class SimpleFileVisitor implements FileVisitor {
    protected SimpleFileVisitor() {}

    @Override
    public FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs)
        throws IOException
    {
        Objects.requireNonNull(dir);
        Objects.requireNonNull(attrs);
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(T file, BasicFileAttributes attrs)
        throws IOException
    {
        Objects.requireNonNull(file);
        Objects.requireNonNull(attrs);
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFileFailed(T file, IOException exc)
        throws IOException
    {
        Objects.requireNonNull(file);
        throw exc;
    }

    @Override
    public FileVisitResult postVisitDirectory(T dir, IOException exc)
        throws IOException
    {
        Objects.requireNonNull(dir);
        if (exc != null)
            throw exc;
        return FileVisitResult.CONTINUE;
    }
}

4、迭代器模式

4.1、介绍

在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了“开闭原则”。

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。迭代器模式属于行为型模式。

4.2、关系依赖图

4.3、代码实现

抽象迭代器

Iterator

public interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

具体迭代器

ConcreteIterator

public class ConcreteIterator implements Iterator {
    private List