Spring⾥⽤到的设计模式

这篇具有很好参考价值的文章主要介绍了Spring⾥⽤到的设计模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Spring 框架是一个广泛应用于企业级 Java 开发的开源框架,它提供了一系列的模块,包括依赖注入、面向切面编程、事务管理等功能,以简化企业级应用的开发。在 Spring 的设计和实现中,采用了多种设计模式来解决不同的问题,提高代码的可维护性、可扩展性和可重用性。

1. 单例模式(Singleton Pattern)

单例模式是一种创建型设计模式,其主要目的是确保一个类只有一个实例,并提供全局访问点。在 Spring 中,单例模式广泛用于管理 Bean 的生命周期。Spring 容器默认情况下会将所有的 Bean 定义为单例,即在容器中仅存在一个实例,并且在第一次请求时创建。

public class MySingletonBean {
    private static final MySingletonBean instance = new MySingletonBean();

    private MySingletonBean() {
        // 私有构造方法
    }

    public static MySingletonBean getInstance() {
        return instance;
    }
}

Spring 的单例模式确保了在整个应用程序中只有一个 Bean 实例,从而减少了资源消耗和提高了性能。但需要注意的是,单例模式可能引入状态共享的问题,因此在设计时需要考虑线程安全性。

2. 工厂模式(Factory Pattern)

工厂模式是一种创建型设计模式,它提供了一种将对象的实例化过程封装起来的方式。在 Spring 中,工厂模式常常用于创建和管理 Bean 对象。Spring 容器通过工厂模式来管理和创建 Bean,用户只需要配置相应的 Bean 定义,而无需直接调用构造函数。

public interface MyBean {
    void doSomething();
}

public class MyBeanImpl implements MyBean {
    @Override
    public void doSomething() {
        // 具体实现
    }
}

public class MyBeanFactory {
    public MyBean createBean() {
        return new MyBeanImpl();
    }
}

Spring 提供了多种工厂模式的实现,包括简单工厂模式、工厂方法模式和抽象工厂模式。通过配置文件或注解,Spring 容器可以根据用户的需求选择适当的工厂模式来创建和管理 Bean。

3. 代理模式(Proxy Pattern)

代理模式是一种结构型设计模式,它通过创建一个代理对象来控制对其他对象的访问。在 Spring 中,代理模式常被用于实现 AOP(面向切面编程)。

Spring AOP 使用代理模式来实现横切关注点的模块化,将横切关注点(例如日志记录、事务管理)从业务逻辑中分离出来。Spring 提供两种代理模式:静态代理和动态代理。

3.1 静态代理

public interface MyService {
    void doSomething();
}

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        // 具体实现
    }
}

public class MyServiceProxy implements MyService {
    private final MyService target;

    public MyServiceProxy(MyService target) {
        this.target = target;
    }

    @Override
    public void doSomething() {
        // 执行横切关注点(例如日志记录)
        System.out.println("Before method execution");
        
        // 调用目标对象的方法
        target.doSomething();
        
        // 执行横切关注点(例如事务管理)
        System.out.println("After method execution");
    }
}

3.2 动态代理

public interface MyService {
    void doSomething();
}

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        // 具体实现
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private final Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 执行横切关注点(例如日志记录)
        System.out.println("Before method execution");
        
        // 调用目标对象的方法
        Object result = method.invoke(target, args);
        
        // 执行横切关注点(例如事务管理)
        System.out.println("After method execution");
        
        return result;
    }
}

动态代理通过 java.lang.reflect.Proxy 类和 InvocationHandler 接口实现,可以在运行时动态生成代理类,而不需要提前定义。

4. 观察者模式(Observer Pattern)

观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在 Spring 中,观察者模式被广泛应用于事件驱动编程和消息通知。

Spring 的事件机制就是基于观察者模式实现的。通过定义事件、监听器和发布器,应用程序可以轻松实现组件之间的解耦和通信。

public class MyEvent extends ApplicationEvent {
    // 自定义事件类
    public MyEvent(Object source) {
        super(source);
    }
}

public class MyListener implements ApplicationListener<MyEvent> {
    // 自定义监听器类
    @Override
    public void onApplicationEvent(MyEvent event) {
        // 处理事件
    }
}

public class MyPublisher {
    // 事件发布器
    private final ApplicationEventPublisher eventPublisher;

