设计模式的简单整理

Gof 的23种设计模式，个人理解偏多。

• 2022/06/15 更新七大法则描述
• 2022/06/16 更新全部创建型模式描述
• 2022/06/18 更新代理模式和装饰器模式描述
• 迭代器模式、访问者模式、备忘录模式、解释器模式暂时忽略

设计模式的七大法则

说是法则，但是有些不必完全遵守。

以上我理解中的七大法则之间的关系。

设计模式的最终目的：低耦合性，易于扩展，高复用且高稳定性。

开闭原则

开闭原则是最基本的原则之一，可以简单理解为对扩展开放，对修改关闭。

在我的理解中开闭原则是所有设计模式的基础，只有认同开闭原则才会有以下的其他模式。

对于修改关闭，而对扩展开放，扩展的主要手段就是组合和继承，因此其他的原则或者法则都是对这两种扩展方式的约束。

模板方法模式，策略模式就能能很好的体现开闭原则。

模板方法模式中，原始的算法逻辑定义在上层抽象类中，任何的扩展都是继承并实现其中的抽象方法，是通过继承扩展的一种。

里氏替换原则

替换就是指在所有使用父类的地方，可以用子类代替，因此也要求子类不该修改父类的逻辑，如果实际情况违背了里氏替换原则，则表明抽象不合理，父类并不能代表全部的子类特性。

合成复用原则

该原则规定，除非共性固定且突出，否则都应该要尽量使用聚合（组合）关联关系来代替继承关系来实现类之间的关联。

继承就表示子类和父类之间的高耦合度，父类的任何改动都会影响到子类，会对子类会产生一些约束和限制。

如果是高度同质性的，继承还是合理的，并不是完全否定继承的作用。

迪米特法则

该法则规定如果两个类没有直接关系，那么就不应该产生直接的相互调用，可以通过第三方转发该调用。

该法则提高了类之间的独立性，降低了耦合度，是对合成复用原则的约束和补充。

SpringBoot 中对 BeanFactoryPostProcessor 的调用可能就是这个法则，使用 Delegate 类间接调用，而且使用的静态方法也不会额外引入依赖。

依赖倒置原则

类之间的依赖需要按照一定的规则层次，高层抽象类不能依赖以下的具体实现类。

违背依赖倒置原则会大大增加类间的耦合性不利于代码维护。

单一职责原则

简单理解就是希望类的功能尽量单一，一个类不应该承载太多的职责。

降低类的复杂度，减小类的实现粒度，都有利于减小类之间的耦合性，方便重用和后期维护。

不仅仅是针对类，针对类中的方法应该也需要向改原则靠拢，简单清晰的方法更容易维护和重用。

接口隔离原则

和单一职责原则很相似，在我理解可能就是规定的对象不同，接口隔离就是特指接口。

简单理解该原则，可能就是规定接口的粒度需要尽量的小。

比如 Java 中的 Closeable 之类的接口，或者 Spring 中的各类顶级接口。

设计模式的分类

根据目的来分设计模式可以分为创建型，结构型和行为型。

创建型模式主要着力于对象的创建过程，将创建和使用过程分离。

结构型模式主要着力于对象的继承和实现，如何通过一些基本接口和对象组装成一个更大的结构。

行为型模式主要描述类之间的调用关系，规范化方法和方法的职责，用于描述类或对象之间协作的过程。

个人理解，创建型的模式属于行为模式的一种，因为规范的就是创建的行为。

创建型模式

创建型模式主要关注对象的创建过程。

单例模式（Singleton）

单例模式的定义如下:

Ensure a class has only one instance, and provide a global point of access to it.

类图如下:

单例模式必须保证类的实例对象在系统中的唯一性，并提供一个全局的访问点，

类似一些重量级对象都可以使用单例模式实现，保证全局的访问安全，也减少内存的浪费。

单例模式主要有以下几个核心：

1. 构造函数私有化，阻止类外部的初始化
2. 类内部持有自身唯一实例的引用
3. 提供一个对外的获取接口

