Spring框架中使用的设计模式

╰+攻爆jí腚メ 2022-10-24 11:51 247阅读 0赞

### Spring框架中使用的设计模式 ###

*  Spring
 *   *  控制反转IOC
     *  依赖注入DI
 *  工厂设计模式Factory
 *   *  BeanFactory
     *  ApplicationContext
 *  单例设计模式Singleton
 *  代理设计模式Proxy
 *   *  AOP中的代理模式
     *  AspectJ和Spring AOP比较
     *   *  AspectJ
         *  Spring AOP
 *  模板方法模式TemplateMethod
 *  观察者模式Observer
 *   *  Spring事件驱动模型
     *   *  事件角色Event
         *  事件监听者角色Listener
         *  事件发布者角色Publisher
     *  Spring事件流程
 *  适配器模式Adapter
 *   *  Spring AOP中的适配器模式
     *  Spring MVC中的适配器模式
 *  装饰器模式Decorator
 *  总结

# Spring #

## 控制反转IOC ##

*  **控制反转IOC:** Inversion of Control
    
     *  是一种解耦设计原则
     *  主要目的是借助第三方,比如**Spring IOC**容器实现具有依赖关系的对象之间的解耦,从而降低代码之间的耦合度
 *  **Spring IOC容器:**
    
     *  **Spring IOC**容器负责创建对象并将对象连接在一起,配置这些对象.从创建中处理这些对象的整个生命周期,直到对象被完全销毁
     *  **Spring IOC**容器类似一个工厂
     *  在创建对象时,只需要配置好配置文件或者是注解即可,不需要关注对象是如何创建的
 *  **控制反转示例:**
    
     *  对象**a**依赖于对象**b,** 当对象**a**需要使用对象**b**时必须由对象**a**创建对象**b**的实例
     *  引入**IOC**容器后,当对象**a**需要使用对象**b**时,可以指定**IOC**容器去创建一个对象**b**注入到对象**a**中
     *  引入**IOC**容器之后,对象**a**获取对象**b**的过程,由主动行为变为被动行为
 *  实现了**IOC**原则的设计模式:
    
     *  **服务定位器模式ServiceLocator**
     *  **工厂模式Factory**
     *  **抽象工厂模式AbstractFactory**
     *  **模板方法模式TemplateMethod**
     *  **策略模式Strategy**
     *  依赖注入Depedency Inject

## 依赖注入DI ##

*  **依赖注入DI:** Dependency Inject
    
     *  将实例变量传入到一个对象中去
     *  是实现控制反转的一种设计模式

# 工厂设计模式Factory #

*  **Spring**框架中**BeanFactory**和**ApplicationContext**类使用工厂模式创建**Bean**对象

## BeanFactory ##

*  延迟注入,即使用到某个**Bean**时才会进行注入
 *  和**ApplicationContext**相比会占用更少的内存,程序启动速度更快

## ApplicationContext ##

*  容器启动时就创建所有的**Bean**
 *  和**BeanFactory**相比 **,BeanFactory**仅提供了最基本的依赖注入支持 **. ApplicationContext**扩展了**BeanFactory,** 除了**BeanFactory**的功能外还包含其余更多的功能,通常使用**ApplicationContext**创建**Bean**
 *  **ApplicationContext的三个实现类:**
    
     *  **ClassPathXmlApplication:** 将上下文文件作为类路径资源
     *  **FileSystemXmlApplication:** 从文件系统中的**XML**文件中载入上下文定义信息
     *  **XmlWebApplicationContext:** 从**Web**系统中的**XML**文件中载入上下文定义信息

# 单例设计模式Singleton #

*  **Spring**中的**Bean**的作用域默认就是单例**Singleton**的 **. Spring**中的**Bean**还可以定义以下作用域:
    
     *  **prototype:** 每次请求都会创建一个新的**Bean**实例
     *  **request:** 每一次**HTTP**请求都会创建一个新的**Bean**实例,该**Bean**实例仅在当前**HTTP request**中有效
     *  **session:** 每一次**HTTP**请求都会创建一个新的**Bean**实例,该**Bean**实例仅在当前**HTTP session**中有效
 *  **Spring实现单例Bean的方式:**
    
     *  **xml的方式:**
    
        <bean id="bean" class="com.oxford.Bean" scope="singleton"/>
    
     *  **注解的方式:**
    
        @Scope(value="singleton")
 *  **Spring**底层通过**ConcurrentHashMap**实现单例注册表来实现单例模式:

// 通过线程安全的concurrentHashMap实现单例注册表
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);
    
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
    	Assert.notNull(beanName, "'beanName' must not be null");
    	synchronized(this.singletonObjects) { 
    		// 检查缓存中是否存在实例
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null) { 
    			...
    			try { 
    				singleton = singletonFactory.getObject();
    			}
    			...
    			// 如果实例对象不存在,则将对象注册到单例注册表中
    			addSingleton(beanName, singletonObject);
    		}
    		return (singletonObject != NULL_OBJECT ? singletonObject : null);
    	}
    }
    
    protected void addSingleton(String beanName, Object singletonObject) { 
    	synchronized(this.singletonObjects) { 
    		this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
    	}
    }

