Spring 框架中用到的设计模式

Spring 框架的设计模式

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

主要介绍以下四种

一、工厂模式(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、插件机制)。
灵活性:基于接口和抽象类设计,允许运行时动态替换实现(如不同的持久化策略)。

相关推荐
学长毕设18 分钟前
基于SpringBoot社区快递驿站物流配送系统-附源码
java·spring boot·后端
Flynt31 分钟前
Java4Shell 实测:EPYC 一跑就中招,关掉 Base64 硬件加速,1KB 解码慢 14 倍
java·安全·性能优化
Resean02231 小时前
Spring 源码分析(七)AOP 原理(上):代理的创建
java·后端·spring
Tangq一定可以的1 小时前
Spring AI Advisor 详解 - 给大模型调用加上“切面“,日志/过滤/记忆一键搞定
java·后端·spring
小巫编程室2 小时前
我造了一个 Java 能力包:让 AI 直接调用你的业务代码
java·前端·后端
深入云栈2 小时前
Netty 4.2.x 源码深度解析 (二十四):池化内存分配 —— PoolArena、PoolChunk 与 PoolSubpage
java·后端·架构
惜.己3 小时前
Java结合idea简单使用Playwright
java·开发语言·自动化
Vex2une4 小时前
JDK 8 下载安装与环境变量配置完整指南(Windows新手图文教程)
java·windows·环境配置·环境变量·jdk8·jdk下载安装·java入门教程
杨凯凡4 小时前
Spring Framework 7 原生重试与并发限制实战:@Retryable、@ConcurrencyLimit 能替代 Resilience4j 吗?
数据库·spring·sqlserver
文丑颜不良啊5 小时前
LeetCode3281~3300题目解析
java·leetcode