单例模式的持有和创建都在类内部，基本的单例模式如下，首先是饿汉模式：

public class HungrySingle{
        // 内部持有实例引用
        private static final HungrySingle INSTANCE = new HungrySingle();

        // 私有化构造函数
        private HungrySingle(){
                // 私有化之后，JVM也不会自动生成一个public的无参构造
        }

        // 提供统一的话获取方法
        public static HungrySingle getInstance(){
                return INSTANCE;
        }
}

饿汉模式的特点就是在类加载时候就会实例化对象，通过 JVM 的类加载机制保证实例的唯一性。

而另外一种懒汉模式，则是在此基础上增加了懒加载的特性，只有在需要的时候才会初始化。

个人更倾向于饿汉模式，早晚都要创建，何必呢。

public class LazySingle{
        private static final LazySingle INSTANCE;

        private LazySingle(){}

        public static LazySingle getInstance(){
                if(INSTANCE == null){
                        INSTANCE = new LazySingle();
                } 
                return INSTANCE;
        }
}

但以上代码并非是线程安全的，多线程环境下可能仍然会创建多个实例对象。

为了保证懒汉模式的线程安全性，确保实例对象的唯一性，所以又有了静态内部类，枚举以及双重检查锁模式。

以下是双重检查锁的 getInstance 方法：

public class LazySingle{
        // INSTANCE 实例必须使用 volatile 标识
        private volatile static final LazySingle INSTANCE;

        private LazySingle(){}

        public static LazySingle getInstance(){
              // 首次检查确保对象并为被创建
            if(INSTANCE == null){
                          // 保证创建过程的线程安全
                    synchronized(LazySingle.class){
                                  // 在 sync 之后重新判断静态条件
                                  // 在获取到 LazySingle 的锁之后，INSTANCE 可能已经被创建了。
                            if(INSTANCE == null){
                                    INSTANCE = new LazySingle();
                            }
                    }
            }

            return INSTANCE;
        }
}

使用了 synchronized 来保证创建过程的线程安全。

volatile 保证的其实是 INSTANCE 的赋值过程不会被重排序，因为第一次判断并不在 synchronized 里面，所以并不具有可见性就可能出现如下情况：

// 线程1                    线程2
// 分配空间 
// 赋值引用                  
// 初始化                   判断是否为空，不为空则直接使用

线程1的创建过程在重排序之后变成以上的情况，原本应该是先初始化再赋值引用，但真实执行顺序颠倒。
导致线程2在获取到引用地址时，可能并没有初始化完毕，所有可能会出现 NPE 的报错。

静态内部类的实现方式如下：

public class LazySingle{

        private LazySingle(){}

        // 由静态内部类持有单例对象的引用。
        private static class InstanceHolder{
                private static final LazySingle INSTANCE = new LazySingle();
        }

        public static getLazySingle(){
                return InstanceHolder.INSTANCE;
        }
}

唯一实例是由静态内部类持有的。

在加载外部类 LazySingle 的时候并不会直接加载内部类 InstanceHolder，只有在使用到内部类的相关属性的时候才会去进一步加载，也就是在调用 getLazySingle 时才会初始化。

另外就是 effective java 作者也强烈推荐的枚举类实现方式：

public class LazySingle{
        private LazySingle(){}

        private enum  InstanceHolder{
                INSTANCE;

                private final LazySingle single;

                InstanceHolder(){
                        single = new LazySingle();
                }

                private LazySingle getSingle(){
                        return single;
                }
        }

        public static getLazySingle(){
                return InstanceHolder.INSTANCE.getSingle();
        }
}

该种实现方式充分利用了枚举类型的特性，保证了加载的线程安全性和实例对象的唯一性。

而且是所有单利模式中唯一一种免疫序列化，反射破坏形式的实现。

再来说说反射对单例模式的破坏。

单例模式为了防止对象的再次创建，会将构造函数设置为私有的，但是反射是可以绕过这种权限控制的。

