Aware接口使用
Spring中Aware.java是个没有任何方法的接口，有很多子接口，常见的比如BeanNameAware，ApplicationContextAware，每个接口里都有自己特定的方法，我们按照业务需要实现特定的Aware接口，Spring容器会找到这些bean，然后调用我们实现的特定方法，将特定的参数传给bean
例如我们创建了一个bean实现了ApplicationContextAware接口，那么这个bean的setApplicationContext方法就会被调用，入参是applicationContext成员变量，这样我们的bean就能得到applicationContext对象了
@Component
public class AppContext implements ApplicationContextAware {
private static ApplicationContext applicationContext;
public static ApplicationContext getApplicationContext() {
return AppContext.applicationContext;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
AppContext.applicationContext = applicationContext;
}
}
bean从bean定义到初始化的一个简单过程
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("第一步：调用MyBeanFactoryPostProcessor的postProcessBeanFactory");
}
}
@Component
public class AppContext implements ApplicationContextAware {
private static ApplicationContext applicationContext;
public static ApplicationContext getApplicationContext(){
return AppContext.applicationContext;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("第二步：执行各个aware接口实现类的特定方法。此处是执行注入app容器");
AppContext.applicationContext = applicationContext;
}
}
@Component
public class CustomBean implements InitializingBean {
public CustomBean() {
System.out.println("第三步：执行CustomBean类的无参构造函数");
}
public void afterPropertiesSet() throws Exception {
System.out.println("第六步：调用afterPropertiesSet方法");
}
@PostConstruct
public void initMe(){
System.out.println("第五步：初始化方法=====================》");
}
}
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {
System.out.println("第四步：BeanPostProcessor，对象" + beanName +"调用初始化方法之前的数据： " + bean.toString());
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第七步：BeanPostProcessor，对象" + beanName +"调用初始化方法之后的数据：" + bean.toString());
return bean;
}
}
执行main方法，打印结果如下
第一步：调用MyBeanFactoryPostProcessor的postProcessBeanFactory
第四步：BeanPostProcessor，对象springlrApplication调用初始化方法之前的数据： com.example.springlr.SpringlrApplication$$EnhancerBySpringCGLIB$$4a799441@36328d33
第七步：BeanPostProcessor，对象springlrApplication调用初始化方法之后的数据：com.example.springlr.SpringlrApplication$$EnhancerBySpringCGLIB$$4a799441@36328d33
第二步：执行各个aware接口实现类的特定方法。此处是执行注入app容器
第四步：BeanPostProcessor，对象appContext调用初始化方法之前的数据： com.example.springlr.sp.AppContext@545b995e
第七步：BeanPostProcessor，对象appContext调用初始化方法之后的数据：com.example.springlr.sp.AppContext@545b995e
第三步：执行CustomBean类的无参构造函数
第四步：BeanPostProcessor，对象customBean调用初始化方法之前的数据： com.example.springlr.sp.CustomBean@29526c05
第五步：初始化方法=====================》
第六步：调用afterPropertiesSet方法
第七步：BeanPostProcessor，对象customBean调用初始化方法之后的数据：com.example.springlr.sp.CustomBean@29526c05
上面出现的2个第四步和第七步，是因为springboot启动类和手写的aware接口实现类都是bean，所以都会执行bean后处理器的初始化之前和之后的方法。
@PostConstruct和afterPropertiesSet方法都是bean的初始化方法，实际工程中写一个即可
bean初始化流程简单概括如下：
注册bean定义 => BeanFactoryPostProcessor => 实例化bean => 依赖的装配 => BeanPostProcessor => 初始化bean => BeanPostProcessor
Spring如何解决循环依赖问题
循环依赖问题就是A->B->A，spring在创建A的时候,发现需要依赖B,因为去创建B实例,发现B又依赖于A,又去创建A,因为形成一个闭环，无法停止下来就可能会导致cpu计算飙升
如何解决这个问题呢？spring解决这个问题主要靠巧妙的三层缓存，所谓的缓存主要是指这三个map,singletonObjects主要存放的是单例对象，属于第一级缓存；singletonFactories属于单例工厂对象，属于第三级缓存；
earlySingletonObjects属于第二级缓存，如何理解early这个标识呢？它表示只是经过了实例化尚未初始化的对象。Spring首先从singletonObjects（一级缓存）中尝试获取，如果获取不到并且对象在创建中，则尝试从earlySingletonObjects(二级缓存)中获取，如果还是获取不到并且允许从singletonFactories通过getObject获取，则通过singletonFactory.getObject()(三级缓存)获取。
如果获取到了则移除对应的singletonFactory,将singletonObject放入到earlySingletonObjects，其实就是将三级缓存提升到二级缓存,这个就是缓存升级。spring在进行对象创建的时候，会依次从一级、二级、三级缓存中寻找对象，如果找到直接返回。
由于是初次创建，只能从第三级缓存中找到(实例化阶段放入进去的)，创建完实例，然后将缓存放到第一级缓存中。下次循环依赖的再直接从一级缓存中就可以拿到实例对象了。
源码位与DefaultSingletonBeanRegistry下
protected Object getSingleton(String beanName,boolean allowEarlyReference) {
Object singletonObject =this.singletonObjects.get(beanName);
if (singletonObject ==null &&this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
singletonObject =this.earlySingletonObjects.get(beanName);
if (singletonObject ==null && allowEarlyReference) {
ObjectFactory singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory !=null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
SpringBoot自动配置原理
首先在SpringBoot主程序上有这么一个注解，@SpringBootApplication，它是由3个注解构成的，
@SpringBootConfiguration相当于@Configuration，@ComponentScan用于组件扫描，关键就在于@EnableAutoConfiguration这个注解，点进去，
发现导入了一个类AutoConfigurationImportSelector，看名字大概意思就是自动配置导入选择器，这个类有一个方法，
该方法返回所有候选的配置类名称，点进SpringFactoriesLoader这个类看看，
可以看到，这个类里有一个属性叫做工厂资源路径，位置在META-INF文件夹下面的spring.factories文件，而loadFactoryNames方法执行的结果最终是从cache这个缓存里去获取当前类加载器下的配置值，
如果debug运行的话可以看到，cache的结构是这么一个样子，
我们再去看看spring.factories的结构，
可以看到，这个cache就是把spring.factories这个文件里的内容读取封装到了cache这个map里，于是我们就知道了哪些类需要自动配置了
简单总结下：当SpringBoot项目启动时，会先导入AutoConfigurationImportSelector，这个类会帮我们选择所有候选的配置，我们需要导入的配置都是SpringBoot帮我们写好的一个一个的配置类，这些配置类存在于METF-INF/spring.factories文件中，通过这个文件，Spring可以找到这些配置类的位置，然后去加载这些配置
@SpringBootApplication启动类注解 =》 @EnableAutoConfiguration自动配置注解 =》 @Import(AutoConfigurationImportSelector.class)自动导入配置文件选择器 =》 geCandidateConfigurations()获取所有候选配置 =》 通过spring.factories获取配置类的位置 =》 获取配置类，在上层方法中循环封装为Properties供我们使用
另外补充一点，spring.factories里的配置很多，SpringBoot每次启动时并不是全量加载他们，随便点进去一个自动配置类，
可以看到，有这么一类注解@ConditionalOnXXX，顾名思义，满足什么条件下成立，这个注解的意思是如果后面的条件都满足，这个类才会被加载配置。
所以在加载自动配置类的时候，并不是将spring.factories的配置全量加载进来，而是通过这个注解的判断，如果注解中的类都存在，才会进行加载。
