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

相关推荐
速易达网络6 分钟前
Java Web登录系统实现(不使用开发工具)
java·开发语言·前端
瑞士卷@27 分钟前
spring从入门到精通(spring学习笔记,持续更新中)
笔记·学习·spring
悟能不能悟31 分钟前
java重构旧代码有哪些注意的点
java·开发语言·重构
怪兽20141 小时前
Redis过期键的删除策略有哪些?
java·数据库·redis·缓存·面试
筏.k2 小时前
C++ 设计模式系列:生产者-消费者模式完全指南
开发语言·c++·设计模式
workflower4 小时前
单元测试-例子
java·开发语言·算法·django·个人开发·结对编程
YuanlongWang5 小时前
C# 基础——装箱和拆箱
java·开发语言·c#
b78gb5 小时前
电商秒杀系统设计 Java+MySQL实现高并发库存管理与订单处理
java·开发语言·mysql
wb043072016 小时前
性能优化实战:基于方法执行监控与AI调用链分析
java·人工智能·spring boot·语言模型·性能优化
天若有情6737 小时前
Java Swing 实战:从零打造经典黄金矿工游戏
java·后端·游戏·黄金矿工·swin