1.作用

对一类编码的设计经验思想；提升编码思维、复用性、可读性等。

2.设计模式分类

1.创建型模式

描述“如何创建对象”，主要特点是对象创建与使用分离。
包含：单例、工厂方法、抽象工厂、原型、建造者等5中模式；

2.结构型模式

描述“类或对象如何布局成更大结构”。
包含：代理、适配器、桥接、装饰、外观、享元、组合等7中模式；

3.行为型模式

描述“类或对象如何协作完成任务”。
包含：模板方法、策略、命令、责任链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等11种模式。
image.png

3.UML类图

1.类图表示

使用一个圆角矩形表示，包含三个模块：
类名
属性：访问类型：属性名称：数据类型
行为：访问类型：属性名称：返回值类型
image.png

2.类图关系

关联关系是类之间的引用关系。包含一般关联关系、聚合关系、组合关系。

1.关联关系-单向

每个顾客都有一个地址，符号如下。
image.png

2.关联关系-双向

image.png

3.关联关系-自关联

image.png

4.聚合关系

整体与部分之间的关系。如：大学-学生。
image.png

5.组合关系

整体与部分之间的关系。关系更强、整体与部分共存亡。
image.png

6.依赖关系

image.png

7.继承关系

image.png

8.实现关系

image.png

4.七大原则

1.单一原则

模块职责单一化，降低了类的复杂度；

2.开闭原则

模块对扩展开放、对修改关闭；如使用接口、抽象类等。

3.里氏替换原则

子类继承父类之后，子类可以扩展父类，但不能修改父类原有的功能。

4.依赖倒转原则

高层模块不直接依赖底层模块，应该依赖抽象。
如下图所示，电脑组装与不同组件之间通过接口依赖。
image.png

5.接口隔离原则

类与类之间的依赖建立在最小关系上，不应该依赖自己不需要的方法。
如：实现接口需实现全部方法、继承抽象类只需要实现部分方法。

6.迪米特法则

模块之间最少了解、通过第三方进行转发调用。

7.合成复用原则

尽量使用组合、聚合等关联关系实现，之后再考虑继承。

5.创建者模式

1.单例模式

单例模式是一种访问唯一性的模式，不需要创建过多的对象，只需要保持一个实例且不需要实例化。
为何要用单例模式？
多个并发请求、只产生一个实例对象，节约内存资源。如：短信发送、验证码等。

1.实现方式

单例模式提供了两种实现方式：
饿汉式：类加载在进行单例对象的初始化创建
懒汉式：类加载不进行创建，在首次使用时才进行创建

2.饿汉式-静态变量/代码块

该方式中，通过静态变量、代码块直接声明单例实例。
会造成初始化实例后未使用，占用资源。

  1. public class Singleton{
  2.     // 1、声明静态变量实例——直接创建对象
  3.     private static Singleton singleton = new Singleton;
  5.     // 2、声明静态变量实例——使用静态代码块进行初始化
  6.     static {
  7.         singleton = new Singleton;
  8.     }
  10.     // 私有化构造方法
  11.     private Singleton(){}
  13.     // 提供访问获取方法
  14.     public static Singleton getInstance(){
  15.         return singleton;
  16.     }
  17. }

3.懒汉式-线程不安全

该方式中，在访问获取方法中进行实例化，多线程中会出现线程安全问题。
多线程访问：多个线程进入getInstance()方法，创建多个实例。

  1. public clss Singleton{
  2.     private static Singleton singleton;
  4.     private Singleton(){}
  6.     public static Singleton getInstance(){
  7.         if(singleton == null){
  8.             singleton = new Singleton();
  9.         }
  10.         return singleton;
  11.     }
  12. }

4.懒汉式-线程安全

这种模式中，静态实例方法中通过synchronized方法锁进行修饰、不会出现线程并发访问问题。
加锁之后、锁定当前类对象、性能会有所降低。
注意点：对代码块加锁时，并发情况下并不能保证有一个实例存在。

  1. public class Solution{
  2.     public static Singleton singleton;
  4.     private Singleton(){};
  6.     // 只能对类进行加锁、代码块加锁并不能保证单例模式
  7.     public static synchronized Singleton getInstance(){
  8.         if(singleton == null){
  9.             singleton = new Singleton();
  10.         }
  11.         return singleton;
  12.     }
  14.     // 这种代码块锁通过双重非null检验可以避免、但没必要(过于复杂)
  15.     public static synchronized Singleton getInstane(){
  16.         if(singleton == null){
  17.             synchronized(Solution.class){
  18.                 if(singleton == null){
  19.                     singleton = new Singleton();
  20.                 }
  21.             }
  22.         }
  23.         return singleton;
  24.     }
  25. }

