一、设计模式概述

  1. 软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

  2. 维护性，可读性、规范性

  3. 实际应用

  • 基于面向对象(oo)
  • 功能模块[设计模式+算法(数据结构)]
  • =>框 架[使用到多种设计模式]
  • =>架构 [服务器集群]
  1. 设计模式的目的

编写软件过程中，开发人员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好的代码重用性、可读性、可扩展性、可靠性、使程序呈现高内聚，低耦合。

二、设计模式的七大原则

1) 单一职责原则
2) 接口隔离原则
3) 依赖倒转(倒置)原则
4) 里氏替换原则
5) 开闭原则
6) 迪米特法则
7) 合成复用原则

2.1 单一职责原则
  1. 概念：让一个方法去做一件事/一个类去做一类事。
  2. 特点
  • 降低类的复杂度，一个类只负责一项职责。
  • 提高类的可读性，可维护性 降低变更引起的风险
  • 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；
  • 只有类中方法数量足够少，可以在方法级别保持单一职责原则

2.2 接口隔离原则
  1. 定义:客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

  2. 最小接口就是说，某个类只用到两个方法，但是去实现的接口有三个方法，那么这个类就不得不去重写那个他不需要用到的方法，那么这个接口对于这个类来说就不是最小接口。

  3. 处理方法：按隔离原则应当这样处理：

重写写一个接口
将接口Interface拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

2.3 依赖倒转(倒置)原则
  1. 定义：实际上就是再说多态，高层模块不应该依赖低层模块，二者都应该依赖其抽象
  2. 抽象不应该依赖细节，细节应该依赖抽象
  3. 依赖倒转(倒置)的中心思想是面向接口编程
  4. 实质就是：具体服从抽象，抽象高于具体

2.4 里氏替换原则
  1. 继承
  2. 弊端：用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障
  3. 遵循里氏替换原则，在子类中尽量不要重写父类的方法
  4. 解决方法：继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题。


  5. 2.5 开闭原则OCP

  6. 开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。

  7. 一个软件实体如类，模块和函数应该对扩展开放（提供方），对修改关闭（使用方）。用抽象构建框架，用实现扩展细节。
  8. 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
  9. 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

2.6 迪米特法则/最少知道原则
  1. 一个对象应该对其他对象保持最少的了
  2. 类与类关系越密切，耦合度越大
  3. 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息

  4. 迪米特法则还有个更简单的定义：只与直接的朋友通信

    1. 降低不必要的联系（耦合关系），必要的还要保留

    2.7 合成复用原则

    原则是尽量使用合成/聚合的方式，而不是使用继承

三、设计模式

  1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
  2. 针对接口编程，而不是针对实现编程。
  3. 为了交互对象之间的松耦合设计而努力

分类：

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)

    3.1 单例模式 ※手写

  4. 概念所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

    3.1.1饿汉式
  • 在当前类直接去实例化当前实例；
  • 在外界是无法获取当前类的实例的，独此一份。
  • 不会出现线程安全的问题，因为static是类级别的

创建步骤三步走：创建静态常量实例—>构造方法私有化—>提供对外访问静态方法。

  1. public class Singleton01 {
  3.     //在当前类直接去实例化当前类的实例
  4.     private final static Singleton01 singleton01 = new Singleton01();
  6.     //或者把实例创建在静态代码块中。
  8.     //构造方法私有化
  9.     private Singleton01(){
  11.     }
  12.     /**
  13.      * 提供一个静态方法，用于对外界提供访问
  14.      * @return
  15.      */
  16.     public static Singleton01 getInstance(){
  18.         return singleton01;
  19.     }

3.1.2懒汉式
  • 在类中的方法中判断是否有实例，如果没有就创建一个
  • 线程不安全，可以添加锁synchronized。但是要注意效率问题。

  • 双重判断：避免两个线程同时进入，防止多次创建实例。需要双重加锁

    1. public class Singleton03 {
    3.   //在当前类直接去实例化当前类的实例
    4.   private static Singleton03 singleton03;
    6.   //构造方法私有化
    7.   private Singleton03(){
    9.   }
    10.   /**
    11.    * 提供一个静态方法，用于对外界提供访问
    12.    * 多线程在线程安全的基础之上我们要考虑效率问题
    13.    * @return
    14.    */
    15.   public  static Singleton03 getInstance(){
    17.       if (singleton03 == null){
    18.          //加一个类锁
    19.           synchronized (Singleton03.class){
    20.               if (singleton03 == null)
    21.                   singleton03 = new Singleton03();                
    22.           }
    23.       }
    24.       return singleton03;
    25.   }

懒汉式和饿汉式的区别：
懒汉式就是不着急创建对象，用的时候在创建
饿汉式就是先创建一个对象，用的时候直接提供给你。

3.2 代理模式

1) 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
2) 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
3) 代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口， 他是属于动态代理的范畴)

3.2.1 静态代理
  1. 定义：静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类

