spring源码学习二

BeanFactory

  DefaultListableBeanFactory

BeanFactory的实现类DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry（用于注册单例对象）。

//存放单例对象
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

查看BeanFactory中所有的Bean

public void loadByAnnotation(){
		try {
			Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");
			singletonObjects.setAccessible(true);
			AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PersonConfig.class);
			ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
			Map<String, Object> beans = (Map<String, Object>) singletonObjects.get(beanFactory);
			for(Map.Entry entry:beans.entrySet()){
				System.out.println(entry.getKey()+"---->"+entry.getValue());
			}
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

 BeanFactory和ApplicationContext

ApplicationContext不仅仅是继承BeanFactory，还组合和扩展了BeanFactory的功能

 MessageSource国际化能力，EnvironmentCapable读取配置信息的能力ResourcePatternResolver通过通配符查找文件的能力，ApplicationEventPublisher发布事件的能力

通过ApplicationEventPublisher的发布由监听事件能力可以实现解耦

Bean的后处理器

public void loadByAnnotation(){
		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
		//bean的定义（class，scope，初始化，销毁）
		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(PersonConfig.class).setScope("singleton").getBeanDefinition();
		beanFactory.registerBeanDefinition("config",beanDefinition);
		//此时beanFactory还没有解析@Bean的能力，需要为beanFactory添加后处理器增强功能
		AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
		beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach((beanFactoryPostProcessor ->
				beanFactoryPostProcessor.postProcessBeanFactory(beanFactory)));
		for (String name : beanFactory.getBeanDefinitionNames()) {
			System.out.println(name);
		}
	}

BeanFactory不会主动初始化单例，在用到Bean时才会创建，可以调用beanFactory的preInstantiateSingletons()提前初始化好所有的单例对象。

 其中ConfigurationClassPostProcessor为BeanFactory的后处理器用于简析@Bean注解AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor为Bean的后处理器，AutowiredAnnotationBeanPostProcessor用于简析@Autowired，@Value注解，CommonAnnotationBeanPostProcessor用于解析@Resource，@PostConstruct，@PreDestory注解，两个注解同时存在时根据后处理器的添加顺序执行，这里的比较器AnnotationAwareOrderComparator是通过饿汉式单例模式创建的。

Bean的生命周期

实例化-->依赖注入-->初始化-->销毁

主要的Bean后处理器InstantiationAwareBeanPostProcessor,DestructionAwareBeanPostProcessor

@Configuration
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		if(beanName.equals("person"))
		System.out.println("销毁之前执行");
	}

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if(beanName.equals("person"))
		System.out.println("实例化之前执行");
		return null;
	}

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		if(beanName.equals("person"))
		System.out.println("实例化之后执行,返回true表示跳过依赖注入阶段");
		return false;
	}

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		System.out.println("依赖注入阶段执行");
		return null;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if(beanName.equals("person"))
		System.out.println("初始化之前执行");
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if(beanName.equals("person"))
		System.out.println("初始化之后执行");
		return bean;
	}
}