# 代理设计模式Proxy #

## AOP中的代理模式 ##

*  **面向切面编程AOP:** Aspect-Oriented Programming
    
     *  面向切面编程能够**将和业务无关,但是是业务模块中所共同调用的逻辑或者业务功能封装起来,** 比如事务管理,日志管理,权限控制等
     *  有利于减少重复代码,降低模块之间的耦合度,并有利于面向未来的可拓展性和可维护性
        
         *  使用**AOP**可以将一些通用功能抽象出来,在需要使用的地方直接使用,这样可以大大简化代码量
         *  需要增加新功能也会更加简单方便,这样可以提高系统的扩展性
 *  **Spring AOP**基于动态代理实现的:
    
     *  **代理对象实现了接口:**
        
         *  **Spring AOP**会使用**Java**动态代理**JDK Proxy**创建代理对象 完成对象的代理操作
     *  **代理对象没有实现接口:**
        
         *  **Spring AOP**会使用**Cglib Proxy**生成一个被代理对象的子类作为代理类完成对象的代理操作  
            ![在这里插入图片描述][format_png_pic_center]
 *  **Spring AOP**集成了**AspectJ,AspectJ**是**Java**中最为完整的**AOP**框架

## AspectJ和Spring AOP比较 ##

### AspectJ ###

*  **AspectJ**是编译时增强
 *  **AspectJ**基于字节码操作**Bytecode Manipluation**实现
 *  **AspectJ**在切面较多的情况下要比**Spring AOP**的性能强很多

### Spring AOP ###

*  **Spring AOP**是运行时增强
 *  **Spring AOP**基于代理**Proxy**实现
 *  **Spring AOP**中集成了**AspectJ**
 *  **Spring AOP**比较简单,在切面比较少的情况下和**AspectJ**的性能相似

# 模板方法模式TemplateMethod #

*  **模板方法模式:**
    
     *  是一种行为型模式,基于继承的代码复用
     *  定义一个操作的算法骨架,将一些实现步骤延迟到子类中
     *  模板方法使得子类可以不改变一个算法结构的情况下即可重新定义算法的某些特定步骤的实现方式  
        ![在这里插入图片描述][format_png_pic_center 1]
 *  **Spring**中以**Template**结尾的类,比如**jdbcTemplate**等,都是使用了模板方法模式
    
     *  通常情况下,都是使用继承来实现模板模式
     *  在**Spring**中,使用了**Callback**与模板方法相结合的方式,既达到了代码复用的效果,又增加了系统的灵活性

# 观察者模式Observer #

*  **观察者模式:**
    
     *  是一种对象行为模式
     *  表示的是一种对象和对象之间具有依赖关系,当一个对象发生改变,依赖于这个对象的对象也会发生改变
 *  **Spring**事件驱动模型就是基于观察者模式实现的
    
     *  **Spring**事件驱动模型可以在很多应用场景中解耦代码
     *  比如每次添加商品时都需要更新商品索引,这时就可以使用观察者模式

## Spring事件驱动模型 ##

*  **Spring**事件驱动模型包含三种角色:
    
     *  **事件Event角色**
     *  **事件监听者Listener角色**
     *  **事件发布者Publisher角色**

### 事件角色Event ###

*  **ApplicationEvent:** org.springframework.context
    
     *  事件角色抽象类
     *  继承**java.util.Event**并实现了**java.io.Serializable**接口
 *  **Spring**中默认存在以下事件,都是继承自**ApplicationContext**事件角色抽象类:
    
     *  **ContextStartedEvent:**
        
         *  **ApplicationContext**启动后触发的事件
     *  **ContextStoppedEvent:**
        
         *  **ApplicationContext**停止后触发的事件
     *  **ContextRefreshedEvent:**
        
         *  **ApplicationContext**初始化或者刷新后触发的事件
     *  **ContextClosedEvent:**
        
         *  **ApplicationContext**关闭后触发的事件  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70]

### 事件监听者角色Listener ###

*  **ApplicationListener:**
    
     *  事件监听者角色
     *  **ApplicationListener**接口中定义了一个**onApplicationEvent()** 方法来处理**ApplicationEvent.** 只要实现**onApplicationEvent()** 方法即可完成监听事件

@FunctionalInterface
    public interface ApplicationListener<E extends ApplicationEvent> extends EventListener { 
    	void onApplicationEvent(E event);
    }

### 事件发布者角色Publisher ###

