JavaEE 面试常见问题

七、Bean的生命周期

1. 实例化 Bean ：通过反射调用构造方法实例化对象。

2. 依赖注入：装配 Bean 的属性

3. 实现了 Aware 接口的 Bean ，执行接口方法：如顺序执行 BeanNameAware 、 BeanFactoryAware 、 ApplicationContextAware的接口方法。

4. Bean 对象初始化前，循环调用实现了 BeanPostProcessor 接口的预初始化方法 （postProcessBeforeInitialization ）

5. 执行 Bean 对象初始化方法

6. Bean 对象初始化后，循环调用实现了 BeanPostProcessor 接口的后初始化方法

（ postProcessAfterInitialization ）

7. 容器关闭时，执行 Bean 对象的销毁方法

八、Spring三级缓存的理解

什么是循环依赖

@Component
public class A{
@Autowired
private B b;
}
@Component
public class B{
@Autowired
private A a;
}

Bean的生命周期回顾

1. 启动容器：加载 Bean

2. 实例化 Bean 对象

3. 依赖注入：装配 Bean 的属性

4. 初始化 Bean ：执行 aware 接口方法、预初始化方法、初始化方法、后初始化方法

5. 关闭容器：销毁 Bean

循环依赖的问题

1. 容器中没有 A 对象，实例化 A 对象

2. 装配 A 中的 B 对象，发现 B 在容器中没有，需要先实例化 B

3. 实例化 B 对象

4. 装配 B 中的 A 对象，发现 A 在容器中没有，需要先实例化 A

5. 重复第一个步骤

这就套娃了 , 你猜是先 StackOverflow 还是 OutOfMemory ？

Spring 怕你不好猜，就先抛出了 BeanCurrentlyInCreationException

[PS]

• Bean会依赖某些注入的Bean来完成初始化工作
• 由于Spring支持构造方法注入，属性/Setter注入的方式，所以不能简单的先把所有对象全部实例化，放到缓存中，再全部执行初始化。原因很简单，此时所有对象的引用都可以获取到，但属性都是null，执行初始化甚至构造方法都可能出现空指针异常。

那么我们说 Spring 能解决循环依赖，也不是所有的情况都可以解决，只有以下情况才支持。

Spring支持的循环依赖

在 Spring 容器中注册循环依赖的 Bean ，必须是单例模式，且依赖注入的方式为属性注入。

原型模式及构造方法注入的方式，不支持循环依赖。以下为说明：

• 原型模式（prototype）的Bean：原因很好理解，创建新的A时，发现要注入原型字段B，又创建新的B发现要注入原型字段A... 还是典型的套娃行为...
• 基于构造器的循环依赖，就更不用说了，官方文档都摊牌了，你想让构造器注入支持循环依赖，是不存在的，不如把代码改了。

那么默认单例的属性注入场景， Spring 是如何支持循环依赖的？

Spring解决循环依赖

Spring 是使用三级缓存的机制来解决循环依赖问题，以下为三级缓存的定义：

 三级缓存的源码见 DefaultSingletonBeanRegistry ：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
SingletonBeanRegistry {
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>
(256);
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new
HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new
ConcurrentHashMap<>(16);
}

以下是部分说明：

• 三级缓存singletonFactories中保存的是ObjectFactory对象（Bean工厂），其中包含了 BeanName，Bean对象，RootBeanDefinition，该工厂可以生成Bean对象。
• 由于Bean可能被代理，此时注入到其他Bean属性中的也应该是代理Bean。

单例模式的 A 、 B 循环依赖执行流程如下：

为什么要使用三级缓存

依照以上三级缓存的流程，其实使用二级缓存也能满足循环依赖的注入：

• 普通的IoC容器使用一级缓存即可，但无法解决循环依赖问题。
• 解决循环依赖问题：使用二级缓存即可。一级缓存保存完整Bean，二级缓存保存提前曝光的不完 整的Bean。
• 需要AOP代理Bean时，有两种实现思路：                                                                             （1）再加一级缓存                                                                                                                     （2）只使用二级缓存，其中二级缓存保存Bean的代理对象，代理对象中引用不完整的原始对象即可。
• Spring使用三级缓存保存ObjectFactory即Bean工厂，在代码的层次设计及扩展性上都会更好。 ps：ObjectFactory内部可以根据 SmartInstantiationAwareBeanPostProcessor 这样的后置处 理器获取提前曝光的对象。

九、AOP的理解

AOP （ Aspect-Oriented Programming ）：面向切面编程。对多个业务代码横切来实现统一的业务管理，而不用侵入业务代码本身。这样面向切面的编程思想就是AOP 。

使用场景：日志记录，事务管理，性能统计，安全控制，异常处理等

优点：代码解耦，统一业务功能对具体业务无侵入性，这样可扩展性更好，灵活性更高

