创建对象的几种方式

1. new
2. 反射

• 类名.class
• 对象名.class
• class.forName()

1. 工厂模式

什么是bean

bean是由IOC容器实例化，组装，管理的一个对象

bean生命周期开始时间

针对的都是 单例 singleton bean

对于applicationContext来说，当容器启动时bean就被创建了

而对于beanFactory,直到调用getBean()方法时才被实例化

流程

配置文件-解析-使用-卸载

Spring中使用的是反射

Class是方法的入口

1. 减少新生实例的消耗
2. 减少jvm的垃圾回收
3. 快速获取到bean

通过描述bean的信息找到bean
通过你的身份信息找到你

实例后的bean能直接用吗？不能
还要初始化

bean的生命周期

1.创建前准备

主要是一些扩展

2.创建实例化

3.依赖注入

4.容器缓存

5.销毁

1. properties xml yml 准备容器xmlApplication
2. beanDefinitionReader抽象
3. xmlDefinationReader

进入容器 beanFactory

1. beanDefinition (prepareBeanFactory)

• postProcessBeanFactory没有方法，留给子类自己实现
• invokeBeanFactoryPost…
• registerBean….
• initMessageSource
• initApplicationEventMulticaster
• omRefresh
• registerListers
• finishBeanFactoryInitialize(非懒加载)还没有bean 所以要createBean doGetBean

createBeanInstence

1. beanFactoryPostPressor(增强器)
2. 实例化 反射

• 填充属性 populateBean
• 执行初始化方法 initionalizeBean

invokeAwareMethods
Aware接口需要实现的方法 设置系统属性 set

• 前置增强器
• 初始化方法

• 后置增强器 AOP JDK和CGlib

  7.使用

初始化前后应该有增强器 动态代理 (扩展)aop

• 前置 BeanPostProcessor

1. beanBeforePostProcessor

• 后置 BeanPostProcessor

1. BeanAfterPostProcessor

综合前面的代码和分析，现在我们用大白话描述下：

Bean容器找到Spring配置文件中Bean的定义； beanDefinitionReader抽象
通过BeanDefinition
Bean容器为实例化的Bean设置属性值；set注入

如果Bean实现了BeanNameAware接口，则执行setBeanName方法；
如果Bean实现了BeanClassLoaderAware接口，则执行setBeanClassLoader方法；
如果Bean实现了BeanFactoryAware接口，则执行setBeanFactory方法；

• BeanNameAware
• BeanClassLoaderAware
• BeanFactoryAware
• EnvironmentAware
• ResourceLoaderAware
• ApplicationEventPublisherAware
• ApplicationContextAware

