设计模式&设计原则

研发 --> 架构  （定义、例子，框架或接口中用过相关的开发）

一、设计模式

1. 单一职责原则

Single Reposibility Principle

定义：一个类或者模块/服务/架构只负责完成一个职责。

电商拆分成订单、库存、物流、支付。

2. 里氏替换原则

LSP：Liskov Substitution Principle

定义：多用组合，少用继承。（在自己的类里引用其他的类（new一个类））

含义：（1）里氏替换原则是针对继承而言的，如果继承是为了实现代码重用，也就是为了共享方法，那么共享的父类方法就应该保持不变，不能被子类重新定义。子类只能通过新添加方法来扩展功能，父类和子类都可以实例化，而子类继承的方法和父类是一样的，父类调用方法的地方，子类也可以调用同一个继承得来的，逻辑和父类一致的方法，这时用子类对象将父类对象替换掉时，当然逻辑一致，相安无事。（2）如果继承的目的是为了多态，而多态的前提就是子类覆盖并重新定义父类的方法，为了符合LSP，我们应该将父类定义为抽象类，并定义抽象方法，让子类重新定义这些方法，当父类是抽象类时，父类就是不能实例化，所以也不存在可实例化的父类对象在程序里。也就不存在子类替换父类示例（根本不存在父类示例了）时逻辑不一致的可能。

3. 依赖倒置原则

DIP：Dependence Inversion Principle

定义：下层模块引入上层模块的依赖，改变原有自上而下的依赖方向。

 DDD：Domain Driver Design 根据领域划分的领域驱动设计

4. 接口隔离原则ISP

定义：建立单一接口，不要建立臃肿庞大的接口。接口尽量细化，同时接口中的方法尽量少。

含义：

（1）接口要尽量小：不要违反单一职责原则；要适度的小；

（2）接口要高内聚：提高接口、类、模块的处理能力，减少对外的交互；

（3）定制服务：通过对高质量接口的组装，实现服务的定制化（多组合少继承）

5. 迪米特法则（最少知识原则）

LoD：Law of Demeter

定义：只和密友谈话

解释：一个类应该对自己需要耦合或者调用的类知道得最少，你（被耦合或者被调用的类）的内部是如何复杂，那是你的事儿，和我没关系，我就知道你提供的这么多public方法，我就调用这么多，其他的我一概不知。

6. 开闭原则

定义：类、方法、模块应该对扩展开放，对修改关闭。

含义：添加一个功能应该是在已有的代码基础上进行扩展，而不是修改已有的代码。

二、设计原则

（一）、创建型模式

1. 单例 Singleton

某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。

定义：确保一个类只有一个实例，并提供一个全局访问点。

注意：涉及到创建构造器时，构造器都是private的。

五种实现方式：（面）（前三种能写出来）②

（1）饿汉式：线程安全，调用效率高，但是不能延时加载（常用）①

无论用不用，加载进来的时候就会创建一个实例，用到的时候返回该实例即可。

public class SingletonDemo1 {

    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1(){}

    public static SingletonDemo1 getInstance(){
        return instance;
    }
}

（2）懒汉式：线程安全，调用效率不高，但是能延时加载

类初始化时不创建对象（延时加载），真正用的时候再创建，需要写一个创建的方法。

public class SingletonDemo2 {
    //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
    private static SingletonDemo2 instance;

    //构造器私有化
    private SingletonDemo2(){}

