设计模式学习笔记

作者：Grey

原文地址： 设计模式学习笔记

UML和代码

UML图

代码

软件设计六大原则

开闭原则

对扩展开放，对修改关闭，降低维护带来的新风险

不符合开闭原则的代码，每次新增一种类型，都需要增加一个if条件判断（修改）。

public class GraphicEditor {

    public void draw(Shape shape) {
        if (shape.mType == 1) {
            drawRectangle();
        } else if(shape.mType == 2) {
            drawCircle();
        }
        // ... 每次增加一种类型，这里的代码就要加一个if分支。
    }

    public void drawRectangle() {
        System.out.println("画长方形");
    }
    public void drawCircle() {
        System.out.println("画圆形");
    }
    class Shape {
        int mType;
    }
    class Rectangle extends Shape {
        Rectangle() {
            super.mType=1;
        }
    }
    class Circle extends Shape {
        Circle() {
            super.mType=2;
        }
    }
}

调整成开闭原则，增加一种类型，只需要新增一个类，并实现Shape接口即可（扩展）。

public class GraphicEditor1 {

    public void draw(Shape shape) {
        shape.draw();
    }
    interface Shape {
        void draw();
    }
    class Rectangle implements Shape {

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

        @Override
        public void draw() {
            System.out.println("画圆形");
        }
    }
}

依赖倒置

高层不应该依赖低层，这样更利于代码结构的升级扩展

不符合依赖倒置的代码如下，driver方法参数里面写了具体的车的实现，如果以后要换一种车，只能修改代码实现。

public class Benz {
    public void run() {
        System.out.println("奔驰跑起来了!");
    }
}

public class Driver {
    private String name;
    public Driver(String name) {
        this.name = name;
    }

    public void driver(Benz benz) {
        benz.run();
    }
}

public class CarTest {
    public static void main(String[] args) {
        Benz benz = new Benz();
        Driver driver = new Driver("张三");
        driver.driver(benz);
    }
}

调整后的代码如下，因为driver参数变成了抽象的ICar类型，所以，所有实现ICar类型的车都可以调用这个方法。

public interface ICar {
    public void run();
}
public class Benz implements ICar{
    public void run() {
        System.out.println("奔驰跑起来了!");
    }
}
public class BM implements ICar{
    public void run() {
        System.out.println("宝马跑起来了!");
    }
}
public interface IDriver {
    public void driver(ICar car);
}
public class Driver implements IDriver{

    @Override
    public void driver(ICar car) {
        car.run();
    }
}
public class CarTest {
    public static void main(String[] args) {
        IDriver driver = new Driver();
        driver.driver(new Benz());
        driver.driver(new BM());
    }
}

单一职责

一个类只干一件事 便于理解，提高代码的可读性

一般来说，系统有登录，注册，注销的功能，可以写成如下形式

public interface UserOperate {
    void login(UserInfo userInfo);
    void register(UserInfo userInfo);
    void logout(UserInfo userInfo);
}

public class UserOperateImpl implements UserOperate{
    @Override
    public void login(UserInfo userInfo) {
        // 用户登录
    }

    @Override
    public void register(UserInfo userInfo) {
        // 用户注册
    }

    @Override
    public void logout(UserInfo userInfo) {
        // 用户登出
    }
}

以上设计针对各个方法都不是很复杂的情况可以接受，如果每个方法都比较复杂，可以考虑独立成类来做，示例如下

public interface Register {
    void register();
}

public interface Login {
    void login();
}

public interface Logout {
    void logout();
}


public class RegisterImpl implements Register{

    @Override
    public void register() {
        // 用户注册
    }
}

public class LoginImpl implements Login{
    @Override
    public void login() {
        // 用户登录
    }
}

public class LogoutImpl implements Logout{

    @Override
    public void logout() {
        // 登出
    }
}

接口隔离

一个接口只干一件事，功能解耦，高聚合，低耦合

示例：学生成绩管理程序一般包含查询成绩、新增成绩、删除成绩、修改成绩、计算总分、计算平均分、打印成绩信息等功能，如果都写在一个类里面，就会变成如下形式

public interface IStudentScore {
    // 查询成绩
    public void queryScore();

    // 修改成绩
    public void updateScore();

    // 添加成绩
    public void saveScore();

    // 删除成绩
    public void delete();

    // 计算总分
    public double sum();

    // 计算平均分
    public double avg();

    // 打印成绩单
    public void printScore();
}

这样的方式不利于扩展. 比如: 学生只有查看成绩,打印成绩单的权限, 没有增删改的权限; 老师拥有所有的权限。

采用接口隔离原则设计，可以做如下改进

public interface IQueryScore {
    // 查询成绩
    public void queryScore();

    // 打印成绩单
    public void printScore();
}

public interface IOperateScore {

    // 修改成绩
    public void updateScore();

    // 添加成绩
    public void saveScore();

    // 删除成绩
    public void delete();

    // 计算总分
    public double sum();

    // 计算平均分
    public double avg();
}

分为查询接口和操作接口，这样学生端就不需要重写和他不相关的接口了。

迪米特法则

不该知道的不要知道，减少代码臃肿

示例：一个人用咖啡机煮咖啡的过程，例子中只有两个类，一个是人，一个是咖啡机。

首先是咖啡机类CoffeeMachine，咖啡机制作咖啡只需要三个方法

1. 加咖啡豆；
2. 加水；
3. 制作咖啡

如果把咖啡机的所有方法暴露给人调用，就会出现如下代码

/**
 * 咖啡机抽象接口
 */
public interface ICoffeeMachine {

    //加咖啡豆
    void addCoffeeBean();

    //加水
    void addWater();

    //制作咖啡
    void makeCoffee();
}


/**
 * 咖啡机实现类
 */
public class CoffeeMachine implements ICoffeeMachine{

    //加咖啡豆
    public void addCoffeeBean() {
        System.out.println("放咖啡豆");
    }

    //加水
    public void addWater() {
        System.out.println("加水");
    }

    //制作咖啡
    public void makeCoffee() {
        System.out.println("制作咖啡");
    }
}


/**
 * 人, 制作咖啡
 */
public interface IMan {
    /**
     * 制作咖啡
     */
    void makeCoffee();
}

/**
 * 人制作咖啡
 */
public class Man implements IMan {
    private ICoffeeMachine coffeeMachine;

    public Man(ICoffeeMachine coffeeMachine) {
        this.coffeeMachine = coffeeMachine;
    }

    /**
     * 制作咖啡
     */
    public void makeCoffee() {
        coffeeMachine.addWater();
        coffeeMachine.addCoffeeBean();
        coffeeMachine.makeCoffee();
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        ICoffeeMachine coffeeMachine = new CoffeeMachine();

        IMan man = new Man(coffeeMachine);
        man.makeCoffee();

    }
}

其实人根本不关心咖啡机具体制作咖啡的过程。所以我们可以作如下优化：

优化后的咖啡机类，只暴露一个work方法，把制作咖啡的三个具体的方法addCoffeeBean、addWater、makeCoffee设为私有

/**
 * 咖啡机抽象接口
 */
public interface ICoffeeMachine {

    //咖啡机工作
    void work();

}

/**
 * 咖啡机实现类
 */
public class CoffeeMachine implements ICoffeeMachine {

    //加咖啡豆
    public void addCoffeeBean() {
        System.out.println("放咖啡豆");
    }

    //加水
    public void addWater() {
        System.out.println("加水");
    }

    //制作咖啡
    public void makeCoffee() {
        System.out.println("制作咖啡");
    }

    @Override
    public void work() {
        addCoffeeBean();
        addWater();
        makeCoffee();
    }
}

/**
 * 人, 制作咖啡
 */
public interface IMan {
    /**
     * 制作咖啡
     */
    void makeCoffee();
}


/**
 * 人制作咖啡
 */
public class Man implements IMan {
    private ICoffeeMachine coffeeMachine;

    public Man(ICoffeeMachine coffeeMachine) {
        this.coffeeMachine = coffeeMachine;
    }

    /**
     * 制作咖啡
     */
    public void makeCoffee() {
        coffeeMachine.work();
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        ICoffeeMachine coffeeMachine = new CoffeeMachine();

        IMan man = new Man(coffeeMachine);
        man.makeCoffee();

    }
}

