spring到mvc到boot

约定不等于承诺〃 2022-05-08 00:58 216阅读 0赞

### 文章目录 ###

*  什么是spring
 *   *  三大核心思想\[参考文章\](https://blog.csdn.net/yks0527/article/details/54093490)
     *  优点
 *  核心组件
 *   *   *  spring是如何解决循环依赖的
         *  Spring中ApplicationContext和beanfactory区别
         *  bean的生命周期
     *  源码分析
     *   *   *  源码结构
         *  IOC(通过反射机制生成对象注入)
         *   *   *  1.如何证明是反射?
         *  IOC体系
         *   *  BeanFactory
     *  ApplicationListener
     *  SpringAop源码分析
     *   *  AOP(动态代理)
         *  通知（Advice）类型
         *  流程说明
         *  创建AOP代理
         *  Spring主要使用了什么模式？
         *  Spring的事务
         *  mvc
     *  spring用到的设计模式
     *   *  1. 简单工厂
         *  2. 工厂方法（Factory Method）
         *  3. 单例（Singleton）
         *  4. 适配器（Adapter）
         *  5.包装器（Decorator）
         *  6. 代理（Proxy）
         *  7.观察者（Observer）
         *  8. 策略（Strategy）
         *  9.模板方法（Template Method）
     *  spring内部接口
     *   *  InitializingBean

# 什么是spring #

<table> 
 <tbody> 
  <tr> 
   <td><b><font>什么是spring?</font></b></td> 
  </tr> 
 </tbody> 
</table>

Spring是一个\[轻量级|开源\]框架，处于MVC模式中的控制层，  
能应对需求快速的变化，其主要原因  
*它有 一种面向切面编程（AOP）的优势，其次它提升了系统性能，因为通过依赖倒置机制（IOC），系统中用到的对象不是在系统加载时就全部实例化，而是在调用到这个类时才会实例化该类的对象，从而提升了系统性能* 。  
Spring顶层容器为`BeanFactory`

## 三大核心思想[参考文章][Link 1] ##

## 优点 ##

核心就是：简化java开发。

*  轻量 基本版本2MB
 *  控制反转Ioc 松耦合  
    依赖注入是Ioc的一个方面(构造器注入,setter方法注入)
 *  面向切面编程AOP 将应用逻辑和系统服务分开 进行声明式编程
 *  容器 Spring包含管理应用中的对象

# 核心组件 #

**1.Spring AOP:**  
Spring的关键组件之一是AOP框架。  
AOP在Spring中使用：  
提供声明性的企业服务，特别是作为EJB声明式服务的替代品。最重要的服务是声明式事务管理，它建立在Spring的事务抽象之上。允许用户实现自定义的切面，补充他们使用AOP的OOP的使用。  
**2.Spring ORM:**  
ORM包与数据库访问有关。  
它为流行的对象关系映射api提供集成层，包括JDO、Hibernate和iBatis。  
**3.Spring Web:**  
web应用程序开发堆栈，其中包括Spring MVC。  
构建在ApplicationContext模块基础上,提供一个合适的web应用的上下文  
**4.Spring DAO:**  
Spring的DAO（Data Access Object）  
支持主要用于使用JDBC、Hibernate或JDO等技术标准化数据访问工作。  
**5.Spring Context:**  
此包构建在bean包之上，以增加对消息源的支持和观察者的设计模式支持，以及应用程序对象使用一致的API获得资源的能力。  
**6.Spring Web MVC:**  
这是为web应用程序  
提供MVC实现的模块。  
**7.Spring Core:**  
核心包是Spring框架中最重要的组件。  
该组件提供依赖性注入特性。BeanFactory提供了一种工厂模式，它将诸如初始化、创造和访问对象与实际程序逻辑的访问分离开来。

### spring是如何解决循环依赖的 ###

支持单例情况下的循环依赖

### Spring中ApplicationContext和beanfactory区别 ###

`BeanFactory`: **工厂设计模式**的一种体现,提供了控制反转的功能,把应用的配置和依赖从真正的应用代码分离

`ApplicationContext接口`,它由BeanFactory接口派生而来，因而提供BeanFactory所有的功能。ApplicationContext以一种更向面向框架的方式工作以及对上下文进行分层和实现继承，ApplicationContext包还提供了以下的功能：  
• MessageSource, 提供国际化的消息访问  
• 资源访问，如URL和文件  
• 事件传播  
• 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层

[learn more][]

### bean的生命周期 ###

1.Spring对Bean进行**实例化**（相当于程序中的new Xx()）  
2.Spring将值和Bean的引用**注入进Bean对应的属性**中  
3.如果Bean实现了BeanNameAware接口，Spring将Bean的ID传递给**setBeanName()** 方法  
（实现BeanNameAware清主要是为了通过Bean的引用来获得Bean的ID，一般业务中是很少有用到Bean的ID的）  
4.如果Bean实现了BeanFactoryAware接口，Spring将调用setBeanDactory(BeanFactory bf)方法并把BeanFactory容器实例作为参数传入。  
（实现BeanFactoryAware 主要目的是为了获取Spring容器，如Bean通过Spring容器发布事件等）  
5.如果Bean实现了ApplicationContextAwaer接口，Spring容器将调用setApplicationContext()方法，把bean所在的应用上下文的引用传入.  
(作用与BeanFactory类似都是为了获取Spring容器，不同的是Spring容器在调用setApplicationContext方法时会把它自己作为setApplicationContext 的参数传入，而Spring容器在调用setBeanDactory前需要程序员自己指定（注入）setBeanDactory里的参数BeanFactory )  
6.如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessBeforeInitialization（预初始化）方法  
（作用是在Bean实例创建成功后对进行增强处理，如对Bean进行修改，增加某个功能）  
7.如果Bean实现了InitializingBean接口，Spring将调用它们的afterPropertiesSet方法，作用与在配置文件中对Bean使用init-method声明初始化的作用一样，都是在Bean的全部属性设置成功后执行的初始化方法。  
8.如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessAfterInitialization（后初始化）方法（作用与6的一样，只不过6是在Bean初始化前执行的，而这个是在Bean初始化后执行的，时机不同 )  
9.此时，bean已经准备就绪，可以被程序使用了，Bean将一直驻留在应用上下文中给应用使用，直到应用上下文被销毁  
10.如果Bean实现了DispostbleBean接口，Spring将调用它的destory方法，作用与在配置文件中对Bean使用destory-method属性的作用一样，都是在Bean实例**销毁**前执行的方法。

