我的六分钱:

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.

spring文档在这方面做得很好:3.8.1。BeanFactory还是ApplicationContext? 他们有一个比较表，我将发布一个片段:

Bean工厂

Bean实例化/布线

应用程序上下文

Bean实例化/布线 自动BeanPostProcessor注册 自动BeanFactoryPostProcessor注册 方便的MessageSource访问(用于i18n) ApplicationEvent出版

因此，如果您需要应用程序上下文端显示的任何点，您应该使用ApplicationContext。

在实时场景中，Spring IOC核心容器(BeanFactory)和高级J2EE容器(ApplicationContext)之间的区别如下。

BeanFactory will create objects for the beans (i.e., for POJO classes) mentioned in the spring.xml file (<bean></bean>) only when you call the .getBean() method, but whereas ApplicationContext creates the objects for all the beans (<bean></bean> if its scope is not explicitly mentioned as "Prototype") configured in the spring.xml while loading the spring.xml file itself. BeanFactory: (Lazy container because it creates the objects for the beans only when you explicitly call from the user/main class) /* * Using core Container - Lazy container - Because it creates the bean objects On-Demand */ //creating a resource Resource r = (Resource) new ClassPathResource("com.spring.resources/spring.xml"); //creating BeanFactory BeanFactory factory=new XmlBeanFactory(r); //Getting the bean for the POJO class "HelloWorld.java" HelloWorld worldObj1 = (HelloWorld) factory.getBean("test"); ApplicationContext: (Eager container because of creating the objects of all singleton beans while loading the spring.xml file itself) ApplicationContext context = new ClassPathXmlApplicationContext("com/ioc/constructorDI/resources/spring.xml"); Technically, using ApplicationContext is recommended because in real-time applications, the bean objects will be created while the application is getting started in the server itself. This reduces the response time for the user request as the objects are already available to respond.

Bean工厂的特性矩阵vs来自spring文档的应用程序上下文

beanfactory和ApplicationContext功能的截图

Spring提供两种IOC容器，一种是XMLBeanFactory，另一种是ApplicationContext。

通过完整路径加载的FileSystemXmlApplicationContext bean。 通过CLASSPATH加载的bean XMLWebApplicationContext和AnnotationConfigWebApplicationContext bean通过web应用程序上下文加载。 从基于Annotation的配置中加载Spring bean。

例子:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

ApplicationContext是由web.xml中定义的ContextLoaderListener或ContextLoaderServlet和struts-config.xml中定义的ContextLoaderPlugin初始化的容器。

注意:XmlBeanFactory从Spring 3.1开始已弃用，取而代之的是DefaultListableBeanFactory和XmlBeanDefinitionReader。

BeanFactory和ApplicationContext都是从spring IOC容器中获取bean的方法，但仍有一些区别。

BeanFactory是实例化、配置和管理许多bean的实际容器。这些bean通常彼此协作，因此它们之间存在依赖关系。这些依赖关系反映在BeanFactory使用的配置数据中。

BeanFactory和ApplicationContext都是Java接口，而ApplicationContext扩展了BeanFactory。它们都是使用XML配置文件进行配置的。简而言之，BeanFactory提供了基本的控制反转(IoC)和依赖注入(DI)特性，而ApplicationContext提供了高级特性。

BeanFactory由接口“org.springframework.beans”表示。其中BeanFactory有多个实现。

ClassPathResource resource = new ClassPathResource("appConfig.xml");
XmlBeanFactory factory = new XmlBeanFactory(resource);

区别

BeanFactory instantiate bean when you call getBean() method while ApplicationContext instantiate Singleton bean when container is started, It doesn't wait for getBean() to be called. BeanFactory doesn't provide support for internationalization but ApplicationContext provides support for it. Another difference between BeanFactory vs ApplicationContext is ability to publish event to beans that are registered as listener. One of the popular implementation of BeanFactory interface is XMLBeanFactory while one of the popular implementation of ApplicationContext interface is ClassPathXmlApplicationContext. If you are using auto wiring and using BeanFactory than you need to register AutoWiredBeanPostProcessor using API which you can configure in XML if you are using ApplicationContext. In summary BeanFactory is OK for testing and non production use but ApplicationContext is more feature rich container implementation and should be favored over BeanFactory BeanFactory by default its support Lazy loading and ApplicationContext by default support Aggresive loading.