通过减少CoffeeMachine对外暴露的方法，减少Man对CoffeeMachine的了解，从而降低了它们之间的耦合。

里氏替换原则

子类重写方法功能发生改变，不应该影响父类方法的含义，防止继承泛滥。

比如下述代码，就是不符合里氏替换原则的

class A{
    public int func1(int a, int b){
        return a-b;
    }
}
 
public class Client{
    public static void main(String[] args){
        A a = new A();
        System.out.println("100-50="+a.func1(100, 50));
        System.out.println("100-80="+a.func1(100, 80));
    }
}

后来，我们需要增加一个新的功能：完成两数相加，然后再与100求和，由类B来负责。即类B需要完成两个功能：

1. 两数相减。
2. 两数相加，然后再加100。

由于类A已经实现了第一个功能，所以类B继承类A后，只需要再完成第二个功能就可以了，代码如下：

class B extends A{
    public int func1(int a, int b){
        return a+b;
    }
 
    public int func2(int a, int b){
        return func1(a,b)+100;
    }
}
 
public class Client{
    public static void main(String[] args){
        B b = new B();
        System.out.println("100-50="+b.func1(100, 50));
        System.out.println("100-80="+b.func1(100, 80));
        System.out.println("100+20+100="+b.func2(100, 20));
 }
}

类B完成后，运行结果：

100-50=150

100-80=180

100+20+100=220

我们发现原本运行正常的相减功能发生了错误。原因就是类B在给方法起名时无意中重写了父类的方法，造成所有运行相减功能的代码全部调用了类B重写后的方法，造成原本运行正常的功能出现了错误。在本例中，引用基类A完成的功能，换成子类B之后，发生了异常。在实际编程中，我们常常会通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的几率非常大。如果非要重写父类的方法，比较通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合，组合等关系代替。

单例模式

单例模式是创建型模式。

单例的定义：“一个类只允许创建唯一一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。”定义中提到，“一个类只允许创建唯一一个对象”。那对象的唯一性的作用范围是指进程内只允许创建一个对象，也就是说，单例模式创建的对象是进程唯一的（而非线程）

为什么要使用单例

1. 处理资源访问冲突

   比如写日志的类，如果不使用单例，就必须使用锁机制来解决日志被覆盖的问题。

2. 表示全局唯一类

   比如配置信息类，在系统中，只有一个配置文件，当配置文件加载到内存中，以对象形式存在，也理所应当只有一份。

   唯一ID生成器也是类似的机制。如果程序中有两个对象，那就会存在生成重复 ID 的情况，所以，我们应该将 ID 生成器类设计为单例。

饿汉式

类加载的时候就会初始化这个实例，JVM保证唯一实例，线程安全，但是可以通过反射破坏

方式一

public class Singleton1 {
    private final static Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

方式二

public class Singleton2 {
    private static final Singleton2 INSTANCE;

    static {
        INSTANCE = new Singleton2();
    }
    private Singleton2() {
    
    }
    public static Singleton2 getInstance() {
        return INSTANCE;
    }
}

这种方式不支持延迟加载，如果实例占用资源多（比如占用内存多）或初始化耗时长（比如需要加载各种配置文件），提前初始化实例是一种浪费资源的行为。最好的方法应该在用到的时候再去初始化。不过，如果初始化耗时长，那最好不要等到真正要用它的时候，才去执行这个耗时长的初始化过程，这会影响到系统的性能，我们可以将耗时的初始化操作，提前到程序启动的时候完成，这样就能避免在程序运行的时候，再去初始化导致的性能问题。如果实例占用资源多，按照 fail-fast 的设计原则（有问题及早暴露），那我们也希望在程序启动时就将这个实例初始化好。如果资源不够，就会在程序启动的时候触发报错（比如Java中的PermGen Space OOM），我们可以立即去修复。这样也能避免在程序运行一段时间后，突然因为初始化这个实例占用资源过多，导致系统崩溃，影响系统的可用性。

这两种方式都可以通过反射方式破坏，例如：

Class<?> aClass=Class.forName("singleton.Singleton2",true,Thread.currentThread().getContextClassLoader());
Singleton2 instance1=(Singleton2)aClass.newInstance();
Singleton2 instance2=(Singleton2)aClass.newInstance();
System.out.println(instance1==instance2);

输出：false

懒汉式

虽然可以实现按需初始化，但是线程不安全, 因为在判断 INSTANCE == null的时候，如果是多个线程操作的话， 一个线程还没有把 INSTANCE初始化好，另外一个线程判断 INSTANCE==null得到true，就会继续初始化

public class Singleton3 {
    private static Singleton3 INSTANCE;

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        if (INSTANCE == null) {
            // 模拟初始化对象需要的耗时操作
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton3();
        }
        return INSTANCE;
    }
}

为了防止线程不安全，可以在 getInstance方法上加锁，这样既实现了按需初始化，又保证了线程安全，

但是加锁可能会导致一些性能的问题：我们给 getInstance()这个方法加了一把大锁，导致这个函数的并发度很低。量化一下的话，并发度是 1，也就相当于串行操作了。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，那频繁加锁、释放锁及并发度低等问题，会导致性能瓶颈，这种实现方式就不可取了。

public class Singleton4 {
    private static Singleton4 INSTANCE;

    private Singleton4() {
    }

    public static synchronized Singleton4 getInstance() {
        if (INSTANCE == null) {
            // 模拟初始化对象需要的耗时操作
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton4();
        }
        return INSTANCE;
    }
}

为了提升一点点性能，可以不给 getInstance()整个方法加锁，而是对 INSTANCE判空这段代码加锁, 但是又带来了线程不安全的问题

public class Singleton5 {
    private static Singleton5 INSTANCE;

    private Singleton5() {
    }

    public static Singleton5 getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton5.class) {
                // 模拟初始化对象需要的耗时操作
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Singleton5();
            }
        }
        return INSTANCE;
    }
}

Double Check Locking模式,就是双加锁检查模式，这种方式中，Volatile是必需的，目的为了防止指令重排，生成一个半初始化的的实例，导致生成两个实例。

具体可参考 双重检索(DCL)的思考: 为什么要加volatile?

public class Singleton6 {
    private volatile static Singleton6 INSTANCE;

    private Singleton6() {
    }

    public static Singleton6 getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton6.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton6();
                }
            }
        }
        return INSTANCE;
    }
}

以下两种更为优雅的方式，既保证了线程安全，又实现了按需加载。

方式一：静态内部类方式，JVM保证单例，加载外部类时不会加载内部类，这样可以实现懒加载

public class Singleton7 {
    private Singleton7() {
    }

    public static Singleton7 getInstance() {
        return Holder.INSTANCE;
    }

    private static class Holder {
        private static final Singleton7 INSTANCE = new Singleton7();
    }

}

方式二： 使用枚举, 这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化,这种方式是 Effective Java 作者
Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

public enum Singleton8 {
    INSTANCE;
}

单例模式的替代方案

使用静态方法

   // 静态方法实现方式
public class IdGenerator {
    private static AtomicLong id = new AtomicLong(0);
   
    public static long getId() { 
       return id.incrementAndGet();
    }
}

// 使用举例
long id = IdGenerator.getId();

使用依赖注入

   // 1. 老的使用方式
   public demofunction() {
     //...
     long id = IdGenerator.getInstance().getId();
     //...
   }
   
   // 2. 新的使用方式：依赖注入
   public demofunction(IdGenerator idGenerator) {
     long id = idGenerator.getId();
   }
   // 外部调用demofunction()的时候，传入idGenerator
   IdGenerator idGenerator = IdGenerator.getInsance();
   demofunction(idGenerator);

线程单例

通过一个 HashMap来存储对象，其中 key 是线程 ID，value 是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java 语言本身提供了 ThreadLocal工具类，可以更加轻松地实现线程唯一单例。不过，ThreadLocal底层实现原理也是基于下面代码中所示的 HashMap。

public class IdGenerator {
  private AtomicLong id = new AtomicLong(0);

  private static final ConcurrentHashMap<Long, IdGenerator> instances = new ConcurrentHashMap<>();

  private IdGenerator() {}

  public static IdGenerator getInstance() {
    Long currentThreadId = Thread.currentThread().getId();
    instances.putIfAbsent(currentThreadId, new IdGenerator());
    return instances.get(currentThreadId);
  }