![在这里插入图片描述][70]

## 源码分析 ##

#### 源码结构 ####

l org.springframework.aop是AOP实现的源代码目录  
l org.springframework.jdbc是JDBC的源代码部分  
l org.springframework.orm是O/R Mapping对应的源代码实现部分

<table> 
 <tbody> 
  <tr> 
   <td><b><font>SpringIOC源码分析</font></b></td> 
  </tr> 
 </tbody> 
</table>

### IOC(通过反射机制生成对象注入) ###

IoC容器的源代码目录org.springframework.context

##### 1.如何证明是反射? #####

将bean的构造器私有化,代码仍进构造函数  
**xml实现原理**  
[dom4j][](解析xml)+反射机制  
**注解实现原理**  
1、 XmlBeanFactory(屌丝IOC)的整个流程  
2、 FileSystemXmlApplicationContext 的IOC容器流程  
1、高富帅IOC解剖  
2、 设置资源加载器和资源定位  
3、AbstractApplicationContext的refresh函数载入Bean定义过程：  
4、AbstractApplicationContext子类的refreshBeanFactory()方法：  
5、AbstractRefreshableApplicationContext子类的loadBeanDefinitions方法：  
6、AbstractBeanDefinitionReader读取Bean定义资源：  
7、资源加载器获取要读入的资源：  
8、XmlBeanDefinitionReader加载Bean定义资源：  
9、DocumentLoader将Bean定义资源转换为Document对象：  
10、XmlBeanDefinitionReader解析载入的Bean定义资源文件：  
11、DefaultBeanDefinitionDocumentReader对Bean定义的Document对象解析：  
12、BeanDefinitionParserDelegate解析Bean定义资源文件中的元素：  
13、BeanDefinitionParserDelegate解析元素：  
14、解析元素的子元素：  
15、解析子元素：  
16、解析过后的BeanDefinition在IoC容器中的注册：  
17、DefaultListableBeanFactory向IoC容器注册解析后的BeanDefinition：

### IOC体系 ###

#### BeanFactory ####

Spring Bean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在Spring中有许多的IOC容器的实现供用户选择和使用，其相互关系如下：