SpringAOP 是采取动态代理的方式，具体是基于 JDK 和 CGLIB 两种：

• JDK动态代理：需要被代理类实现接口，使用 InvocationHandler 和 Proxy 动态的生成代理类
• CGLIB动态代理：需要被代理类能被继承，不能被final修饰。使用 MethodInterceptor 来对方法拦截。CGLIB底层是基于ASM字节码框架，在运行时动态生成代理类

SpringAOP 如何使用： @Aspect 定义切面，并注册到容器中，使用 @Pointcut 定义好切点方法后，可以对目标方法进行拦截：

• 前置通知    使用@Before：通知方法会在目标方法调用之前执行。

• 后置通知    使用@After：通知方法会在目标方法返回或者抛出异常后调用。
• 返回之后通知    使用@AfterReturning：通知方法会在目标方法返回后调用。
• 抛异常后通知    使用@AfterThrowing：通知方法会在目标方法抛出异常后调用。
• 环绕通知    使用@Around：通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为。

十、Spring事务中的隔离级别有哪几种？

在 TransactionDefinition 接口中定义了五个表示隔离级别的常量：

• ISOLATION_DEFAULT：使用后端数据库默认的隔离级别，Mysql默认采用的REPEATABLE_READ 隔离级别；Oracle默认采用的READ_COMMITTED隔离级别。
• ISOLATION_READ_UNCOMMITTED：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。
• ISOLATION_READ_COMMITTED：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
• ISOLATION_REPEATABLE_READ：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
• ISOLATION_SERIALIZABLE：最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

十一、Spring事务中有哪几种事务传播行为？

在 TransactionDefinition 接口中定义了七个表示事务传播行为的常量。

支持当前事务的情况：

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

不支持当前事务的情况：

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

其他情况：

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

 12.SpringMVC的流程

文章来源地址https://www.toymoban.com/news/detail-628329.html

• 第一步：（发起）发起请求到前端控制器(DispatcherServlet)
• 第二步：（查找）前端控制器请求HandlerMapping查找 Handler（可以根据xml配置、注解进行查找）
• 第三步：（返回）处理器映射器HandlerMapping向前端控制器返回Handler，HandlerMapping 会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象，多个HandlerInterceptor拦截器对象），通过这种策略模式，很容易添加新的映射策略
• 第四步：（调用）前端控制器调用处理器适配器去执行Handler
• 第五步：（执行）处理器适配器HandlerAdapter将会根据适配的结果去执行Handler
• 第六步：（返回）Handler执行完成给适配器返回ModelAndView
• 第七步：（接收）处理器适配器向前端控制器返回ModelAndView （ModelAndView是
• SpringMVC框架的一个底层对象，包括 Model和view）
• 第八步：（解析）前端控制器请求视图解析器去进行视图解析 （根据逻辑视图名解析成真正的视图 (jsp)），通过这种策略很容易更换其他视图技术，只需要更改视图解析器即可
• 第九步：（返回）视图解析器向前端控制器返回View
• 第十步：（渲染）前端控制器进行视图渲染 （视图渲染将模型数据(在ModelAndView对象中)填充到request域）
• 第十一步：（响应）前端控制器向用户响应结果

以下是对出现的一些组件的介绍：

(1) 前端控制器 DispatcherServlet （不需要程序员开发）。

作用：接收请求，响应结果，相当于转发器，中央处理器。有了 DispatcherServlet 减少了其它组件之间

的耦合度。

(2) 处理器映射器 HandlerMapping （不需要程序员开发）。

作用：根据请求的 url 查找 Handler 。

(3) 处理器适配器 HandlerAdapter （不需要程序员开发）。

作用：按照特定规则（ HandlerAdapter 要求的规则）去执行 Handler 。

(4) 处理器 Handler （需要程序员开发）。

注意：编写 Handler 时按照 HandlerAdapter 的要求去做，这样适配器才可以去正确执行 Handler

(5) 视图解析器 ViewResolver （不需要程序员开发）。

作用：进行视图解析，根据逻辑视图名解析成真正的视图（ view ）

(6) 视图 View （需要程序员开发 jsp ）。

注意： View 是一个接口，实现类支持不同的 View 类型（ jsp 、 freemarker 、 pdf… ）

ps: 不需要程序员开发的，需要程序员自己做一下配置即可。

十三、Mybatis中，#{}和${}的区别

• #{变量名} 是预处理替换的方式，本质是 jdbc 中占位符的替换。如传入字符串，会替换为带单引号的值。可以安全性更好，
• ${变量名} 是字符串的替换，只是对 sql 字符串进行拼接。如传入字符串，会直接替换为字符串的值，不加单引号。

# 的方式可以很大程度的防止 sql 注入，相对来说更安全。而 $ 的方式不能。

十四、Mybatis中如何一对一、一对多关联

十五、SpringBoot 自动配置原理