设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的，是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式分为三种类型，共23种：

创建型模式

创建型模式的主要关注点是“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。

这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

创建型模式分为：

单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对于某个类只能存在一个实例，该类负责创建自己的实例，并且该类只提供一个取得其实例的方法（静态方法）。

单例设计模式的实现方法

1. 饿汉式
方法1: 静态常量

步骤如下：

  1. 将构造器私有化（防止通过 new 创建一个实例）

  2. 在类的内部创建一个实例

  3. 对外暴露一个静态的公共方法。

    1
    public static Object getInstance();

【实例】

1
2
3
4
5
6
7
8
9
10
11
12
class Singleton {
  // 1.将构造器私有化
  private Singleton();
  
  // 2.在类的内部创建一个实例
  private final static Singleton instance = new Singleton();
  
  // 3.对外提供一个静态的公共方法，返回实例对象
  public static Object getInstance(){
    return instance;
  }
}
1
2
3
4
5
6
@Test
public void singletonTest{
  Singleton instance1 = Singleton.getnstance();
  Singleton instance2 = Singleton.getnstance();
  assert (instance1==instance2);
}

【优缺点】

  • 优点：写法简单、避免线程同步问题（装载类的时候就完成了实例化）
  • 缺点：没有达到懒加载的要求（如果始终没有用到这个实例，那么内存空间就被浪费了）
方法2: 静态代码块

参考上述【静态常量方法】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Singleton{
  // 1.将构造器私有化
  private Singleton();
  
  // 2.在类的内部创建一个实例
  private static Singleton instance;
  static { // 在静态代码块中创建实例
    instance = new Singleton()
  }
  
  // 3.对外提供一个静态的公共方法，返回实例对象
  public static Object getInstance(){
    return instance;
  }
}

【静态常量方法】与【静态代码块方法】本质上是一样的。

2. 懒汉式
方法1: 线程不安全
1
2
3
4
5
6
7
8
9
10
11
12
class Singleton {
  private static Singleton instance;
  private Singleton(){}
  
  // 提供一个静态的公共方法，当调用该方法时，才去创建 instance。即懒汉式
  public static Singleton getInstance() {
    if(instance == null){
      instance = new Singleton();
    }
    return instance;
  }
}
1
2
3
4
5
6
@Test
public void singletonTest{
  Singleton instance1 = Singleton.getnstance();
  Singleton instance2 = Singleton.getnstance();
  assert (instance1==instance2);
}

【优缺点】

  • 优点：在饿汉式的基础上达到懒加载的要求。
  • 缺点：在【多线程】下，由于 if(instance == null){} 代码块不是原子性的，会存在【线程冲突】（不是单例模式）
方法2: 线程安全

由上述我们可知，在【多线程】情况下，不同线程可能会满足 if(instance == null){} 代码块，从而存在线程冲突。所以我们决定在其基础上加入同步代码 synchronized

1
2
3
4
5
6
7
8
9
10
11
12
class Singleton {
  private static Singleton instance;
  private Singleton(){}
  
  // 提供一个静态的公共方法并加入同步代码，解决了线程安全问题
  public static synchronized Singleton getInstance() {
    if(instance == null){
      instance = new Singleton();
    }
    return instance;
  }
}

【优缺点】

  • 优点：达到懒加载的要求并解决了多线程下线程安全问题
  • 缺点：因为使用了 synchronized，效率低
方法3: 双重检查 (Double Check)

