Spring源码学习-4.IoC容器其他特征分析

1.ApplicationContext和Bean的初始化与销毁

对于Beanfactory特别是 ApplicationContext,容器自身也有一个初始化与销毁关闭的过程,下面我们一起来探究这个过程

在prepareBeanFactory这个方法里面为BeanFactory设置了classLoad等属性

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// Tell the internal bean factory to use the context's class loader.beanFactory.setBeanClassLoader(getClassLoader());// Populate the bean factory with context-specific resource editors.beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));// Configure the bean factory with context callbacks.beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);beanFactory.ignoreDependencyInterface(MessageSourceAware.class);beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);// BeanFactory interface not registered as resolvable type in a plain factory.// MessageSource registered (and found for autowiring) as a bean.beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// Detect a LoadTimeWeaver and prepare for weaving, if found.if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME) && JdkVersion.isAtLeastJava15()) {// Register the (JDK 1.5 specific) LoadTimeWeaverAwareProcessor.try {Class ltwapClass = ClassUtils.forName("org.springframework.context.weaving.LoadTimeWeaverAwareProcessor",AbstractApplicationContext.class.getClassLoader());BeanPostProcessor ltwap = (BeanPostProcessor) BeanUtils.instantiateClass(ltwapClass);((BeanFactoryAware) ltwap).setBeanFactory(beanFactory);beanFactory.addBeanPostProcessor(ltwap);}catch (ClassNotFoundException ex) {throw new IllegalStateException("Spring's LoadTimeWeaverAwareProcessor class is not available");}// Set a temporary ClassLoader for type matching.beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}

同样,容器在关闭时,也会有 一系列的操作,这些操作在DoClose方法中

