面试经典-Spring篇

1、解释Spring框架中bean的生命周期

• 实例化

通过反射去推断构造函数进行实例化
实例工厂、静态工厂

• 属性赋值

解析自动装配（byname、bytype、 constractor、 @Autowired）
循环依赖

• 初始化

调用XXXAware回调方法（BeanNameAware、BeanFactoryAware、ApplicationContextAware）
调用BeanPostProcessor的预初始化方法
调用初始化生命周期3中回调（@PostConstract、InitializingBean、init-method）
调用自定义初始化方法
调用BeanPostProcessor的初始化后方法
如果bean实现AOP，创建动态代理

• 销毁

在Spring容器关闭的时候进行调用
调用销毁生命周期回调（@PreDestroy、 DisposableBean、 destroy-method）

2、单例Bean的优势

• 减少了新生成实例的消耗，spring通过反射或者cglib来生成bean是耗性能的操作，给对象分配内存也会设计复杂算法
• 减少jvm垃圾回收，由于不会给每个请求都新生成bean实例，回收的对象少了
• 可以快速获取到bean，处理第一次生成bean之外，其余的都是从缓存里获取的

3、Spring的bean是线程安全的吗

• 如果在类中声明成员变量，并且有读写操作（有状态），就会线程不安全
• 只需要把成员变量声明在方法中，单例bean是线程安全的

4、Spring如何处理线程并发问题

• 只需要把成员变量声明在方法中，单例bean是线程安全的
• 设置为多例
• 将成员变量放在ThreadLocal
• 同步锁 会影响服务器吞吐量

5、Spring实例化bean有几种方式

• 构造器方式（反射）： @Component
• 静态工厂方式：factory-method
• 实例工厂方式：@Bean 或 factory-bean + factory-method
• FactoryBean方式： implements FactoryBean，重写getObject、getType方法

6、什么是bean装配？什么是bean的自动装配？

• @Autowired

7、自动注入有什么限制吗？

• 一定要声明set方法
• 覆盖：你仍可以用 和配置来定义依赖
• 基本数据类型：不能自动装配简单的属性，如基本数据类型、字符串和类（手动可以， @Value）
• 模糊特性：自动装配不如显式装配精确，推荐使用手动装配@Autowired(根据类型，名字) ref=""这种方式更加灵活清晰

8、自动装配的方式有几种

• no：默认，通过手工设置ref属性来进行装配bean，@Autowired来进行手动置顶需要自动注入的属性
• byName：通过bean的名称进行自动装配，如果一个bean的property与另一bean的name相同，就进行自动装配
• byType：通过参数的数据类型进行自动装配
• constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配
• autodetect:自动探测，如果有构造方法，通过construct的方式自动装配，否则使用byType的方式装配（Spring 3.0+弃用）

9、bean有哪些生命周期的回调方法？有哪几种实现

初始化

• @PostConstruct----被注解标注的方法
• InitializingBean------afterPropertiesSet
• init-method-----------通过配置指定的方法

销毁

• @PerDestroy-----------被注解标注的方法
• DisposableBean-------destroy
• destroy-method--------通过配置指定的方法

@PostConstruct
public void init(){
	System.out.println("初始化")；
}
@PreDestroy
public void init(){
	System.out.println("销毁")；
}
----------------------------------------------
@Override
public void afterPropertiesSet() throws Exception{
	System.out.println("初始化2")；
}
@Override
public void destroy() throws Exception{
	System.out.println("销毁2")；
}
----------------------------------------------
@Bean(initMethod = "init3",destroyMethod = "destroy3")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

10、Spring在加载过程中Bean有哪几种形态

11、Spring如何解决bean的循环依赖

Spring是如何解决循环依赖：采用的三级缓存解决的，就是三个Map，一定要有一个缓存保存他的早期对象作为死循环的出口

1. 一级缓存： 存储完整的bean
2. 二级缓存：避免多重循环依赖的情况，重复创建动态代理
3. 三级缓存：