public class Solution {
    static class Single {
        static int cnt = 0;

        private Single() {
            cnt++;
        }

        public void single() {
            System.out.println(cnt);
        }
    }
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        final Class<Single> singleClass = Single.class;
        // 获取构造函数
        final Constructor<Single> declaredConstructor = singleClass.getDeclaredConstructor();
        // 修改访问权限
        declaredConstructor.setAccessible(true);
        for (int i = 0; i < 10; i++) {
            final Single single = declaredConstructor.newInstance();
            single.single();
        }
    }
}

反射在提供了更大的便利的同时，好像也出现了一些安全问题啊。

单例模式的使用实例：

• Spring Bean（存在一定争议，Spring 中单例的实现以 Bean 名称为单元而非真实对象。

单例模式分为饿汉模式和懒汉模式，懒汉模式实现有双重检查锁，枚举类，静态内部类等。

最后来总结一下单例模式的优点：

1. 单例模式保证了一个类仅有唯一的实例，并提供一个全局访问点，保证全局的访问便利。
2. 有效的节省资源

原型模式（Prototype）

原型模式的定义如下:

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

类图如下:

public class Prototype implements Cloneable{
        // 原型类只需要提供一个克隆的方法
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
}

// 工厂类
public class SimpleFactory {
    public Product createProduct(String productName){
        if(productName.equals("A")){
            return new ProductA();
        }
        if(productName.equals("B")){
            return new ProductB();
        }
        return null;
    }
}

// 产品类接口
interface Product{
    String getName();
}

// 产品A
class ProductA implements Product{
    @Override
    public String getName() {
        return "A";
    }
}

// 产品B
class ProductB implements Product{
    @Override
    public String getName() {
        return "B";
    }
}

interface FactoryMethodInterface {
        Reader create(File file) throws FileNotFoundException;
}

class BufferReaderFactory implements FactoryMethodInterface {
        @Override
        public BufferedReader create(File file) throws FileNotFoundException {
                final FileInputStream in = new FileInputStream(file);
                final InputStreamReader in1 = new InputStreamReader(in);
                return new BufferedReader(in1);
        }
}

class FileReaderFactory implements FactoryMethodInterface {
        @Override
        public Reader create(File file) throws FileNotFoundException {
                return new FileReader(file);
        }
}

class BufferReaderFactory implements AbstractFactoryInterface {
    @Override
    public BufferedReader createReader(File file) throws FileNotFoundException {
        final FileInputStream in = new FileInputStream(file);
        final InputStreamReader in1 = new InputStreamReader(in);
        return new BufferedReader(in1);
    }

    @Override
    public Writer createWriter(File file) throws FileNotFoundException {
        final FileOutputStream out = new FileOutputStream(file);
        final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(out);
        return new BufferedWriter(outputStreamWriter);
    }
}

class FileReaderFactory implements AbstractFactoryInterface {
    @Override
    public Reader createReader(File file) throws FileNotFoundException {
        return new FileReader(file);
    }

    @Override
    public Writer createWriter(File file) throws IOException {
        return new FileWriter(file);
    }
}
//  抽象工厂接口
interface AbstractFactoryInterface {
    Reader createReader(File file) throws FileNotFoundException;

    Writer createWriter(File file) throws IOException;
}

class Director{
    private Builder interBuilder = new InterBuilder();
    private Builder amdBuilder = new AMDBuilder();

    public Computer builder(){
        final Computer computer = new Computer();
        computer.cpu = interBuilder.cpu();
        computer.memory = amdBuilder.memory();
        return computer;
    }

}

class Computer{
    private String cpu;
    private String memory;
}

interface Builder{
    String cpu();
    String memory();
}

class InterBuilder implements Builder{
    @Override
    public String cpu() {
        return "Inter CPU";
    }
    @Override
    public String memory() {
        return "Inter Memory";
    }
}

class AMDBuilder implements Builder{
    @Over建造者模式关注的是对象的创建过程或者说步骤。ride
        public String cpu() {
        return "AMD CPU";
    }
    @Override
    public String memory() {
        return "AMD Memory";
    }
}