为了解决懒汉式中因为使用了 synchronized从而效率低的问题，我们使用如下方法：

  1. 使用 volatile 防止重排序以及在线程之间共享变量的内存可见性：new 创建对象 的过程分为三步，(1) 分配内存空间；(2) 初始化对象；(3) 指向对象的内存地址。而 (2) 和 (3) 可能被编译器自动重排，导致 if 判断为非空从而返回一个未经初始化的对象。
  2. 双重检查单例是否为空。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Singleton {
  private static volatile Singleton instance;
  private Singleton(){}
  
  // 提供一个静态的公共方法并加入同步代码，解决了线程安全问题
  public static Singleton getInstance() {
    if(instance == null){ // a、b
      synchronized (Singleton.class) { // a先进入同步代码块，完成初始化。b在进入时再检查，非空
        if(instance == null){ // 不会重复执行同步代码，保证了效率
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}
  • Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton== null) 检查，这样就可以保证线程安全了。
  • 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步
  • 线程安全、延迟加载、效率较高。

在实际开发中，推荐使用这种单例设计模式

方法4: 静态内部类
  • 当外部类 (Singleton) 装载时静态内部类 (SingletonInstance) 不会被装载
  • 当访问静态内部类中的属性或方法时，静态内部类才会被装载
  • 静态内部类是线程安全的（JVM 底层机制）
1
2
3
4
5
6
7
8
9
10
11
12
class Singleton {
  private Singleton() {}
  
  // 静态内部类，该类中有一个静态的属性
  private static class SingletonInstance() {
    private static final Singleton INSTANCE = new Singleton();
  }
  
  public static Singleton getInstance() {
    return SingletonInstance.INSTANCE;
  }
}
  • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
  • 静态内部类方式在 Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用 getlnstance方法，才会装载 SingletonInstance类，从而完成 Singleton 的实例化。
  • 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  • 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用。
3. 枚举
1
2
3
4
5
6
enum Singleton{
  INSTANCE;
  public void method() {
    // 方法
  }
}
  • 借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

存在的问题

如何破坏单例模式？

除了【枚举】方法外，我们可以使上述的单例类创建多个实例对象（即破坏单例）。

有两种方法，分别是【序列化】和【反射】。

序列化与反序列化
1
2
3
4
5
6
public static void writeObjectToFile() {
  Singleton instance = Singleton.getInstance();
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename));
  oos.writeObject(instance);
  oos.close();
}
1
2
3
4
5
6
public static Object readObjectFromFile() {
  ObjectIntputStream ois = new ObjectInputStream(new FileInputStream(filename));
  Singleton instance = (Singleton) oos.readObject();
  ois.close();
  return instance;
}
1
2
3
4
5
6
7
@Test
public void singletonSerializationTest() {
  writeObjectToFile();
  Singleton instance1 = readObjectFromFile();
  Singleton instance2 = readObjectFromFile();
  assert (instance1 != instance2)
}
反射
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void singletonReflexTest() {
  // 1.获取Singleton的字节码对象
  Class<Singleton> clazz = Singleton.class;
  // 2.获取无参构造方法的对象
  Constructor cons = clazz.getDeclaredConstructor();
  // 3.因为Singleton是private的，所以我们需要“暴力反射”
  cons.setAccessible(true);
  // 4.创建Singleton对象
  Singleton instance1 = (Singleton) cons.newInstance();
  Singleton instance2 = (Singleton) cons.newInstance();
  
  assert (instance1 != instance2);
}

解决上述问题

“序列化与反序列化”破坏单例的解决方案

在 Singleton 类中添加 readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新 new 出来的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Singleton {
  // 1.将构造器私有化
  private Singleton() {}
  
  // 2.静态内部类，该类中有一个静态的属性
  private static class SingletonInstance() {
    private static final Singleton INSTANCE = new Singleton();
  }
  
  // 3.对外提供一个静态的公共方法，返回实例对象
  public static Singleton getInstance() {
    return SingletonInstance.INSTANCE;
  }
  
  // 当进行反序列化时，会自动调用该方法
  public Object readResolve() {
    return SingletonInstance.INSTANCE;
  }
}
1
2
3
4
5
6
public static void writeObjectToFile() {
  Singleton instance = Singleton.getInstance();
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename));
  oos.writeObject(instance);
  oos.close();
}
1
2
3
4
5
6
public static Object readObjectFromFile() {
  ObjectIntputStream ois = new ObjectInputStream(new FileInputStream(filename));
  Singleton instance = (Singleton) oos.readObject();
  ois.close();
  return instance;
}
1
2
3
4
5
6
7
@Test
public void singletonSerializationTest() {
  writeObjectToFile();
  Singleton instance1 = readObjectFromFile();
  Singleton instance2 = readObjectFromFile();
  assert (instance1 == instance2);
}
“反射”破坏单例的解决方案
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Singleton {
  private static boolean flag = false;
  
  // 1.将构造器私有化
  private Singleton() {
    synchronized (Singleton.class) {
      // 判断flag是否为真，若是，则说明不是第一次访问，则抛出异常；若不是，则初始化对象
      if(flag) {
        throw new RuntimeException("不能创建多个对象");
      }
      flag = true;
    }
  }
  
  // 2.静态内部类，该类中有一个静态的属性
  private static class SingletonInstance() {
    private static final Singleton INSTANCE = new Singleton();
  }
  
  // 3.对外提供一个静态的公共方法，返回实例对象
  public static Singleton getInstance() {
    return SingletonInstance.INSTANCE;
  }
  
  // 当进行反序列化时，会自动调用该方法
  public Object readResolve() {
    return SingletonInstance.INSTANCE;
  }
}