  public long getId() {
    return id.incrementAndGet();
  }
}

集群模式下单例

我们需要把这个单例对象序列化并存储到外部共享存储区（比如文件）。进程在使用这个单例对象的时候，需要先从外部共享存储区中将它读取到内存，并反序列化成对象，然后再使用，使用完成之后还需要再存储回外部共享存储区。为了保证任何时刻，在进程间都只有一份对象存在，一个进程在获取到对象之后，需要对对象加锁，避免其他进程再将其获取。在进程使用完这个对象之后，还需要显式地将对象从内存中删除，并且释放对对象的加锁。

如何实现一个多例模式

“单例”指的是一个类只能创建一个对象。对应地，“多例”指的就是一个类可以创建多个对象，但是个数是有限制的，比如只能创建 3 个对象。多例的实现也比较简单，通过一个 Map 来存储对象类型和对象之间的对应关系，来控制对象的个数。

单例模式的应用举例

• JDK的 Runtime类

public class Runtime {
  private static Runtime currentRuntime = new Runtime();

  public static Runtime getRuntime() {
    return currentRuntime;
  }
  
  /** Don't let anyone else instantiate this class */
  private Runtime() {}
.......
}

• Spring中 AbstractBeanFactory中包含的两个功能。
  • 从缓存中获取单例Bean
  • 从Bean的实例中获取对象

工厂模式

工厂模式是创建型模式。

简单工厂

这个模式很简单，比如我们需要制造不同类型的鼠标，我们只需要创建一个鼠标工厂

public class MouseFactory {
    public static Mouse createMouse(int type) {
        switch (type) {
            case 1:
                return new HpMouse();
            case 2:
                return new LenovoMouse();
            case 0:
            default:
                return new DellMouse();
        }
    }

    public static void main(String[] args) {
        Mouse mouse = MouseFactory.createMouse(1);
        mouse.sayHi();
    }
}

根据不同的type来创建不同的鼠标即可。这个模式的缺点很明显：违反了开闭原则 ，所以我们引入工厂方法

工厂方法

工厂方法中，我们可以定义对应产品的对应工厂，以上面这个鼠标的例子为例，我们可以增加工厂的接口

public interface MouseFactory {
    Mouse createMouse();
}

不同类型的鼠标工厂实现这个工厂即可，以Dell鼠标工厂为例

public class DellMouseFactory implements MouseFactory {
    @Override
    public Mouse createMouse() {
        return new DellMouse();
    }
}

主函数在调用的时候，直接指定工厂即可制造对应的产品了：

public class FactoryMethodDemo {
    public static void main(String[] args) {
        MouseFactory mf = new HpMouseFactory();
        Mouse mouse = mf.createMouse();
        mouse.sayHi();
    }
}

工厂方法的优点是符合开闭原则，但是缺点也很明显，就是在增加子类的时候，同时要增加一个子类的工厂，而且，只支持同一类产品的创建，不适用于同一产品族。

抽象工厂

举例，现在需要通过工厂来制造交通工具，如果是现代的工厂，制造的就是汽车，如果是古代的工厂，制造的就是马车, 我们可以先把工厂抽象出来，

package factory.abstractfactory;

/**
 * @author Grey
 * @date 2020/4/13
 */
public abstract class AbstractFactory {
    /**
     * 子类实现
     *
     * @return
     */
    protected abstract Transportation createTransportation();

    /**
     * 子类实现
     *
     * @return
     */
    protected abstract WritingInstrument createWritingInstrument();
}

交通工具我们也可以抽象出来

public abstract class Transportation {
    protected abstract void go();
}

对于马车和汽车来说，只需要继承这个Transportation类，实现对应的go方法即可,以汽车为例

public class Car extends Transportation {
    @Override
    protected void go() {
        System.out.println("car go");
    }
}

对于现代工厂还是古代工厂，我们只需要继承AbstractFactory这个抽象类，实现createTransportation方法即可，以现代工厂为例

package factory.abstractfactory;

/**
 * @author Grey
 * @date 2020/4/13
 */
public class ModernFactory extends AbstractFactory {

    @Override
    protected Transportation createTransportation() {
        return new Car();
    }

    @Override
    protected WritingInstrument createWritingInstrument() {
        return new Pen();
    }
}

主方法在调用的时候，只需要

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ModernFactory();
        factory.createTransportation().go();
    }
}

抽象工厂的UML图如下：

Java8提供了Supplier这个函数式接口，我们可以通过这个接口很方便的实现工厂类，举例：

我们可以定义一个 MovableFactory，里面的 create方法，传入的是一个 Supplier，你可以把所有 Movable的子类实现传给这个参数，示例如下：

public class MovableFactory {
    public static Movable create(Supplier<? extends Movable> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        MovableFactory.create(Car::new).go();
        MovableFactory.create(() -> new Ship()).go();
    }
}

注：单例模式就是一种工厂模式（静态工厂）

工厂模式应用举例

• JDK中 Calendar.getInstance()方法。
• LogBack中 LoggerFactory.getLogger()方法。
• 在Spring中，所有工厂都是 BeanFactory的子类。通过对 BeanFactory的实现，我们可以从Spring的容器访问Bean。根据不同的策略调用 getBean()方法，从而获得具体对象。
• Hibernate换数据库只需换方言和驱动就可以切换不同数据库。

建造者模式

建造者模式是创建型模式。

我们在对一个实体类进行属性的get或set的时候，可以通过封装一些常用的构造方法来简化实体类的构造。

比如 Effective Java中文版（第3版） 中举到到这个例子

package builder;

// Effective Java 3th examples
public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      = 0;
        private int fat           = 0;
        private int sodium        = 0;
        private int carbohydrate  = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val) { 
            calories = val;  
            return this;
        }

        public Builder fat(int val) { 
           fat = val;   
           return this;
        }

        public Builder sodium(int val) { 
           sodium = val;  
           return this; 
        }

        public Builder carbohydrate(int val) { 
           carbohydrate = val;  
           return this; 
        }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

其中Builder就是一个内部类，用于构造NutritionFacts的必要信息，外部调用NutritionFacts的构造方法时候，可以这样使用：

NutritionFacts cocaCola=new NutritionFacts.Builder(240,8).calories(100).sodium(35).carbohydrate(27).build();

构造器模式也适用于类层次结构。抽象类有抽象的Builder，具体类有具体的Builder。Effective Java中文版（第3版）
中还有一个例子， 假设我们抽象出一个披萨类，各种各样的披萨均可以继承披萨这个抽象类来实现自己的具体类型的披萨。

Pizza抽象类如下：

package builder;

import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;

// Effective Java 3th examples
public abstract class Pizza {
    public enum Topping {HAM, MUSHROOM, ONION, PEPPER, SAUSAGE}
    final Set<Topping> toppings;
  
    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }
  
        abstract Pizza build();
  
        // Subclasses must override this method to return "this"
        protected abstract T self();
    }

    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // See Item 50
    }
}

其中的Builder方法是抽象的，所以子类需要实现具体的Builder策略，

一种披萨的具体实现NyPizza

import java.util.Objects;

public class NyPizza extends Pizza {
    public enum Size {SMALL, MEDIUM, LARGE}

    private final Size size;

    public static class Builder extends Pizza.Builder<Builder> {
        private final Size size;

        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }

        @Override
        public NyPizza build() {
            return new NyPizza(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }
}

另一种披萨的具体实现Calzone

public class Calzone extends Pizza {
    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
        private boolean sauceInside = false; // Default

        public Builder sauceInside() {
            sauceInside = true;
            return this;
        }