BeanFactory定义了 IOC 容器的最基本形式，并提供了 IOC 容器应遵守的的最基本的接口，也就是Spring IOC 所遵守的最底层和最基本的编程规范。在 Spring 代码中， BeanFactory 只是个接口，并不是 IOC容器的具体实现，但是 Spring 容器给出了很多种实现，如 DefaultListableBeanFactory 、 XmlBeanFactory 、ApplicationContext 等，都是附加了某种功能的实现。

## ApplicationListener ##

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Engineable { 
    }
    
    
    /** * 实现监听上下文 */
    @Component
    public class ApplicationStarterListener implements ApplicationListener<ContextRefreshedEvent> { 
    	private final Logger logger = LoggerFactory.getLogger(getClass());
    	/** * 监听到容器启动时,执行此处 */ 
    	@Override
    	public void onApplicationEvent(final ContextRefreshedEvent event) { 
    		// 获取到上下文
    		ApplicationContext context = event.getApplicationContext();
    		// 获取到这个注解的所有类
    		String[] engineNames = context.getBeanNamesForAnnotation(Engineable.class);
    
    		for (String engineName : engineNames) { 
    			// 获取实例并转化为Thread
    			Thread engine = context.getBean(engineName, Thread.class);
    			// 启动线程
    			if (engine.getState() != State.RUNNABLE) { 
    				engine.start();
    
    				logger.info(engineName + " started !");
    			}
    		}
    	}
    }

## SpringAop源码分析 ##

### AOP(动态代理) ###

概念  
切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。  
连接点（Joinpoint） ：程序执行过程中的某一行为。  
通知（Advice） ：“切面”对于某个“连接点”所产生的动作。  
切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。  
目标对象（Target Object） ：被一个或者多个切面所通知的对象。  
AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。

### 通知（Advice）类型 ###

*  前置通知（Before advice） ：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext中在aop:aspect里面使用aop:before元素进行声明。  
    后通知（After advice） ：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext中在aop:aspect里面使用aop:after元素进行声明。
 *  返回后通知（After return advice） ：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext中在aop:aspect里面使用元素进行声明。
 *  环绕通知（Around advice） ：包围一个连接点的通知，类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext中在aop:aspect里面使用aop:around元素进行声明。
 *  抛出异常后通知（After throwing advice） ： 在方法抛出异常退出时执行的通知。 ApplicationContext中在aop:aspect里面使用aop:after-throwing元素进行声明。  
    切入点表达式 ：如execution(\* com.spring.service.*.*(…))  
    特点  
    1、降低模块之间的耦合度  
    2、使系统容易扩展  
    3、更好的代码复用。

### 流程说明 ###

1）AOP标签的定义解析刘彻骨肯定是从NamespaceHandlerSupport的实现类开始解析的，这个实现类就是AopNamespaceHandler。至于为什么会是从NamespaceHandlerSupport的实现类开始解析的，这个的话我想读者可以去在回去看看Spring自定义标签的解析流程，里面说的比较详细。  
2）要启用AOP，我们一般会在Spring里面配置<aop:aspectj-autoproxy/> ，所以在配置文件中在遇到aspectj-autoproxy标签的时候我们会采用AspectJAutoProxyBeanDefinitionParser解析器  
3）进入AspectJAutoProxyBeanDefinitionParser解析器后，调用AspectJAutoProxyBeanDefinitionParser已覆盖BeanDefinitionParser的parser方法，然后parser方法把请求转交给了AopNamespaceUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary去处理  
4）进入AopNamespaceUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法后，先调用AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法，里面在转发调用给registerOrEscalateApcAsRequired，注册或者升级AnnotationAwareAspectJAutoProxyCreator类。对于AOP的实现，基本是靠AnnotationAwareAspectJAutoProxyCreator去完成的，它可以根据@point注解定义的切点来代理相匹配的bean。  
5）AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法处理完成之后，接下来会调用useClassProxyingIfNecessary() 处理proxy-target-class以及expose-proxy属性。如果将proxy-target-class设置为true的话，那么会强制使用CGLIB代理，否则使用jdk动态代理，expose-proxy属性是为了解决有时候目标对象内部的自我调用无法实现切面增强。  
6）最后的调用registerComponentIfNecessary 方法，注册组建并且通知便于监听器做进一步处理。

### 创建AOP代理 ###