protected void doClose() {if (isActive()) {if (logger.isInfoEnabled()) {logger.info("Closing " + this);}try {// Publish shutdown event.publishEvent(new ContextClosedEvent(this));}catch (Throwable ex) {logger.error("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);}// Stop all Lifecycle beans, to avoid delays during individual destruction.Map lifecycleBeans = getLifecycleBeans();for (Iterator it = new LinkedHashSet(lifecycleBeans.keySet()).iterator(); it.hasNext();) {String beanName = (String) it.next();doStop(lifecycleBeans, beanName);}// Destroy all cached singletons in the context's BeanFactory.destroyBeans();// Close the state of this context itself.closeBeanFactory();onClose();synchronized (this.activeMonitor) {this.active = false;}}}

2.lazy-init属性与预实例化

IoC容器初始化过程中,只完成了对Bean的定位,载入和注册,但是并没有对Bean进行依赖注入,依赖注入发生在调用getBean时,但是也有一个例外,就是lazy-init属性,他会在

初始化时就对Bean进行依赖注入.

lazy-init属性的实现是在refresh这个方法中,我们来重新看下这个方法

public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// Prepare this context for refreshing.prepareRefresh();// Tell the subclass to refresh the internal bean factory.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// Prepare the bean factory for use in this context.prepareBeanFactory(beanFactory);try {// Allows post-processing of the bean factory in context subclasses.postProcessBeanFactory(beanFactory);// Invoke factory processors registered as beans in the context.invokeBeanFactoryPostProcessors(beanFactory);// Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);// Initialize message source for this context.initMessageSource();// Initialize event multicaster for this context.initApplicationEventMulticaster();// Initialize other special beans in specific context subclasses.onRefresh();// Check for listener beans and register them.registerListeners();<span style="white-space:pre"></span>//在这里对lazy-init属性进行处理// Instantiate all remaining (non-lazy-init) singletons.finishBeanFactoryInitialization(beanFactory);// Last step: publish corresponding event.finishRefresh();}catch (BeansException ex) {// Destroy already created singletons to avoid dangling resources.beanFactory.destroySingletons();// Reset 'active' flag.cancelRefresh(ex);// Propagate exception to caller.throw ex;}}}

完成对Bean的注册后,调用这个方法,对lazy-init属性进行处理

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// Stop using the temporary ClassLoader for type matching.beanFactory.setTempClassLoader(null);// Allow for caching all bean definition metadata, not expecting further changes.beanFactory.freezeConfiguration();<span style="white-space:pre"></span>//在这里开始处理// Instantiate all remaining (non-lazy-init) singletons.beanFactory.preInstantiateSingletons();}

public void preInstantiateSingletons() throws BeansException {if (this.logger.isInfoEnabled()) {this.logger.info("Pre-instantiating singletons in " + this);}//检测BeanDefinition需要提前依赖注入的对象synchronized (this.beanDefinitionMap) {for (Iterator it = this.beanDefinitionNames.iterator(); it.hasNext();) {String beanName = (String) it.next();RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);if (factory instanceof SmartFactoryBean && ((SmartFactoryBean) factory).isEagerInit()) {//实现依赖注入getBean(beanName);}}else {//实现依赖注入getBean(beanName);}}}}}

3.FactoryBean的实现

FactorBean的作用是为应用生成需要的对象,如ProxyFactoryBean等,

在doGetBean中调用了

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

然后又调用了

object = getObjectFromFactoryBean(factory, beanName, !synthetic);

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {//如果不是对FactoryBean的调用,那么结束// Don't let calling code try to dereference the factory if the bean isn't a factory.if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());}// Now we have the bean instance, which may be a normal bean or a FactoryBean.// If it's a FactoryBean, we use it to create a bean instance, unless the// caller actually wants a reference to the factory.if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}Object object = null;if (mbd == null) {object = getCachedObjectForFactoryBean(beanName);}if (object == null) {// Return bean instance from factory.FactoryBean factory = (FactoryBean) beanInstance;// Caches object obtained from FactoryBean if it is a singleton.if (mbd == null && containsBeanDefinition(beanName)) {mbd = getMergedLocalBeanDefinition(beanName);}boolean synthetic = (mbd != null && mbd.isSynthetic());//从FactoryBean中得到Beanobject = getObjectFromFactoryBean(factory, beanName, !synthetic);}return object;}

protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {if (factory.isSingleton() && containsSingleton(beanName)) {synchronized (getSingletonMutex()) {Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));}return (object != NULL_OBJECT ? object : null);}}else {return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);}}

private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName, final boolean shouldPostProcess)throws BeanCreationException {AccessControlContext acc = AccessController.getContext();return AccessController.doPrivileged(new PrivilegedAction() {public Object run() {Object object;try {//从Factory的getBean从FactoryBean中获取Beanobject = factory.getObject();}catch (FactoryBeanNotInitializedException ex) {throw new BeanCurrentlyInCreationException(beanName, ex.toString());}catch (Throwable ex) {throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);}// Do not accept a null value for a FactoryBean that's not fully// initialized yet: Many FactoryBeans just return null then.if (object == null && isSingletonCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");}if (object != null && shouldPostProcess) {try {object = postProcessObjectFromFactoryBean(object, beanName);}catch (Throwable ex) {throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);}}return object;}}, acc);}

这里使用的就是工程模式,getObjectForBeanInstance就想相当于createInstance

4.BeanPostProcessor的实现

BeanPostProcessor是Bean的后置处理器

依赖注入中对于后置处理器的实现发生在population后面,是依赖注入的一个重要组成部分.

5.autowiring(自动依赖装配)

如果当前Bean配置了Autowiring属性,那么在populate中,就会根据name或者type,查找同名的bean,并触发另一个bean的依赖注入与生成

//通过nama自动完成依赖注入protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (int i = 0; i < propertyNames.length; i++) {String propertyName = propertyNames[i];if (containsBean(propertyName)) {Object bean = getBean(propertyName);pvs.addPropertyValue(propertyName, bean);registerDependentBean(propertyName, beanName);if (logger.isDebugEnabled()) {logger.debug("Added autowiring by name from bean name '" + beanName +"' via property '" + propertyName + "' to bean named '" + propertyName + "'");}}else {if (logger.isTraceEnabled()) {logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +"' by name: no matching bean found");}}}}