        @Override
        public Calzone build() {
            return new Calzone(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private Calzone(Builder builder) {
        super(builder);
        sauceInside = builder.sauceInside;
    }
}

我们在具体调用的时候，可以通过如下方式：

NyPizza pizza=new NyPizza.Builder(SMALL).addTopping(SAUSAGE).addTopping(ONION).build();
Calzone calzone=new Calzone.Builder().addTopping(HAM).sauceInside().build();

实际应用有非常多，很多组件都提供这样的构造方式，比如OkHttpClient的构造方法：

    public static OkHttpClient create(long connectTimeOut) {
        return new OkHttpClient().newBuilder()
            .connectionSpecs(Arrays.asList(ConnectionSpec.MODERN_TLS, ConnectionSpec.COMPATIBLE_TLS, ConnectionSpec.CLEARTEXT))
            .connectTimeout(connectTimeOut, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(30, TimeUnit.SECONDS)
            .connectionPool(CONNECTION_POOL)
            .retryOnConnectionFailure(true)
            .followRedirects(true)
            .followSslRedirects(true)
            .hostnameVerifier(new HostnameVerifier() {
             @Override
             public boolean verify(String s, SSLSession sslSession) {
                 return true;
             }
         }).cookieJar(new CookieJar() {
             private List<Cookie> cookies;
             @Override
             public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
                 this.cookies = cookies;
             }
             @Override
             public List<Cookie> loadForRequest(HttpUrl url) {
                 if (cookies != null) {
                     return cookies;
                 }
                 return Collections.emptyList();
             }
         }).build();
    }

应用

• JDK中的Calender

Calendar calendar = new Calendar.Builder().build();

• MyBatis中 CacheBuilder.build()和 SqlSessionFactoryBuilder.build()

• Spring中 BeanDefinitionBuilder.getBeanDefinition()方法

原型模式

原型模式是创建型模式。

如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同），在这种情况下，我们可以利用对已有对象（原型）进行复制（或者叫拷贝）的方式来创建新对象，以达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式（Prototype Design Pattern），简称原型模式。

实际上，创建对象包含的申请内存、给成员变量赋值这一过程，本身并不会花费太多时间，或者说对于大部分业务系统来说，这点时间完全是可以忽略的。应用一个复杂的模式，只得到一点点的性能提升，这就是所谓的过度设计，得不偿失。但是，如果对象中的数据需要经过复杂的计算才能得到（比如排序、计算哈希值），或者需要从RPC、网络、数据库、文件系统等非常慢速的 IO 中读取，这种情况下，我们就可以利用原型模式，从其他已有对象中直接拷贝得到，而不用每次在创建新对象的时候，都重复执行这些耗时的操作。

原型模式用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，典型的应用是对象的克隆方法

public class Person implements Cloneable {
    String name = "lisa";
    int age = 1;
    Location loc = new Location("xy", 10);

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person p = (Person) super.clone();
        p.loc = (Location) loc.clone();
        return p;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", loc=" + loc + '}';
    }
}

public class Location implements Cloneable {
    private String street;
    private int roomNo;

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

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

    @Override
    public String toString() {
        return "Location{" + "street='" + street + '\'' + ", roomNo=" + roomNo + '}';
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p = new Person();
        System.out.println(p);
        Person p2 = (Person) p.clone();
        System.out.println(p2);
    }
}

UML图如下：

注：Java自带的 clone（）方法进行的就是浅克隆。而如果我们想进行深克隆，可以直接在 super.clone（）后，手动给克隆对象的相关属性分配另一块内存，不过如果当原型对象维护很多引用属性的时候，手动分配会比较烦琐。因此，在Java中，如果想完成原型对象的深克隆，则通常使用序列化（Serializable）的方式。

使用示例

克隆一个巨大的HashMap，如果构建散列表的代价很大，我们可以通过

1. HashMap的clone方法（注意：默认的clone方法是浅拷贝，需要递归拷贝HashMap里面的内容，直到类型是基础类型为止）
2. 使用序列化方式克隆

如果只是增量拷贝，可以通过浅拷贝拿到一个新的HashMap，然后拿到增量的数据单独进行深拷贝即可。

Spring中创建对象的方式默认采用单例模式，可以通过设置 @Scope("prototype")注解将其改为原型模式。

代理模式

代理模式是结构型模式。

静态代理

举例说明，假设我们需要在某个类的某段代码的前后加上日志记录，我们就可以通过静态代理的方式实现

public class Main {
    public static void main(String[] args) {
        new Tank().move();
    }
}

假设我们需要在move方法的前后都加上日志记录，我们可以设置一个代理类

public class TankLogProxy implements Moveable {
    private Moveable m;

    public TankLogProxy(Moveable m) {
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("log before");
        m.move();
        System.out.println("log after");
    }
}

这样的话，原先的调用就改成了：

public class Main {
    public static void main(String[] args) {
        new TankLogProxy(new Tank()).move();
    }
}

即可实现在move方法调用前后加入日志记录的操作。

UML图如下：

动态代理

JDK自带

如果需要通过动态代理（jdk自带的方式）的方式来完成上述功能，我们可以这样来做

public class MovableProxy implements InvocationHandler {
    private Movable movable;

    public MovableProxy(Movable movable) {
        this.movable = movable;
    }

    public void before() {
        System.out.println("before , do sth");
    }

    public void after() {
        System.out.println("after , do sth");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object o = method.invoke(movable, args);
        after();
        return o;
    }
}

主方法调用的时候：

package proxy.dynamic.jdk;

import java.lang.reflect.Proxy;

/**
 * @author Grey
 * @date 2020/4/15
 */
public class Main {
    public static void main(String[] args) {
        Movable tank = new Tank();

        //reflection 通过二进制字节码分析类的属性和方法

        Movable m = (Movable) Proxy.newProxyInstance(Movable.class.getClassLoader(),
                new Class[]{Movable.class},
                new MovableProxy(tank)
        );

        m.move();
        m.go();
    }
}

UML图如下：

Cglib

JDK自带的方式实现动态代理需要被代理对象实现一个接口，Cglib不需要，使用示例：

其中被代理的Tank类无需实现接口

public class Tank {
    public void move() {
        System.out.println("tank move");
    }
    public void go() {
        System.out.println("tank go");
    }
}

import net.sf.cglib.proxy.Enhancer;

public class Main {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //设置目标类的字节码文件
        enhancer.setSuperclass(Tank.class);
        //设置回调函数
        enhancer.setCallback(new MyMethodInterceptor());

        //这里的creat方法就是正式创建代理类
        Tank m = (Tank) enhancer.create();
        m.move();
        m.go();
    }
}

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        before();
        Object o = proxy.invokeSuper(obj, args);
        after();
        return o;
    }

    public void before() {
        System.out.println("before , do sth");
    }

    public void after() {
        System.out.println("after , do sth");
    }
}

实际应用

• 在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志,缓存。我们将这些附加功能与业务功能解耦，放到代理类中统一处理。
• RPC框架可以看成一种代理模式。
• Spring AOP
  • JdkDynamicAopProxy
  • CglibAopProxy
  • 可以使用 <aop:aspectj-autoproxy proxy-target-class="true">配置强制使用Cglib动态代理
• jdk自带
  • 底层是使用ASM操作二进制码
  • Java Instrumentation
  • 必须面向接口
• cglib
  • final类不行，代理类的子类 底层也是ASM机制。

桥接模式

桥接模式是一种结构型模式。

使用桥接模式，可以将抽象和具体的发展单独分支(抽象中持有一个具体的引用)
举例说明：

GG在追MM的时候，可以送书和花两种礼物

public class GG {
    public void chase(MM mm) {
        Gift g = new WarmGift(new Flower());
        give(mm, g);
    }

    public void give(MM mm, Gift g) {
        System.out.println(g + "gived!");
    }
}

如上代码，Flower被包装成了一个WarmGift送给MM，WarmGift和WildGift都是Gift的一种抽象，Flower和Book都算Gift的一种具体实现, 我们让Gift这个抽象类中，持有一个GiftImpl的引用

public abstract class Gift {
    protected GiftImpl impl;
}

public class Flower extends GiftImpl {
}

public class WarmGift extends Gift {
    public WarmGift(GiftImpl impl) {
        this.impl = impl;
    }
}

UML示例图如下：

如果说代理模式是一个类与另一个类的组合，那么桥接模式是一组类和另外一组类的组合。

桥接模式的应用

• jdbc驱动配置

当我们把具体的Driver实现类（比如: com.mysql.jdbc.Driver）注册到DriverManager之后，后续所有对JDBC接口的调用，都会委派到对具体的Driver实现类来执行。而Driver实现类都实现了相同的接口（java.sql.Driver），这也是可以灵活切换Driver的原因。

装饰器模式

装饰器模式是一种结构型模式。