5.懒汉式-双重检验

双重检验中、通过volatile、synchronized双重校验机制保证单例模式的并发线程安全模式
volatile：保证了线程并发情况下的可见性(线程之间共享变量的最新状态)
读取前：先从主存中刷新最新的值
写入后：立即同步到主存中

  1. public class Solution{
  3.     // volatile防止指令重排、可见性、同步刷新
  4.     private static volatile Singleton singleton;
  6.     private Solution(){}
  8.     public static getInstance(){
  9.         if(singleton == null){
  10.             synchronized(Solution.class){
  11.                 if(singleton == null){
  12.                     singleton = new Singleton();
  13.                 }
  14.             }
  15.         }
  16.         return singleton;
  17.     }
  18. }

2.工厂模式

将对象的创建过程进行内部封装、调用者无需知道对象的创建过程，只需要通过工厂类中传递指定方式获取即可。
特点：隐藏对象的创建细节。

1.工程模式类型

简单工厂模式、工厂方法模式、抽象工厂模式

2.简单工厂

内部封装具有相同行为特征的接口实现类、隐藏这些类的具体实现细节，对外提供一个Factory对象工厂。调用者只需要传递对应的字符串获取相应的对象实体执行调用即可。
特点：调用者无需关系具体的创建过程、只需要获取即可
缺点：扩展时、不仅需要增加响应的实现类、也需要增加响应的工厂类

  1. /**
  2.     创建产品接口
  3. */
  4. public interface Product{
  6.     // 接口方法
  7.     void method();
  8. }
  10. /**
  11.     产品1-实现产品接口
  12. */
  13. public class ProductA implements Product{
  15.     @Override
  16.     void method(){
  17.         // 代码块
  18.     }
  19. }
  21. /**
  22.     产品2-实现产品接口
  23. */
  24. public class ProductB implements Product{
  26.     @Override
  27.     void method(){
  28.         // 代码块
  29.     }
  30. }
  32. /**
  33.     产品工厂类
  34. */
  35. public class ProductFactory{
  36.     public Product getProductInstance(String type){
  37.         if(type == A){
  38.             return new ProductA();
  39.         }else if(type == B){
  40.             return new ProductB();
  41.         }
  43.         return null;
  44.     }
  45. }

3.工厂方法

image.png
简单工厂模式中、系统扩展过程中，如果需要添加产品之外的其他类型，如支付方式时，则需要创建响应的工厂。
工厂方法则是对上述模式的一种优化、工厂接口中创建不同的工厂实现类实现工厂接口（不同的产品中又有不同的大小）
特点：高可扩展性
缺点：扩展难度高、需要创建对应的工厂类方法

  1. /**
  2.     创建产品接口
  3. */
  4. public interface Product{
  6.     // 接口方法
  7.     void method();
  8. }
  10. /**
  11.     产品1-实现产品接口
  12. */
  13. public class ProductASizeA implements Product{
  15.     @Override
  16.     void method(){
  17.         // 代码块
  18.     }
  19. }
  21. /**
  22.     产品1-实现产品接口
  23. */
  24. public class ProductASizeB implements Product{
  26.     @Override
  27.     void method(){
  28.         // 代码块
  29.     }
  30. }
  32. /**
  33.     产品2-实现产品接口
  34. */
  35. public class ProductBSizeA implements Product{
  37.     @Override
  38.     void method(){
  39.         // 代码块
  40.     }
  41. }
  43. /**
  44.     产品2-实现产品接口
  45. */
  46. public class ProductBSizeB implements Product{
  48.     @Override
  49.     void method(){
  50.         // 代码块
  51.     }
  52. }
  54. // 创建工厂接口
  55. public interface Factory{
  56.     public Product getProduct(size);
  57. }
  59. // 创建A类产品工厂
  60. public class ProductAFactory implements Factory{
  61.     @Override
  62.     public Product getProductA(String size){
  63.         if(size == A){
  64.             return new ProductASizeA();
  65.         }else if(size == B){
  66.             return new ProductASizeB();
  67.         }
  68.     }
  69. }
  71. // 创建B类产品工厂
  72. public class ProductBFactory implements Factory{
  73.     @Override
  74.     public Product getProductB(String size){
  75.         if(size == A){
  76.             return new ProductBSizeA();
  77.         }else if(size == B){
  78.             return new ProductBSizeB();
  79.         }
  80.     }
  81. }
  84. // 工厂方法调用类
  85. public class ProductApi{
  86.     Factory factory;
  88.     public Product getInstance(String type, String size){
  89.         if(type == A){
  90.             factory = new ProductAFactory();
  91.         }else{
  92.             factory = new ProductBFactory();
  93.         }
  95.         return factory.getProduct(size);
  96.     }
  97. }

