IOC容器其他相关特性设计与实现

ApplicationContext和Bean初始化、销毁

启动过程在AbstractApplicationContext中
准备过程在prepareBeanFactory方法，为容器配置了ClassLoader、PropertyEditor和BeanPostProcessor

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {    // Tell the internal bean factory to use the context's class loader etc.    beanFactory.setBeanClassLoader(getClassLoader());    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));    // 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.ignoreDependencyInterface(EnvironmentAware.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)) {        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));        // Set a temporary ClassLoader for type matching.        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));    }    // Register default environment beans.    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());    }    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());    }    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());    }}

容器关闭时，先发出容器关闭的信号，然后逐个Bean关闭，最后关闭容器
AbstractApplicationContext的doClose：

protected void doClose() {    if (this.active.get() && this.closed.compareAndSet(false, true)) {        if (logger.isInfoEnabled()) {            logger.info("Closing " + this);        }        LiveBeansView.unregisterApplicationContext(this);        try {            // Publish shutdown event.            publishEvent(new ContextClosedEvent(this));        }        catch (Throwable ex) {            logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);        }        // Stop all Lifecycle beans, to avoid delays during individual destruction.        try {            getLifecycleProcessor().onClose();        }        catch (Throwable ex) {            logger.warn("Exception thrown from LifecycleProcessor on context close", ex);        }        // Destroy all cached singletons in the context's BeanFactory.        destroyBeans();        // Close the state of this context itself.        closeBeanFactory();        // Let subclasses do some final clean-up if they wish...        onClose();        this.active.set(false);    }}

在应用开发时，一般初始化需要执行固定的动作，比如建立数据库连接，网络连接。

同样，结束阶段的操作也是差不多固定的。

为此spring IOC设计了相关功能，可以定制Bean的初始化和销毁过程。

看下Bean的生命周期：
AbstractAutowireCapableBeanFactory的initializeBean

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {    if (System.getSecurityManager() != null) {        AccessController.doPrivileged(new PrivilegedAction<Object>() {            @Override            public Object run() {                invokeAwareMethods(beanName, bean);                //BeanNameAware、ApplicationContextAware、BeanFactoryAware接口                return null;            }        }, getAccessControlContext());    }    else {        invokeAwareMethods(beanName, bean);    }    Object wrappedBean = bean;    if (mbd == null || !mbd.isSynthetic()) {        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);    }    try {        invokeInitMethods(beanName, wrappedBean, mbd);    }    catch (Throwable ex) {        throw new BeanCreationException(                (mbd != null ? mbd.getResourceDescription() : null),                beanName, "Invocation of init method failed", ex);    }    if (mbd == null || !mbd.isSynthetic()) {        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);    }    return wrappedBean;}private void invokeAwareMethods(final String beanName, final Object bean) {    if (bean instanceof Aware) {        if (bean instanceof BeanNameAware) {            ((BeanNameAware) bean).setBeanName(beanName);        }        if (bean instanceof BeanClassLoaderAware) {            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());        }        if (bean instanceof BeanFactoryAware) {            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);        }    }}protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)            throws Throwable {    boolean isInitializingBean = (bean instanceof InitializingBean);    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {        if (logger.isDebugEnabled()) {            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");        }        if (System.getSecurityManager() != null) {            try {                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                    @Override                    public Object run() throws Exception {                        ((InitializingBean) bean).afterPropertiesSet();                        return null;                    }                }, getAccessControlContext());            }            catch (PrivilegedActionException pae) {                throw pae.getException();            }        }        else {            ((InitializingBean) bean).afterPropertiesSet();        }    }    if (mbd != null) {        String initMethodName = mbd.getInitMethodName();        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&                !mbd.isExternallyManagedInitMethod(initMethodName)) {            invokeCustomInitMethod(beanName, bean, mbd);        }    }}protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {    String initMethodName = mbd.getInitMethodName();    final Method initMethod = (mbd.isNonPublicAccessAllowed() ?            BeanUtils.findMethod(bean.getClass(), initMethodName) :            ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));    if (initMethod == null) {        if (mbd.isEnforceInitMethod()) {            throw new BeanDefinitionValidationException("Couldn't find an init method named '" +                    initMethodName + "' on bean with name '" + beanName + "'");        }        else {            if (logger.isDebugEnabled()) {                logger.debug("No default init method named '" + initMethodName +                        "' found on bean with name '" + beanName + "'");            }            // Ignore non-existent default lifecycle methods.            return;        }    }    if (logger.isDebugEnabled()) {        logger.debug("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");    }    if (System.getSecurityManager() != null) {        AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {            @Override            public Object run() throws Exception {                ReflectionUtils.makeAccessible(initMethod);                return null;            }        });        try {            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                @Override                public Object run() throws Exception {                    initMethod.invoke(bean);                    return null;                }            }, getAccessControlContext());        }        catch (PrivilegedActionException pae) {            InvocationTargetException ex = (InvocationTargetException) pae.getException();            throw ex.getTargetException();        }    }    else {        try {            ReflectionUtils.makeAccessible(initMethod);            initMethod.invoke(bean);        }        catch (InvocationTargetException ex) {            throw ex.getTargetException();        }    }}

可以看到生命周期如下：

• Bean实例创建
• 属性set注入
• BeanNameAware、BeanClassLoaderAware、BeanFactoryAware分别Set

• 后处理器方法postProcessorsBeforeInitialization（before）

  applyBeanPostProcessorsBeforeInitialization负责返回代理后的Bean（wrappedBean）

• invokeInitMethods（Bean的初始化方法init-method）

如果Bean实现了InitializingBean接口，这中间会调用afterPropertiesSet
可以看到，首先找到定义的init-method，然后获取Method，反射调用之

• postProcessorsAfterInitialization 后处理器方法（after）

applyBeanPostProcessorsAfterInitialization负责返回代理后的Bean（wrappedBean）

• 使用Bean
• 销毁Bean

下面是Bean的销毁过程（doClose见上文）：

DisposableBeanAdapter的destroy

@Overridepublic void destroy() {    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {            processor.postProcessBeforeDestruction(this.bean, this.beanName);        }    }    if (this.invokeDisposableBean) {        if (logger.isDebugEnabled()) {            logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'");        }        try {            if (System.getSecurityManager() != null) {                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                    @Override                    public Object run() throws Exception {                        ((DisposableBean) bean).destroy();                        return null;                    }                }, acc);            }            else {                ((DisposableBean) bean).destroy();            }        }        catch (Throwable ex) {            String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";            if (logger.isDebugEnabled()) {                logger.warn(msg, ex);            }            else {                logger.warn(msg + ": " + ex);            }        }    }    if (this.destroyMethod != null) {        invokeCustomDestroyMethod(this.destroyMethod);    }    else if (this.destroyMethodName != null) {        Method methodToCall = determineDestroyMethod();        if (methodToCall != null) {            invokeCustomDestroyMethod(methodToCall);        }    }}

可以看到，销毁时调用顺序是：
1、postProcessBeforeDestruction
2、destory
3、自定义销毁方法

lazy-init和预实例化

lazy-init默认 = false，就是容器初始化的时候，Bean也会实例化
这里《Spring技术内幕》写反了。。。

在AbstractApplicationContext的refresh中预先实例化

@Overridepublic 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();            // Instantiate all remaining (non-lazy-init) singletons.            // 这里是对Bean预先实例化            finishBeanFactoryInitialization(beanFactory);            // Last step: publish corresponding event.            finishRefresh();        }        catch (BeansException ex) {            if (logger.isWarnEnabled()) {                logger.warn("Exception encountered during context initialization - " +                        "cancelling refresh attempt: " + ex);            }            // Destroy already created singletons to avoid dangling resources.            destroyBeans();            // Reset 'active' flag.            cancelRefresh(ex);            // Propagate exception to caller.            throw ex;        }        finally {            // Reset common introspection caches in Spring's core, since we            // might not ever need metadata for singleton beans anymore...            resetCommonCaches();        }    }}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {    // Initialize conversion service for this context.    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {        beanFactory.setConversionService(                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));    }    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);    for (String weaverAwareName : weaverAwareNames) {        getBean(weaverAwareName);    }    // Stop using the temporary ClassLoader for type matching.    beanFactory.setTempClassLoader(null);    // Allow for caching all bean definition metadata, not expecting further changes.    beanFactory.freezeConfiguration();    // Instantiate all remaining (non-lazy-init) singletons.    beanFactory.preInstantiateSingletons();}

DefaultListableBeanFactory实现了preInstantiateSingletons预处理

@Overridepublic void preInstantiateSingletons() throws BeansException {    if (this.logger.isDebugEnabled()) {        this.logger.debug("Pre-instantiating singletons in " + this);    }    // Iterate over a copy to allow for init methods which in turn register new bean definitions.    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);    // Trigger initialization of all non-lazy singleton beans...    for (String beanName : beanNames) {        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {            if (isFactoryBean(beanName)) {                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);                boolean isEagerInit;                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                        @Override                        public Boolean run() {                            return ((SmartFactoryBean<?>) factory).isEagerInit();                        }                    }, getAccessControlContext());                }                else {                    isEagerInit = (factory instanceof SmartFactoryBean &&                            ((SmartFactoryBean<?>) factory).isEagerInit());                }                if (isEagerInit) {                    getBean(beanName);                }            }            else {                getBean(beanName);            }        }    }    // Trigger post-initialization callback for all applicable beans...    for (String beanName : beanNames) {        Object singletonInstance = getSingleton(beanName);        if (singletonInstance instanceof SmartInitializingSingleton) {            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;            if (System.getSecurityManager() != null) {                AccessController.doPrivileged(new PrivilegedAction<Object>() {                    @Override                    public Object run() {                        smartSingleton.afterSingletonsInstantiated();                        return null;                    }                }, getAccessControlContext());            }            else {                smartSingleton.afterSingletonsInstantiated();            }        }    }}

FactoryBean的实现

FactoryBean为应用生成需要的对象，这些对象往往是经过特殊处理的，如ProxyFactoryBean这样的特殊Bean

• AbstractBeanFactory的getObjectForBeanInstance

protected Object getObjectForBeanInstance(            Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {    // 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中得到Bean        object = getObjectFromFactoryBean(factory, beanName, !synthetic);    }    return object;}

• FactoryBeanRegistrySupport的getObjectFromFactoryBean和doGetObjectFromFactoryBean

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);                // Only post-process and store if not put there already during getObject() call above                // (e.g. because of circular reference processing triggered by custom getBean calls)                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);                if (alreadyThere != null) {                    object = alreadyThere;                }                else {                    if (object != null && shouldPostProcess) {                        try {                            object = postProcessObjectFromFactoryBean(object, beanName);                        }                        catch (Throwable ex) {                            throw new BeanCreationException(beanName,                                    "Post-processing of FactoryBean's singleton object failed", ex);                        }                    }                    this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));                }            }            return (object != NULL_OBJECT ? object : null);        }    }    else {        Object object = doGetObjectFromFactoryBean(factory, beanName);        if (object != null && shouldPostProcess) {            try {                object = postProcessObjectFromFactoryBean(object, beanName);            }            catch (Throwable ex) {                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);            }        }        return object;    }}private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)            throws BeanCreationException {    Object object;    try {        if (System.getSecurityManager() != null) {            AccessControlContext acc = getAccessControlContext();            try {                object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                    @Override                    public Object run() throws Exception {                            //这里调用factory的getObject从FactoryBean中获取Bean                            return factory.getObject();                        }                    }, acc);            }            catch (PrivilegedActionException pae) {                throw pae.getException();            }        }        else {            //这里调用factory的getObject从FactoryBean中获取Bean            object = 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");    }    return object;}

这里返回的已经是FactoryBean生产后产品，而不是FactoryBean本身。
FactoryBean可以为我们提供一个很好的封装机制，比如Proxy，RMI，JNDI。
getObject是主要的FactoryBean接口，需要特定的工厂生产过程。

BeanPostProcessor实现

BeanPostProcessor有两个接口方法：
postProcessorBeforeInitialization（初始化前）
postProcessorAfterInitialization（初始化后）
这两个回调方法参数都是：Bean实例化对象和Bean名字

注册方法是在：
doCreateBean -> initializeBean -> applyBeanPostProcessorsBeforeInitialization

AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization

@Overridepublic Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)        throws BeansException {    Object result = existingBean;    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {        result = beanProcessor.postProcessBeforeInitialization(result, beanName);        if (result == null) {            return result;        }    }    return result;}@Overridepublic Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)        throws BeansException {    Object result = existingBean;    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {        result = beanProcessor.postProcessAfterInitialization(result, beanName);        if (result == null) {            return result;        }    }    return result;}

autowiring（自动依赖装配）实现

populateBean对autowiring的处理：

if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);    // Add property values based on autowire by name if applicable.    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {        autowireByName(beanName, mbd, bw, newPvs);    }    // Add property values based on autowire by type if applicable.    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {        autowireByType(beanName, mbd, bw, newPvs);    }    pvs = newPvs;}

AbstractAutowireCapableBeanFactory的autowireByName和autowireByType

protected void autowireByName(            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);    for (String propertyName : propertyNames) {        if (containsBean(propertyName)) {            // 使用当前Bean的属性名作为Bean名字，向IOC容器索取Bean            // 然后把从容器得到的Bean设置到当前Bean的属性中            Object bean = getBean(propertyName);            pvs.add(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");            }        }    }}

protected void autowireByType(            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {    TypeConverter converter = getCustomTypeConverter();    if (converter == null) {        converter = bw;    }    Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);    for (String propertyName : propertyNames) {        try {            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);            // Don't try autowiring by type for type Object: never makes sense,            // even if it technically is a unsatisfied, non-simple property.            if (Object.class != pd.getPropertyType()) {                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);                // Do not allow eager init for type matching in case of a prioritized post-processor.                boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);                if (autowiredArgument != null) {                    pvs.add(propertyName, autowiredArgument);                }                for (String autowiredBeanName : autowiredBeanNames) {                    registerDependentBean(autowiredBeanName, beanName);                    if (logger.isDebugEnabled()) {                        logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +                                propertyName + "' to bean named '" + autowiredBeanName + "'");                    }                }                autowiredBeanNames.clear();            }        }        catch (BeansException ex) {            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);        }    }}

Bean的依赖检查

创建Bean的时候会检查依赖

AbstractAutowireCapableBeanFactory 的 checkDependencies

protected void checkDependencies(            String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, PropertyValues pvs)            throws UnsatisfiedDependencyException {    int dependencyCheck = mbd.getDependencyCheck();    for (PropertyDescriptor pd : pds) {        if (pd.getWriteMethod() != null && !pvs.contains(pd.getName())) {            boolean isSimple = BeanUtils.isSimpleProperty(pd.getPropertyType());            boolean unsatisfied = (dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_ALL) ||                    (isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_SIMPLE) ||                    (!isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);            if (unsatisfied) {                throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, pd.getName(),                        "Set this property value or disable dependency checking for this bean.");            }        }    }}

Bean对IOC容器感知

主要是BeanAware接口
ApplicationContextAwareProcessor的postProcessBeforeInitialization和invokeAwareInterfaces

@Overridepublic Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {    AccessControlContext acc = null;    if (System.getSecurityManager() != null &&            (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||                    bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||                    bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {        acc = this.applicationContext.getBeanFactory().getAccessControlContext();    }    if (acc != null) {        AccessController.doPrivileged(new PrivilegedAction<Object>() {            @Override            public Object run() {                invokeAwareInterfaces(bean);                return null;            }        }, acc);    }    else {        invokeAwareInterfaces(bean);    }    return bean;}private void invokeAwareInterfaces(Object bean) {    if (bean instanceof Aware) {        if (bean instanceof EnvironmentAware) {            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());        }        if (bean instanceof EmbeddedValueResolverAware) {            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(                    new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));        }        if (bean instanceof ResourceLoaderAware) {            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);        }        if (bean instanceof ApplicationEventPublisherAware) {            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);        }        if (bean instanceof MessageSourceAware) {            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);        }        if (bean instanceof ApplicationContextAware) {            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);        }    }}