Spring知识点总结

﹏ヽ暗。殇╰゛Y 2021-11-05 07:48 424阅读 0赞

## Spring ##

Spring是一个java企业级应用开源开发框架. Spring主要用来开发Java应用, 有些扩展是针对构建J2EE平台的web应用. spring框架目标是简化Java企业级应用开发,提供全面的企业应用开发一站式的解决方案.

**特点 :**

*  轻量 : Spring是轻量的
 *  控制反转 : Spring通过控制反转实现了松散耦合, 对象给出他们的依赖, 而不是创建或查找以来的对象们
 *  面向切面编程(AOP) : 支持面向切面编程, 把应用业务逻辑和系统服务分开
 *  容器 : Spring容器包含并管理应用中对象的声明周期和配置
 *  MVC框架 :
 *  事务管理 : Spring提供一个持续的事务管理接口, 可扩展到上至本地事务, 下至全局事务

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

### 1.Spring IoC ###

#### 1>概念 ####

Spring通过一个配置文件描述Bean及Bean之间的依赖关系, 利用Java语言的反射功能**实例化Bean并建立Bean之间的依赖关系**. Spring的IOC容器在完成这些底层工作的基础上, 还提供了Bean实例缓存, 生命周期管理, Bean实例代理, 事件发布, 资源装载等高级服务

#### 2>Spring容器高层视图 ####

Spring启动时读取应用程序提供的Bean配置信息, 并在Spring容器中生成一份相应的Bean配置注册表, 然后根据这张注册表去实例化Bean, 装配好Bean之间的依赖关系, 为上层应用提供准备就绪的运行环境. 其中Bean缓存池为HashMap实现

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

#### 3>IoC容器实现 ####

*  BeanFactory : 框架基础设施
    
    BeanFactory是Spring框架的基础设施, 面向Spring本身; ApplicationContext面向使用Spring框架的开发者, 几乎所有的应用场合我们都直接使用ApplicationContext而非底层的BeanFactory. 最主要的方法就是getBean(String beanName), 该方法
 *  BeanDefinitionRegistry : 注册表
    
    Spring配置文件中的每一个节点元素在Spring容器里都通过一个BeanDefinition对象表示, 它描述了Bean的配置信息. 而BeanDefinitionRegistry接口提供了向容器手工注册BeanDefinition对象的方法
 *  BeanFactory会缓存Bean实例, 所以第二次使用getBean()获取Bean时会直接从IoC容器的缓存中获取Bean实例

### 3.Spring Bean作用域 ###

Spring为Bean定义了五种作用域, 分别为singleton(单例), prototype(原型), request, session和global session

*  **singleton : 单例模式(多线程下不安全)**
    
    Spring IoC容器中只会存在一个共享的Bean实例, 无论有多少个Bean引用它, 它始终指向同一对象. 该模式在多线程下是不安全的. Singleton作用域是Spring中的默认作用域
 *  **prototype : 原型模式每次使用时创建**
    
    每次通过Spring容器获取prototype定义的bean时, 容器都将创建一个新的Bean实例, 每个Bean实例都有自己的状态和属性, 而Singleton全局只有一个对象. 一般来说, **对有状态的bean使用prototype, 而对无状态的bean使用singleton作用域**
 *  **request : 一次request一个实例**
    
    再一次Http请求中, 容器会返回该Bean的同一实例. 而对不同的Http请求则会产生新的Bean, 而且该Bean仅在当前Http Request内有效, 当前Http请求结束, 该Bean实例也被销毁
 *  **session :** 再一次Http session中, 容器会返回该Bean的同一实例. 而对不同的Session请求 则会创建新的实例
 *  global session :一个全局的Http Session中, 容器会返回该Bean的同一实例

### 4.Spring Bean生命周期 ###

