Java架构师之路九、设计模式：常见的设计模式，如单例模式、工厂模式、策略模式、桥接模式等

Java架构师之路九、设计模式：常见的设计模式，如单例模式、工厂模式、策略模式、桥接模式等
目录

常见的设计模式：

单例模式：

工厂模式：

策略模式：

桥接模式：

责任链模式：

Java架构师之路八、安全技术：Web安全、网络安全、系统安全、数据安全等-CSDN博客

 Java架构师之路十、框架和工具：Spring Framework、Spring Boot、Spring Cloud、MyBatis、Hibernate、Dubbo、Zookeeper、Redis等-CSDN博客

常见的设计模式：

在 Java 中，设计模式是软件开发中常用的解决方案模板，可以帮助开发者解决特定的设计问题并提高代码的可重用性、可维护性和灵活性。Java 中常见的设计模式包括创建型模式、结构型模式、行为型模式以及其他模式，其中还包括责任链模式。
1. 创建型模式：
  - 工厂模式（Factory Pattern）：定义一个创建对象的接口，但让子类决定实例化哪个类。
  - 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
  - 建造者模式（Builder Pattern）：将一个复杂对象的构建过程与其表示分离，使相同的构建过程可以创建不同的表示。
2. 结构型模式：
  - 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口，使原本由于接口不兼容而不能在一起工作的类可以一起工作。
  - 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不影响从这个类派生的其他对象。
  - 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
3. 行为型模式：
  - 观察者模式（Observer Pattern）：定义对象间的一对多依赖关系，使得当一个对象改变状态时，所有依赖它的对象都会得到通知并自动更新。
  - 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们可以互相替换。
  - 模板方法模式（Template Method Pattern）：定义算法的框架，由子类实现具体步骤。
  - 责任链模式（Chain of Responsibility Pattern）：为请求创建一个接收者对象的链，并沿着这条链传递请求，直到有对象处理请求为止。
4. 其他模式：
  - 享元模式（Flyweight Pattern）：通过共享技术来有效支持大量细粒度对象的复用。
  - 备忘录模式（Memento Pattern）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
这些设计模式在 Java 开发中有着广泛的应用，合理运用设计模式可以提高软件的质量和可维护性，降低系统的耦合度，使代码更加清晰易懂。责任链模式特别适用于处理请求的场景，可以灵活地组织处理者链条，实现请求与处理者的解耦，提高代码的灵活性和可扩展性。

单例模式：

单例模式是一种创建型设计模式，保证一个类只有一个实例，并提供一个全局访问点。在实际应用中，有些对象只需要一个实例，例如线程池、缓存、对话框、注册表设置等。单例模式可以确保系统中某个类只有一个实例，避免了重复创建对象，节省了系统资源，并且方便对该实例的控制和管理。

在 Java 中，单例模式通常有几种实现方式：
1. 懒汉式：
  - 延迟加载，在第一次使用时创建实例。
  - 线程安全需要考虑，可以通过 synchronized 加锁，或者使用双重检查锁定（Double-Checked Locking）。
  - 可能会存在性能问题，因为每次获取实例都需要进行同步操作。
2. 饿汉式：
  - 类加载时即创建实例。
  - 线程安全，但可能会浪费内存。
3. 静态内部类：
  - 利用类加载机制保证线程安全且延迟加载。
  - 通过静态内部类持有外部类的实例，当外部类被加载时静态内部类并不会被加载和初始化。
4. 枚举：
  - 最简洁、安全的实现方式，由 JVM 保证只会实例化一次。
  - 防止反射和序列化攻击。
实现单例模式时需要考虑线程安全性、延迟加载、性能等因素。在选择实现方式时，可以根据具体需求和场景来决定使用哪种方式。单例模式在很多框架和库中都有广泛应用，如 Spring 框架中的 Bean 默认就是单例模式，保证了在应用中只有一个 Bean 实例存在。

总的来说，单例模式是一种常见且重要的设计模式，合理使用可以提高代码的效率和可维护性，但也需要注意避免滥用单例模式导致的问题，如增加代码耦合度、隐藏依赖关系等。

懒汉式单例模式：

在懒汉式单例模式中，实例在需要的时候才被创建。

