spring源码学习笔记

1.Spring容器的refresh()

1.1 this.prepareRefresh()刷新前的预处理;

1)this.initPropertySources()初始化一些属性设置;这是一个空方法,需要子类自定义个性化的属性设置方法;
2)this.getEnvironment().validateRequiredProperties();检验属性的合法等
3)earlyApplicationEvents= new LinkedHashSet

1.2 this.prepareBeanFactory(beanFactory)

BeanFactory的预准备工作(以上通过ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory()创建了beanFactory,接下来对BeanFactory对象进行一些设置属性);
1)设置BeanFactory的类加载器、支持表达式解析器...
2)添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
3)设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx;
4)注册可以解析的自动装配;我们能直接在任何组件中自动注入:BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5)添加BeanPostProcessor【ApplicationListenerDetector】
6)添加编译时的AspectJ;
7)给BeanFactory中注册一些能用的组件;
	environment【ConfigurableEnvironment】+ systemProperties【Map<String, Object>】+
	systemEnvironment【Map<String, Object>】

1.3 postProcessBeanFactory(beanFactory)

BeanFactory准备工作完成后进行的后置处理工作;这是一个空方法,需要子类自行根据需要重写这个方法,实现BeanFactory的后置处理工作。

====================以上是BeanFactory的创建及预准备工作

1.4 this.invokeBeanFactoryPostProcessors(beanFactory)

	执行BeanFactoryPostProcessor的方法;【处理BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor】
	BeanFactoryPostProcessor:BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的;
	两个接口:BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
		0) 先执行BeanDefinitionRegistryPostProcessor
			registryProcessor.postProcessBeanDefinitionRegistry(registry);
		1)获取所有的BeanDefinitionRegistryPostProcessor的名称
		
		2)先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor,
			postProcessor.postProcessBeanDefinitionRegistry(registry)
			
		3)在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor,
			postProcessor.postProcessBeanDefinitionRegistry(registry)
			
		4)最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors,
			postProcessor.postProcessBeanDefinitionRegistry(registry)
			
		5)执行普通的PostProcessors的方法:
			postProcessor.postProcessBeanDefinitionRegistry(registry)

		再执行BeanFactoryPostProcessor的方法
		1)获取所有的BeanFactoryPostProcessor
		
		2)看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
			postProcessor.postProcessBeanFactory()
			
		3)在执行实现了Ordered顺序接口的BeanFactoryPostProcessor
			postProcessor.postProcessBeanFactory()
			
		4)最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor
			postProcessor.postProcessBeanFactory()

1.5 this.registerBeanPostProcessors(beanFactory)

	注册BeanPostProcessor(Bean的后置处理器)【处理BeanPostProcessor】 【 intercept bean creation】
	不同接口类型的BeanPostProcessor;在Bean创建前后的执行时机是不一样的
	BeanPostProcessor[允许在bean初始化前后进行一些特殊的处理]、
	DestructionAwareBeanPostProcessor[对象销毁的后置处理器,可以允许在对象销毁时进行一些特殊处理]
	InstantiationAwareBeanPostProcessor[允许在bean对象实例化前进行一些特殊的处理]、
	SmartInstantiationAwareBeanPostProcessor、
	MergedBeanDefinitionPostProcessor【internalPostProcessors】、

	1)获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
	
	2)先注册PriorityOrdered优先级接口的BeanPostProcessor;
		其实就是把每一个BeanPostProcessor添加到BeanFactory中:
		beanFactory.addBeanPostProcessor(postProcessor);
		
	3)再注册Ordered接口的,同上
	
	4)最后注册没有实现任何优先级接口的,同上
	
	5)最终注册MergedBeanDefinitionPostProcessor,也是把beanpostProcessor添加到beanFactory中。
	
	6)注册一个ApplicationListenerDetector;来在Bean创建完成后检查是否是ApplicationListener,如果是
		applicationContext.addApplicationListener((ApplicationListener<?>) bean);

1.6 this.initMessageSource()

	初始化MessageSource组件(做国际化功能;消息绑定,消息解析);
	1)获取BeanFactory
	2)看容器中是否有id为messageSource的,类型是MessageSource的组件
	如果有赋值给messageSource,如果没有自己创建一个DelegatingMessageSource;
	MessageSource:取出国际化配置文件中的某个key的值;能按照区域信息获取;
	3)把创建好的MessageSource注册在容器中,以后获取国际化配置文件的值的时候,可以自动注入MessageSource;
		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
		MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);以后可通过getMessage获取

1.7 this.initApplicationEventMulticaster()

	初始化事件派发器;
	1)获取BeanFactory
	2)从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster;
	3)如果上一步没有配置;创建一个SimpleApplicationEventMulticaster
	4)将创建的ApplicationEventMulticaster添加到BeanFactory中,以后其他组件直接自动注入

1.8 onRefresh()

	留给子容器(子类)
	1) 子类重写这个方法,在容器刷新的时候可以自定义逻辑;

1.9 registerListeners();给容器中将所有项目里面的ApplicationListener注册进来;

	1) 从容器中拿到所有的ApplicationListener
	2) 将每个监听器添加到事件派发器中;
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	3) 派发之前步骤产生的事件;

