【Spring】之 Spring 中常用的设计模式

目录

• 一、工厂模式
• 二、单例模式
• 三、代理模式
• 四、模板方法模式
• 五、观察者模式
• 六、适配器模式
• 七、装饰模式

一、工厂模式

---

1、工厂模式简介

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

2、Spring 中的工厂模式应用

Spring 中的工厂模式应用为：通过 BeanFactory 或 ApplicationContext 创建 bean 对象。它们两者的区别为：

• BeanFactory：延迟注入(使用到某个 bean 的时候才会注入)，相比于 ApplicationContext 来说会占用更少的内存，程序启动速度更快；
• ApplicationContext：容器启动的时候，不管你用没用到，一次性创建所有 bean。

BeanFactory 仅提供了最基本的依赖注入支持，而 ApplicationContext 则扩展了 BeanFactory ，除了有 BeanFactory 的功能之外还有额外更多功能，所以一般开发人员使用 ApplicationContext 会更多。

ApplicationContext 的三个实现类：

• ClassPathXmlApplication：把上下文文件当成类路径资源；
• FileSystemXmlApplication：从文件系统中的 XML 文件载入上下文定义信息；
• XmlWebApplicationContext：从 Web 系统中的 XML 文件载入上下文定义信息。

代码示例：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MyApplication {
    public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext(
                "application.xml");

        myDemo demoObj = (myDemo) context.getBean("myDemo");
        demoObj.getInfo();
    }
}

二、单例模式

---

1、单例模式简介

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

使用单例模式的好处：

• 对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
• 由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

2、Spring 中的单例模式应用

Spring 中 bean 的默认作用域就是 singleton（单例）的，除了 singleton 作用域，Spring 中 bean 还有下面几种作用域：

• prototype：每次请求都会创建一个新的 bean 实例；
• request：每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效；
• session：每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效；
• global-session：全局session作用域，仅仅在基于 portlet 的 web 应用中才有意义，Spring5 已经没有了。Portlet 是能够生成语义代码（例如：HTML）片段的小型 Java Web 插件。它们基于 portlet 容器，可以像 servlet 一样处理 HTTP 请求。但是，与 servlet 不同，每个 portlet 都有不同的会话。

Spring实现单例的方式：

• xml：例如 <bean id="userService" class="cp.com.bean.UserService" scope="singleton"/>
• 注解：例如：@Scope(value = "singleton")

三、代理模式

---

1、代理模式简介

代理模式（Proxy Pattern），即一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

AOP 介绍：

AOP（Aspect-Oriented Programming），即面向切面编程，能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

2、Spring 中代理模式的应用

Spring AOP 就是基于动态代理的，如果要代理的对象实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象，而对于没有实现接口的对象，Spring AOP 会使用 Cglib，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理。

当然也可以使用 AspectJ，Spring AOP 以及集成了 AspectJ，AspectJ 应该算得上是 Java 生态系统中最完整的 AOP 框架了。

Spring AOP 和 AspectJ AOP 的区别：

• Spring AOP 属于运行时增强，而 AspectJ 是编译时增强；
• Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)；

AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单，功能更弱。如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，它比 Spring AOP 快很多。

四、模板方法模式

---

1、模板方法模式简介

模板方法模式是一种行为设计模式，它定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤的实现方式。

2、Spring 中模板方法模式的应用

Spring 中 jdbcTemplate、redisTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是 Spring 并没有使用这种方式，而是使用 Callback 模式与模板方法模式配合，既达到了代码复用的效果，同时增加了灵活性。

五、观察者模式

---

1、观察者模式简介

观察者模式是一种对象行为型模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变的时候，这个对象所依赖的对象也会做出反应。

2、Spring 中观察者模式的应用

Spring 事件驱动模型就是观察者模式很经典的一个应用。Spring 事件驱动模型非常有用，在很多场景都可以解耦我们的代码。比如我们每次添加商品的时候都需要重新更新商品索引，这个时候就可以利用观察者模式来解决这个问题。

Spring 事件驱动模型中的三种角色

1）事件角色

ApplicationEvent (org.springframework.context包下)充当事件的角色，这是一个抽象类，它继承了 java.util.EventObject 并实现了 java.io.Serializable 接口。

Spring 中默认存在以下事件，他们都是对 ApplicationContextEvent 的实现：

• ContextStartedEvent：ApplicationContext 启动后触发的事件；
• ContextStoppedEvent：ApplicationContext 停止后触发的事件；
• ContextRefreshedEvent：ApplicationContext 初始化或刷新完成后触发的事件；
• ContextClosedEvent：ApplicationContext 关闭后触发的事件。

2）事件监听者角色

ApplicationListener 充当了事件监听者角色，它是一个接口，里面只定义了一个 onApplicationEvent() 方法来处理 ApplicationEvent。ApplicationListener 接口类源码如下