说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
  3. 单例模式使用的场景：
    • 需要频繁的进行创建和销毁的对象
    • 创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象
    • 工具类对象
    • 频繁访问数据库或文件的对象(比如数据源、session工厂等）

工厂模式

概述

需求：设计一个咖啡店点餐系统。

设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡 Americano和意式浓缩咖啡 Espresso）；再设计一个咖啡店类（Cafe），咖啡店具有点咖啡的功能。

设计如下：

image-20220706101024505

Coffee 咖啡类：

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Coffee {
  
  public abstract String getName();
  
  public void addSugar() {
    System.out.println("Add sugar...");
  }
  
  public void addMilk() {
    System.out.println("Add milk...");
  }
}
1
2
3
4
5
public class Americano extends Coffee {
  public String getName(){
    return "Americano";
  }
}
1
2
3
4
5
public class Espresso extends Coffee {
  public String getName(){
    return "Espresso";
  }
}

Cafe 咖啡店类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Cafe {
  public Coffee orderCoffee(String type){
    // 声明Coffee类型的变量，根据不同的类型创建不同的Coffee子类对象
    Coffee coffee = null;
    if(type.equals("Americano")){
      coffee = new Americano();
    }
    else if(type.equals("Espresso")){
      coffee = new Espresso();
    }
    else {
      throw new RuntimeException("ERROR: Unknown coffee type");
    }
    // 添加配料
    coffee.addMilk();
    coffee.addSugar();
    return coffee;
  }
}

以上我们可见，如果我们想加入另一种 Caffee 类型，我们需要修改很多代码，耦合度高，这显然违背了软件设计的开闭原则。

如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

在本教程中会介绍三种工厂的使用

  • 简单工厂模式（不属于GOF的23种经典设计模式）
  • 工厂方法模式
  • 抽象工厂模式

简单工厂/静态工厂模式

简单工厂/静态工厂不是一种设计模式，反而像是一种编程习惯。

结构

简单工厂/静态工厂包含如下角色：

  • 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品 ：实现或者继承抽象产品的子类
  • 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
实现

现在使用简单工厂对上面案例进行改进，类图如下：

image-20220706104353075

Coffee 咖啡类：

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Coffee {
  
  public abstract String getName();
  
  public void addSugar() {
    System.out.println("Add sugar...");
  }
  
  public void addMilk() {
    System.out.println("Add milk...");
  }
}
1
2
3
4
5
public class Americano extends Coffee {
  public String getName(){
    return "Americano";
  }
}
1
2
3
4
5
public class Espresso extends Coffee {
  public String getName(){
    return "Espresso";
  }
}

SimpleCoffeeFactory 简单咖啡工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static class SimpleCoffeeFactory {
  public Coffee createCoffee(String type) {
    Coffee coffee = null;
    if(type.equals("Americano")){
      coffee = new Americano();
    }
    else if(type.equals("Espresso")){
      coffee = new Espresso();
    }
    else {
      throw new RuntimeException("ERROR: Unknown coffee type");
    }
    return coffee;
  }
}

Cafe 咖啡店类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Cafe {
  public Coffee orderCoffee(String type) {
    // SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
    // Coffee coffee = factory.createCoffee(type);
    
    // 静态工厂
    Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
    
    // 添加配料
    coffee.addMilk();
    coffee.addSugar();
    return coffee;
  }
}

工厂（factory）处理创建对象的细节，一旦有了 SimpleCoffeeFactory，Cafe 类中的 orderCoffee() 就变成此对象的客户，后期如果需要 Coffee 对象直接从工厂中获取即可。

这样也就解除了和 Coffee 实现类的耦合，同时又产生了新的耦合，Cafe 对象和 SimpleCoffeeFactory 工厂对象的耦合，工厂对象和商品对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改 SimpleCoffeeFactory 的代码，违反了开闭原则（对修改关闭，对扩展开放）。工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。

【优点】

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

【缺点】

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

工厂方法模式

针对上例中的缺点，使用工厂方法模式就可以完美的解决，完全遵循开闭原则。

概念

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

结构

工厂方法模式的主要角色：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
  • 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
实现

使用工厂方法模式对上例进行改进，类图如下：

image-20220706110450907

Coffee 咖啡类：

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Coffee {
  
  public abstract String getName();
  
  public void addSugar() {
    System.out.println("Add sugar...");
  }
  
  public void addMilk() {
    System.out.println("Add milk...");
  }
}
1
2
3
4
5
public class Americano extends Coffee {
  public String getName(){
    return "Americano";
  }
}
1
2
3
4
5
public class Espresso extends Coffee {
  public String getName(){
    return "Espresso";
  }
}

CoffeeFactory 咖啡工厂接口类：

1
2
3
public interface CoffeeFactory {
  Coffee createCoffee();
}

具体的咖啡工厂类：

1
2
3
4
5
6
public class AmericanoFactory implements CoffeeFactory {
  @Override
  public Coffee createCoffee {
    return new Americano(); 
  }
}
1
2
3
4
5
6
public class EspressoFactory implements CoffeeFactory {
  @Override
  public Coffee createCoffee {
    return new Espresso(); 
  }
}

Cafe 咖啡店类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Cafe {
  private CoffeeFactory factory;
  public void setFactory(CoffeeFactory factory) {
    this.factory = factory;
  }
  
  public Coffee orderCoffee(String type) {
    Coffee coffee = factory.createCoffee();
    // 添加配料
    coffee.addMilk();
    coffee.addsugar();
    return coffee;
  }
}

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。

工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

【优点】

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
  • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

【缺点】

  • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

抽象工厂模式

前面介绍的工厂方法模式中考虑的是一类产品的生产，这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示

image-20220706114743401
  • 横轴是产品等级，也就是同一类产品；
  • 纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。
概念

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

结构

抽象工厂模式的主要角色如下：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
  • 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
实现

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏 Tiramisu、抹茶慕斯 MatchaMousse 等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生【类爆炸】情况。其中，

  • 意式浓缩咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；

  • 意式浓缩咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）；

所以这个案例可以使用抽象工厂模式实现。类图如下：

image-20220719134607944

代码如下：

抽象工厂

1
2
3
4
public interface Factory {
  Coffee createCoffee();
  Dessert createDessert();
}
1
2
3
4
5
6
7
8
9
public class AmericanFlavorFactory implements Factory {
  public Coffee createCoffee(){
    return new Americano;
  }
  
  public Dessert createDessert(){
    return new MatchaMousse;
  }
}
1
2
3
4
5
6
7
8
9
public class ItalyFlavorFactory implements Factory {
  public Coffee createCoffee(){
    return new Espresso;
  }
  
  public Dessert createDessert(){
    return new Tiramisu;
  }
}

Coffee 咖啡类：

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Coffee {
  
  public abstract String getName();
  
  public void addSugar() {
    System.out.println("Add sugar...");
  }
  
  public void addMilk() {
    System.out.println("Add milk...");
  }
}
1
2
3
4
5
public class Americano extends Coffee {
  public String getName(){
    return "Americano";
  }
}
1
2
3
4
5
public class Espresso extends Coffee {
  public String getName(){
    return "Espresso";
  }
}

甜品类 Dessert

1
2
3
public abstract class Dessert {
  public abstract void show();
}
1
2
3
4
5
public class Tiramisu extends Dessert{
  public void show(){
    System.out.println("Tiramisu");
  }
}
1
2
3
4
5
public class MatchaMousse extends Dessert{
  public void show(){
    System.out.println("MatchaMousse");
  }
}

测试方法

1
2
3
4
5
6
@Test
public createTiramisuTest(){
  ItalyDessertFactory factory = new ItalyDessertFactory();
  Dessert tiramisu = factory.createDessert();
  tiramisu.show();
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

【优缺点】

  • 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
  • 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

【使用场景】

  • 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
  • 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
  • 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

结构型模式

代理模式

意图：为对象提供一种代理，以控制对这个对象的访问，同时也可以对这个对象进行功能增强。代理对象在其中充当中介的作用。

**主要解决：**在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

例如，我们有一个 A 类，我们想调用 C 类的方法以完成某项功能，但是 C 类不允许 A 类调用。此时，我们可以在 A 类和 C 类之间创建一个代理类 C_Proxy，让 A 类访问 C_Proxy 完成功能。

image-20220705163306183

被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象

使用代理模式的作用：

  1. 功能增强：在原有的功能上，增加了额外的功能。新增加的功能，就叫做功能增强。
  2. 控制访问：不允许之间访问被代理类

实现代理的方式：

  1. 静态代理：
    • 代理类是我们手动实现的，自己创建一个 Java 类表示代理类
    • 同时所要代理的类是确定的
    • 特点：实现简单；容易理解
  2. 动态代理：

静态代理

静态代理在使用时，需要定义接口，被代理对象（即目标对象）与代理对象一起实现相同的接口或继承相同的父类

【实例】

image-20220705164019880

  • 定义一个接口：Teacher

  • 目标对象 TeacherImpl 实现接口 Teacher

  • 使用静态代理方式，就需要在代理对象 TeacherImplProxy 中也实现接口 Teacher

  • 调用时，通过调用代理对象，来实现调用目标对象

    ⚠️ 目标对象和代理对象要实现相同的接口。

1
2
3
4
public interface Teacher {
    
    public void teach();
}
1
2
3
4
5
6
7
8
public class TeacherImpl implements Teacher {
    
    // 重写实现方法
    @Override
    public void teach(){
        System.out.println("teaching...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TeacherImplProxy implements Teacher {
    
    // 被代理对象，通过接口聚合
    private Teacher teacher;
    
    // 构造方法，传入一个被代理对象的接口
    public TeacherImplProxy (Teacher teacher) {
        this.teacher = teacher;
    }

    // 重写代理方法
    @Override
    public void teach(){
        System.out.println("代理开始");
        target.teach();
        System.out.println("代理结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Client {
    public static void main(String[] args) {
        
        // 创建目标对象（被代理对象）
        Teacher teacher = new TeacherImpl();
        
        // 创建代理对象，同时将被代理对象传递给代理对象
        TeacherImplProxy teacherProxy = new TeacherImplProxy(teacher);
        
        // 通过代理对象，调用被代理对象的方法
        // 即：执行的是代理对象的方法，代理对象再去调用被代理对象的方法
        teacherProxy.teach();
    }
}

如果对接口进行改动，那么目标对象和代理对象都要改动。此时我们考虑动态代理。

动态代理

动态代理的基本介绍：

  • 代理对象不需要实现接口，但是目标对象需要实现接口，否则不能使用动态代理

  • 代理对象的生成，是利用 JDK 提供的 API 实现的。动态的在内存中构建代理对象

    • 代理类所在包：java.lang.reflect.Proxy（基于反射）

    • JDK 实现代理只需要调用 newProxyInstance() 方法

      1
      2
      3
      static Object newProxyInstance(ClassLoader loader,			//类加载器，需要指定动态生成的代理类的类加载器
                                    Class<?>[] interfaces, 		// 传入目标对象
                                    InvocationHandler handler);	// 设置代理类中的抽象方法如何重写

  • 动态代理也叫做 JDK 代理、接口代理

【实例】（参考静态代理）

image-20220705164425482

  • 定义一个接口：Teacher

  • 目标对象 TeacherImpl 实现接口 Teacher

  • 使用静态代理方式，就需要在代理对象 TeacherImplProxy 中也实现接口 Teacher

  • 调用时，通过调用代理对象，来实现调用目标对象

    ⚠️ 目标对象和代理对象要实现相同的接口。

1
2
3
4
public interface Teacher {
  public void teach();
  public void sayHello(String name);
}
1
2
3
4
5
6
7
8
9
10
public class TeacherImpl implements Teacher {
  @Override
  public void teach(){
    System.out.println("teaching...");
  }
  @Override
  public void sayHello(String name){
    System.out.println("Hello, " + name);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class CalculateProxyFactory {
    // 被代理的对象
    private Object proxyTarget;

    public CalculateProxyFactory(Object proxyTarget) {
        this.proxyTarget = proxyTarget;
    }

    public Object getProxyInstance() {
        /**
         * Proxy.newProxyInstance 传入参数:
         *      ClassLoader loader: 类加载器，需要指定动态生成的代理类的类加载器
         *      Class<?>[] interfaces: 获取目标对象实现的所有接口
         *      InvocationHandler h: 设置代理类中的抽象方法如何重写
         */
        return Proxy.newProxyInstance(
                proxyTarget.getClass().getClassLoader(),
                proxyTarget.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy,
                                         Method method,
                                         Object[] args
                                        ) throws Throwable {
                        /**
                         * Object proxy: 表示被代理的对象
                         * Method method: 要执行的方法
                         * Object[] args: method 方法的参数列表
                         */
                        Object result = null;
                        try {
                            System.out.println("方法开始");
                            // 调用proxyTarget对象的方法
                            result = method.invoke(proxyTarget, args);
                            System.out.println("方法结束");
                        } catch (Exception e){
                            System.out.println("捕获异常: ");
                            e.printStackTrace();
                        } finally {
                            System.out.println("代理结束");
                        }

                        return result;
                    }
                });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {
    public static void main(String[] args) {
        
        // 创建目标对象（被代理对象）
        Teacher teacher = new TeacherImpl();
        
        // 创建代理对象，内存中动态生成了代理对象
        Teacher teacherProxy = (Teacher) new ProxyFactory(teacher).getProxyInstance();
        
        // 通过代理对象，调用被代理对象的方法
        // 即：执行的是代理对象的方法，代理对象再去调用被代理对象的方法
        teacherProxy.teach();
        teacherProxy.sayHello("gdai");
    }
}
1
2
3
4
5
6
7
8
方法开始
teaching...
方法结束
代理结束
方法开始
Hello, gdai
方法结束
代理结束

装饰模式

模式定义

在不改变原有对象的基础上，将其他功能附加到对象上。

【优点】

  1. 不改变原有对象的情况下给一个对象拓展功能
  2. 使用不同的组合可以实现不同的效果
  3. 体现开闭原则
  4. 低耦合

例如我们想开发一个【拍照功能】，我们已经写好了一个基础的【拍照功能】，现在我们想在这个基础功能上添加【滤镜功能】。我们不能直接对原有的【拍照功能】进行更改，因为这样有可能会破坏原有功能，所以我们使用装饰器模式来增强原有功能

类图

image-20220617141948195

代码结构

1
2
3
public interface Component {
  void operation();
}
1
2
3
4
5
6
public class ConcerteComponent implements Component {
  @Override
  public void operation(){
    System.out.println("拍照...");
  }
}
1
2
3
4
5
6
7
abstract class Decorator implements Component {
  public Component compontent;
  
  public Decorator(Component compontent){
    this.component = compontent;
  }
}
1
2
3
4
5
6
7
8
9
10
public class ConcreteDecorator_Filter extends Decorator{
  public ConcreteDecorator_Filter(Component compontent){
    super.compontent;
  }
  @Override
  public void operation(){
    System.out.println("添加滤镜...");
    compontent.operation(); // 原有的功能
  }
}
1
2
3
4
5
6
public class DecoratorTest {
  public static void main (String[] args){
    Component component = new ConcreteDecorator_Filter(new ConcreteComponent());
    component.operation();
  }
}
1
2
添加滤镜...
拍照...

Python 中的装饰器

我们有如下两个函数 func1() 和 func_muilt(*args,**kwargs)，我们需要在这个在这两个函数的前后分别加入登入login(func) 和登出logout(func) 两个功能。我们就可以使用到装饰器 Decorator

1
2
3
4
5
6
7
# @login 为调用装饰器login
@login
@logout
def func1(): # 无参函数
  print('this is func1')
  
func1()
1
2
3
login...
this is func1
logout...
1
2
3
4
5
6
7
8
# 以下就是python中装饰器的标准形式
def login(func):
  # *args为可变参数，可以适配多个传入参数
  # **kwargs为可变关键字参数，可以适配多个关键字参数
  def wrapper(*args, **kwargs):
    print('login...')
    func(*args, **kwargs)
  return wrapper
1
2
3
4
5
def logout(func):
  def wrapper(*args, **kwargs):
    func(*args, **kwargs)
    print('logout...')
  return wrapper
1
2
3
4
5
6
7
8
# 带参
@login
@logout
def func_muilt(*args,**kwargs):
  print('this is func_muilt', *args)
  print(**kwargs)
  
func_muilt('python', y1='ok', y2='oui')
1
2
3
4
login...
this is func_muilt python
{'y1':'ok', 'b2':'oui'}
logout...

行为型模式