顾名思义，就是对某个方法或者对象进行装饰，举个简单的例子，有个圆形类（Circle），我需要把这个圆形的涂上红色，其实就是新增一个装饰器来装饰这个圆形类。如果要让装饰器通用一些，可以处理圆形类对应的抽象类Sharp，那么对于任意Sharp的子类，都可以用红色装饰器来涂红色。

我们先定义Sharp这个抽象类：

public abstract class Sharp {
    protected abstract void draw();
}

然后我们定义Sharp的装饰类SharpDecorator,这个类是所有装饰器类的抽象类，后续的装饰器只需要实现这个抽象类就可以对Sharp进行各种装饰了，

public abstract class SharpDecorator extends Sharp {
    protected Sharp decoratedSharp;

    public SharpDecorator(Sharp decoratedSharp) {
        this.decoratedSharp = decoratedSharp;
    }
}

红色装饰器实现这个抽象类即可：

public class RedSharpDecorator extends SharpDecorator {
    public RedSharpDecorator(Sharp decoratedSharp) {
        super(decoratedSharp);
    }

    private static void redIt() {
        System.out.println("[RED]");
    }

    @Override
    protected void draw() {
        redIt();
        this.decoratedSharp.draw();
        redIt();
    }
}

主方法调用的时候只需要：

new RedSharpDecorator(new Circle()).draw();

UML图如下：

说明：

1. 装饰器类和原始类继承同样的父类，这样我们可以对原始类“嵌套”多个装饰器类。

2. 装饰器类是对功能的增强，这也是装饰器模式应用场景的一个重要特点。符合“组合关系”这种代码结构的设计模式有很多，比如代理模式、桥接模式，还有现在的装饰器模式。尽管它们的代码结构很相似，但是每种设计模式的意图是不同的。就拿比较相似的代理模式和装饰器模式来说，代理模式中，代理类附加的是跟原始类无关的功能，而在装饰器模式中，装饰器类附加的是跟原始类相关的增强功能。

实际上，如果去查看JDK的源码，你会发现，BufferedInputStream、DataInputStream并非继承自InputStream，而是另外一个叫FilterInputStream的类。那这又是出于什么样的设计意图，才引入这样一个类呢？

因为InputStream是一个抽象类而非接口，而且它的大部分函数（比如 read()、available()）都有默认实现，按理来说，我们只需要在 BufferedInputStream 类中重新实现那些需要增加缓存功能的函数就可以了，其他函数继承 InputStream的默认实现。但实际上，这样做是行不通的。对于即便是不需要增加缓存功能的函数来说，BufferedInputStream还是必须把它重新实现一遍，简单包裹对 InputStream 对象的函数调用。那 BufferedInputStream 类就无法将最终读取数据的任务，委托给传递进来的InputStream对象来完成，DataInputStream也存在跟 BufferedInputStream同样的问题。为了避免代码重复，Java IO抽象出了一个装饰器父类 FilterInputStream，InputStream 的所有的装饰器类（BufferedInputStream和 DataInputStream）都继承自这个装饰器父类。这样，装饰器类只需要实现它需要增强的方法就可以了，其他方法继承装饰器父类的默认实现。

装饰器模式的应用

• Java中的IO流， Read/InputStream ,Write/OutputStream

• JDK中的 UnmodifiableCollection

• Spring中的 HttpHeadResponseDecorator, 还有对 Cache的装饰类 TransactionAwareCacheDecorator

适配器模式

适配器模式是一种结构型模式。

举例说明，假设有一个播放器，需要根据不同格式以及对应的文件来播放，接口设计如下：

public interface MediaPlayer {
    void play(String type, String fileName);
}

不同类型的播放器只需要实现这个接口即可，比如我们有一个ClassicMediaPlayer，这个只能播放mp3类型的文件

public class ClassicMediaPlayer implements MediaPlayer {
    @Override
    public void play(String type, String fileName) {
        if ("mp3".equalsIgnoreCase(type)) {
            System.out.println("play mp3");
        } else {
            System.out.println("not supported format");
        }
    }
}

如果我想扩展，我们可以增加一个适配器：

public class PlayerAdapter implements MediaPlayer {
    private AdvanceMediaPlayer advanceMediaPlayer;

    public PlayerAdapter(String type) {
        if ("mp4".equalsIgnoreCase(type)) {
            advanceMediaPlayer = new MP4Player();
        } else if ("AVI".equalsIgnoreCase(type)) {
            advanceMediaPlayer = new AVIPlayer();
        }
    }

    @Override
    public void play(String type, String fileName) {
        if ("mp4".equalsIgnoreCase(type)) {
            advanceMediaPlayer.playMP4(fileName);
        } else if ("AVI".equalsIgnoreCase(type)) {
            advanceMediaPlayer.playAVI(fileName);
        } else {
            new ClassicMediaPlayer().play(type, fileName);
        }
    }
}

这个适配器就是根据不同类型来构造不同的播放器的，然后定义一个ExtendMediaPlayer，在里面持有PlayAdapter，这样，ExtendMediaPlayer就拥有了播放不同类型文件的能力，所以我们在调用的时候，只需要：

ExtendMediaPlayer audioPlayer=new ExtendMediaPlayer();
audioPlayer.play("mp3","beyond the horizon.mp3");
audioPlayer.play("mp4","alone.mp4");
audioPlayer.play("avi","far far away.vlc");

UML图如下：

适配器模式：适配器模式是一种事后的补救策略。适配器提供跟原始类不同的接口，而代理模式、装饰器模式提供的都是跟原始类相同的接口。

适配器模式的应用

• java.io

• jdbc-odbc bridge

• ASM transformer

• 老版本的JDK提供了Enumeration类来遍历容器。新版本的JDK用Iterator类替代Enumeration类来遍历容器。

/**
 * Returns an enumeration over the specified collection.  This provides
 * interoperability with legacy APIs that require an enumeration
 * as input.
 *
 * @param  <T> the class of the objects in the collection
 * @param c the collection for which an enumeration is to be returned.
 * @return an enumeration over the specified collection.
 * @see Enumeration
 */
public static <T> Enumeration<T> enumeration(final Collection<T> c) {
  return new Enumeration<T>() {
    private final Iterator<T> i = c.iterator();

    public boolean hasMoreElements() {
      return i.hasNext();
    }

    public T nextElement() {
      return i.next();
    }
  };
}

使用Enumeration遍历容器方法示例

public class TestEnumeration {
    public static void main(String[] args) {
        Vector<String> v = new Vector<>();
        v.addElement("Lisa");
        v.addElement("Billy");
        v.addElement("Mr Brown");
        Enumeration<String> e = v.elements();// 返回Enumeration对象
        while (e.hasMoreElements()) {
            String value = (String) e.nextElement();// 调用nextElement方法获得元素
            System.out.print(value);
        }
    }
}

门面模式

门面模式是一种结构型模式。

门面模式为子系统提供一组统一的接口，定义一组高层接口让子系统更易用。

假设建造一个房子需要有如下三个步骤：

第一步，和泥

第二步，搬砖

第三步，砌墙

如果每次我们制造一个房子都要分别调用这三个方法，就会比较麻烦一些，我们可以设置一个门面，这个门面封装了这三个步骤，后续建造房子，只需要调用这个门面即可。

和泥

public class Mason {
    public void mix() {
        System.out.println("我和好泥了!");
    }
}

搬砖

public class BrickWorker {
    public void carry() {
        System.out.println("我搬好砖了!");
    }
}

砌墙

public class BrickLayer {
    public void neat() {
        System.out.println("我砌好墙了!");
    }
}

门面

public class LabourConstractor {
    private Mason work1 = new Mason();
    private BrickWorker work2 = new BrickWorker();
    private BrickLayer work3 = new BrickLayer();

    public void buildHouse() {
        work1.mix();
        work2.carry();
        work3.neat();
    }
}

这样主函数只需要调用门面的buildHourse()方法，就可以建造一个房子了

public class Client {
    public static void main(String[] args) {
        LabourConstractor labour = new LabourConstractor();
        labour.buildHouse();
    }
}

门面模式的UML图如下

门面模式应用

• Linux的系统调用和Shell脚本