实现步骤：
1. 将构造函数设置为私有，防止外部直接实例化该类。
2. 提供一个静态方法获取实例，在方法内部判断实例是否为空，为空则创建实例，否则直接返回实例。
Java 代码示例：
```
public class LazySingleton {
    private static LazySingleton instance;
 
    private LazySingleton() {
        // 私有构造函数
    }
 
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
```
示例代码说明：
- LazySingleton 类中的构造函数是私有的，外部无法直接实例化。
- getInstance() 方法是获取实例的静态方法，通过判断instance 是否为空来决定是否创建实例。
测试代码：
```
public class Main {
    public static void main(String[] args) {
        LazySingleton singleton1 = LazySingleton.getInstance();
        LazySingleton singleton2 = LazySingleton.getInstance();
 
        System.out.println(singleton1 == singleton2); // 输出 true，说明是同一个实例
    }
}
```
示例说明：
- 在上面的示例中，通过调用 LazySingleton.getInstance() 方法两次获取实例，得到的两个实例是相同的，因为单例模式确保了只有一个实例存在。
- 这种懒汉式单例模式虽然简单，但在多线程环境下存在线程安全问题，可能会创建多个实例。可以通过加锁或使用双重检查锁定等方式来解决线程安全性问题。
工厂模式：

工厂模式是一种创建型设计模式，它提供一种封装对象创建过程的方式。工厂模式通过定义一个共同的接口来创建对象，但具体的实现由子类决定。这样可以将对象的创建与使用代码解耦，提高代码的灵活性和可维护性。

工厂模式常见的几种变体包括简单工厂模式、工厂方法模式和抽象工厂模式。

下面分别详细介绍这三种工厂模式的实现方式，并给出相应的代码示例：

1. 简单工厂模式（Simple Factory Pattern）：

简单工厂模式通过一个工厂类负责创建多个不同类型的对象。

实现步骤：
1. 创建一个共同的接口或抽象类，用于描述所要创建的对象。
2. 创建具体的实现类，实现共同的接口或抽象类。
3. 创建一个简单工厂类，负责根据参数的不同返回不同的具体对象。
Java 代码示例：
```
// 共同的接口
public interface Product {
    void operation();
}
 
// 具体的实现类
public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}
 
public class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}
 
// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}
```
示例代码说明：
- Product 是一个共同的接口，描述了所要创建的对象应具有的行为。
- ConcreteProductA 和 ConcreteProductB 是具体的实现类，实现了 Product 接口。
- SimpleFactory 是简单工厂类，根据参数的不同返回不同的具体对象。
测试代码：
```
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation(); // 输出 "ConcreteProductA operation"
 
        Product productB = SimpleFactory.createProduct("B");
        productB.operation(); // 输出 "ConcreteProductB operation"
    }
}
```
2. 工厂方法模式（Factory Method Pattern）：

工厂方法模式将对象的创建延迟到子类，每个子类负责创建一个具体的对象。

实现步骤：
1. 创建一个抽象工厂类，声明一个抽象的工厂方法。
2. 创建具体的工厂类，实现抽象工厂类中的工厂方法，每个具体工厂类负责创建一个具体的对象。
3. 创建一个共同的接口或抽象类，用于描述所要创建的对象。
4. 创建具体的实现类，实现共同的接口或抽象类。
Java 代码示例：
```
// 共同的接口
public interface Product {
    void operation();
}
 
// 具体的实现类
public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}
 
public class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}
 
// 抽象工厂类
public abstract class Factory {
    public abstract Product createProduct();
}
 
// 具体的工厂类
public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
 
public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
```
示例代码说明：
- Product 是一个共同的接口，描述了所要创建的对象应具有的行为。
- ConcreteProductA 和 ConcreteProductB 是具体的实现类，实现了 Product 接口。
- Factory 是抽象工厂类，声明了一个抽象的工厂方法 createProduct()。
- ConcreteFactoryA 和 ConcreteFactoryB 是具体的工厂类，分别负责创建 ConcreteProductA 和 ConcreteProductB 对象。
测试代码：
```
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation(); // 输出 "ConcreteProductA operation"
 
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation(); // 输出 "ConcreteProductB operation"
    }
}
```
3. 抽象工厂模式（Abstract Factory Pattern）：

抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象。