4.抽象工厂

抽象工厂是对简单工厂和工厂方法的一种结合、提高了更高的可扩展性、但是维护程度更加难以维护。

3.建造者模式

1.构建过渡

传统构建：可以通过定义多个类型的构造器分别创建、这种需要重载过多的构造器、也可以通过流水线创建

  1. // 构造器创建
  2. public class Computer {
  3.     private String screen;
  4.     private String mouse;
  5.     private String cpu;
  6.     private String mainBoard;
  7.     private String disk;
  8.     private String memory;
  10.     public Computer setScreen(String screen) {
  11.         this.screen = screen;
  12.         return this;
  13.     }
  15.     public Computer setMouse(String mouse) {
  16.         this.mouse = mouse;
  17.         return this;
  18.     }
  20.     public Computer setCpu(String cpu) {
  21.         this.cpu = cpu;
  22.         return this;
  23.     }
  25.     public Computer setMainBoard(String mainBoard) {
  26.         this.mainBoard = mainBoard;
  27.         return this;
  28.     }
  30.     public Computer setDisk(String disk) {
  31.         this.disk = disk;
  32.         return this;
  33.     }
  35.     public Computer setMemory(String memory) {
  36.         this.memory = memory;
  37.         return this;
  38.     }
  39. }
  41. Computer computer = new Computer()
  42.                 .setScreen("高清屏幕")
  43.                 .setMouse("罗技鼠标")
  44.                 .setCpu("i7处理器")
  45.                 .setMainBoard("联想主板")
  46.                 .setMemory("32G内存")
  47.                 .setDisk("512G磁盘");

建造者模式：将复杂的构建过程与具体表示相分离、依次来提高高可可扩展性。
再来观察一种创建方式、通过静态内部类的方式构建对象

  1. public class Computer{
  2.     private String name;
  3.     private String size;
  4.     private String action;
  5.     private String cpu;
  7.     // 通过静态内部类Builder构建
  8.     Computer(Builder builder){
  9.         this.name = builder.name;
  10.         this.size = builder.size;
  11.         this.action = builder.action;
  12.         this.cpu = builder.cpu;
  13.     }
  15.     /**
  16.      * 静态内部类构造器、用于构建复杂的属性
  17.      */
  18.     public static class Builder{
  19.         private String name;
  20.         private String size;
  21.         private String action;
  22.         private String cpu;
  24.         public Builder setName(String name){
  25.             this.name = name;
  26.             return this;
  27.         }
  29.         public Builder setSize(String size){
  30.             this.size = size;
  31.             return this;
  32.         }
  33.         ......
  35.         public Computer builder(){
  36.             retunr new Computer(this);
  37.         }
  38.     }
  39. }
  41. // 构建测试
  42. public class Solution{
  43.     Computer computer = new Computer.builder()
  44.         .setName()
  45.         .setSize()
  46.         .setAction()
  47.         .setCpu()
  48.         .builder();
  49.     // 调用对象即可
  50. }

上述建造过程似乎可以满足、但任然无法适应复杂对象的构建

2.建造者构建

将内部类抽离成外部抽象类来构建、并自定义构造器继承构建器

  1. // 需要创建的对象
  2. public class Computer{
  3.     private String name;
  4.     private String size;
  6.     public void setName(String name){
  7.         this.name = name;
  8.     }
  10.     public void setSize(String size){
  11.         this.size = size;
  12.     }
  13. }
  15. // 抽象构建器
  16. public abstract class Builder{
  17.     // 抽象设置名称方法
  18.     abstract Builder buildName(String name);
  20.     // 抽象设置大小方法
  21.     abstract Builer buildSize(String size);
  23.     // 抽象构建对象
  24.     abstract Computer builder();
  25. }
  27. // 构建自定义构建器继承构建器
  28. public class ProductBuilder extends Builder{
  29.     // 实例化对象
  30.     private Computer computer = new Computer();
  32.     @Override
  33.     public Builder buildName(String name){
  34.         computer.setName(name);
  35.         return this;
  36.     }
  38.     @Override
  39.     public Builder buildSize(String size){
  40.         computer.setSize(String size);
  41.         return this;
  42.     }
  44.     // 构建对象
  45.     @Override
  46.     public Computer builder(){
  47.         return computer;
  48.     }
  49. } 
  51. // 使用构建
  52. public class Solution{
  53.     Builder builder = new ProductBuilder();
  55.     Computer computer = builder.buildName().buildSize();
  56. }

