spring框架基础

1.Spring框架概述

spring 是轻量级的开源的JavaEE框架。
Spring有两个核心部分：IOC和AOP
IOC：控制反转，把创建对象的过程交给Spring管理
AOP：面向切面，不修改源代码进行功能增强。
Spring 特点：
方便解耦，简化开发
AOP编程的支持
声明式事务的支持
方便程序的测试
方便集成各种优秀框架
核心组件
Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；
Spring Core：核心类库，所有功能都依赖于该类库，提供IOC和DI服务；
Spring AOP：AOP服务；
Spring Web：提供了基本的面向Web的综合特性，提供对常见框架如Struts2的支持，Spring能够管理这些框架，将Spring的资源注入给框架，也能在这些框架的前后插入拦截器；
Spring MVC：提供面向Web应用的Model-View-Controller，即MVC实现。
Spring DAO：对JDBC的抽象封装，简化了数据访问异常的处理，并能统一管理JDBC事务；
Spring ORM：对现有的ORM框架的支持；

1-A.Spring容器的启动流程

https://blog.csdn.net/a745233700/article/details/113761271

1.Spring的启动流程可以归纳为三个步骤：

1、初始化Spring容器，注册内置的BeanPostProcessor的BeanDefinition到容器中
① 实例化BeanFactory【DefaultListableBeanFactory】工厂，用于生成Bean对象
② 实例化BeanDefinitionReader注解配置读取器，用于对特定注解（如@Service、@Repository）的类进行读取转化成BeanDefinition 对象，（BeanDefinition 是 Spring 中极其重要的一个概念，它存储了 bean 对象的所有特征信息，如是否单例，是否懒加载，factoryBeanName 等）
③ 实例化ClassPathBeanDefinitionScanner路径扫描器，用于对指定的包目录进行扫描查找 bean 对象
2、将配置类的BeanDefinition注册到容器中
doRegisterBean0将配置类[SpringConfig]注册到容器中，这里只是注册BeanDefinition信息，并非实例化
3、调用refresh()方法刷新容器
① prepareRefresh()刷新前的预处理：
② obtainFreshBeanFactory()：获取在容器初始化时创建的BeanFactory：
③ prepareBeanFactory(beanFactory)：BeanFactory的预处理工作，向容器中添加一些组件：
④ postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在BeanFactory创建并预处理完成以后做进一步的设置
⑤ invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory标准初始化之后执行BeanFactoryPostProcessor的方法，即BeanFactory的后置处理器：
⑥ registerBeanPostProcessors(beanFactory)：向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能
⑦ initMessageSource()：初始化MessageSource组件，主要用于做国际化功能，消息绑定与消息解析：
⑧ initApplicationEventMulticaster()：初始化事件派发器，在注册监听器时会用到：
⑨ onRefresh()：留给子容器、子类重写这个方法，在容器刷新的时候可以自定义逻辑
⑩ registerListeners()：注册监听器：将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件：
⑪ finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的单实例bean，核心方法是preInstantiateSingletons()，会调用getBean()方法创建对象；
⑫ finishRefresh()：发布BeanFactory容器刷新完成事件：

2.IOC容器

什么是IOC
控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。
降低耦合度
做入门案例就是IOC的实现。
IOC底层原理
xml解析、工厂模式、反射

1.IOC（接口）

IOC思想基于IOC容器完成，IOC容器底层就是工厂对象。
Spring中提供IOC容器实现方式：
BeanFactory：IOC容器基本实现，是Spring内容的使用接口

• 加载配置文件的时候不会创建对象，在获取对象才去创建对象。
  ApplicationContext：BeanFactory的子接口
  *加载配置文件的时候就会把配置文件对象进行创建。

2.DI依赖注入：

控制反转是同一个概念的不同角度的描述，即 应用程序在运行时依赖IoC容器来动态注入对象需要的外部依赖。
3BeanFactory和ApplicationContext有什么区别？
BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。

