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），再次进行处理。如果没有合适的处理者，请求将无法被处理。

通过使用责任链模式，订单处理过程被解耦，每个处理者只需要关注自己的处理逻辑，增加新的处理者或者调整处理者的顺序也变得灵活和简单。