interface FinancialManagement {
    void investmentFund(float money);
}

class RealFinancialManagement implements FinancialManagement {
    @Override
    public void investmentFund(float money) {
        System.out.println("亏不死你!");
    }
}

class Proxy implements FinancialManagement {

    RealFinancialManagement realFinancialManagement = new RealFinancialManagement();

    @Override
    public void investmentFund(float money) {
        realFinancialManagement.investmentFund(money);
    }
}

interface Subject{
    void doSomething();
}

class RealSubject implements Subject{
    @Override
    public void doSomething() {
        System.out.println("// realSubject do something");
    }
}

class MyProxy implements InvocationHandler{
    Subject subject;
    public MyProxy(Subject subject) {
        this.subject = subject;
    }
    void before(){
        System.out.println("// ====== before");
    }
    void after(){
        System.out.println("// ====== after");
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        method.invoke(subject,args);
        after();
        return null;
    }
}

public class Main {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 获取代理类
        // JDK动态代理只能代理接口
        final Class<?> proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader(), Subject.class);
        // 获取构造函数
        final Constructor<?> constructor = proxyClass.getConstructor(InvocationHandler.class);
        // 创建具体的代理对象
        final Subject subject = (Subject) constructor.newInstance(new MyProxy(new RealSubject()));
        subject.doSomething();
        // 另外一种创建形式
        //        final Subject subject1 = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, new MyProxy(new RealSubject()));
    }
}

/**
     * 就是将乘2的方法变成乘4的过程
     */
interface Target {
    int multiply4(int i);
}
class Adaptee {
    int multiply2(int i) {
        return i * 2;
    }
}
class Adapter implements Target {
    Adaptee adaptee = new Adaptee();
    @Override
    public int multiply4(int i) {
        return adaptee.multiply2(i) * 2;
    }
}

interface Memory{
    void store();
}
class SamsungMemory implements Memory{
    @Override
    public void store() {
        System.out.println("三星的内存");
    }
}
class ToshibaMemory implements Memory{
    @Override
    public void store() {
        System.out.println("东芝的内存");
    }
}
static abstract class Computer{
    Memory memory;
    public Computer(Memory memory) {
        this.memory = memory;
    }
    abstract void doSomething();
}
class MyComputer extends Computer {
    public MyComputer(Memory memory) {
        super(memory);
    }
    @Override
    public void doSomething() {
        super.memory.store();
    }
}

public enum Strategy {
    ADD {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },
    REDUCE {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    };

    public abstract int calculate(int a, int b);
}

// 相当于 Command 的接口，声明了统一的方法签名，也定义了入参和返回值
ublic interface HttpCommand {
    /**
     * 执行命令
     *
     * @param request 请求
     * @return 响应
     */
    Response executor(Request request);
}

// 封装的对 Get 请求的调用命令
// 使用 HttpClient 实现
public class GetCommand implements HttpCommand {

    // HttpClient 

    @Override
    public Response executor(Request request) {
        return null;
    }
}

// 封装的对 Post 请求的调用命令
// 使用 OkHttp 实现
public class PostCommand implements HttpCommand {

    // OkHttp

    @Override
    public Response executor(Request request) {
        return null;
    }
}

// 真实调用者
public class Invoker {

    public static void main(String[] args) {
        // 真实调用就不需要直到 Get 或者 Post 的实现，直接使用命令类就好
        HttpCommand command = new GetCommand();
        final Response response = command.executor(new Request() {
        });
    }
}

public enum HttpCommandEnum {
    /**
     * get 请求
     */
    GET(new HttpCommand() {
        @Override
        public Response executor(Request request) {
            return null;
        }
    }),
    /**
     * post 请求
     */
    POST(new HttpCommand() {
        @Override
        public Response executor(Request request) {
            return null;
        }
    });
    private HttpCommand command;
    HttpCommandEnum(HttpCommand command) {
        this.command = command;
    }
}