我的六分钱:

BeanFactory and ApplicationContext both are interfaces where ApplicationContext extends BeanFactory. So ApplicationContext is a child interface and BeanFactory is the parent interface. In other words, ApplicationContext has all the features of BeanFactory and it has some additional features that are not present in BeanFactory. BeanFactory loads beans on-demand that is Lazy Loading whereas ApplicationContext loads all beans at startup that is Eager Loading. BeanFactory does not support annotations whereas ApplicationContext supports annotations. ApplicationContext has additional features that are not present in BeanFactory: Internationalization, Event Publishing, AOP features. BeanFactory only supports two scopes — Singleton and Prototype whereas ApplicationContext supports all bean scopes. BeanFactory does not register BeanFactoryPostProcessor and BeanPostProcessor automatically whereas ApplicationContext automatically registers them.

BeanFactory和ApplicationContext的区别如下:

BeanFactory uses lazy initialization but ApplicationContext uses eager initialization. In case of BeanFactory, bean is created when you call getBeans() method, but bean is created upfront in case of ApplicationContext when the ApplicationContext object is created. BeanFactory explicitly provide a resource object using syntax but ApplicationContext creates and manages resource objects on its own. BeanFactory doesnt support internatiolization but ApplicationContext supports internationalization. With BeanFactory annotation based dependency injection is not supported but annotation based dependency injection is supported in ApplicationContext.

使用BeanFactory:

BeanFactory beanfactory = new XMLBeanFactory(new FileSystemResource("spring.xml"));
 Triangle triangle =(Triangle)beanFactory.getBean("triangle");

使用ApplicationContext:

ApplicationContext context = new ClassPathXMLApplicationContext("spring.xml")
Triangle triangle =(Triangle)context.getBean("triangle");

对我来说，选择BeanFactory而不是ApplicationContext的主要区别似乎是ApplicationContext将预先实例化所有的bean。来自Spring文档:

Spring sets properties and resolves dependencies as late as possible, when the bean is actually created. This means that a Spring container which has loaded correctly can later generate an exception when you request an object if there is a problem creating that object or one of its dependencies. For example, the bean throws an exception as a result of a missing or invalid property. This potentially delayed visibility of some configuration issues is why ApplicationContext implementations by default pre-instantiate singleton beans. At the cost of some upfront time and memory to create these beans before they are actually needed, you discover configuration issues when the ApplicationContext is created, not later. You can still override this default behavior so that singleton beans will lazy-initialize, rather than be pre-instantiated.

考虑到这一点，我最初选择BeanFactory用于集成/性能测试，因为我不想加载整个应用程序来测试孤立的bean。但是——如果我说错了，有人会纠正我——BeanFactory不支持类路径XML配置。因此，BeanFactory和ApplicationContext都提供了我想要的关键特性，但两者都没有。

据我所知，文档中关于覆盖默认实例化行为的说明发生在配置中，而且它是每个bean的，所以我不能在XML文件中设置“lazy-init”属性，否则我就不得不维护一个版本用于测试，另一个版本用于部署。

我最终所做的是扩展ClassPathXmlApplicationContext以惰性加载bean以在测试中使用，如下所示:

public class LazyLoadingXmlApplicationContext extends ClassPathXmlApplicationContext {

    public LazyLoadingXmlApplicationContext(String[] configLocations) {
        super(configLocations);
    }

    /**
     * Upon loading bean definitions, force beans to be lazy-initialized.
     * @see org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)
     */

    @Override
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        super.loadBeanDefinitions(reader);
        for (String name: reader.getBeanFactory().getBeanDefinitionNames()) {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) reader.getBeanFactory().getBeanDefinition(name);
            beanDefinition.setLazyInit(true);
        }
    }

}

BeanFactory指的是在运行时调用getBean()方法后延迟实例化bean对象的spring容器。

ApplicationContext指的是spring框架，它在部署期间主动实例化bean对象，而不在运行时调用getBean()方法。

ApplicationContext: 它加载spring配置文件中配置的spring bean，并在CONTAINER启动时管理spring bean的生命周期。它不会等到getBean("springbeanref")被调用。

BeanFactory 它加载spring配置文件中配置的springbean，在调用getBean("springbeanref")时管理springbean的生命周期。因此，当我们在springbean生命周期开始时调用getBean(“springbeanref”)时。

ApplicationContext是BeanFactory的老大哥，这将是BeanFactory提供的所有东西，还有许多其他的东西。

除了标准的org.springframework.bean .factory. beanfactory生命周期功能外，ApplicationContext实现还可以检测和 调用ApplicationContextAware bean以及ResourceLoaderAware、ApplicationEventPublisherAware和MessageSourceAware bean。