实现步骤：
1. 创建一组共同的接口，用于描述所要创建的对象。
2. 创建多个具体的实现类，实现共同的接口。
3. 创建一个抽象工厂类，声明创建一组对象的抽象方法。
4. 创建具体的工厂类，实现抽象工厂类中的抽象方法，负责创建一组相关的对象。
Java 代码示例：
```
// 共同的接口
public interface ProductA {
    void operationA();
}
 
public interface ProductB {
    void operationB();
}
 
// 具体的实现类
public class ConcreteProductA1 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operationA");
    }
}
 
public class ConcreteProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}
 
public class ConcreteProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1 operationB");
    }
}
 
public class ConcreteProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operationB");
    }
}
 
// 抽象工厂类
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}
 
// 具体的工厂类
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
 
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
 
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
 
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
```
示例代码说明：
- ProductA 和 ProductB 是一组共同的接口，描述了所要创建的对象应具有的行为。
- ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是具体的实现类，分别实现 ProductA 和 ProductB 接口。
- AbstractFactory 是抽象工厂类，声明了创建一组对象的抽象方法 createProductA() 和 createProductB()。
- ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别负责创建一组相关的对象。
测试代码：
```
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.operationA(); // 输出 "ConcreteProductA1 operationA"
        ProductB productB1 = factory1.createProductB();
        productB1.operationB(); // 输出 "ConcreteProductB1 operationB"
 
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.operationA(); // 输出 "ConcreteProductA2 operationA"
        ProductB productB2 = factory2.createProductB();
        productB2.operationB(); // 输出 "ConcreteProductB2 operationB"
    }
}
```
工厂模式通过封装对象的创建过程，将对象的具体类型与使用代码解耦，提供了一种灵活的方式来创建对象。它能够隐藏对象的创建细节，简化了客户端的代码，并且方便扩展和维护。工厂模式在实际应用中经常被使用，例如在 Java 中，Spring 框架的 BeanFactory 就是一个工厂模式的实现。

策略模式：

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装在独立的类中，使得它们可以互相替换。策略模式使得算法可以独立于使用它的客户端而变化。

在策略模式中，有三个核心角色：
1. 上下文（Context）：上下文是客户端与策略模式之间的接口，它负责调用具体的策略对象来完成任务。
2. 策略（Strategy）：策略是定义了一组相同行为的接口或抽象类，它代表了一种算法或行为。
3. 具体策略（Concrete Strategy）：具体策略是策略接口的实现类，它实现了具体的算法或行为。
策略模式的优点包括：
1. 提高代码的可扩展性：由于策略模式将算法封装在独立的类中，因此可以很容易地添加新的策略类来扩展系统的功能。
2. 提供了一定程度的灵活性：客户端可以根据需要选择不同的策略来完成特定的任务，而不需要修改客户端的代码。
3. 使代码易于理解和维护：策略模式将不同的算法分离开来，使得每个算法都具有清晰的目的和职责，使代码更加可读和易于维护。
下面是一个简单的策略模式的示例，以计算商品折扣价格为例：
```
// 策略接口
public interface DiscountStrategy {
    double applyDiscount(double price);
}
 
// 具体策略类
public class NoDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price;
    }
}
 
public class FixedDiscountStrategy implements DiscountStrategy {
    private double discountAmount;
 
    public FixedDiscountStrategy(double discountAmount) {
        this.discountAmount = discountAmount;
    }
 
    @Override
    public double applyDiscount(double price) {
        return price - discountAmount;
    }
}
 
public class PercentageDiscountStrategy implements DiscountStrategy {
    private double discountPercentage;
 
    public PercentageDiscountStrategy(double discountPercentage) {
        this.discountPercentage = discountPercentage;
    }
 
    @Override
    public double applyDiscount(double price) {
        return price * (1 - discountPercentage);
    }
}
 
// 上下文类
public class Product {
    private String name;
    private double price;
    private DiscountStrategy discountStrategy;
 
    public Product(String name, double price, DiscountStrategy discountStrategy) {
        this.name = name;
        this.price = price;
        this.discountStrategy = discountStrategy;
    }
 
    public double getPriceAfterDiscount() {
        return discountStrategy.applyDiscount(price);
    }
}
 
// 客户端代码
public class Main {
    public static void main(String[] args) {
        Product product1 = new Product("Product 1", 100.0, new NoDiscountStrategy());
        System.out.println("Price: " + product1.getPriceAfterDiscount());  // 输出 "Price: 100.0"
 
        Product product2 = new Product("Product 2", 100.0, new FixedDiscountStrategy(20.0));
        System.out.println("Price: " + product2.getPriceAfterDiscount());  // 输出 "Price: 80.0"
 
        Product product3 = new Product("Product 3", 100.0, new PercentageDiscountStrategy(0.25));
        System.out.println("Price: " + product3.getPriceAfterDiscount());  // 输出 "Price: 75.0"
    }
}
```
在上述示例中，策略模式通过定义 DiscountStrategy 接口和具体的策略类 NoDiscountStrategy、FixedDiscountStrategy 和 PercentageDiscountStrategy 来实现不同的折扣算法。Product 类作为上下文类，它包含一个折扣策略对象，并通过调用 applyDiscount() 方法来计算最终的折扣价格。