Linux系统调用函数就可以看作一种“门面”。它是Linux操作系统暴露给开发者的一组“特殊”的编程接口，它封装了底层更基础的Linux内核调用。再比如，Linux的Shell命令，实际上也可以看作一种门面模式的应用。它继续封装系统调用，提供更加友好、简单的命令，让我们可以直接通过执行命令来跟操作系统交互。

• Spring JDBC中的 JdbcUtils类，包装了JDBC相关的所有操作。

• Tomcat中的 RequestFacade, ResponseFacade, StandardSessionFacade。

组合模式

组合模式是一种结构型模式。

组合模式中，最常用的一个用法就是目录层级的遍历，话不多说，直接上代码，主方法中

public class Main {
    public static void main(String[] args) {
        BranchNode root = new BranchNode("root");
        BranchNode branch1 = new BranchNode("branch1");
        BranchNode branch2 = new BranchNode("branch2");
        branch1.addNode(new LeafNode("leaf1"));
        root.addNode(branch1);
        root.addNode(branch2);
        tree(root, 0);
    }
}

其中，BranchNode为分支节点，LeafNode是叶子节点 达到的效果就是打印如下的形式

root
--branch1
----leaf1
--branch2

递归方法

    static void tree(Node node, int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("--");
        }
        node.print();
        if (node instanceof BranchNode) {
            for (Node n : ((BranchNode) node).getNodes()) {
                tree(n, depth + 1);
            }
        }
    }

其中BranchNode和LeafNode都实现了Node接口，Node接口(也可以为定义抽象类)仅提供了一个属性(content属性，用于标识节点内容)和一个打印方法：

public abstract class Node {
    protected String content;

    protected abstract void print();
}

BranchNode下可以包含多个Node，因为一个分支下面可以有多个分支（这个分支可以是任意的Node子类)

public class BranchNode extends Node {
    private List<Node> nodes = new ArrayList<>();

    public BranchNode(String content) {
        this.content = content;
    }

    @Override
    public void print() {
        System.out.println(content);
    }    // get..set方法略 
}

组合模式的UML图如下：

组合模式的应用

MyBatis解析各种Mapping文件中的SQL语句时，设计了一个非常关键的类叫作SqlNode，XML中的每一个Node都会被解析为一个SqlNode对象，最后把所有SqlNode都拼装到一起，就成为一条完整的SQL语句。

享元模式

享元模式是一种结构型模式。

运用共享技术有效地支持大量细粒度的对象。主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

假设我们有一个子弹类,同时我们设计一个子弹池，子弹池负责提供子弹

public class BulletPool {
    List<Bullet> bullets = new ArrayList<>();
    {
        for (int i = 0; i < 10; i++) {
            bullets.add(new Bullet(true));
        }
    }
    public Bullet getBullet() {
        for (int i = 0; i < bullets.size(); i++) {
            if (bullets.get(i).living) {
                return bullets.get(i);
            }
        }
        return new Bullet(true);
    }
}

可以看到getBullet逻辑，如果池子中有子弹，就拿池中的子弹，如果没有，就new一个新的子弹返回。

UML图如下

享元模式应用

• 使用对象池对高并发下的内存进行管理

对于开发者来说，垃圾回收是不可控的，而且是无法避免的。但是，我们还是可以通过一些方法来降低垃圾回收的频率，减少进程暂停的时长。我们知道，只有使用过被丢弃的对象才是垃圾回收的目标，所以，我们需要想办法在处理大量请求的同时，尽量少的产生这种一次性对象。最有效的方法就是，优化你的代码中处理请求的业务逻辑，尽量少的创建一次性对象，特别是占用内存较大的对象。比如说，我们可以把收到请求的Request对象在业务流程中一直传递下去，而不是每执行一个步骤，就创建一个内容和Request对象差不多的新对象。这里面没有多少通用的优化方法。对于需要频繁使用，占用内存较大的一次性对象，我们可以考虑自行回收并重用这些对象。实现的方法是这样的：我们可以为这些对象建立一个对象池。收到请求后，在对象池内申请一个对象，使用完后再放回到对象池中，这样就可以反复地重用这些对象，非常有效地避免频繁触发垃圾回收。

• Java中Boolean的valueOf(boolean b) 方法 ，这个方法返回的Boolean对象不会新new出来，而是复用的同一个, 源码如下：

public static Boolean valueOf(boolean b){
    return(b?TRUE:FALSE);
}
public static final Boolean TRUE=new Boolean(true);
public static final Boolean FALSE=new Boolean(false);

• 连接池管理，例如：Apache Commons Pool

• IntegerCache和String

在Java Integer的实现中，-128到127之间的整型对象会被事先创建好，缓存在IntegerCache类中。当我们使用自动装箱或者valueOf()来创建这个数值区间的整型对象时，会复用IntegerCache类事先创建好的对象。这里的IntegerCache类就是享元工厂类，事先创建好的整型对象就是享元对象。在Java String类的实现中，JVM开辟一块存储区专门存储字符串常量，这块存储区叫作字符串常量池，类似于 Integer中的IntegerCache。不过，跟IntegerCache不同的是，它并非事先创建好需要共享的对象，而是在程序的运行期间，根据需要来创建和缓存字符串常量

注：Java提供了两个配置IntegerCache的参数

//方法一：
-Djava.lang.Integer.IntegerCache.high=255
//方法二：
-XX:AutoBoxCacheMax=255

观察者模式

观察者模式是一种行为型模式。在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

一般可以用做事件处理往往和责任链模式搭配使用, 举个例子 按钮上一般都可以绑定事件，当我们按下按钮的时候，可以触发这些事件的执行，这里就可以用观察者模式来做, 我们先定义按钮这个对象

public class Button {
    private List<ActionListener> listeners = new ArrayList<>();

    public void addActionListener(ActionListener listener) {
        this.listeners.add(listener);
    }

    @Override
    public String toString() {
        return "Button{" + "listeners=" + listeners + '}';
    }

    public void buttonPressed() {
        ActionEvent event = new ActionEvent(System.currentTimeMillis(), this);
        listeners.forEach(item -> item.actionPerformed(event));
    }
}

由上可知，Button中持有了一个列表，这个列表里面装的就是所有事件的列表，我们可以把事件绑定到这个按钮的事件列表中，这样就可以实现按钮执行press操作的时候，把对应的事件触发执行了

public interface ActionListener {
    void actionPerformed(ActionEvent event);
}

模拟两个监听事件

public class Listener1 implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent event) {
        System.out.println("Listener 1 listened it source: [" + event.getSource() + "], when is [" + event.getWhen() + "]");
    }
}

public class Listener2 implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent event) {
        System.out.println("Listener 2 listened it source: [" + event.getSource() + "], when is [" + event.getWhen() + "]");
    }
}

主方法在调用的时候

public class Main {
    public static void main(String[] args) {
        Button button = new Button();
        button.addActionListener(new Listener1());
        button.addActionListener(new Listener2());
        button.buttonPressed();
    }
}

当执行

button.buttonPressed()

的时候，对应的listener1和listener2就可以执行了。

UML图如下

观察者模式的应用

• Spring ApplicationEvent

• 邮件订阅、RSS Feeds，本质上都是观察者模式。

• Google Guava EventBus

模板方法

模板方法是一种行为型模式。

假设我们要实现一个游戏，这个游戏有初始化，启动，结束三个方法，我们可以定义一个游戏的模板：

public abstract class Game {
    protected abstract void init();

    protected abstract void start();

    protected abstract void end();

    protected final void play() {
        init();
        start();
        end();
    }
}

每种类似这样结构（有初始化，启动，结束）的游戏都可以继承这个类来实现这三个方法，比如BasketballGame

public class BasketballGame extends Game {
    @Override
    protected void init() {
        System.out.println("basketball init");
    }

    @Override
    protected void start() {
        System.out.println("basketball start");
    }

    @Override
    protected void end() {
        System.out.println("basketball end");
    }
}

FootballGame

public class FootballGame extends Game {
    @Override
    protected void init() {
        System.out.println("football init");
    }

    @Override
    protected void start() {
        System.out.println("football start");
    }

    @Override
    protected void end() {
        System.out.println("football end");
    }
}

主方法在调用的时候，直接：

Game basketballGame=new BasketballGame();
basketballGame.play();
Game footballGame=new FootballGame();
footballGame.play();

另外一个例子：

