ApplicationContext---容器的扩展功能

最新推荐文章于 2024-07-07 18:01:17 发布

原创最新推荐文章于 2024-07-07 18:01:17 发布 · 366 阅读

CC 4.0 BY-SA版权

本文详细解析了Spring框架中的ApplicationContext与BeanFactory的区别及其实现原理，深入探讨了ApplicationContext如何提供更丰富的功能，包括环境准备、BeanFactory加载、BeanPostProcessor注册与调用、资源初始化、监听器注册等关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ApplicationContext包含Beanfactory的所有功能

ApplicationContext context=new ClassPathXmlApplicationContext("users.xml");

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);//设置路径，可以设置多个路径（数组并且对其中的特殊字符进行替换）
    if(refresh) {
        this.refresh();//主要是这个函数，几乎包含了ApplicationContext 所提供的所有功能。

    }

}

（1）准备上下文的环境this.prepareRefresh();

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    if(this.logger.isInfoEnabled()) {
        this.logger.info("Refreshing " + this);
    }

    this.initPropertySources();
    this.getEnvironment().validateRequiredProperties();
    this.earlyApplicationEvents = new LinkedHashSet();
}

（2）加载beanfactory，经过了obtainFreshBeanFactory()的方法就已经拥有了beanfactory的全部功能，也就可以对bean进行提取等基础操作了。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    this.refreshBeanFactory();
    ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
    if(this.logger.isDebugEnabled()) {
        this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
    }

    return beanFactory;
}

refreshBeanFactory初始化beanfactoy

实现refreshBeanFactory方法

protected final void refreshBeanFactory() throws BeansException {

DefaultListableBeanFactory beanFactory = this.createBeanFactory();//创建DefaultListableBeanFactory

beanFactory.setSerializationId(this.getId());//序列化id
this.customizeBeanFactory(beanFactory);//定制beanfactory

this.loadBeanDefinitions(beanFactory);//加载beanfactory

}

customizeBeanFactory()//定制beanfactoty这里已经开始对了beanfactory的扩展设置了是否允许覆盖和注解qualifier和autowired的支持

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    if(this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding.booleanValue());
    }

    if(this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences.booleanValue());
    }

}

this.loadBeanDefinitions(beanFactory) 加载DefaultListableBeanFactory 还需要xmldefinitionbeanReader来读取xml

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    this.initBeanDefinitionReader(beanDefinitionReader);
   //上面的一些设置过后，这一步完全是beanfactory的套路
    //得到doc属性 的到root节点...解析注册
    this.loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = this.getConfigResources();
    if(configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
}

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {

int counter = 0;
Resource[] var3 = resources;
int var4 = resources.length;

for(int var5 = 0; var5 < var4; ++var5) {
    Resource resource = var3[var5];
    counter += this.loadBeanDefinitions((Resource)resource);
}

}

//XmlBeanDefinitionReader.java 这里真正和beanfactroy一模一样了（结束）

********************************************

**************************************************************************

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return this.loadBeanDefinitions(new EncodedResource(resource));
}

-------------------------------------------------------------------------------------------------------------------------------------------

上面已经完成了对spring的解析配置.

（3）ApplicationContext的扩展功能由此展开在prepareBeanFactory（）方法中

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.setBeanClassLoader(this.getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置几个忽略自动自动装配的接口
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//注册依赖
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

if(beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

if(!beanFactory.containsLocalBean("environment")) {
beanFactory.registerSingleton("environment", this.getEnvironment());
}

if(!beanFactory.containsLocalBean("systemProperties")) {
beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
}

if(!beanFactory.containsLocalBean("systemEnvironment")) {
beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
}

}

setBeanExpressionResolver（）对spel的支持

（4）//激活注册的BeanfactoryPostProcessor使用方法：在容器实例化之前对bean的任意属性进行修改，还可以用过order来确定beanfactorypostprocess的执行次序。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    if(beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

}

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    Set<String> processedBeans = new HashSet();
    int var9;
    ArrayList currentRegistryProcessors;
    String[] postProcessorNames;
    if(beanFactory instanceof BeanDefinitionRegistry) {//对 BeanDefinitionRegistry类型进行处理
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList();
        Iterator var6 = beanFactoryPostProcessors.iterator();

}

只要实现beanfactorypostprocess的接口并且经自己的类通过注解注入到容器中就可以在bean初始化之前修改beandefiniton的值

修改前：

修改后：

具体过程看源码.......//todo

//对处理器进行分类处理

//接下来对处理器进行排序

-----------------------------------------------------------------------------------------------------------------------------------------------

（5）注册beanpostprocessor注意这里是注册不是调用，它真正的调用实在实例化阶段这是一个很重要的功能

也是很多功能beanfactory不支持的原因。因为spring的很多功能都是通过后处理器扩展的，beanfactory没有自动注册功能

需要手动注册，但是applicationContext容器添加了自动注册。

registerBeanPostProcessors（）方法对BeanPostProcessors进行处理

重复注册

注册beanpostprocessor将其注册到beanfactory容器中

对于的beanpostprocessor的排序问题

public class Beanpostprocessor2 implements BeanPostProcessor,PriorityOrdered{}

public class Beanpostprocessor  implements BeanPostProcessor,Ordered{}

会先执行实现PriorityOrdered的后处理器，其次是ordered,之后才是没有排序的。

创建好beanpostProcessor的实例后，然后就是初始化

1）、创建Bean的实例
2）、populateBean；给bean的各种属性赋值
3）、initializeBean：初始化bean；

BeanPostProcessor和BeanfactoryPostProcessor这个是相似的
（6）初始化资源信息

（7）注册监听器

（8）初始化非延迟加载单例

（9）this.finishRefresh();

总结：BeanFactoryPostProcessor和BeanPostProcessor一个是可以在初始化之前，一个实在初始化之后。

AbstractAutowireCapableBeanFactory.java
 try {
            this.populateBean(beanName, mbd, instanceWrapper);
            if(exposedObject != null) {
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            }

初始化bean方法


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);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
        // aware同样是对外提供的钩子
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        // 这一步就是执行自定义的beanpostprocessor的before操作
    }

    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
        // 执行init方法
    }
    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);
        // 这一步就是执行自定义的beanpostprocessor的after操作
    }
    return wrappedBean;
}

public Object applyBeanPostProcessorsBeforeInitialization(
                    Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
       // 获取所有的BeanPostProcessor对象，执行postProcessBeforeInitialization方法
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
    // 然后把执行结果返回
}

根据对spring 源码的分析我们知道BeanPostProcessor原理在对bean的实例化和初始化时AbstractAutowireCapableBeanFactory.java中的doCreateBean方法中

populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
initializeBean
{
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

应用ApplicationContextAwareProcessor实现了BeanPostProcessor
 public 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>() {
                public Object run() {
                    ApplicationContextAwareProcessor.this.invokeAwareInterfaces(bean);
                    return null;
                }
            }, acc);
        } else {
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }

判断各种aware 然后注入到ioc容器中