1.10 finishBeanFactoryInitialization(beanFactory)

### this.getBean(weaverAwareName)
	如果可以从BeanFactory里面获取到Bean实例,这直接返回。第一次启动spring的时候,默认BeanFactory里面的没有Bean实例的。
### beanFactory.preInstantiateSingletons()
	初始化后剩下的单实例bean,跟进
1)获取容器中的所有beanNames,依次进行初始化和创建对象
2)获取Bean的定义信息:RootBeanDefinition bd = this.getMergedLocalBeanDefinition(beanName);//其实是从spring里面一个存储Bean信息的Map取出来:Map<String, RootBeanDefinition> mergedBeanDefinitions
3)判断该Bean不是抽象的,是否单实例的,是否属于懒加载;
	3.1)判断是否是FactoryBean;是否是实现FactoryBean接口的Bean;
		>>如果是,根据this.getBean("&" + beanName);取出bean实例并返回。
		>> 如果不是继续执行下面逻辑。
	3.2)不是工厂Bean。利用getBean(beanName);创建对象
		>> getBean(beanName): ioc.getBean();
		>> doGetBean(name, null, null, false);
		>>getSingleton(beanName)
		先获取缓存中保存的单实例Bean<<跟进去其实就是从MAP中拿>>。如果能获取到说明这个Bean之前被创建过(所有创建过的单实例Bean都会被缓存起来),从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取。
		>> 缓存中获取不到,开始Bean的创建对象流程;
		>> 标记当前bean已经被创建:this.markBeanAsCreated(beanName);(防止多线程同时创建,方法内使用synchronized)
		>> 获取Bean的定义信息;RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);	>>getDependsOn(),bean.xml里创建person时,加depend-on="jeep,moon"是先把jeep和moon创建出来【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来;】
		>>启动单实例Bean的创建流程;
			>>>> this.createBean(beanName, mbd, args);
			>>>> Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			让BeanPostProcessor先拦截返回代理对象【InstantiationAwareBeanPostProcessor】:提前执行;
				>>>>>>先触发:postProcessBeforeInstantiation();
				>>>>>>如果有返回值:触发postProcessAfterInitialization();
			>>>>如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象,调用Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
				>>>>>>【创建Bean实例】;createBeanInstance(beanName, mbd, args);
					利用工厂方法或者对象的构造器创建出Bean实例;
				>>>>>> applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);??????
					调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
				>>>>>>【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
					赋值之前:
					1)拿到InstantiationAwareBeanPostProcessor后置处理器:postProcessAfterInstantiation();
					2)拿到InstantiationAwareBeanPostProcessor后置处理器:postProcessPropertyValues();
				=====赋值之前:===
					3)、应用Bean属性的值;为属性利用setter方法等进行赋值;
						applyPropertyValues(beanName, mbd, bw, pvs);
				>>>>>>【Bean初始化】initializeBean(beanName, exposedObject, mbd);
						>>>>>>>>【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
							BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
						>>>>>>>>【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
							BeanPostProcessor.postProcessBeforeInitialization();
						>>>>>>>>【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
							1)是否是InitializingBean接口的实现;执行接口规定的初始化;
							2)是否自定义初始化方法;如果是,执行方法:invokeCustomInitMethod(beanName, bean, mbd);
								1)ReflectionUtils.makeAccessible(initMethod); //使用反射方式调用init-method
						>>>>>>>>【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
							BeanPostProcessor.postProcessAfterInitialization();

				>>>>>>将创建的Bean添加到缓存中singletonObjects;调用方法:this.addSingleton(beanName, singletonObject);
								this.singletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
								this.earlySingletonObjects.remove(beanName);
								this.registeredSingletons.add(beanName);
								ioc容器就是这些Map;很多的Map里面保存了单实例Bean,环境信息。。。。;
4)所有Bean都利用getBean创建完成以后;
	检查所有的Bean是否是SmartInitializingSingleton接口的;如果是;就执行 afterSingletonsInstantiated();【如果你希望在所有Bean创建结束后,做一些特殊的需求,可以定义一个Bean实现SmartInitializingSingleton接口。并重写afterSingletonsInstantiated方法】

1.11 finishRefresh()

	完成BeanFactory的初始化创建工作;IOC容器就创建完成;
	1)initLifecycleProcessor();初始化和生命周期有关的后置处理器;LifecycleProcessor
	默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】;如果没有new DefaultLifecycleProcessor();加入到容器;

	2)getLifecycleProcessor().onRefresh();
	拿到前面定义的生命周期处理器(BeanFactory);回调onRefresh();
	3)publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件;
	4)liveBeansView.registerApplicationContext(this);

1.12 总结

1)、Spring容器在启动的时候,先会保存所有注册进来的Bean的定义信息BeanDefinition;
    1)xml注册bean;<bean>
    2)注解注册Bean;@Service、@Component、@Bean、xxx
2)、Spring容器会合适的时机创建这些Bean
    1)用到这个bean的时候;利用getBean创建bean;创建好以后保存在容器中;
    2)统一创建剩下所有的bean的时候;finishBeanFactoryInitialization();