（1）BeanFactory是Spring里面最底层的接口，是IoC的核心，定义了IoC的基本功能，包含了各种Bean的定义、加载、实例化，依赖注入和生命周期管理。ApplicationContext接口作为BeanFactory的子类，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：
继承MessageSource，因此支持国际化。
资源文件访问，如URL和文件（ResourceLoader）。
载入多个（有继承关系）上下文（即同时加载多个配置文件） ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。
提供在监听器中注册bean的事件。
（2）①BeanFactroy采用的是延迟加载形式来注入Bean的，只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能提前发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。
②ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。
③ApplicationContext启动后预载入所有的单实例Bean，所以在运行的时候速度比较快，因为它们已经创建好了。相对于BeanFactory，ApplicationContext 唯一的不足是占用内存空间，当应用程序配置Bean较多时，程序启动较慢。
（3）BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。
（4）BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

3.IOC Bean管理

（1）什么是Bean管理
Spring 创建对象。
Spring 注入属性。
（2）Bean管理操作的方式
基于xml创建对象。

基于XML方式注入属性（DI：依赖注入（注入属性））

有参构造函数注入 p名称空间注入（了解即可） <?xml version="1.0" encoding="UTF-8"?>

<bean id="book" class="com.atguigu.spring5.Book" p:bname="very" p:bauthor="good">
</bean>

注入空值和特殊符号

<!--（2）特殊符号赋值-->
 <!--属性值包含特殊符号
   a 把<>进行转义 &lt; &gt;
   b 把带特殊符号内容写到CDATA
  -->
<property name="address">
    <value><![CDATA[<<南京>>]]></value>
</property>

注入属性-外部bean 注入属性-内部bean 注入属性-级联赋值

xml 注入集合属性

<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>java课程</value>
            <value>数据库课程</value>
        </array>
    </property>
    <!--list类型属性注入-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>小三</value>
        </list>
    </property>
    <!--map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>

向集合中注入对象值

<!--注入list集合类型，值是对象-->
   <property name="courseList">
       <list>
           <ref bean="course1"></ref>
           <ref bean="course2"></ref>
       </list>
   </property>

读取集合中的值

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:util=“http://www.springframework.org/schema/util”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd”>

<util:list id="bookList">
    <value>易筋经</value>
    <value>九阴真经</value>
    <value>九阳神功</value>
</util:list>

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="bookList"></property>

4、ICO操作Bean管理（FactoryBean）

（1）Spring中有两种Bean，一种是普通bean，另一种是工厂bean（FactoryBean）
（2）普通 bean：在配置文件中定义 bean 类型就是返回类型
（3）工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样：
第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型
public class MyBean implements FactoryBean {
public User getObject() throws Exception {
User user = new User();
user.setId(1);
return user;
}

public Class<?> getObjectType() {
    return null;
}

public boolean isSingleton() {
    return false;
}

}

5、Bean的作用域

在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例。
scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象。

singleton 和 prototype 区别 ​ singleton 单实例，prototype 多实例 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象 ；设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时候创建多实例对象.

（1）singleton：默认作用域，单例bean，每个容器中只有一个bean的实例。
（2）prototype：为每一个bean请求创建一个实例。
（3）request：为每一个request请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。
（4）session：与request范围类似，同一个session会话共享一个实例，不同会话使用不同的实例。
（5）global-session：全局作用域，所有会话共享一个实例。如果想要声明让所有会话共享的存储变量的话，那么这全局变量需要存储在global-session中。

Bean创建流程
获取 BeanName，对传入的 name 进行解析，转化为可以从 Map 中获取到 BeanDefinition 的 bean name。
合并 Bean 定义，对父类的定义进行合并和覆盖，如果父类还有父类，会进行递归合并，以获取完整的 Bean 定义信息。
实例化，使用构造或者工厂方法创建 Bean 实例。
属性填充，寻找并且注入依赖，依赖的 Bean 还会递归调用 getBean 方法获取。
初始化，调用自定义的初始化方法。
获取最终的 Bean，如果是 FactoryBean 需要调用 getObject 方法，如果需要类型转换调用 TypeConverter 进行转化。