a.缓存的是函数接口，通过lambda把方法传进去（把bean的实例和bean的名字传进去）
b.不会立即调用，如果实例化后立即调用的话，所有的aop不管bean是否循环依赖都会在实例化创建动态代理（正常bean 其实Spring还是希望遵循生命周期的在初始化创建动态代理）
c.会在ABA(第二次getBean(A)才会在调用三级缓存，如果实现了aop才会创建动态代理，录入过么有实现依然返回Bean的实例
d.放入二级缓存，避免重复创建

12、Spring使用三级缓存解决循环依赖

13、二级缓存能不能解决循环依赖

• 如果只是死循环的问题，一级缓存就可以解决，无法避免在并发下获取不完整的Bean
• 二级缓存可以解决循环依赖，只不过如果出现重复循环依赖，会多次创建AOP动态代理

14、Spring有没有解决多例Bean的循环依赖

• 多例不会使用缓存进行存储（多例bean每次使用都需要重新创建）
• 不缓存早期对象就无法解决循环依赖

15、Spring有没有解决构造函数参数bean的循环依赖

• 构造函数的循环依赖也会报错
• 可以通过@Lazy，就不会立即创建依赖的bean了，而是等到用到了才通过动态代理创建

16、@Lazy循环依赖的原理

17、Spring IOC容器的加载过程

从概念态到定义态

• 实例化一个ApplicationContext对象
• 调用bean工厂后置处理器完成扫描
• 循环解析扫描出来的类信息
• 实例化一个BeanDefinition对象来存储解析出来的信息
• 把实例化好的beanDeifinition对象put到beanDefinitionMap中缓存起来，以便后面实例化bean
• 再次调用其他bean工厂后置处理器

从定义态到纯净态

• 调用finishBeanFactoryInitialization方法来实例化单例bean，实例化之前要做验证，需要遍历所有扫描出来的类，依次判断这个bean是否lazy，是否prototype，是否abstract等等
• 如果验证完成，spring会推断一个bean的构造方法，通过构造方法反射实例化一个对象，此时的对象不是一个完整的bean

从纯净态到成熟态

• spring处理合并后的beanDefinition
• 完成属性注入
• 判断bean的类型回调aware接口
• 调用生命周期回调方法
• 完成aop动态代理
• put到单例池，bean完成

18、Spring IOC有哪些扩展点？在什么时候调用

• 执行BeanFactoryPostProcessor的postProcessBeanFactory方法（修改BeanDefinition）
• 执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法（注册BeanDefinition）
• 加载BeanPostProcessor实现类，在bean生命周期会调用9次Bean的后置处理器
• 初始化阶段调用XXXAware接口的setXXXAware方法
• 执行BeanPostProcessor实现类的postProcessBeforeInitialization方法
• 执行InitializingBean实现类的afterPropertiesSet方法
• 执行bean的init-method属性指定的初始化方法
• 执行BeanPostProcessor实现类的postProcessAfterInitialization方法
• 初始化完成
• 关闭容器，执行DiposibleBean实现类的destory方法
• 执行bean的destroy-method属性指定的方法

19、配置bean有哪几种方式

• xml:
• 注解：@Component、@Clontroller，配置component-scan,，反射调用构造方法
• javaConfig:@Bean 可以自己控制实例化
• @Import 3中方式

20、Spring有几种作用域

singleton、prototype、request、session、application

21、Spring支持的事务管理类型

编程式事务(TransactionTemplate)、声明式事务

• 基于接口

a.基于TransactionInterceptor的声明式事务
b.基于TransactionProxyFactoryBean的声明式事务

• 基于和命名空间的声明式事务：目前推荐的方式，可以与AOP紧密结合，充分利用切点表达式的强大支持，使得管理事务更加灵活
• 基于@Transactional的全注解方式：将声明式事务管理简化到极致

22、Spring事务传播行为的原理

Spring的事务信息是存在ThreadLocal中的，所有一个线程永远只能有一个事务

• 融入：拿到外部事务ThreadLocal中的Connection，共享一个数据库连接共同提交、回滚
• 创建新事务：将嵌套新事务存入ThreadLocal、再将外部事务暂存起来，当嵌套事务提交、回滚，会将暂存的事务信息恢复到ThreadLocal中

23、Spring多线程事务能否保证事务的一致性

• Spring的事务信息是存在ThreadLocal中的，所有一个线程永远只能有一个事务
• 多线程事务无法保证事务的一致性
• 可以通过编程式事务，或者通过分布式事务的思路：二阶段提交方式实现

24、Spring事务的失效原因

• 方法是private的
• 目标类没有配置为Bean
• 自己捕获了异常
• 使用cglib动态代理，但是@Transaction声明在接口上
• 内部调用，没经过动态代理，重新拿到代理对象再执行方法才能进行增强

在本类中自动注入当前的bean
设置暴露当前代理对象到本地线程，可以通过AopContext.currentProxy()拿到当前正在调用的动态代理对象

25、Spring框架中用了哪些设计模式

• 简单工厂-----BeanFactory
• 工厂方法-----FactoryBean
• 单例模式-----Bean实例
• 适配器模式–SpringMVC中的HandlerAdapter
• 装饰器模式–BeanWrapper
• 代理模式-----AOP
• 观察者模式–spring的事件监听
• 策略模式-----excludeFilters、includeFilters
• 模版方法模式-所有外接扩展都用这种模式
• 责任链模式–AOP的方法调用