*  **ApplicationEventPublisher:**
    
     *  事件发布者角色
     *  **ApplicationEventPublisher**接口中定义了**publishEvent()** 方法来发布事件,这个方法在**AbstractApplicationContext**中实现
     *  在**AbstractApplicationContext**中,事件是通过**ApplicationEventMulticaster**广播的

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

## Spring事件流程 ##

*  **定义一个事件:**
    
     *  实现一个继承自ApplicationEvent的事件类,并写出相应的构造函数
 *  **定义一个事件监听者:**
    
     *  实现**ApplicationListener**接口
     *  重写**onApplicationEvent()** 方法
 *  **使用事件发布者发布消息:**
    
     *  使用**ApplicationEventPublisher**的**publishEvent()** 方法
     *  重写**publishEvent()** 方法发布消息
 *  [Spring事件模型示例][Spring]

# 适配器模式Adapter #

*  **适配器模式:**
    
     *  是结构型模式,也是各种结构型模式的起源
     *  将一个接口转换为调用方需要的接口
     *  适配器使得接口不兼容的类之间可以一起工作.适配器又被称为包装器**Wrapper**

## Spring AOP中的适配器模式 ##

*  **Spring AOP**中的增强和通知**Advice**使用了适配器模式,接口是**AdvisorAdapter**
 *  常用的**Advice**类型包括:
    
     *  **BeforeAdvice:** 前置通知. 目标方法调用前增强
     *  **AfterAdvice:** 后置通知. 目标方法调用后增强
     *  **AfterReturningAdvice:** 目标方法执行结束之后 **,return**之前
 *  每个通知**Advice**都有对应的拦截器:
    
     *  **BeforeAdvice - MethodBeforeAdviceInterceptor**
     *  **AfterAdvice - MethodAfterAdviceInterceptor**
     *  **AfterReturningAdvice - MethodAfterReturningAdviceInterceptor**
 *  **Spring**中预定义的通知要通过对应的适配器,适配成为**MethodInterceptor**接口类型的对象

## Spring MVC中的适配器模式 ##

*  **Spring MVC**中 **,DispatchServlet**根据请求信息调用**HanlderMapping,** 解析请求对应的**Handler,** 解析到对应的**Handler**后,开始由**HandlerAdapter**适配器进行处理
 *  **HandlerAdapter**作为期望接口,具体的适配器实现类对具体目标类进行适配 **.controller**作为需要适配的类
 *  通过使用适配器**AdapterHandler**可以对**Spring MVC**中众多类型的**Controller**通过不同的方法对请求进行处理

# 装饰器模式Decorator #

*  **装饰器模式:**
    
     *  动态地给对象添加一些额外的属性或者行为
     *  和继承相比,装饰器模式更加灵活
 *  **装饰器模式使用场景:**
    
     *  当需要修改原有的功能,但是不想直接修改原有的代码,就可以设计一个装饰器**Decorator**类在原有的代码的外面,这样可以在不修改原有的类的基础上扩展新的功能
 *  **Spring**中配置**DataSource**时 **,DataSource**可以是不同的数据库和数据源.为了在少修改原有类的代码下动态切换不同的数据源,这时就用到了装饰器模式
 *  **Spring**中含有**Wrapper**和含有**Decorator**的类都用到了装时期模式,都是动态地给一个对象添加一些额外的属性或者功能

# 总结 #

*  **Spring框架中使用的设计模式:**

<table> 
 <thead> 
  <tr> 
   <th>设计模式</th> 
   <th>Spring框架</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>工厂模式</td> 
   <td>BeanFactory<br>ApplicationContext</td> 
  </tr> 
  <tr> 
   <td>单例模式</td> 
   <td>Spring中的Bean</td> 
  </tr> 
  <tr> 
   <td>代理模式</td> 
   <td>Spring AOP</td> 
  </tr> 
  <tr> 
   <td>模板方法模式</td> 
   <td>Spring中以Template结尾的类</td> 
  </tr> 
  <tr> 
   <td>观察者模式</td> 
   <td>Spring事件驱动模型</td> 
  </tr> 
  <tr> 
   <td>适配器模式</td> 
   <td>Spring AOP中的AdvisorAdapter<br>Spring MVC中的HandlerAdapter</td> 
  </tr> 
  <tr> 
   <td>装饰器模式</td> 
   <td>Spring中含有Wrapper和含有Decorator的类</td> 
  </tr> 
 </tbody> 
</table>

[format_png_pic_center]: /images/20221024/7247725c5dca41a19d95030b783cc643.png
[format_png_pic_center 1]: /images/20221024/615a2e1b21144f86a275e81e62f99e9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pld2F2ZU94Zm9yZA_size_16_color_FFFFFF_t_70]: /images/20221024/f5c7d21cc7ab4ef4bcb4fa296788939e.png
[Spring]: https://github.com/siege-projects/chova-siege/tree/master/siege-framework/src/main/java/com/oxford/framework/spring/event