一、spring 的框架中用到了哪些设计模式

1. 工厂模式：BeanFactory是工厂模式的实现，用来创建对象实例。
2. 单例模式：定义的bean默认是单例模式。
3. 代理模式: spring aop 实现了代理模式。
4. 模板方法模式: 用来解决代码重复的问题，比如JdbcTemplate/RestTemplate等等。
5. 策略模式: 比如bean的创建过程中，spring 大量使用了策略模式来。
6. 观察者模式: 比如容器启动过程中事件的发布，或者程序借助spring 自定义事件的发布。

二、spring 是如何解决循环依赖的

首先，原型的场景不支持循环依赖，循环依赖通常在单例场景下才有意义。另外，并不是说所有的单例场景下都支持循环依赖：比如基于构造器的循环依赖是不支持的，另外如果有需要可以手动调用
setAllowCircularReferences(false)可以明确要求不支持循环依赖。

spring 内部解决基于三级缓存解决循环依赖问题:

• 一级缓存(singletonObjects):是单例对象:存储的完全实例化和初始化的bean。
• 二级缓存(earlySingletonObjects):存储的是bean的半成品，只是早期的bean引用，属性还没有装配。
• 三级缓存(singletonFactories):存储的是一个objectFactory 本质上是一个lamba表达式（借助beanPostProcessor 的 getEarlyBeanReference方法获取提前暴露的半成品对象）工厂。

当出现循环依赖的时候，第二次获取同一个bean,一定是先从三级缓存singletonFactories中获取到一个ObjectFactory工厂对象，然后通过执行objectFactory.getObject()获取到半成品对象，并把半成品对象放到二级缓存earlySingletonObjects中同时从三级缓存移除掉对应的ObjectFactory，由此解决了循环依赖的问题（参考Bean的查找逻辑图片）。

其实仅仅依靠第一级缓存和第三级缓存也能解决循环依赖的问题，引入第二级缓存是防止三级缓存中objectFactory.getObject()方法执行多次的问题。

三、spring mvc 的处理流程

(1).用户发送请求至前端控制器DispatcherServlet。

(2).DispatcherServlet收到请求调用HandlerMapping处理器映射器

(3).处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet

(4).DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

(5).执行处理器(Controller，也叫后端控制器)

(6).Controller执行完成返回ModelAndView

(7).HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

(8).DispatcherServlet将ModelAndView传给ViewReslover视图解析器

(9).ViewReslover解析后返回具体View

(10).DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）

备注：spring mvc的一些核心组件

• MultipartResolver：文件解析器，用于支持服务器的文件上传
• LocaleResolver：国际化解析器，可以提供国际化的功能
• ThemeResolver：主题解析器，类似于软件皮肤的转换功能
• HandlerMappings：处理器映射器，它会包装用户提供一个控制器的方法和它的一些拦截器
• HandlerAdapters：处理器适配器，因为处理器会在不同的上下文运行，所以Spring MVC会找到合适的适配器，然后运行处理器服务方法
• HandlerExceptionResolvers：处理器异常解析器，处理器有可能产生异常，如果产生异常，则通过异常解析器来处理它
• RequestToViewNameTranslator：视图逻辑名称转换器，在控制器中返回一个视图的名称，通过它可以找到实际的视图。当处理器没有返回逻辑视图名等相关信息时，自动请求URL映射为逻辑视图名
• ViewResolvers：视图解析器，当控制器返回后，通过视图解析器会把逻辑视图名称进行解析，然后定位实际视图

四、spring事务定义的传播规则

1. REQUIRED：没有事务则创建新的事务，没有则创建。
2. SUPPORTS: 有事务则支持，没有事务则以非事务的形式执行。
3. MANDATORY：必须要有事务，没有事务则抛出异常。
4. REQUIRES_NEW：要求在新事务中执行，如果当前存在事务则把当前事务挂起。
5. NOT_SUPPORTED：以非事务的形式执行，如果当前存在事务则把当前事务挂起。
6. NEVER：以非事务的形式执行，如果当前存在事务则抛出异常。
7. NESTED：如果当前存在事务，则以嵌套事务的形式执行，如果不存在事务则与REQUIRED类似的操作。

备注NESTED嵌套事务特性:

1. 主事务和嵌套事务属于同一个事务。
2. 嵌套事务回滚不会影响到主事务。
3. 主事务回滚会影响到嵌套事务，嵌套事务也会回滚。

//传播规则枚举值如下:
public enum Propagation {

	/**
	 * Support a current transaction, create a new one if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p>This is the default setting of a transaction annotation.
	 */
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

	/**
	 * Support a current transaction, execute non-transactionally if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p>Note: For transaction managers with transaction synchronization,
	 * {@code SUPPORTS} is slightly different from no transaction at all,
	 * as it defines a transaction scope that synchronization will apply for.
	 * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
	 * will be shared for the entire specified scope. Note that this depends on
	 * the actual synchronization configuration of the transaction manager.
	 * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
	 */
	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

	/**
	 * Support a current transaction, throw an exception if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 */
	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