package org.springframework.context;
import java.util.EventListener;
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E var1);
}

所以，在 Spring 中我们只要实现 ApplicationListener 接口实现 onApplicationEvent() 方法即可完成监听事件。

3）事件发布者角色

ApplicationEventPublisher 充当了事件的发布者，它也是一个接口，源码如下：

@FunctionalInterface
public interface ApplicationEventPublisher {
    default void publishEvent(ApplicationEvent event) {
        this.publishEvent((Object)event);
    }

    void publishEvent(Object var1);
}

ApplicationEventPublisher 接口的 publishEvent() 这个方法在 AbstractApplicationContext 类中被实现，查看这个方法的源码会发现实际上事件真正是通过 ApplicationEventMulticaster 来广播出去的。

Spring 的事件流程：

• 1、定义一个事件：实现一个继承自 ApplicationEvent，并且写相应的构造函数；
• 2、定义一个事件监听者：实现 ApplicationListener 接口，重写 onApplicationEvent() 方法；
• 3、使用事件发布者发布消息：可以通过 ApplicationEventPublisher 的 publishEvent() 方法发布消息。

代码示例如下：

/*
 * 定义一个事件，继承自ApplicationEvent并且写相应的构造函数
 */
public class DemoEvent extends ApplicationEvent{
    private static final long serialVersionUID = 1L;

    private String message;

    public DemoEvent(Object source，String message){
        super(source);
        this.message = message;
    }

    public String getMessage() {
         return message;
    }
}

/*
 * 定义一个事件监听者，实现ApplicationListener接口，重写 onApplicationEvent() 方法
 */
@Component
public class DemoListener implements ApplicationListener<DemoEvent>{

    //使用onApplicationEvent接收消息
    @Override
    public void onApplicationEvent(DemoEvent event) {
        String msg = event.getMessage();
        System.out.println("receive msg："+msg);
    }

}

/*
 * 发布事件，可以通过ApplicationEventPublisher  的 publishEvent() 方法发布消息
 */
@Component
public class DemoPublisher {

    @Autowired
    ApplicationContext applicationContext;

    public void publish(String message){
        //发布事件
        applicationContext.publishEvent(new DemoEvent(this， message));
    }
}

当调用 DemoPublisher 的 publish() 方法的时候，比如 demoPublisher.publish(“hello”) ，控制台就会打印出：receive msg：hello 。

六、适配器模式

---

1、适配器模式简介

适配器模式（Adapter Pattern）的功能为：将一个接口转换成客户希望的另一个接口。适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器（Wrapper）。

2、Spring 中适配器模式的应用

1）Spring AOP 中的适配器模式

我们知道 Spring AOP 的实现是基于代理模式，但是 Spring AOP 的增强或通知（Advice）使用到了适配器模式，与之相关的接口是 AdvisorAdapter 。

Advice 常用的类型有：BeforeAdvice（目标方法调用前，前置通知）、AfterAdvice（目标方法调用后，后置通知）、AfterReturningAdvice(目标方法执行结束后，return 之前)等等。每个类型 Advice（通知）都有对应的拦截器：MethodBeforeAdviceInterceptor、AfterReturningAdviceAdapter、AfterReturningAdviceInterceptor。

Spring预定义的通知要通过对应的适配器，适配成 MethodInterceptor 接口（方法拦截器）类型的对象（如：MethodBeforeAdviceInterceptor 负责适配 MethodBeforeAdvice）。

2）Spring MVC 中的适配器模式

在 Spring MVC 中，DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler。解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由HandlerAdapter 适配器处理。HandlerAdapter 作为期望接口，具体的适配器实现类用于对目标类进行适配，Controller 作为需要适配的类。

为什么要在 Spring MVC 中使用适配器模式？

Spring MVC 中的 Controller 种类众多，不同类型的 Controller 通过不同的方法来对请求进行处理。如果不利用适配器模式的话，DispatcherServlet 直接获取对应类型的 Controller，就需要的自行来判断。

七、装饰模式

---

1、装饰模式简介

装饰者模式可以动态地给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。简单点儿说就是当我们需要修改原有的功能，但我们又不愿直接去修改原有的代码时，设计一个 Decorator 套在原有代码外面。

其实在 JDK 中就有很多地方用到了装饰者模式，比如 InputStream 家族，InputStream 类下有 FileInputStream (读取文件)、BufferedInputStream (增加缓存，使读取文件速度大大提升)等子类都在不修改InputStream 代码的情况下扩展了它的功能。

2、Spring 中装饰模式的应用

Spring 中配置 DataSource 的时候，DataSource 可能是不同的数据库和数据源。我们能否根据客户的需求在少修改原有类的代码下动态切换不同的数据源？这个时候就要用到装饰者模式。

Spring 中用到的包装器模式在类名上含有 Wrapper 或者 Decorator。这些类基本上都是动态地给一个对象添加一些额外的职责。