如果 ……真的，到这我经常忘记，但前面三个Aware接口肯定能记住；
如果Bean实现了ApplicationContextAware接口，则执行setApplicationContext方法；
如果加载了BeanPostProcessor相关实现类，则执行postProcessBeforeInitialization方法；
如果Bean定义初始化方法（PostConstruct注解、配置init-method、实现了InitializingBean接口），则执行定义的初始化方法；
如果加载了BeanPostProcessor相关实现类，则执行postProcessAfterInitialization方法；
当要销毁这个Bean时，如果自定义了销毁方法（PreDestroy注解、配置destroy-method、实现了DisposableBean接口），则执行定义的销毁方法。 [

](https://www.iamshuaidi.com/1529.html))

1、使用 Spring 框架的好处是什么？

1. 轻量：Spring 是轻量的，基本的版本大约 2MB。
2. 控制反转：Spring 通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
3. 面向切面的编程(AOP)：Spring 支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
4. 容器：Spring 包含并管理应用中对象的生命周期和配置。
5. MVC框架：Spring 的 Web 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。
6. 事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。

7. 异常处理：Spring 提供方便的 API 把具体技术相关的异常（比如由 JDBC，Hibernate or JDO 抛出的）转化为一致的 unchecked 异常

   2、解释下什么是 AOP？

   AOP（Aspect-Oriented Programming，面向方面编程），可以说是 OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。也就是说，OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如：安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在 OOP 设计中，它导致了大量代码的重复，而不利于各个模块的重用。
   而 AOP 技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP 代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。
   使用“横切”技术，AOP 把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，它们经常发生在核心关注点的多处，而各处都基本相似。比如：权限认证、日志、事务处理、异常。AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

   3、AOP 的代理有哪几种方式？

   AOP 思想的实现一般都是基于代理模式 ，在 Java 中一般采用 JDK 动态代理模式，但是我们都知道，JDK 动态代理模式只能代理接口而不能代理类。因此，Spring AOP 会按照下面两种情况进行切换，因为 Spring AOP 同时支持 CGLIB、ASPECTJ、JDK 动态代理。

8. 如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；

9. 如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类。
10. 不过这个选择过程对开发者完全透明、开发者也无需关心。

    4、怎么实现 JDK 动态代理？

    JDK 动态代理最核心的一个接口和方法如下所示：

    1. java.lang.reflect 包中的 InvocationHandler 接口：

    public interface InvocationHandler { 
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; 
    }

    对于被代理的类的操作都会由该接口中的 invoke 方法实现，其中的参数的含义分别是：
    proxy：被代理的类的实例；
    method：调用被代理的类的方法；
    args：该方法需要的参数。
    使用方法首先是需要实现该接口，并且我们可以在 invoke 方法中调用被代理类的方法并获得返回值，自然也可以在调用该方法的前后去做一些额外的事情，从而实现动态代理。

    2. java.lang.reflect 包中的 Proxy 类中的 newProxyInstance 方法：

    ```java public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

``` 其中的参数含义如下：
loader：被代理的类的类加载器；
interfaces：被代理类的接口数组；
invocationHandler：调用处理器类的对象实例
该方法会返回一个被修改过的类的实例，从而可以自由的调用该实例的方法

5、AOP 的基本概念：切面、连接点、切入点等？

1. 切面（Aspect）：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。
2. 连接点（Join point）：程序执行过程中的某一行为。 方法
3. 切入点（Pointcut）：匹配连接点的断言，在 AOP 中通知和一个切入点表达式关联。连接点的集合
4. 目标对象（Target Object）：被一个或者多个切面所通知的对象。增强之前的对象
5. 通知（Advice）：“切面”对于某个“连接点”所产生的动作。 logic 前还是后
6. AOP 代理（AOP Proxy）：在 Spring AOP 中有两种代理方式，JDK 动态代理和 CGLIB 代理。

7. Introduction

   6、通知类型（Advice）型（Advice）有哪些？

8. 前置通知（Before advice）：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext 中在 里面使用元素进行声明；

9. 后置通知（After advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext 中在里面使用元素进行声明。
10. 返回后通知（After return advice ：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext 中在 里面使用 <> 元素进行声明。
11. 环绕通知（Around advice）：包围一个连接点的通知，类似 Web 中 Servlet规范中的 Filter 的 doFilter 方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext 中在 里面使用元素进行声明。

12. 抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。ApplicationContext 中在 里面使用元素进行声明。

    7、谈谈你对 IOC 的理解？

    IOC 是 Inversion of Control 的缩写，多数书籍翻译成“控制反转”。简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。IOC 理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦。如下图：
    
    由于引进了中间位置的“第三方”，也就是 IOC 容器，使得 A、B、C、D 这 4 个对象没有了耦合关系，齿轮之间的传动全部依靠“第三方”了，全部对象的控制权全部上缴给“第三方”IOC 容器，所以，IOC 容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用，把系统中的所有对象粘合在一起发挥作用，如果没有这个“粘合剂”，对象与对象之间会彼此失去联系，这就是有人把 IOC 容器比喻成“粘合剂”的由来。
    把上图中间的 IOC 容器拿掉，然后再来看看这套系统：
    
    现在看到的画面，就是我们要实现整个系统所需要完成的全部内容。这时候，A、B、C、D 这 4 个对象之间已经没有了耦合关系，彼此毫无联系，这样的话，当你在实现 A 的时候，根本无须再去考虑 B、C 和 D了，对象之间的依赖关系已经降低到了最低程度。所以，如果真能实现 IOC 容器，对于系统开发而言，这将是一件多么美好的事情，参与开发的每一成员只要实现自己的类就可以了，跟别人没有任何关系！
    我们再来看看，控制反转(IOC)到底为什么要起这么个名字？我们来对比一下：
    软件系统在没有引入 IOC 容器之前，对象 A 依赖于对象 B，那么对象 A 在初始化或者运行到某一点的时候，自己必须主动去创建对象 B 或者使用已经创建的对象 B。无论是创建还是使用对象 B，控制权都在自己手上。
    软件系统在引入 IOC 容器之后，这种情形就完全改变了，由于 IOC 容器的加入，对象 A 与对象 B 之间失去了直接联系，所以，当对象 A 运行到需要对象 B 的时候，IOC 容器会主动创建一个对象 B 注入到对象 A 需要的地方。
    通过前后的对比，我们不难看出来：对象 A 获得依赖对象 B 的过程，由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。

    8、Bean 的生命周期？

    在传统的 Java 应用中，bean 的生命周期很简单，使用 Java 关键字 new 进行 Bean 的实例化，然后该 Bean 就能够使用了。一旦 Bean 不再被使用，则由 Java 自动进行垃圾回收。
    相比之下，Spring 管理 Bean 的生命周期就复杂多了，正确理解 Bean 的生命周期非常重要，因为 Spring 对 Bean 的管理可扩展性非常强，下面展示了一个 Bean 的构造过程：
    

13. Spring 启动，查找并加载需要被 Spring 管理的 Bean，进行 Bean 的实例化；

14. Bean 实例化后，对 Bean 的引入和值注入到 Bean 的属性中；
15. 如果 Bean 实现了 BeanNameAware 接口的话，Spring 将 Bean 的 Id 传递给 setBeanName() 方法；
16. 如果 Bean 实现了 BeanFactoryAware 接口的话，Spring 将调用 setBeanFactory() 方法，将 BeanFactory 容器实例传入；
17. 如果 Bean 实现了 ApplicationContextAware 接口的话，Spring 将调用 Bean 的 setApplicationContext() 方法，将 Bean 所在应用上下文引用传入进来；
18. 如果 Bean 实现了 BeanPostProcessor 接口，Spring 就将调用它们的 postProcessBeforeInitialization() 方法；
19. 如果 Bean 实现了 InitializingBean 接口，Spring 将调用它们的 afterPropertiesSet() 方法。类似地，如果 Bean 使用 init-method 声明了初始化方法，该方法也会被调用；
20. 如果 Bean 实现了 BeanPostProcessor 接口，Spring 就将调用它们的 postProcessAfterInitialization() 方法；
21. 此时，Bean 已经准备就绪，可以被应用程序使用了。它们将一直驻留在应用上下文中，直到应用上下文被销毁；

22. 如果 Bean 实现了 DisposableBean 接口，Spring 将调用它的 destory() 接口方法，同样，如果 Bean 使用了 destory-method 声明销毁方法，该方法也会被调用。

    9、Bean 的作用域?

23. singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的；

24. prototype : 每次请求都会创建一个新的 bean 实例；
25. request：每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效；
26. session : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效；

27. global-session：全局 session 作用域，仅仅在基于 portlet 的 web 应用中才有意义，Spring5 已经没有了。Portlet 是能够生成语义代码(例如：HTML)片段的小型 Java Web 插件。它们基于 portlet 容器，可以像 servlet 一样处理 HTTP 请求。但是，与 servlet 不同，每个 portlet 都有不同的会话。

    10、Spring 中的单例 Bean 的线程安全问题了解吗？

    大部分时候我们并没有在系统中使用多线程，所以很少有人会关注这个问题。单例 bean 存在线程问题，主要是因为：当多个线程操作同一个对象的时候，对这个对象的非静态成员变量的写操作会存在线程安全问题。常见的有两种解决办法：

28. 在 Bean 对象中尽量避免定义可变的成员变量（不太现实）。

29. 在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal 中（推荐的一种方式）。

    11、谈谈你对 Spring 中的事物的理解？

    事务是逻辑上的一组操作，要么都执行，要么都不执行。
    事务特性
    原子性：事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
    一致性：执行事务前后，数据保持一致；
    隔离性：并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的；
    持久性: 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
    Spring 事务管理接口

30. PlatformTransactionManager：（平台）事务管理器；

31. TransactionDefinition：事务定义信息（事务隔离级别、传播行为、超时、只读、回滚规则）；
32. TransactionStatus：事务运行状态；

所谓事务管理，其实就是“按照给定的事务规则来执行提交或者回滚操作”。

12、Spring 中的事务隔离级别？

当两个事务对同一个数据库的记录进行操作时，那么，他们之间的影响是怎么样的呢？
这就出现了事务隔离级别的概念。数据库的隔离性与并发控制有很大关系。
数据库的隔离级别是数据库的事务特性ACID的一部分
ACID，即原子性(atomicity)、一致性(consistency)、隔离性(isolation)和持久性(durability)。
Spring的事务隔离级别有四个：READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ和SERIALIZABLE，还有一个，是数据库默认的隔离级别DEFAULT，MySQL默认是REPEATABLE_READ。
TransactionDefinition 接口中定义了五个表示隔离级别的常量：
TransactionDefinition.ISOLATION_DEFAULT：使用后端数据库默认的隔离级别，
MySQL 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别；

READ_UNCOMMITTED

最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读；

READ_COMMITTED

允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生；

REPEATABLE_READ

对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生；

ISOLATION_SERIALIZABLE

最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

脏读 读到了其他事务还没有提交的数据
不可重复读 对某数据进行读取，发现两次读取的结果不同，也就是说没有读到相同的内容。这是因为有其他事务对这个数据同时进行了修改或删除
幻读 事务 A 根据条件查询得到了 N 条数据，但此时事务 B 更改或者增加了 M 条符合事务 A 查询条件的数据，这样当事务 A 再次进行查询的时候发现会有 N+M 条数据，产生了幻读

13、Spring 中的事物传播行为？

事务传播行为是为了解决业务层方法之间互相调用的事务问题。当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。
例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。在 TransactionDefinition 定义中包括了如下几个表示传播行为的常量：

• 支持当前事务的情况：

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务；
TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行；
TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

• 不支持当前事务的情况：

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起；
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

• 其他情况：

TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 TransactionDefinition.PROPAGATION_REQUIRED。

14、Spring 常用的注入方式有哪些？

1. 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
2. Setter 方法注入：Setter 方法注入是容器通过调用无参构造器或无参 static 工厂方法实例化 bean 之后，调用该 bean 的 Setter 方法，即实现了基于 Setter 的依赖注入。

3. 基于注解的注入：最好的解决方案是用构造器参数实现强制依赖，Setter 方法实现可选依赖。

   15、Spring 框架中用到了哪些设计模式？

4. 工厂设计模式 : Spring 使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象；

5. 代理设计模式 : Spring AOP 功能的实现；
6. 单例设计模式 : Spring 中的 Bean 默认都是单例的；
7. 模板方法模式 : Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式；
8. 包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源；
9. 观察者模式：Spring 事件驱动模型就是观察者模式很经典的一个应用；

10. 适配器模式：Spring AOP 的增强或通知(Advice)使用到了适配器模式、SpringMVC 中也是用到了适配器模式适配 Controller。

    16、ApplicationContext 通常的实现有哪些?

11. FileSystemXmlApplicationContext：此容器从一个 XML 文件中加载beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。

12. ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载beans 的定义，这里，你需要正确设置 classpath 因为这个容器将在 classpath 里找 bean 配置。
13. WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 Web 应用的所有 bean。

    
    spring循环依赖