上面说到AOP的核心逻辑是在AnnotationAwareAspectJAutoProxyCreator类里面实现，那么我们先来看看这个类的层次关系  
流程说明  
1）spring 容器启动，每个bean的实例化之前都会先经过AbstractAutoProxyCreator类的postProcessAfterInitialization（）这个方法，然后接下来是调用wrapIfNecessary方法。

### Spring主要使用了什么模式？ ###

工厂模式：每个Bean的创建通过方法  
单例模式：默认的每个Bean的作用域都是单例  
代理模式：关于Aop的实现通过代理模式

### Spring的事务 ###

编程式事务管理：编程方式管理事务，极大灵活性，难维护。  
声明式事务管理：可以将业务代码和事务管理分离，用注解和xml配置来管理事务。

<table> 
 <tbody> 
  <tr> 
   <td><b><font>SpringMVC工作原理(表现层)</font></b></td> 
  </tr> 
 </tbody> 
</table>

SpringMvc 的控制器是不是单例模式，如果是，有什么问题，怎么解决？  
问题：单例模式，在多线程访问时有线程安全问题  
解决方法：不要用同步，在控制器里面不能写字段

SpringMvc中的转发和重定向?  
转发：return：“hello”  
重定向 ：return：“redirect:hello.jsp”

### mvc ###

https://www.cnblogs.com/xiaoxi/p/6164383.html

![在这里插入图片描述][format_png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]

其工作流程为:  
1、用户发送请求至前端控制器DispatcherServlet  
2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。  
3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(二者组成HandlerExecutionChain),并将其一并返回给DispatcherServlet。  
4、DispatcherServlet通过HandlerAdapter处理器适配器调用处理器  
5、执行处理器(Controller，也叫后端控制器)。  
6、Controller执行完成返回ModelAndView  
7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet  
8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器  
9、ViewReslover解析后返回具体View  
10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。  
11、DispatcherServlet对用户进行响应

简而言之，SpringMVC通过DispatcherServlet这个前端控制器(也叫中央调度器，我认为中央调度器更能体现其作用)，来调用mvc的三大件:Controller、Model、View。这样就保证MVC的每一个组件只与DispatcherServlet耦合，而彼此之间独立运行，大大降低了程序的耦合性。

再来说一下，SpringMVC这个框架时如何实现MVC模式的。  
注意SpringMVC中并没有涉及有关于Controller接口规范的实现,SpringMVC是通过调用Handler来实现Controller这一层的。

SpringMVC使用了适配器模式，前端控制器使用HandlerAdapter来调用不同的Controller,然后才是Controller调用Model产生数据模型;  
产生的数据模型将会再次返回到前端控制器，并由前端控制器决定使用不同的模板引擎将页面进行渲染。

## spring用到的设计模式 ##

### 1. 简单工厂 ###

又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

### 2. 工厂方法（Factory Method） ###

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

### 3. 单例（Singleton） ###

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为Spring管理的是是任意的Java对象。

### 4. 适配器（Adapter） ###

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。  
由于Advisor链需要的是MethodInterceptor（拦截器）对象，所以每一个Advisor中的Advice都要适配成对应的MethodInterceptor对象。

### 5.包装器（Decorator） ###

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

### 6. 代理（Proxy） ###

为其他对象提供一种代理以控制对这个对象的访问。

从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

Spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

### 7.观察者（Observer） ###

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

Spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

### 8. 策略（Strategy） ###

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

Spring中在实例化对象的时候用到Strategy模式，见如下图：

在SimpleInstantiationStrategy中有如下代码说明了策略模式的使用情况：

### 9.模板方法（Template Method） ###

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。Spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。

以下是一个具体的例子：

JdbcTemplate中的execute方法：

JdbcTemplate执行execute方法

## spring内部接口 ##

### InitializingBean ###

`InitializingBean`接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。

[Link 1]: https://blog.csdn.net/yks0527/article/details/54093490
[learn more]: https://blog.csdn.net/pseudonym_/article/details/72826059
[70]: /images/20220508/b26de6e3201e4086a810599f81be0da2.png
[dom4j]: https://www.cnblogs.com/sharpest/p/7877501.html
[format_png]: /images/20220508/66ec4984d02b446cba707b794933cd71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]: /images/20220508/794c2714264f48dba89a73a2c3836b32.png