*  1.**实例化 :** 实例化一个Bean, 也就是常说的new
 *  2.**IoC依赖注入 :** 按照Spring上下文对实例化的Bean进行配置, 也就是IoC注入
 *  3.**setBeanName实现 :** 如果Bean实现了BeanNameAware接口, 会调用它实现的setBeanName(String)方法, 此处传递的就是Spring配置文件中Bean的id值
 *  4.**BeanFactoryAware实现 :** 如果Bean实现了BeanFactoryAware接口, 会调用它实现的setBeanFactory, setBeanFactory(BeanFactory) 传递的是工厂自身(可以用这个方式来获取其他Bean)
 *  **5.ApplicationContextAware实现 : 如果这个Bean已经实现了ApplicationContextAware接口, 会调用SetApplicationContext(Application)方法, 传入Spring上下文**
 *  **6.postProcessBeforeInitialization接口实现 - 初始化预处理**
    
    如果这个Bean关联了BeanPostProcessor接口, 将会调用postProcessBeforeInitialization(Object obj, String s)方法, BeanPostProcessor经常被用作是Bean内容的更改, 并且由于这个是在Bean初始化结束时调用的方法, 也可以被应用于内存或缓存技术
 *  7.init-metod : 如果Bean在Spring配置文件里面配置类init-method属性, 会自动调用其配置的初始化方法
 *  8.postProcessAfterInitialization : 如果这个Bean关联了BeanPostProcessor接口, 将会调用postProcessAfterInitialization(Object obj, String s)方法. **到这里就可以应用这个bean了**
 *  **9.Destory过期自动清理 :** 当Bean不再需要时, 会经过清理阶段, 如果Bean实现了DisposableBean这个接口, 会调用那个其实现的destroy()方法
 *  10.destroy-method自配置清理 : 如果这个Bean的Spring配置中配置了destroy-method属性, 会自动调用其配置的销毁方法

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

### 5.Spring如何解决循环依赖 ###

简单来讲, spring解决循环依赖是依靠 对象已经完成实例化, 但尚未完成所有属性设置. 就暴露该对象的引用(称之为早期引用). 其使用了三级缓存来处理这个问题

#### 1>Spring Bean初始化 ####

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

*  1.实例化, 就是调用对象的构造方法实例化对象
 *  2.populateBean : 填充属性, 这一步主要是bean之间的依赖属性填充
 *  3.InitializationBean : 调用spring配置文件中的init方法

从上述的初始化步骤可以看到, 循环依赖主要发生在第一, 第二步. 也就是构造器循环依赖和field循环依赖.

所以要解决循环依赖也应该从初始化过程入手, 对于单例来说, 在Spring容器整个生命周期内 , 有且只有一个对象, 所以就能想到这个对象应该存在Cache中, Spring为了解决单例的循环依赖问题, 使用了**三级缓存**

/** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
    
    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
    
    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

这三级缓存分别指 :

*  singletonFactories : 单例对象工厂的cache
 *  earlySingletonObjects : 提前曝光的单例对象的Cache
 *  singletonObjects : 单例对象的cache

我们在创建bean的时候, 首先可以从cache中获取这个单例的bean, 以下是getSingleton()的代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
            synchronized (this.singletonObjects) {
        
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
        
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
        
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

分析上述代码, 可以看书Spring首先从一级缓存singletonObjects中获取bean , 如果获取不到, 并且对象正在创建中, 就再从二级缓存earlySingletonObjects中获取. 如果还是获取不到且允许singletonFactories通过getObjects()获取, 从三级缓存singletonFactory.getObject()中获取. 如果获取到了则将它放入earlySingletonObjects

综上 : 如果A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步，并且将**自己提前曝光到singletonFactories中**，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），**尝试三级缓存singletonFactories**，由于A通过ObjectFactory将自己提前曝光了，**所以B能够通过ObjectFactory.getObject拿到A对象**(虽然A还没有初始化完全)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，进去了一级缓存singletonObjects中，并且，由于B拿到了A的对象引用，所以B现在hold住的A对象完成了初始化。

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

### 6.Spring AOP ###

#### 1>概述 ####

AOP技术利用一种称为"横切"的技术, 剖解开封装的对象内部, 并将哪些影响了多个类的**公共行为封装到一个可重用模块**, 并将其命名为"Aspect". 所谓"面", 就是将那些与业务无关, 却为业务模块所共同调用的逻辑或责任封装起来, 便于减少系统的重复代码, 降低模块见得耦合度, 并有利于未来的可操作性和可维护性

AOP将软件系统分为两部分: 核心关注点和横切关注点. 业务处理的主要流程是核心关注点, 与之关系不大的是横切关注点. 横切关注点的一个特点是, 他们经常发生在核心关注点的多处, 而且基本都相似. 例如权限认证, 日志, 事务处理. AOP的作用在于分离系统中的各种关注点, 将核心关注点和横切关注点分离开来

#### 2>AOP原理 ####

Spring提供了两种方式来生成代理对象 : JDK 动态代理和CGLib, 具体使用哪种方式生成由AopProxyFactory根据AdviceSupport对象的配置来决定. **默认的策略是如果目标类是接口, 则使用JDK 动态代理, 否则使用CGLib**

**JDK动态代理 :**

JDK动态代理主要涉及到java.lang.reflect包中的两个类 : **Proxy 和 InvocationHandler**. InvocationHandler是一个接口, 通过实现该接口定义横切逻辑, 并通过反射机制调用目标类的代码, 动态将横切逻辑和业务逻辑编制在一起. Proxy 利用 InvocationHandler 动态创建一个符合某一接口的实例, 生成目标类的代理对象

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

**CGLib动态代理 :**

CGlib动态代理通过继承业务类\*\*, 生成的动态代理类是业务类的子类, 通过重写业务方法进行代理.\*\*

CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少, 但是CGLib在创建代理对象时花费的时间却比JDK要多得多. **所以对于单例的对象, 因为无须频繁创建对象, 用CGLib合适, 反之, 使用JDK方式要更为合适一些.**

### 7.Spring事务 ###

#### 1>事务的实现方式 ####

*  1.编程式事务(begin Transaction() , commit(), rollbak()),
 *  2.基于TransactionProxyFactoryBean声明式事务
 *  3.基于@Transactional的声明式事务
 *  4.基于Aspectj AOP配置事务

#### 2>事务的传播级别 ####

*  1.PROPAGATION\_REQUIRED, 默认的Spring事务传播级别. 如果上下文已经存在事务, 那就在事务中执行, 如果上下文不存在事务, 则新建事务执行.
 *  2.PROPAGATION\_SUPPORTS, 支持. 如果上下文存在事务, 则加入事务, 如果没有事务, 那就以非事务的方式执行
 *  3.PROPAGATION\_MANDATORY, 要求上下文必须存在事务, 否则就会抛出异常
 *  4.PROPAGATION\_REQUIRES\_NEW, 每次都要一个新事务, 同时将上下文中的事务挂起, 执行完当前事务后再恢复
 *  5.PROPAGATION\_NOT\_SUPPORTED,不支持事务, 如果上下文中存在事务, 则先挂起事务, 执行当前逻辑, 结束后恢复上下文的事务
 *  6.PROPAGATION\_NEVER , 要求上下文不能存在事务, 否则抛出异常
 *  7.PROPAGATION\_NESTED, 嵌套级别事务, 如果上下文存在事务, 则嵌套事务执行. 如果不存在事务, 则新建事务

#### 3>嵌套事务 ####

嵌套事务是 自事务在父事务中执行, 自事务是父事务中的一部分, 在进入子事务之前, 父事务建立一个回滚点, 叫savepoint, 然后执行子事务, 这个子事务执行也是父事务的一部分, 然后子事务执行结束, 父事务继续执行

如果子事务回滚, 那么父事务会回滚到savepoint

如果父事务回滚, 那么子事务也会跟着提交.

子事务先提交, 然后父事务在结束之后同一提交

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70]: /images/20211104/0fa85cf021e447b5b7f8323ebff7ecdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70 1]: /images/20211104/ca8a22a00ece46c399cc3ebcdb547523.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70 2]: /images/20211104/7c59656ee03745d584c9eb05658dd45b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70 3]: /images/20211104/3bf9a9f90f6a4b6e9cdc871c8b6bb984.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70 4]: /images/20211104/946ffd65ce224fa1adc5d5d667e7bc41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70 5]: /images/20211104/3da7d339d00f4bcda8cb6c350b63fca4.png