	/**
	 * Create a new transaction, and suspend the current transaction if one exists.
	 * Analogous to the EJB transaction attribute of the same name.
	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
	 * on all transaction managers. This in particular applies to
	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
	 * which requires the {@code javax.transaction.TransactionManager} to be
	 * made available to it (which is server-specific in standard Java EE).
	 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
	 */
	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

	/**
	 * Execute non-transactionally, suspend the current transaction if one exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
	 * on all transaction managers. This in particular applies to
	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
	 * which requires the {@code javax.transaction.TransactionManager} to be
	 * made available to it (which is server-specific in standard Java EE).
	 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
	 */
	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

	/**
	 * Execute non-transactionally, throw an exception if a transaction exists.
	 * Analogous to EJB transaction attribute of the same name.
	 */
	NEVER(TransactionDefinition.PROPAGATION_NEVER),

	/**
	 * Execute within a nested transaction if a current transaction exists,
	 * behave like {@code REQUIRED} otherwise. There is no analogous feature in EJB.
	 * <p>Note: Actual creation of a nested transaction will only work on specific
	 * transaction managers. Out of the box, this only applies to the JDBC
	 * DataSourceTransactionManager. Some JTA providers might support nested
	 * transactions as well.
	 * @see org.springframework.jdbc.datasource.DataSourceTransactionManager
	 */
	NESTED(TransactionDefinition.PROPAGATION_NESTED);
	private final int value;
	Propagation(int value) {
		this.value = value;
	}
	public int value() {
		return this.value;
	}
}

五、spring常用的注解

声明bean的注解:

• @Component : 泛指各类组件
• @Controller：控制器
• @Service ： 业务层
• @Repository：数据库访问层

Bean注入的注解:

• @Autowired: spring 提供
• @Resource：JSR-250提供

Bean配置相关的注解:

• @Configuration:声明配置类
• @Bean: 声明bean
• @ComponentScan: 组件扫描

AOP相关的注解：

• @Aspect: 声明切面
• @PointCut:声明切点
• @After：在方法执行之后执行
• @Before: 在方法执行之前通知
• @Around:环绕通知
• @EnableAspectJAutoProxy：开启Spring对AspectJ代理的支持

Bean属性相关的注解:

• @Value: 配置属性
• @Scope: 指定作用域

事务相关的注解:

• @EnableTransactionManagement：开启事务支持
• @Transactional ：支持事务

异步执行相关的注解

• @EnableAsync：开启异步方法的支持
• @EnableScheduling：开启计划任务的支持

spring mvc 相关的注解

• @RequestMapping：url请求映射
• @ResponseBody：直接返回文本内容，而不是一个页面
• @GetMapping：get请求处理
• @PostMapping ： post请求处理
• @CookieValue： 获取cookie值
• @RequestHeader：获取指定的header值
• @POSTMapping
• @PathVariable: 路径变量
• @RestController：相当于@Controller+@ResponseBody
• @ControllerAdvice: 全局异常处理
• @ExceptionHandler：处理异常

六、BeanFactory和ApplicationContext的区别

1. BeanFactory是spring框架中ioc容器的顶层接口，它定义了一些基础功能以及基础规范。
2. applicationContext是beanFactory的子集接口，ApplicationContext是具备着beanFactory的全部功能。
3. BeanFactory为spring IOC基础容器，applicationContext是容器的高级接口，beanfactory具备更多的功能，比如国际化支持和资源访问（xml、Java配置等等）。

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

1. ClassPathXmlApplicationContext :此容器实现从类路径的一个XML文件中加载beans的定义。
2. FileSystemXmlApplicationContext : 此容器实现从文件路径的一个XML文件中加载beans的定义。
3. AnnotationConfigServletWebServerApplicationContext: 通常的web实现的ApplicationContext。
4. AnnotationConfigApplicationContext:非web环境下spring boot 项目启动使用的ApplicationContext。

八、spring bean 的定义包含哪些内容?

一个Spring Bean的定义包含容器必知的所有配置元数据：包括如何创建一个bean ，它的生命周期详情及它的依赖、scope信息等等。

九、JDK 动态代理和 CGLIB 代理有什么区别?

1. JDK 动态代理主要是针对类实现了某个接口，AOP 则会使用 JDK 动态代理。他基于反射的机制实现，生成一个实现同样接口的一个代理类，然后通过重写方法的方式，实现对代码的增强。
2. 如果某个类没有实现接口，AOP 则会使用 CGLIB 代理，底层原理是通过修改字节码生成一个子类，然后重写父类的方法，实现对代码的增强。

十、FactoryBean 和 BeanFactory有什么区别?

1. BeanFactory是Bean的工厂，ApplicationContext 的父类，IOC 容器的核心，负责生成和管理Bean对象。
2. FactoryBean是Bean，可以通过实现FactoryBean接口定制实例化Bean的逻辑，比如对生成的bean做一些增强处理等等。

//FactoryBean 接口的定义
public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	@Nullable
	T getObject() throws Exception;
	@Nullable
	Class<?> getObjectType();
	default boolean isSingleton() {
		return true;
	}
}