    public MyPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void publishEvent() {
        // 发布事件
        eventPublisher.publishEvent(new MyEvent(this));
    }
}

5. 策略模式(Strategy Pattern)

策略模式是一种行为型设计模式,它定义了一族算法,将每个算法封装起来,并使它们可以互相替换。在 Spring 中,策略模式常被用于定义和管理一系列可互换的算法或行为。

Spring 中的事务管理就是一个典型的策略模式的应用。Spring 提供了多种事务管理的策略,包括编程式事务管理和声明式事务管理,用户可以根据需要选择合适的策略。

public interface TransactionStrategy {
    void beginTransaction();
    void commit();
    void rollback();
}

public class ProgrammaticTransactionStrategy implements TransactionStrategy {
    // 编程式事务管理策略的具体实现
    @Override
    public void beginTransaction() {
        // 实现具体的事务开始逻辑
    }

    @Override
    public void commit() {
        // 实现具体的事务提交逻辑
    }

    @Override
    public void rollback() {
        // 实现具体的事务回滚逻辑
    }
}

public class DeclarativeTransactionStrategy implements TransactionStrategy {
    // 声明式事务管理策略的具体实现
    @Override
    public void beginTransaction() {
        // 实现具体的事务开始逻辑
    }

    @Override
    public void commit() {
        // 实现具体的事务提交逻辑
    }

    @Override
    public void rollback() {
        // 实现具体的事务回滚逻辑
    }
}

通过定义一个通用的接口,可以轻松地切换和扩展不同的事务管理策略,而不影响业务逻辑的实现。

6. 模板方法模式(Template Method Pattern)

模板方法模式是一种行为型设计模式,它定义了一个算法的骨架,将一些步骤的具体实现延迟到子类。在 Spring 中,模板方法模式常被用于定义一些通用的算法骨架,以便子类可以按需实现具体步骤。

Spring 的 JdbcTemplate 就是模板方法模式的一个例子。JdbcTemplate 定义了一系列执行数据库操作的方法,其中一些步骤是通用的,而一些是具体的,由子类实现。

public abstract class JdbcTemplate {
    public final void execute() {
        // 通用步骤1
        getConnection();

        // 具体步骤由子类实现
        doExecute();

        // 通用步骤2
        releaseConnection();
    }

    protected abstract void doExecute();

    private void getConnection() {
        // 获取数据库连接的通用实现
    }

    private void releaseConnection() {
        // 释放数据库连接的通用实现
    }
}

public class MyJdbcTemplate extends JdbcTemplate {
    @Override
    protected void doExecute() {
        // 具体步骤的实现
    }
}

通过模板方法模式,JdbcTemplate 将通用的数据库操作流程封装在 execute 方法中,而具体的操作由子类实现,实现了算法的复用和业务逻辑的分离。

7. 适配器模式(Adapter Pattern)

适配器模式是一种结构型设计模式,它允许将一个类的接口转换成客户端期望的另一个接口。在 Spring 中,适配器模式常被用于解决接口不兼容的问题。

Spring MVC 中的 HandlerAdapter 就是适配器模式的一个应用。HandlerAdapter 负责将处理请求的 Controller 转换成合适的处理器,以适应不同的 Controller 接口。

public interface Controller {
    void handleRequest();
}

public class SimpleController implements Controller {
    @Override
    public void handleRequest() {
        // 处理请求的具体实现
    }
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    private final SimpleController controller;

    public SimpleControllerHandlerAdapter(SimpleController controller) {
        this.controller = controller;
    }

    @Override
    public boolean supports(Object handler) {
        return handler instanceof SimpleController;
    }

    @Override
    public void handle(Object handler) {
        controller.handleRequest();
    }
}

通过适配器模式,SimpleControllerHandlerAdapter 将 SimpleController 转换成 HandlerAdapter 接口,使得它可以被 Spring MVC 框架正确地处理。

最后

Spring 框架广泛应用了多种设计模式,这些设计模式在提高代码的可维护性、可扩展性和可重用性方面发挥了重要作用。通过单例模式、工厂模式、代理模式、观察者模式、策略模式、模板方法模式和适配器模式等设计模式的应用,Spring 实现了面向对象设计原则,使得框架更加灵活、可扩展和易于维护。熟练掌握这些设计模式有助于开发者更好地理解和使用 Spring 框架,提高代码质量和开发效率。