实质：在不修改目标对象的前提下，完成对目标功能的增强/拓展。（通过代理对象完成对目标对象的拓展）

  1. 操作方法

包含有：①接口、②代理对象、③被代理/目标对象。
直接用被代理类

  1. 优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
  2. 缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类一旦接口增加方法,目标对象与代理对象都要维护

3.2.1 JDK动态代理
  1. 代理对象,不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
  2. 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象
  3. 动态代理也叫做：JDK代理、接口代理
  4. 动态代理与静态代理的区别：静态代理是我们手动创建的，动态代理是通过反射机制动态创建的。

通知：用于增强目标类方法的内容。

3.3 Cglib动态代理

1) 静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现 代理-这就是Cglib代理
2) Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。
3) Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接 口.它广泛的被许多AOP的框架使用,例如Spring AOP，实现方法拦截
4) 在AOP编程中如何选择代理模式：
1. 目标对象需要实现接口，用JDK代理
2. 目标对象不需要实现接口，用Cglib代理
5) Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

动态代理案例
  1. 代理类是目标类的子类，需要先获取目标类的父类对象，在

  2. 主要设计目的：就是有一个我们原来需要使用到的类，为了给这个类新添加功能而不去修改原来的类，就把这个类作为父类（目标类、被代理类）。

    1. public class CglibProxyimpl {
    2.  public void getmMethod(){
    3.      System.out.println("我是一个被Cglib代理的方法");
    4.  }
    5. }
    1. public class CreateCglibProxy {
    2.  private  Object object;
    4.  public CreateCglibProxy(Object object) {
    5.      this.object = object;
    6.  }
    7.  /*
    8.  * 用于获取代理对象*/
    9.  public Object getProxy(){
    10.      //创建cglib核心对象
    11.      Enhancer enhancer = new Enhancer();
    13.      //设置父类对象，通过父类（目标类/被代理类）对象获取其对应的父类（目标类）
    14.      enhancer.setSuperclass(object.getClass());
    16.      //设置回调函数
    17.      enhancer.setCallback(new MethodInterceptor() {
    18.          @Override
    19.          public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    20.              System.out.println("cglib前置通知————————————————");
    22.              Object invoke = method.invoke(object, objects);
    24.              System.out.println("cglib后置通知————————————————");
    25.              return invoke;
    26.          }
    27.      });
    28.      Object obj = enhancer.create();
    29.      return obj;
    30.  }
    1. public class Test {
    2.  public static void main(String[] args) {
    3.      //创建目标对象
    4.      CglibProxyimpl cglibProxyimpl = new CglibProxyimpl();
    6.      //创建代理对象
    7.      CglibProxyimpl proxy = (CglibProxyimpl)new CreateCglibProxy(cglibProxyimpl).getProxy();
    8.      proxy.getmMethod();
    9.  }
    10. }

3.4 工厂模式
  1. 普通/简单工厂模式

定义：是指由一个工厂对象决定创建出哪一种产品类 的实例。属于创建型模式。

  1. 适用场景：
  • 适用于工厂类负责创建的对象较少的场景。
  • 且客户端只需要传入工厂类的参数，对于如何创 建对象的逻辑不需要关心。
  1. 简单工厂模式缺点：
  • 工厂类的职业相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则（ocp）。
  • 不易于扩展过于复杂的产品结构。

3.5 工厂方法模式

3.5.1 工厂方法模式定义
  1. 是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。
  2. 工厂方法让类的实例化推迟到子类中进行用户只需要关心所需产品对应的工厂，无须关心创建细节，加入新的产品不符合开闭原则。

————>静态工厂模式：
每个方法前面加一个static修饰，可以使得不用创建工厂对应的类就可以直接调用工厂内的方法，相对来说可以降低耦合性。

3.5.2 工厂方法模式的特点

工厂方法模式的适用场景：
1、创建对象需要大量重复的代码
2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，一个类通过其子类来指定创建哪个对象。
工厂方法模式的优点：
1、用户只关系所需产品对应的工厂，无须关心创建细节。
2、加入新产品符合开闭原则，提高了系统的可扩展性。
工厂方法模式的缺点：
1、类的个数容易过多，增加了代码结构的复杂度。
2、增加了系统的抽象性和理解难度。

3.6 抽象工厂模式

遵循ocp原则。

  1. 定义：是指提供一个创建一系列相关或者相互依赖对象的接口，无须指定他们具体的类。
  2. 抽象工厂模式使用场景：

1、客户端（应用层）不依赖于产品类实例如何被创建，实现等细节。
2、强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。
3、提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体的实现。

  1. 抽象工厂模式优点：

1、具体产品在应用层代码隔离，无须关系创建细节。
2、将一个系列的产品族统一到一起创建。

案例：
需求：通过反射的方式创建实例，使用抽象工厂模式
设计流程：

  1. 抽象工厂对应的类中，创建方法，
  2. 方法中

①方法形参对应全类名String；
②创建反射对象；
③判断对象是否是该方法对应的返回对象类，否则强转。