Spring 框架中用到的设计模式

Spring 框架的设计模式

[一、工厂模式（Factory Pattern）](#一、工厂模式（Factory Pattern）)
[二、单例模式（Singleton Pattern）](#二、单例模式（Singleton Pattern）)
[三、代理模式（Proxy Pattern）](#三、代理模式（Proxy Pattern）)
[四、模板方法模式（Template Method Pattern）](#四、模板方法模式（Template Method Pattern）)

工厂模式，单例模式，策略模式，代理模式，模板方法，
适配器模式

主要介绍以下四种

一、工厂模式（Factory Pattern）

核心作用：创建对象，将对象的创建和使用分离。

根据传入的参数创建对应的产品对象，将对象创建逻辑封装在工厂类中

提供创建一系列相关或相互依赖对象的接口，无需指定具体类

java 复制代码

// 产品接口
interface Product {
    void operation();
}
// 具体产品类1
class ConcreteProduct1 implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct1 operation");
    }
}
// 具体产品类2
class ConcreteProduct2 implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct2 operation");
    }
}
// 工厂类
class Factory {
    public static Product createProduct(String type) {
        if ("product1".equals(type)) {
            return new ConcreteProduct1();
        } else if ("product2".equals(type)) {
            return new ConcreteProduct2();
        }
        return null;
    }
}

二、单例模式（Singleton Pattern）

核心作用：确保一个类仅有一个实例，并提供全局访问点。

懒汉原则

只创建一个对象,当方法再被调用时如果已创建过对象则直接返回该对象不重新创建

java 复制代码

public class SingletonLazy {
    private static SingletonLazy instance;
    // 私有构造函数
    private SingletonLazy() {}
    // 静态访问方法
    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

饿汉原则

调用一次方法返回创建一次对象,但由于对象变量被static修饰,所以只能创建一次

java 复制代码

public class SingletonEager {
    private static final SingletonEager instance = new SingletonEager();
    // 私有构造函数
    private SingletonEager() {}
    // 静态访问方法
    public static SingletonEager getInstance() {
        return instance;
    }
}

使用步骤

构造私有函数

为了防止外部代码通过 new 关键字创建类的实例，单例类的构造函数必须是私有的。

静态实例变量

在类内部定义一个静态的实例变量，用于保存该类的唯一实例。

静态访问方法

提供一个静态方法，用于获取该类的唯一实例。这个方法通常会在第一次调用时创建实例，之后每次调用都返回同一个实例。

三、代理模式（Proxy Pattern）

动态（无实体代理类）

优点：方法隔离，代码增强

系统提供动态代理创建通过内部类

第三方提供动态代理对象的创建

静态（有代理类）

核心作用：为对象提供一个代理，以控制对原对象的访问（如添加额外功能）。

使用步骤：

1，获取代理对象

2，创建构造方法

3，调用不同代理对象的方法

java 复制代码

// 抽象主题接口
interface Subject {
    void request();
}
// 真实主题类
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject handling request");
    }
}
// 代理类
class Proxy implements Subject {
    private RealSubject realSubject;
    public Proxy() {
        this.realSubject = new RealSubject();
    }
    @Override
    public void request() {
        // 预处理
        System.out.println("Proxy pre - processing");
        realSubject.request();
        // 后处理
        System.out.println("Proxy post - processing");
    }
}

四、模板方法模式（Template Method Pattern）

核心作用：定义一个算法的骨架，将具体步骤延迟到子类实现。

就是在父类中定义算法的主要流程，而把一些个性化的步骤延迟到子类中去实现

父类始终控制着整个流程的主动权，子类只是辅助父类实现某些可定制的步骤

java 复制代码

// 抽象父类
abstract class AbstractClass {
    // 模板方法，定义算法骨架
    public final void templateMethod() {
        method1();
        method2();
    }
    // 基本方法，子类实现
    protected abstract void method1();
    protected abstract void method2();
}
// 具体子类
class ConcreteClass extends AbstractClass {
    @Override
    protected void method1() {
        System.out.println("ConcreteClass method1 implementation");
    }
    @Override
    protected void method2() {
        System.out.println("ConcreteClass method2 implementation");
    }
}
});

总结：

Spring 框架通过多种设计模式的组合，实现了以下目标：
解耦：通过工厂模式和依赖注入（DI）降低组件间的耦合度。
复用：利用模板方法、策略模式封装通用逻辑，提高代码复用性。
扩展：通过代理、适配器、装饰器等模式支持功能扩展（如 AOP、插件机制）。
灵活性：基于接口和抽象类设计，允许运行时动态替换实现（如不同的持久化策略）。