3.JDK应用场景

StringBuilder类中继承了AbstractStringBuilder抽象构建类(append方法)、就是一种建造者模式
image.png
image.png

6.结构型模式

1.代理模式

通过在服务调用者与服务对象之间增加一层代理对象、 通过代理对象来对目标对象进行扩展操作而不改变原有对象的代码功能。
image.png
静态代理、动态代理

2.静态代理

静态代理指的是通过手动创建Proxy代理对象来对目标方法进行增强的一种代理机制。每个目标对象都需要创建自己的代理对象。
代理过程：
1、创建目标对象接口、创建目标对象接口实现类
2、创建目标代理对象同样实现目标对象接口
3、调用代理对象中的方法接口
特点：
1、静态代理只能代理实现了接口的目标对象
2、静态代理中难以扩展、目标对象和代理对象都要进行修改
代码实现：

  1. // 创建目标对象接口
  2. public interface TargetService{
  3.     // 发送信息方法
  4.     public String send(String msg);
  5. }
  7. // 创建目标对象接口实现类
  8. public class TargetServiceImpl implements TargetService{
  9.     // 实现发送短信方法
  10.     @Override
  11.     public String send(String msg){
  12.         sout(发送消息);
  13.     }
  14. }
  16. // 创建代理对象同样实现目标对象接口
  17. public class Proxy implements TargetService{
  18.     // 注入目标对象
  19.     private TargetService target;
  21.     // 构造器注入目标方法
  22.     public Proxy(TargetService targetService){
  23.         this.target - targetService;
  24.     }
  26.     // 实现代理方法
  27.     @Override
  28.     public String send(String msg){
  29.         // 调用目标对象前的执行逻辑
  30.         sout("调用前增强");
  32.         // 调用目标对象方法
  33.         target.send(msg);
  35.         // 调用目标对象后的执行逻辑
  36.         sout("调用后增强");
  37.     }
  38. }
  40. // 代理对象测试
  41. public class Solution{
  42.     public static void main(String[] args){
  43.         // 创建代理对象
  44.         Proxy proxy = new Proxy(new TargetServiceImpl());
  46.         // 调用代理对象方法
  47.         proxy.send(msg);
  48.     }
  49. }

3.动态代理

动态代理中不需要为每个目标对象都创建一个代理对象、目标对象也不需要实现接口就可以进行代理。
动态代理类型:
JDK动态代理：适合于代理实现了接口的目标对象、或者直接代理接口
CGLIB动态代理：适合代理未实现接口的目标对象进行代理

1.JDK动态代理

JDK代理用于代理那些 实现了接口的目标对象、或者直接代理接口。JDK代理中，有两大核心：
InvocationHandler接口、Proxy类
代理过程：
1、定义目标对象接口及其实现类
2、自定义InvocationHandler、重写invoke()方法、invoke()方法中调用目标方法及其增强逻辑
3、Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocarionHandler h)创建代理对象并调用方法
代码示例：

  1. // 定义目标对象接口及其实现类
  2. public interface TargetService{
  3.     public class send(msg);
  4. }
  6. public class TargetServiceImpl implements TargetService{
  7.     @Override
  8.     public String send(Stirng send){
  9.         // 方法体
  10.     }
  11. }
  13. // 自定义InvocationHandler对象、重写invoke方法
  14. public MyInvocationHandler implements InvocationHandler{
  15.     // 被代理的目标兑现
  16.     private Object target;
  18.     public MyInvocationHandler(Object target){
  19.         this.target = target;
  20.     }
  22.     /**
  23.      * proxy: 动态生成的代理对象
  24.      * method：与被代理对象中的方法向对应
  25.      * args：当前method方法中的参数
  26.      */
  27.     @Override
  28.     public Object invoke(Object proxy, Method method, Object[] args){
  29.         sout("执行方法前增强");
  31.         // invoke实际上调用了被代理对象中的方法
  32.         Object result = method.invoke(target, args);
  33.         sout("执行方法后增强");
  35.         return result;
  36.     }
  37. }
  39. // 创建代理工厂
  40. public class ProxyFactory{
  41.     public static Object getProxy(Object target){
  42.         return Proxy.newProxyInstance(
  43.             target.getClass().getClassLoader(),        // 目标对象加载器
  44.             target.getClass().getInterfaces(),        // 代理接口
  45.             new InvocationHandler(target)
  46.         );
  47.     }
  48. }
  50. // 使用代理对象
  51. public class Solution{
  52.     public static void main(String[] args){
  53.         TargetService server = (TargetService) ProxyFactory.getProxy(new TargetServiceImpl());
  55.         server.send("jdk动态代理");
  56.     }
  57. }