    //方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance(){
        if(instance == null) {
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

因为方法上加了synchronized，所有的对象都会阻塞在该方法处，需要一个个按序串行调用，解决该问题需要双重校验。

（3）双重校验

在懒汉式的基础上进行了双重校验的优化。

public class SingletonDemo3 {

    private volatile static SingletonDemo3 singletonDemo3;

    private SingletonDemo3() {}

    public static SingletonDemo3 newInstance() {
        if (singletonDemo3 == null) {
            synchronized (SingletonDemo3.class) {
                if (singletonDemo3 == null) {
                    singletonDemo3 = new SingletonDemo3();
                }
            }
        }
        return singletonDemo3;
    }
}

当有多个对象调用newInstance方法时，由于没有synchronized，快的几个对象都会进入该方法，到达锁处，其中最快的对象会再判断是否为空，如果为空则创建对象，然后返回，剩下几个同一批次进来的在锁之后判断不为空则直接返回，比这几个对象慢的其他对象进入方法后判断对象不为空，直接返回。

（4）静态内部类：线程安全，调用效率高，可以延时加载（不常用）

使用内部类的方式创建了实例。

public class SingletonDemo4 {

    private SingletonDemo4(){}

    /** 静态内部类 */
    private static class SingletonClassInstance {
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    public static SingletonDemo4 getInstance(){
        return SingletonClassInstance.instance;
    }
}

（5）枚举类

public enum SingletonDemo5 {

    // 枚举元素本身就是单例
    INSTANCE;

    // 添加自己需要的操作，直接通过SingletonDemo5.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。
    public void doSomething() {
        System.out.println("doSomething");
    }
}

class Test {
    public static void main(String[] args) {
        SingletonDemo5.INSTANCE.doSomething();
    }
}

单例可以被破坏③：

（1）反射获得对应的构造函数，可以setAccessible=true破坏掉private，进而创建破坏单例的对象。

（2）通过反序列化Serializable（RPC中常见）

2. 原型 Prototype

将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。也就是说，这种不通过new关键字来产生一个对象，而是通过对象复制（Java中的clone或者反序列化）来实现的模式，叫做原型模式。

性能：原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环内产生大量的对象时，原型模式可能更好地体现其优点。

逃避构造函数的约束，直接在内存中拷贝，构造函数式不会执行的。克隆不走构造函数①

/**
 * 通过clone方法创建的Prototype对象不会执行构造方法
 */
public class Prototype implements Cloneable {
    public static void main(String[] args) {
        System.out.println("【步骤1】开始执行Prototype类型的对象创建工作");
        Prototype prototype = new Prototype();

        /** 执行clone方法创建的Prototype对象 */
        System.out.println("【步骤2】开始执行clone操作");
        prototype.clone();
    }

    public Prototype() {
        System.out.println("-----Prototype的构造方法被执行了！-----");
    }

    @Override
    protected Prototype clone() {
        try {
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

执行结果：可以看到在克隆的时候没有执行构造方法。

深拷贝与浅拷贝②：（面）

/**
 * 浅拷贝&深拷贝
 */
@Data
public class Prototype1 implements Cloneable {
    private String name;
    private List arrayList = new ArrayList<>();

    public static void main(String[] args) {
        Prototype1 prototype1 = new Prototype1();
        prototype1.setName("original object");
        prototype1.setValue("original object");

        Prototype1 clonePrototype1 = prototype1.clone();
        clonePrototype1.setName("clone object");
        /** 发现添加了执行了clone对象的setValue之后，也修改了prototype1中的arrayList中数据 */
        clonePrototype1.setValue("clone object");
        System.out.println(prototype1);
        System.out.println(clonePrototype1);
    }

    public void setValue(String value) {
        this.arrayList.add(value);
    }

    public List getValue() {
        return this.arrayList;
    }

    /**
     * 浅拷贝
     * @return
     */
//    @Override
//    protected Prototype1 clone() {
//        try {
//            return (Prototype1)super.clone();
//        } catch (CloneNotSupportedException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }

    /**
     * 深拷贝
     * @return
     */
    @Override
    protected Prototype1 clone() {
        Prototype1 prototype1 = null;
        try {
            prototype1 = (Prototype1)super.clone();
            prototype1.setArrayList(new ArrayList<>());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype1;
    }

}

浅拷贝的运行结果：

深拷贝的运行结果：（深拷贝重新创建了一个arrayList，跟原来的arrayList没关系了。另外基础类型和String类型不需要深度拷贝，对象和容器会需要深度拷贝。）

使用场景③：

（1）类的初始化需要消耗非常多的资源。

（2）通过new产生一个对象需要非常繁琐的数据准备或访问。

（3）一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时。

3. 工厂方法 FactoryMethod

定义一个用于创建产品的接口，由子类决定生产什么产品。

（简单工厂 Simple Factory：不是设计模式，更像是一种编程习惯。用得多）

定义：定义了一个创建对象的接口（类或接口中的方法），但由子类决定要实例化的类 是哪一个。工厂方法把实例化推迟（下移）到子类。

4. 抽象工厂 AbstractFacory

提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。（用得少）

定义： 提供一个接口，用于创建 相关或依赖对象的家族， 而不需要明确指定具体类。

工厂方法： 通过抽象方法提供对象生成入口。（继承）

抽象工厂： 通过接口，来创建一组产品。（组合）

5. 建造者 / 生成器模式 Builder

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

定义：使用生成器模式，可以封装一个产品的构造过程，并允许按步骤构造产品。

优点：

（1）将一个复杂对象的创建过程封装起来。

（2）允许对象通过多个步骤来创建，并且可以改变过程。

（3）向客户隐藏产品内部的表现。

（4）产品的实现可以被替换，因为客户只看到一个抽象接口。

用途： 经常被用来创建组合结构。

缺点：与工厂模式相比，采用生成器模式创建对象的客户，需要具备更多的领域知识

（二）结构型模式

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

6. 代理 Proxy

为某对象提供一种代理以控制对该对象的访问。即：客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

解决问题：当我们想要对一个业务类进行某些横切性的增强时，例如：增加请求与响应 的日志、增加权限校验、增加远程请求对象封装等等。我们可以采用代理模式去实现，而不需要修改原有的类。

定义：代理模式为另一个对象提供一个替身或占位符，以控制对这个对象的访问。使用 代理模式创建代理对象，让代理对象控制某对象的访问，被代理的对象可以是远程的对 象、创建开销大的对象或需要安全控制的对象。

SpringAOP中采用的JDK动态代理，就是最典型的例子。

补充……

7. 适配器 Adapter

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

定义：将一个类的接口，转换成客户期望的另一 个接口。适配器让原本接口不兼容的类可以合作 无间。

8. 桥接 Bridge

将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。

定义：将抽象部分和实现部分，分离解耦，使得两者可以独立地变化。桥接模式通过将实现和抽象放在两个不同的类层次中而使它们可以独立变化。

优点：

（1）将实现予以解耦，抽象和实现可以独立扩展，不会影响到对方。

（2）对于“具体的抽象类”所做的改变，不会影响到客户。

用途： 适合使用在需要跨越多个平台的图形和窗口系统上。 当需要用不同的方式改变接口和实现时，你会发现桥接模式很好用。

缺点：增加了复杂度。

9. 装饰 Decorator

动态地给对象增加一些职责，即：增加其额外的功能。（附加+家族的概念）

定义：动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更弹性的替代方案

10. 门面 Facade

为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。（最小知识原则）

定义：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

11. 享元 / 蝇量 Flyweight 

运用共享技术来有效地支持大量细粒度对象的复用。 （非面）

定义：享元模式是池技术的重要实现方式，其定义如下：使用共享对象可以有效地支持 大量的细粒度的对象。

12. 组合 Composite

将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性（很少用）

定义：允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合

（三）、行为型模式

定义：行为型模式用于描述程序在运行时复杂的流程控制，即：描述多个类或对象之间 怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

行为型模式分为类行为模式（采用继承机制来在类间分派行为）和对象行为模式（采用 组合或聚合在对象间分配行为）。由于组合关系或聚合关系比继承关系耦合度低，满足 “合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

行为型模式是GoF设计模式中最为庞大的一类，它包含以下 11 种模式：

13. 模版方法 Template Method  ※※※※※

定义一个操作中的算法骨架，将算法的一些步骤延迟到 子类中，使得子类在可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

定义：在一个方法中定义一个算法骨架，而将一些步骤延迟到子类中。模板方法使得子类 可以在不改变算法结构的情况下，重新定义算法中的某些步骤

14. 策略 Strategy ※※※※※

定义了一系列算法，并将每个算法封装起来，使它们可以相互替换， 且算法的改变不会影响使用算法的客户。

定义：定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化 独立于使用算法的客户。

15. 命令 Command ※※※※※

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开

定义：将“请求”封装成命令对象，以便使用不同的请求、队列或日志来参数化其他对象。

在消息中间件常见。类似最小知识原则。

16. 职责链 Chain of Reponsibility ※※※

把请求从链中的一个对象传到下一个对象，直到请 求被响应为止。通过这种方式去除对象之间的耦合。

定义： 当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。 使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将 这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。（一般在配置中去设置）

网关场景。

17. 状态 State ※※※

状态机 ※※※※※

允许一个对象在其内部状态发生改变时改变其行为能力。

定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

18. 观察者 Observer ※※※※※

多个对象间存在一对多关系，当一个对象发生改变时，把这种改 变通知给其他多个对象，从而影响其他对象的行为。

定义：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依 赖者都会收到通知并自动更新。

19. 中介者 Mediator ※※※※

定义一个中介对象来简化原有对象之间的交互关系，降低系统中 对象间的耦合度，使原有对象之间不必相互了解。

定义：使用中介者模式来集中相关对象之间复杂的沟通和控制方式。

20. 迭代器 Iterator 

不用自己做。

提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

定义： 提供一个方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

21. 访问者 Visitor ※

在不改变集合元素的前提下，为一个集合中的每个元素提供多种访 问方式，即每个元素有多个访问者对象访问。

定义：表示一个作用于某个对象结构中的各元素的操作。它使你可以在不改变各元素的 类的前提下定义作用于这些元素的新操作。

22. 备忘录 Memento ※

在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。

定义： 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可以将该对象恢复到原先保存的状态。当你需要让对象返回之前的状 态时（例如：你的用户请求“撤销”），就使用备忘录模式

23. 解释器 Interpreter 

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。