黑马程序员新版Spring零基础入门到精通,一套搞定spring全套视频教程(含实战源码)文章来源地址https://www.toymoban.com/news/detail-806263.html

到了这里,关于Spring⾥⽤到的设计模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JAVA设计模式第七讲:设计模式在 Spring 源码中的应用

    设计模式(design pattern)是对软件设计中普遍存在的各种问题,所提出的解决方案。本文以面试题作为切入点,介绍了设计模式的常见问题。 我们需要掌握各种设计模式的原理、实现、设计意图和应用场景,搞清楚能解决什么问题 。 本文是第七篇:设计模式在 Spring 源码中的

    2024年02月09日
    浏览(41)
  • Java 设计者模式以及与Spring关系(七) 命令和迭代器模式

    本文是个系列一次会出两个设计者模式作用,如果有关联就三个,除此外还会讲解在spring中作用。 23设计者模式以及重点模式 我们都知道 设计者模式 有 3 类 23 种设计模式,标红是特别重要的设计者模式建议都会,而且熟读于心,标蓝是指其次重要建议也要明白。 (1)创建

    2024年01月24日
    浏览(34)
  • Java 设计者模式以及与Spring关系(六) 装饰和模版方法模式

    本文是个系列一次会出两个设计者模式作用,如果有关联就三个,除此外还会讲解在spring中作用。 23设计者模式以及重点模式 我们都知道 设计者模式 有 3 类 23 种设计模式,标红是特别重要的设计者模式建议都会,而且熟读于心,标蓝是指其次重要建议也要明白。 (1)创建

    2024年01月24日
    浏览(41)
  • 【Spring】Spring中的设计模式

    责任链模式介绍 Spring源码介绍 spring中Aop的责任链模式,相对于传统的责任链模式做了一定的改造。 传统的设计模式,抽象处理者会有一个方法设置和获取具体处理者的下一个处理者的方法。 如: 但是Spring中的责任链模式没有这两个方法,而是抽出一个公共的处理方法,方

    2024年02月14日
    浏览(41)
  • spring的设计模式----简单工厂模式

    spring中IoC 控制反转,底层是工厂模式。 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式,可以将对象的

    2024年02月17日
    浏览(45)
  • Spring学习笔记(二)Spring的控制反转(设计原则)与依赖注入(设计模式)

    是一种设计原则,降低程序代码之间的耦合度 对象由Ioc容器统一管理,当程序需要使用对象时直接从IoC容器中获取。这样对象的控制权就从应用程序转移到了IoC容器 依赖注入是一种消除类之间依赖关系的设计模式。例如,A类要依赖B类,A类不再直接创建B类,而是把这种依赖

    2024年02月19日
    浏览(37)
  • Spring中的设计模式

    目录 1.Spring中使用到的设计模式有: 2.工厂模式 3.单例模式 4.代理模式 5.模板模式 6.适配器模式         工厂模式:实现IoC容器         单例模式:将bean设置为单例         代理模式:AOP的底层实现         模板模式:比如引入jdbc依赖后出现的jdbcTemplate         适配器模

    2024年02月12日
    浏览(44)
  • spring用到的设计模式

    在Spring中,默认情况下,Spring容器中的所有Bean都是单例(Singleton)的,也就是说,Spring容器中每个Bean的实例只有一个。这是因为Spring默认使用单例模式来创建Bean,确保每个Bean在整个应用中只有一个实例,从而提高应用性能和资源利用率。 在Spring中,单例 Bean 是 Spring Appli

    2024年02月08日
    浏览(37)
  • 设计模式_spring框架中常用的8种设计模式

    spring框架中常用到的8种设计模式清单如下: 设计模式 使用地方 备注 工厂模式 BeanFactory ApplicationContext 单例模式 Spring中的Bean 代理模式 Spring AOP java反射实现动态代理 模板方法模式 Spring中以Template结尾的类 使用继承的方式实现 观察者模式 Spring事件驱动模型 适配器模式 Spri

    2023年04月08日
    浏览(43)
  • Spring中常见的设计模式

    使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性、更具有灵活、优雅,而Spring中共有九种常见的设计模式 工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创

    2024年02月20日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包