public abstract class TestCase {
    public void run() {
        if (doTest()) {
            System.out.println("Test succeed.");
        } else {
            System.out.println("Test failed.");
        }
    }

    public abstract boolean doTest();
}

public class JunitApplication {
    private static final List<TestCase> testCases = new ArrayList<>();

    public static void register(TestCase testCase) {
        testCases.add(testCase);
    }

    public static final void main(String[] args) {
        for (TestCase c : testCases) {
            c.run();
        }
    }
}

public class UserServiceTest extends TestCase {

    @Override
    public boolean doTest() {
        System.out.println("do test...");
        return false;
    }

}

UML图如下：

模板方法实际应用场景

• 钩子函数

• Spring中的RestTemplate、JDBCTemplate等。

• Collections.sort()方法也可以看成模板方法。

• AbstractList定义了一些模板方法，ArrayList作为子类实现了对应的模板方法。

• MyBatis中的BaseExecutor定义了模板方法，子类ReuseExecutor、SimpleExecutor、BatchExecutor和ClosedExecutor实现了对应的模板方法

• Redission的红锁和联锁设计。

策略模式

实例： 假设我们有一个猫类，这个类里面有体重和身高这两个属性，给你一个猫的集合，然后需要你按猫的体重从小到大排序

思路： 我们可以把体重从小到大这个看成是一个策略，后续可能衍生其他的策略，比如： 按身高从高到低，体重从小到大，体重一样的身高从高到低

以身高从低到高排序这个策略为例

public class CatSortStrategy implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.getHeight() - o2.getHeight();
    }
}

假设我们定义猫排序的方法是: sort 那么这个方法必然需要传入一个排序策略的参数（否则我怎么知道要怎么排序猫？） 所以定义的sort方法可以是：

public class Sorter {
    public Cat[] sort(Cat[] items, Comparator<Cat> strategy) {
        int length = items.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (strategy.compare(items[i], items[j]) > 0) {
                    Cat tmp = items[i];
                    items[i] = items[j];
                    items[j] = tmp;
                }
            }
        }
        return items;
    }
}

进一步抽象，如果我想让Sorter这个工具类不仅可以对猫进行各种策略的排序(基于比较的排序算法)，还可以对狗进行各种策略的排序(基于比较排序算法)，可以将Sorter定义成泛型

public class Sorter<T> {
    public T[] sort(T[] items, Comparator<T> strategy) {
        int length = items.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (strategy.compare(items[i], items[j]) > 0) {
                    T tmp = items[i];
                    items[i] = items[j];
                    items[j] = tmp;
                }
            }
        }
        return items;
    }
}

调用的时候, 泛型版本的Sorter可以对猫和狗都进行基于特定排序策略的排序。

Sorter<Cat> sorter = new Sorter<>();
Cat[] sortedCats = sorter.sort(cats,new CatSortStrategy());
Sorter<Dog> sorter = new Sorter<>();
Dog[] sortedCats = sorter.sort(dogs,new DogSortStrategy());

策略模式UML图如下

策略模式的应用

• Spring中的Resource接口。

责任链模式

责任链模式是一种行为型模式。

有一段文本需要过滤敏感字，我们可以通过责任链模式来设计这个功能，假设文本是scripts Hell World! 996

我们有多个过滤规则，比如第一个规则是：过滤scripts这个关键字(实际的规则可能很复杂，目前只是举这个简单例子来说明情况)
第二个规则是：过滤996这个关键字

我们可以抽象一个Filter接口，各种过滤规则无非就是实现这个接口即可

public interface Filter {
    boolean doFilter(Msg msg);
}

过滤 996 的规则：

public class SensitiveFilter implements Filter {
    @Override
    public boolean doFilter(Msg msg) {
        msg.setContent(msg.getContent().replace("996", ""));
        return true;
    }
}

过滤 scripts 的规则：

public class HTMLFilter implements Filter {
    @Override
    public boolean doFilter(Msg msg) {
        msg.setContent(msg.getContent().replace("scripts", ""));
        return true;
    }
}

主方法调用的时候，就直接New 相应的Filter来处理即可：

Msg msg=new Msg();
msg.setContent("scripts Hell World! 996");
System.out.println("before filter , the content is : "+msg.getContent());
Filter html=new HTMLFilter();
Filter sensitive=new SensitiveFilter();
html.doFilter(msg);
sensitive.doFilter(msg);
System.out.println("after filter , the content is : "+msg.getContent());

不过，更为优雅的一种方式是设计一个FilterChain，我们把所有的Filter都加入到这个FilterChain里面，对于Msg直接去调用FilterChain的过滤方法即可把FilterChain中的所有Filter都执行(
而且还可以很灵活指定Filter顺序)

package cor;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Grey
 * @date 2020/4/13
 */
public class FilterChain implements Filter {
    private List<Filter> filters = new ArrayList<>();

    public FilterChain addFilter(Filter filter) {
        filters.add(filter);
        return this;
    }

    @Override
    public boolean doFilter(Msg msg) {
        for (Filter filter : filters) {
            if (!filter.doFilter(msg)) {
                return false;
            }
        }
        return true;
    }
}

那么主方法在调用的时候，可以直接通过如下的方式：

public class Main {
    public static void main(String[] args) {
        FilterChain filterChain = new FilterChain();
        filterChain.addFilter(new HTMLFilter()).addFilter(new SensitiveFilter());
        Msg msg = new Msg();
        msg.setContent("scripts Hell World! 996");
        System.out.println("before filter , the content is : " + msg.getContent());
        filterChain.doFilter(msg);
        System.out.println("after filter , the content is : " + msg.getContent());
    }
}

UML图如下：

责任链模式应用

• Servlet filter

• Structs interceptor

• SpringMVC interceptor

• Dubbo Filter

• Netty ChannelPipeline

状态模式

状态模式是一种行为型模式。

对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

举个例子，Person有Cry, Smile, Say三种行为，但是在不同状态(SadState, HappyState)下，这三种行为不一样，

public class Person {
    private State state;

    public Person(State state) {
        this.state = state;
    }

    void cry() {
        state.cry();
    }

    void smile() {
        state.smile();
    }

    void say() {
        state.say();
    }
}

在Sad状态下，行为可能是：

public class SadState implements State {
    @Override
    public void cry() {
        System.out.println("Sad cry");
    }

    @Override
    public void smile() {
        System.out.println("Sad smile");
    }

    @Override
    public void say() {
        System.out.println("Sad say");
    }
}

Happy状态下同理，那么主方法在调用的时候：

public class Main {
    public static void main(String[] args) {
        Person person = new Person(new SadState());
        person.cry();
        person.say();
        person.smile();
        person = new Person(new HappyState());
        person.cry();
        person.say();
        person.smile();
    }
}

Person就可以根据不同的状态来执行cry，say，smile的行为了

UML图如下：

状态模式的应用

• Spring中的StateMachine

迭代器模式

迭代器模式是一种行为型模式。

迭代器最典型的应用是容器遍历

模仿JDK的容器，我们自定义一个容器并实现iterator方法 我们先定义一个容器接口：Collection_.java

public interface Collection_<E> {
    int size();

    void add(E element);

    Iterator_<E> iterator();
}

里面包括了一个iterator方法，所以每个实现这个容器接口的具体容器类型，都必须自定义iterator方法, 然后定义一个Iterator接口Iterator_.java, 具体容器中可以增加一个内部类来专门实现这个接口，比如我们的具体容器类是ArrayList_.java

package Iterator;

import static java.lang.System.arraycopy;

/**
 * @author Grey
 * @date 2020/4/15
 */
public class ArrayList_<E> implements Collection_<E> {
    private E[] objects = (E[]) new Object[10];
    private int index = 0;

    @Override
    public int size() {
        return index;
    }

    @Override
    public void add(E element) {
        if (objects.length == size()) {
            // 满了就扩容为原来的两倍
            E[] newObjects = (E[]) new Object[objects.length * 2];
            arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }
        objects[index] = element;
        index++;
    }

    @Override
    public Iterator_<E> iterator() {
        return new ArrayListIterator_<>();
    }

    private class ArrayListIterator_<E> implements Iterator_<E> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < index;
        }

        @Override
        public E next() {
            E o = (E) objects[currentIndex];
            currentIndex++;
            return o;
        }
    }

}

