Spring的知识点整理学习并记录

秒速五厘米 2022-11-06 06:57 142阅读 0赞

spring的循环依赖问题：  
spring通过三级缓存机制解决循环依赖问题，其中一级缓存为单例池（singletonobjects），二级缓存为早期曝光的对象（elarysingtonobjects），三级缓存为早期曝光对象工厂（singletonfactories），当A，B两个类发生循环引用时，当A完成实例化之后，就是用实例化后的对象创建一个工厂，并添加到三级缓存中，如果A被aop代理，那么通过这个工厂获取到的就是A的代理后的对象，如果A没有被代理，那么这个工厂获取到的就是A实例化对象，当A进行属性注入的时候，去创建B，同时B又依赖了A，所以创建B的同时又去调用getBean（a）来获取A的依赖，此时会从缓存中去获取，首先取到三级缓存中的工厂，调用对象工厂的getObject方法来获取对应的对象，得到的对象将其注入到b中，紧接着b会走完生命周期流程，包括初始化、后置处理器等，当B创建完后，会将B注入到A中，此时A完成整个生命周期，流程结束

为什么要使用三级缓存？入籍缓存能解决以来问题吗？  
如果使用二级缓存解决循环依赖，意味着所有的bean在实例化后就要完成aop代理，违背了spring的设计原则，spring在设计之初就通过AnnotationAwareAspectJAtuoProxyCreator这个后置处理器来在bean的生命周期最后一步完成aop处理，而不是实例化之后就立马进行aop处理

spring事务什么情况会失效？

*  数据库不支持事务
 *  service没有被spring管理
 *  方法不是 public 的
    
     *  @Transactional 只能用于 public 的方法上，否则事务不会失效，如果要用在非 public 方法上，可以开启 AspectJ 代理模式
 *  没有被事务管理的方法调用被事务管理的方法，事务不会生效
 *  数据源没有配置事务管理器
 *  不支持事务
    
     *  Propagation.NOT\_SUPPORTED： 表示不以事务运行，当前若存在事务则挂起
 *  异常被吃了
    
     *  catch了异常情况，但是没有抛出异常，spring在抛出RuntimeException时才会回滚

Spring用到了哪些设计模式？  
工厂模式： 创建bean，获取bean  
单例模式|原型模式：创建bean时，设置作用域，singleton/prototype  
监听模式：自定义发布时间，监听模式。比如ApplicationListener 当某个动作触发时，就会自动执行一个通知  
责任链模式：aop  
策略模式：创建代理

BeanPostProcessor与BeanFactoryPostProcessor的区别？  
实现BeanFactoryPostProcessor接口，spring可以在创建bean之前，修改bean的定义属性，spring允许BeanFactoryPostProcessor在容器实例化任何其他bean之前读取元数据，并根据需要进行修改，例如bean的scope从单例改为原型，同时可以配置多个BeanFactoryPostProcessor，可通过实现order接口来控制各个beanfactorypostprocessor的执行顺序  
实现BeanPostProcessor接口，可以让spring在实例化bean之后，执行bean的初始化方法方法前后，添加自己的处理逻辑  
BeanPostProcessor是spring容器在加载了bean的定义文件并且实例化bean之后执行的，beanpostprocessor的执行顺序是在beanfactorypostprocessor之后执行

BeanFactory与ApplicationContext的区别  
BeanFactory是Spring最底层的接口，提供了简单的容器的功能，只提供了实例化对象和拿对象的功能  
ApplicationContext应用上下文，它是spring的一个高级的接口，提供了更多有用的功能  
\- 国际化  
\- 访问资源  
\- 载入多个上下文  
\- 消息发送，响应机制  
\- aop等

BeanFactory与FactoryBean的区别？  
BeanFactory是ioc最基本的容器，负责生产和管理bean  
FactoryBean是一个接口，当在ioc容器中的bean实现了factorybean后，通过getBean获取到bean的对象并不是FactoryBean的实现类对象，而是这个实现类中getObject（）方法返回的对象，想要获取Factorybean，就要getBean之前加上&

Spring的事务传播特性

public enum Propagation { 
 
 	/** * Support a current transaction, create a new one if none exists. * Analogous to EJB transaction attribute of the same name. * 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. * 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. * NOTE: 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. * NOTE: 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. * 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 * 支持当前事务，新增savepoint点，与当前事务同步提交或回滚 */
 	NESTED(TransactionDefinition.PROPAGATION_NESTED);
 
 
 	private final int value;
 
 
 	Propagation(int value) { 
 		this.value = value;
 	}
 
 	public int value() { 
 		return this.value;
 	}
 
 }