通过使用策略模式，客户端可以根据具体的需求选择不同的折扣策略，而无需修改上下文类的代码。这样一来，当需要添加新的折扣策略时，只需要创建新的具体策略类并实现 DiscountStrategy 接口即可，而不会对原有的代码造成影响。这提高了代码的可扩展性和灵活性。

桥接模式：

桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立变化而互不影响。桥接模式通过组合的方式，将抽象和实现解耦，从而可以在两者之间建立一座桥梁，使它们可以独立地进行变化和扩展。

在桥接模式中，有四个核心角色：
1. 抽象类（Abstraction）：定义了抽象部分的接口，维护一个指向实现类的引用。
2. 具体实现类（Concrete Implementation）：实现了实现部分的接口，并具体实现了其方法。
3. 实现类接口（Implementation）：定义了实现部分的接口，供具体实现类实现。
4. 具体抽象类（Concrete Abstraction）：继承自抽象类，实现了抽象部分的具体功能。
桥接模式的优点包括：
1. 解耦抽象和实现：桥接模式通过将抽象部分和实现部分分离，使得它们可以独立变化，互不影响。
2. 扩展性强：由于抽象部分和实现部分可以独立变化，因此很容易添加新的抽象类或实现类，扩展系统的功能。
3. 隐藏实现细节：桥接模式可以隐藏实现部分的细节，使客户端只需要关注抽象部分即可。
下面是一个简单的桥接模式的示例，以形状和颜色为例：
```
// 颜色接口
public interface Color {
    void applyColor();
}
 
// 红色类
public class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying red color");
    }
}
 
// 蓝色类
public class BlueColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}
 
// 形状抽象类
public abstract class Shape {
    protected Color color;
 
    public Shape(Color color) {
        this.color = color;
    }
 
    public abstract void applyColor();
}
 
// 圆形类
public class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }
 
    @Override
    public void applyColor() {
        System.out.print("Circle filled with ");
        color.applyColor();
    }
}
 
// 正方形类
public class Square extends Shape {
    public Square(Color color) {
        super(color);
    }
 
    @Override
    public void applyColor() {
        System.out.print("Square filled with ");
        color.applyColor();
    }
}
 
// 客户端代码
public class Main {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedColor());
        redCircle.applyColor();  // 输出 "Circle filled with Applying red color"
 
        Shape blueSquare = new Square(new BlueColor());
        blueSquare.applyColor();  // 输出 "Square filled with Applying blue color"
    }
}
```
在上述示例中，桥接模式通过将形状类和颜色类分离，使它们可以独立变化。Shape 是抽象类，它包含一个颜色对象，并定义了一个抽象方法 applyColor()。Circle 和 Square 是具体抽象类，它们继承自 Shape，并实现了 applyColor() 方法来应用颜色。

通过使用桥接模式，客户端可以选择不同的颜色来填充不同的形状，而不需要修改形状类的代码。这样一来，当需要添加新的形状或颜色时，只需要创建新的具体抽象类并传入相应的颜色对象即可，而不会对原有的代码造成影响。桥接模式提高了代码的灵活性和可扩展性。

责任链模式：

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，用于解耦发送者和接收者之间的关系。在责任链模式中，多个对象（处理者）依次处理请求，直到其中一个对象能够处理该请求为止。这些对象被串成一条链，请求沿着链传递，直到有一个处理者处理它为止。

责任链模式通常包括以下几个角色：
1. 抽象处理者（Handler）：定义一个处理请求的接口，通常包括一个处理请求的方法和一个设置下一个处理者的方法。
2. 具体处理者（ConcreteHandler）：实现抽象处理者接口，在处理请求时可以决定是否自己处理，或者将请求传递给下一个处理者。
3. 客户端（Client）：创建责任链，并向链头的处理者发送请求。
责任链模式的优点包括：
- 解耦发送者和接收者：发送者不需要知道具体的接收者，只需将请求发送给第一个处理者即可。
- 灵活性增强：可以动态地修改责任链中的处理者顺序或增加新的处理者，而不需要修改客户端代码。
- 可以动态地指定处理者：每个处理者都有机会处理请求，客户端可以根据需要灵活地指定处理者的顺序。
然而，责任链模式也存在一些缺点，包括：
- 请求可能未被处理：如果责任链没有正确配置或者最终没有处理请求的处理者，请求可能会被漏掉。
- 性能问题：请求需要沿着责任链传递，可能导致一定的性能损失，特别是在责任链较长时。
总的来说，责任链模式适合于多个对象可以处理同一请求，且客户端不需要明确指定处理者的情况下使用。通过合理设计责任链，可以更好地管理和处理请求，提高系统的灵活性和可扩展性。