3)、后置处理器;BeanPostProcessor
    1)、每一个bean创建完成,都会使用各种后置处理器进行处理;来增强bean的功能;
        AutowiredAnnotationBeanPostProcessor:处理自动注入
        AnnotationAwareAspectJAutoProxyCreator:来做AOP功能;
        xxx....
        增强的功能注解:
        AsyncAnnotationBeanPostProcessor
        ....
4)、事件驱动模型;
    ApplicationListener;事件监听;

    ApplicationEventMulticaster;事件派发:
	
	
IOC容器	本质是一个很大的app里面存放了很多以BeanName为key,以Bean实例为value的集合里面。在spring启动的时候,会先创建好BeanFactory,会往BeanFactory里面设置一些属性,初始化和保存一些bean的定义信息,执行BeanFactory的后置处理器。然后在用到某个Bean实例的时候,会先去容器中去取,如果去不到,就走创建Bean实例的流程。通过Bean的定义信息,利用工厂方法或者对象的构造方法创建Bean对象,并对Bean实例的进行属性赋值。每个Bean实例创建完成后,会通过执行后置处理器Bean对Bena的功能进行增强。最后再把Bean存放回去IOC容器里面。

2.AutowiredAnnotationBeanPostProcessor实现依赖注入

2.1 AutowiredAnnotationBeanPostProcessor的继承关系

//主要关注MergedBeanDefinitionPostProcessor这个后置处理器
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware

2.2 执行流程

  • doGetBean

  • instanceWrapper = this.createBeanInstance(beanName, mbd, args); 这个时候其实Bean实例已经创建,但是没有初始化

  • this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);这这个方法里面所有的MergedBeanDefinitionPostProcessor并执行postProcessMergedBeanDefinition方法,在postProcessMergedBeanDefinition方法里面判断该Bean是否通过了@Autowire或者@Value注解注入其他的bean,如果是就把这些属性缓存起来。

  • this.populateBean(beanName, mbd, instanceWrapper);在属性赋值的时候,call到PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);这个方法时候,实际会调用AutowiredAnnotationBeanPostProcessor里面的postProcessProperties方法,在该方法内会调用metadata.inject(bean, beanName, pvs);通过注入的方式一步步地把依赖的Bean进行注入。

  • exposedObject = this.initializeBean(beanName, exposedObject, mbd);初始化bean的时候会执行Bean的后置处理器和初始化方法。具体执行顺序是:

    • 在初始化之前执行后置处理器的的applyBeanPostProcessorsBeforeInitialization (wrappedBean, beanName);方法
    • 执行初始化方法
    • 在初始化之后执行后置处理器的this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

3.AnnotationAwareAspectJAutoProxyCreator实现AOP功能

3.1入口

首先@EnableAspectJAutoProxy注解的源码知道,该注解通过@import,动态注册一个Bean(实现 ImportBeanDefinitionRegistrar 接口)AspectJAutoProxyRegistrar.class。
通过AspectJAutoProxyRegistrar.class的源码知道这个Bean的BeanName等于org.springframework.aop.config.internalAutoProxyCreator,BeanClass是AnnotationAwareAspectJAutoProxyCreator.class.

3.2但是这个Bean是如何实现aop功能的呢?代理的是哪个?

通过查看AnnotationAwareAspectJAutoProxyCreator的源码,我们知道AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口,会在Bean初始化后分别执行postProcessBeforeInitialization和postProcessAfterInitialization方法。我们重点关注postProcessAfterInitialization方法,在父类AbstractAutoProxyCreator中,我们可以看到postProcessAfterInitialization方法的实现。每个bean在初始化后,都会执行后置处理器AnnotationAwareAspectJAutoProxyCreator的方法:postProcessAfterInitialization,在这个方法里面spring通过遍历所有的BeanName,判断遍历的Bean是否加了@Aspect注解,如果加了@Aspect注解,则同时把该Bean的所有切点方法缓存起来。
spring会在遍历Bean的时候,同时通过反射的方式获取每个Bean的所有Method,然后再和遍历缓存起来的所有切点方法进行匹配,判断该方法是否mathc切点表达式。如果match,则根据match的切点方法,先排序,然后创建该bean的一个代理对象(targetClass)。这些被创建的代理对象也会存放在一个以beanName为Key的Map里面。以后每当调用targetClass目标方法时,实际上call的是代理对象的方法。

关键代码:

//1.获取该bean匹配上的所有切点方法
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
>> IntroductionAdvisor
>> PointcutAdvisor
//2.创建代理对象
Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
>> this.createAopProxy().getProxy(classLoader);

判断什么时候使用jdk的动态代理,什么时候使用的是第三方的CGlib动态代理:
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		//
        if(!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class<?> targetClass = config.getTargetClass();
            if(targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass)?new ObjenesisCglibAopProxy(config):new JdkDynamicAopProxy(config));
            }
        }
    }

proxy-target-class vs expose-proxy

posted on 2019-12-02 23:14  lukelin1989  阅读(325)  评论(0编辑  收藏  举报

导航