2.CGLIB代理

CGLIB代理是对JDK代理的一种弥补措施、JDK动态代理中只能代理实现了接口的类以及接口。CGLIB代理可以代理未实现接口的类。CGLIB中也包含两大核心类：
MethodInterceptor接口、Enhancer类
代理过程：
1、创建需要代理的目标对象
2、自定义MethodInterceptor、重写intecept()方法、实现增强逻辑
3、通过Enhancer类的create()方法创建代理对象
代码示例：

  1. // 创建目标对象类
  2. public class TargetService{
  4.     // 发送短信方法
  5.     public String sned(String msg){
  6.         sout("发送信息");
  7.     }
  8. }
  10. // 自定义MethodInterceptor类实现MethodInterceptor接口
  11. public class MyMethodInteceptor implements MethodInteceptor{
  13.     /**
  14.      * obj：需求增强的对象
  15.      * method：需要增强的方法
  16.      * args: 方法入参
  17.      * methodProxy：用户调用原始方法
  18.      */
  19.     @Override
  20.     public Obejct intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy){
  21.         sout("执行前增强逻辑");
  22.         Obejct result = methodProxy.invokeSuper(obj, args);
  23.         sout("知心后增强逻辑");
  25.         return result;
  26.     }
  27. } 
  29. // 创建代理工厂
  30. public class CglibFactory{
  31.     // 通过类的字节码文件进行代理
  32.     public static Object getProxy(Class<?> clazz){
  33.         // 创建cglibdialing增强列
  34.         Enhancer enhancer = new Enhancer();
  36.         // 设置类加载器
  37.         enhancer.setClassLoader(clazz.getClassLoader());
  39.         // 设置被代理类的字节码对象
  40.         enhancer.setSuperclass(clazz);
  42.         // 设置拦截器
  43.         enhancer.setCallback(new MyInterceptor());
  45.         // 返回创建的代理对象
  46.         return enhancer.create();
  47.     }
  48. }
  50. // 调用测试
  51. public class Solution{
  52.     public static void main(String[] args){
  53.         // 从代理工厂中获取代理对象
  54.         TargetService service = (TargetService) CglibFactory.getProxy(TargetService.class);
  56.         service.send("cglib代理测试");
  57.     }
  58. }

4.代理差异

1.静态&动态

灵活性：
1、静态代理只能代理实现了接口的类以及接口、需要为每一个类创建代理类；需要同时修改
2、动态代理中两者皆可以实现代理、且代理修改更加灵活
JVM：
静态代理是在编译时就将接口、 实现类、代理类就转变为class文件。
动态代理是在运行时动态生成类字节码、并加载到JVM中。

2.JDK&CGLIB

扩展性：
JDK代理可代理接口、及其实现了接口的类、且效率更高
CGLIB代理只能代理未实现任何接口的类；是通过生成被代理类的子类来拦截被代理类的方法调用、因此不能代理被final修改的类及其方法。

7.行为型模式

1.策略模式

策略模式指的是通过内部提供多种策略实现机制实现相同的策略接口，调用者需要在策略环境中通过传入对象类型创建对应的策略模式类，然后再执行不同的策略方法。
使用场景：简化冗余判断、高可扩展性。
设计模式之美 - 图16
代码示例：

  1. /**
  2.     创建策略接口
  3. */
  4. public interface Strategy{
  6.     // 接口方法
  7.     void method();
  8. }
  10. /**
  11.     策略1-实现策略接口
  12. */
  13. public class StrategyA implements Strategy{
  15.     @Override
  16.     void method(){
  17.         // 代码块
  18.     }
  19. }
  21. /**
  22.     策略2-实现策略接口
  23. */
  24. public class StrategyB implements Strategy{
  26.     @Override
  27.     void method(){
  28.         // 代码块
  29.     }
  30. }
  32. /**
  33.     策略环境类
  34. */
  35. public class Context{
  36.     // 根据不同的类型、使用不同的策略类
  37.     public void strategyMethodApi(String type){
  38.         Strategy instance;
  40.         // 根据对象进行注入
  41.         public Context(Strategy st){
  42.             this.instance = st;
  43.         }
  45.         // 调用方法
  46.         instance.method();
  47.     }
  48. }

总结：
上述模式应用中，虽然通过不同的策略类简化的行为过程、但是还是难以避免使用if-else判断。可以通过简单工厂模式进行优化策略调用。