假设我们有一个在线商城系统，当用户下单购买商品时，订单需要经过一系列的处理流程来验证和处理。这时候可以使用责任链模式来处理订单。

首先，我们定义一个抽象处理者（Handler）接口，其中包含处理请求的方法和设置下一个处理者的方法。
```
public interface OrderHandler {
    void handleOrder(Order order);
    void setNextHandler(OrderHandler handler);
}
```
然后，我们创建具体的处理者类，实现抽象处理者接口，并在处理请求时决定是否自己处理或者将请求传递给下一个处理者。
```
public class StockHandler implements OrderHandler {
    private OrderHandler nextHandler;
    
    public void handleOrder(Order order) {
        if (order.getStock() >= order.getQuantity()) {
            System.out.println("库存充足，可以继续处理订单。");
            // 处理订单逻辑...
        } else {
            System.out.println("库存不足，无法处理订单，将请求传递给下一个处理者。");
            passToNextHandler(order);
        }
    }
    
    public void setNextHandler(OrderHandler handler) {
        this.nextHandler = handler;
    }
    
    private void passToNextHandler(Order order) {
        if (nextHandler != null) {
            nextHandler.handleOrder(order);
        } else {
            System.out.println("没有合适的处理者，请求无法处理。");
        }
    }
}
 
public class PaymentHandler implements OrderHandler {
    private OrderHandler nextHandler;
    
    public void handleOrder(Order order) {
        if (order.isPaymentValid()) {
            System.out.println("支付有效，可以继续处理订单。");
            // 处理订单逻辑...
        } else {
            System.out.println("支付无效，无法处理订单，将请求传递给下一个处理者。");
            passToNextHandler(order);
        }
    }
    
    public void setNextHandler(OrderHandler handler) {
        this.nextHandler = handler;
    }
    
    private void passToNextHandler(Order order) {
        if (nextHandler != null) {
            nextHandler.handleOrder(order);
        } else {
            System.out.println("没有合适的处理者，请求无法处理。");
        }
    }
}
```
最后，我们创建客户端代码，创建责任链，并向链头的处理者发送订单请求。
```
public class Client {
    public static void main(String[] args) {
        OrderHandler stockHandler = new StockHandler();
        OrderHandler paymentHandler = new PaymentHandler();
        
        stockHandler.setNextHandler(paymentHandler);
        
        Order order = new Order("ABC123", 10, 100.0);
        stockHandler.handleOrder(order);
    }
}
```
在上述例子中，订单首先会经过库存处理者（StockHandler），如果库存充足，则订单被处理；否则，请求会被传递给支付处理者（PaymentHandler），再次进行处理。如果没有合适的处理者，请求将无法被处理。

通过使用责任链模式，订单处理过程被解耦，每个处理者只需要关注自己的处理逻辑，增加新的处理者或者调整处理者的顺序也变得灵活和简单。
相关阅读:
基于OpenFeign实现服务调用
 亚马逊运营纯干货：如何引流？亚马逊站外引流最全讲解
 记录一次Mac M1 WebStorm 的性能优化记录
 GitLab CI/CD关键词（十三）：资源组 resource_group，部署环境 environment
关系型数据库之 MySQL 详解：从入门到精通【面试圣经】
[附源码]计算机毕业设计基于Springboot绿色生活交流社区网站
 XSS跨站脚本攻击
 集合—Collections工具类
 ROS机器人应用（5）—— 键盘和发布话题控制小车移动
 电机与拖动 - 2 变压器
原文地址：https://blog.csdn.net/shenzhiyoushen/article/details/136232095

常见的设计模式：

单例模式：

懒汉式单例模式：

实现步骤：

Java 代码示例：

示例代码说明：

测试代码：

示例说明：

工厂模式：

1. 简单工厂模式（Simple Factory Pattern）：

实现步骤：

Java 代码示例：

示例代码说明：

测试代码：

2. 工厂方法模式（Factory Method Pattern）：

实现步骤：

Java 代码示例：

示例代码说明：

测试代码：

3. 抽象工厂模式（Abstract Factory Pattern）：

实现步骤：

Java 代码示例：

示例代码说明：

测试代码：

策略模式：

桥接模式：

责任链模式：