6、Bean生命周期

生命周期：对象从创建到销毁的过程。
Beam生命周期：
通过构造器创建Bean实例（无参数构造）
为Bean的属性设置初始化值和其他bean引用（调用set方法）
调用bean的初始化方法（需要进行配置初始化的方法）
bean的使用（获取bean对象）
当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）
bean的后置处理器，bean的生命周期有7步。

通过构造器创建Bean实例（无参数构造）
对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。
为Bean的属性设置初始化值和其他bean引用（调用set方法）
实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成属性设置与依赖注入。
把bean实例传递bean后置处理器方法-----postProcessBeforeInitialization
如果想对Bean进行一些自定义的前置处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。
调用bean的初始化方法（需要进行配置初始化的方法）
如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。
把bean实例传递bean后置处理器方法-----postProcessAfterInitialization
如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；
bean的使用（获取bean对象）
当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）
最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。
*：后置处理器会将xml文件中所有的bean添加后置方法，若配置多个，执行顺序和xml配置顺序一致。
第一步 执行无参数构造创建 bean 实例
第二步 调用 set 方法设置属性值
orders: init before…1111
orders: init before…
第三步 执行初始化的方法
orders: init after…1111
orders: init after…
第五步 执行销毁的方法

7、AOP底层原理

面向切面编程，降低系统代码耦合度，对业务逻辑与其他部分进行隔离。

7.1 使用动态代理。

有接口情况，使用JDK动态代理。
创建接口实现类代理对象，增强类的方法。
JDK动态代理的核心是InvocationHandler接口和Proxy类，在获取代理对象时，使用Proxy类来动态创建目标类的代理类（即最终真正的代理类，这个类继承自Proxy并实现了我们定义的接口），当代理对象调用真实对象的方法时， InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起。

没有接口情况，使用CJLIB动态代理。
创建当前类子类的代理对象。
如果被代理类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

7.2 术语

连接点
类中那些方法可以被增强，这些方法被称为连接点。
切入点
实际被真正增强的方法，被成为切入点。
通知（增强）
实际增强的逻辑部分被称为通知：前置通知，后置通知，环绕通知，异常通知，返回后通知（AfterReturning Advice）。
切面
把通知应用到切入点的过程。

8、Spring 循环依赖

循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。如下图：

8.1解决方案：三级缓存。

https://blog.csdn.net/f641385712/article/details/92801300
在Spring容器整个生命周期内，有且只有一个对象，所以很容易想到这个对象应该存在Cache中，Spring为了解决单例的循环依赖问题，使用了三级缓存。
先从一级缓存singletonObjects中去获取。（如果获取到就直接return）
如果获取不到或者对象正在创建中（isSingletonCurrentlyInCreation()），那就再从二级缓存earlySingletonObjects中获取。（如果获取到就直接return）
如果还是获取不到，且允许singletonFactories（allowEarlyReference=true）通过getObject()获取。就从三级缓存singletonFactory.getObject()获取。（如果获取到了就从singletonFactories中移除，并且放进earlySingletonObjects。其实也就是从三级缓存移动（是剪切、不是复制哦~）到了二级缓存）
加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决

9、Spring基于xml注入bean的几种方式：

https://blog.csdn.net/a745233700/article/details/89307518
set()方法注入；
构造器注入：①通过index设置参数的位置；②通过type设置参数类型；
静态工厂注入；
实例工厂；

10、Spring的自动装配：

（1）在Spring框架xml配置中共有5种自动装配：
no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装配bean。
byName：通过bean的名称进行自动装配，如果一个bean的 property 与另一bean 的name 相同，就进行自动装配。
byType：通过参数的数据类型进行自动装配。
constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配。
autodetect：自动探测，如果有构造方法，通过 construct的方式自动装配，否则使用 byType的方式自动装配。
（2）基于注解的自动装配方式：
使用@Autowired、@Resource注解来自动装配指定的bean。
@Autowired可用于：构造函数、成员变量、Setter方法
@Autowired和@Resource之间的区别：
(1) @Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。
(2) @Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。