我们主要看 ArrayListIterator_.java这个内部类，里面其实是实现了 Iterator_ 这个接口，所以 ArrayList_ 的遍历操作会执行这个内部类中的操作规则来对其进行遍历。

如何实现一个快照迭代器

我们可以在容器中，为每个元素保存两个时间戳，一个是添加时间戳 addTimestamp，一个是删除时间戳 delTimestamp。当元素被加入到集合中的时候，我们将 addTimestamp 设置为当前时间，将 delTimestamp 设置成最大长整型值（Long.MAX_VALUE）。当元素被删除时，我们将 delTimestamp 更新为当前时间，表示已经被删除。注意，这里只是标记删除，而非真正将它从容器中删除。同时，每个迭代器也保存一个迭代器创建时间戳 snapshotTimestamp，也就是迭代器对应的快照的创建时间戳。当使用迭代器来遍历容器的时候，只有满足addTimestamp < snapshotTimestamp < delTimestamp的元素，才是属于这个迭代器的快照。如果元素的addTimestamp > snapshotTimestamp，说明元素在创建了迭代器之后才加入的，不属于这个迭代器的快照；如果元素的delTimestamp < snapshotTimestamp，说明元素在创建迭代器之前就被删除掉了，也不属于这个迭代器的快照。这样就在不拷贝容器的情况下，在容器本身上借助时间戳实现了快照功能。

迭代器模式应用

MyBatis中的DefaultCursor，它实现了Cursor接口，而且定义了一个成员变量cursorIterator，其定义的类型为CursorIterator。继续查看CursorIterator类的源码实现，它是DefaultCursor的一个内部类，并且实现了JDK中的Iterator接口。

访问者模式

访问者模式是一种行为型模式。

访问者模式在结构不变的情况下动态改变对于内部元素的动作，举例说明：

假设我们需要构造一台电脑，有主板（Board），CPU，内存（Memory），但是针对企业用户和个人用户，电脑组件的价格是不一样的，我们需要根据不同客户获取一台电脑的总价格。

我们先抽象出电脑组件这个类

public abstract class ComputerPart {
    abstract void accept(Visitor visitor);

    abstract int getPrice();
}

每个具体组件会继承这个抽象类,以主板(Board)为例

public class Board extends ComputerPart {
    @Override
    void accept(Visitor visitor) {
        visitor.visitBoard(this);
    }

    @Override
    int getPrice() {
        return 20;
    }
}

抽象出一个访问者(Visitor)接口，

public interface Visitor {
    void visitCPU(CPU cpu);

    void visitBoard(Board board);

    void visitMemory(Memory memory);
}

每个具体类型的访问者实现这个接口，然后定义其不同的价格策略，以公司访问者为例(CorpVisitor)

public class CorpVisitor implements Visitor {
    private int totalPrice;

    @Override
    public void visitCPU(CPU cpu) {
        totalPrice += cpu.getPrice() - 1;
    }

    @Override
    public void visitBoard(Board board) {
        totalPrice += board.getPrice() - 2;
    }

    @Override
    public void visitMemory(Memory memory) {
        totalPrice += memory.getPrice() - 3;
    }

    public int getTotalPrice() {
        return totalPrice;
    }
}

个人访问者(PersonalVisitor）类似

主方法调用

package visitor;

/**
 * @author Grey
 * @date 2020/4/16
 */
public class Main {
    public static void main(String[] args) {
        ComputerPart cpu = new CPU();
        ComputerPart memory = new Memory();
        ComputerPart board = new Board();
        PersonalVisitor personalVisitor = new PersonalVisitor();
        cpu.accept(personalVisitor);
        memory.accept(personalVisitor);
        board.accept(personalVisitor);
        System.out.println(personalVisitor.getTotalPrice());

        ComputerPart cpu2 = new CPU();
        ComputerPart memory2 = new Memory();
        ComputerPart board2 = new Board();
        CorpVisitor corpVisitor = new CorpVisitor();
        cpu2.accept(corpVisitor);
        memory2.accept(corpVisitor);
        board2.accept(corpVisitor);
        System.out.println(corpVisitor.getTotalPrice());
    }
}

UML图如下

jdk中的FileVisitor使用了访问者模式，使用示例

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;

/**
 * @author <a href="mailto:410486047@qq.com">GreyZeng</a>
 * @version 1.0, 2022/8/11
 */
public class FileVisitorTest {
    public static void main(String[] args) throws IOException {
        // 使用FileVisitor对目录进行遍历
        // 访问当前目录的所有文件
        Files.walkFileTree(Paths.get("."), new SimpleFileVisitor<Path>() {

            // 在访问子目录前触发该方法
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("正在访问" + dir + "目录");
                return FileVisitResult.CONTINUE;
            }

            // 在访问文件时触发该方法
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("正在访问" + file + "文件");
                return FileVisitResult.CONTINUE;
            }

            // 在访问失败时触发该方法
            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
                // 写一些具体的业务逻辑
                return super.visitFileFailed(file, exc);
            }

            // 在访问目录之后触发该方法
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                // 写一些具体的业务逻辑
                return super.postVisitDirectory(dir, exc);
            }
        });
    }
}

访问者模式其他应用

• 做编译器的时候，需要生成AST，进行类型检查 根据抽象语法树，生成中间代码

• XML文件解析

• Spring中的BeanDefinitionVisitor

备忘录模式

备忘录模式是一种行为型模式。

用于记录对象的某个瞬间 类似快照 应用实例：

• 游戏中的后悔药。

• 打游戏时的存档。

• Windows里的ctr + z。

• 浏览器的后退功能。

一个简单的示例

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "zhangsan";
        person.age = 12;
        new Main().save(person);
        new Main().load();
    }

    public void save(Person person) {
        File c = new File("/tank.data");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(c));) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void load() {
        File c = new File("/tank.data");
        try (ObjectInputStream oos = new ObjectInputStream(new FileInputStream(c));) {
            Person myTank = (Person) oos.readObject();
            System.out.println(myTank);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

UML图：

备忘录模式应用

Spring中StateManageableMessageContext.createMessagesMemento（）

命令模式

命令模式是一种行为型模式。

通过调用者调用接受者执行命令，顺序：调用者→命令→接受者，比如：CopyCommand中的doit方法，就是执行这个copy的命令，undo就是撤销上一次执行的命令，我们可以抽象出Command这个接口：

public interface Command {
    void doit();

    void undo();
}

CopyCommand实现这个接口，并实现doit和undo这两个方法，其他的命令也可以类似的实现出来

public class CopyCommand implements Command {
    private Content content;

    public CopyCommand(Content content) {
        this.content = content;
    }

    @Override
    public void doit() {
        content.msg = content.msg + content.msg;
    }

    @Override
    public void undo() {
        content.msg = content.msg.substring(0, content.msg.length() / 2);
    }
}

UML图如下

命令模式应用

• 结合责任链模式实现多次undo。

• 结合组合模式实现宏命令。

• 结合记忆模式实现事务回滚。

解释器模式

解释器模式是一种行为型模式。

解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器用来处理这个语法。

一般用于脚本语言解释器

示例：如何实现一个自定义接口告警规则功能？

一般来讲，监控系统支持开发者自定义告警规则，比如我们可以用下面这样一个表达式，来表示一个告警规则，它表达的意思是：每分钟API总出错数超过100或者每分钟API总调用数超过10000就触发告警。

api_error_per_minute > 100 || api_count_per_minute > 10000

在监控系统中，告警模块只负责根据统计数据和告警规则，判断是否触发告警。至于每分钟API接口出错数、每分钟接口调用数等统计数据的计算，是由其他模块来负责的。其他模块将统计数据放到一个Map中（数据的格式如下所示），发送给告警模块。接下来，我们只关注告警模块。

Map<String, Long> apiStat = new HashMap<>();
apiStat.put("api_error_per_minute", 103);
apiStat.put("api_count_per_minute", 987);

为了简化讲解和代码实现，我们假设自定义的告警规则只包含||、&&、>、<、==这五个运算符，其中，>、<、==运算符的优先级高于||、&&运算符，&&运算符优先级高于||。在表达式中，任意元素之间需要通过空格来分隔。除此之外，用户可以自定义要监控的 key，比如前面的 api_error_per_minute、api_count_per_minute。