11、Spring事务

（1）事务的四大特性（ACID）
原子性
一致性
隔离性：多事务操作，相互之间不会产生影响。
持久性：事务提交，数据发生变化。
（2）Spring事务的种类：
spring支持编程式事务管理和声明式事务管理两种方式：
①编程式事务管理使用TransactionTemplate。
②声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。
（2）spring的事务传播机制：
spring事务的传播机制说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。事务传播机制实际上是使用简单的ThreadLocal实现的，所以，如果调用的方法是在新线程调用的，事务传播实际上是会失效的。
① PROPAGATION_REQUIRED：（默认传播行为）如果当前没有事务，就创建一个新事务；如果当前存在事务，就加入该事务。
② PROPAGATION_REQUIRES_NEW：无论当前存不存在事务，都创建新事务进行执行。
③ PROPAGATION_SUPPORTS：如果当前存在事务，就加入该事务；如果当前不存在事务，就以非事务执行。
④ PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
⑤ PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则按REQUIRED属性执行。
⑥ PROPAGATION_MANDATORY：如果当前存在事务，就加入该事务；如果当前不存在事务，就抛出异常。
⑦ PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
（3）Spring中的隔离级别：
① ISOLATION_DEFAULT：这是个 PlatfromTransactionManager 默认的隔离级别，使用数据库默认的事务隔离级别。
② ISOLATION_READ_UNCOMMITTED：读未提交，允许事务在执行过程中，读取其他事务未提交的数据。
③ ISOLATION_READ_COMMITTED：读已提交，允许事务在执行过程中，读取其他事务已经提交的数据。
④ ISOLATION_REPEATABLE_READ：可重复读，在同一个事务内，任意时刻的查询结果都是一致的。
⑤ ISOLATION_SERIALIZABLE：所有事务逐个依次执行。
13、Spring 框架中都用到了哪些设计模式？
（1）工厂模式：Spring使用工厂模式，通过BeanFactory和ApplicationContext来创建对象
（2）单例模式：Bean默认为单例模式
（3）策略模式：例如Resource的实现类，针对不同的资源文件，实现了不同方式的资源获取策略
（4）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术
（5）模板方法：可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中，用来解决代码重复的问题。比如RestTemplate, JmsTemplate, JpaTemplate
（6）适配器模式：Spring AOP的增强或通知（Advice）使用到了适配器模式，Spring MVC中也是用到了适配器模式适配Controller
（7）观察者模式：Spring事件驱动模型就是观察者模式的一个经典应用。
（8）桥接模式：可以根据客户的需求能够动态切换不同的数据源。比如我们的项目需要连接多个数据库，客户在每次访问中根据需要会去访问不同的数据库。
14、Spring框架中的Bean是线程安全的么？如果线程不安全，那么如何处理？
Spring容器本身并没有提供Bean的线程安全策略，因此可以说Spring容器中的Bean本身不具备线程安全的特性，但是具体情况还是要结合Bean的作用域来讨论。
（1）对于prototype作用域的Bean，每次都创建一个新对象，也就是线程之间不存在Bean共享，因此不会有线程安全问题。
（2）对于singleton作用域的Bean，所有的线程都共享一个单例实例的Bean，因此是存在线程安全问题的。但是如果单例Bean是一个无状态Bean，也就是线程中的操作不会对Bean的成员执行查询以外的操作，那么这个单例Bean是线程安全的。比如Controller类、Service类和Dao等，这些Bean大多是无状态的，只关注于方法本身。
有状态Bean(Stateful Bean) ：就是有实例变量的对象，可以保存数据，是非线程安全的。
无状态Bean(Stateless Bean)：就是没有实例变量的对象，不能保存数据，是不变类，是线程安全的。