BeanFactory与ApplicationContext

spring managed-bean applicationcontext

193466 观看

20回复

109411 作者的声誉

我是Spring Framework的新手,我一直在玩它并将一些示例应用程序放在一起,以便评估Spring MVC用于即将到来的公司项目。到目前为止,我非常喜欢我在Spring MVC中看到的内容,看起来非常容易使用,并鼓励您编写非常适合单元测试的类。

就像练习一样,我正在为我的一个示例/测试项目编写一个主要方法。我不清楚的一件事是BeanFactory和之间的确切差异ApplicationContext- 适合在哪些条件下使用?

我理解ApplicationContext扩展BeanFactory,但如果我只是编写一个简单的主要方法,我是否需要ApplicationContext提供额外的功能?究竟是什么类型的额外功能ApplicationContext提供了?

除了回答“我应该在main()方法中使用哪个”之外,对于在这种情况下我应该使用哪种实现,是否有任何标准或指南?我的main()方法是否应该依赖于bean /应用程序配置来编写XML格式 - 这是一个安全的假设,还是我将用户锁定为特定的东西?

这个答案是否会在网络环境中发生变化 - 如果我的任何课程需要了解Spring,他们是否更有可能需要ApplicationContext

谢谢你的帮助。我知道很多这些问题可能在参考手册中得到了解答,但是我很难找到这两个界面的明确细分以及每个界面的优点/缺点,而无需通过精细梳齿阅读手册。

作者: matt b 的来源 发布者: 2008 年 10 月 28 日

回应 (20)


191

12944 作者的声誉

决定

春季文档很棒:3.8.1。BeanFactory或ApplicationContext?。他们有一个比较表,我将发布一个片段:

豆厂

  • Bean实例化/布线

应用背景

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

因此,如果您需要在应用程序上下文方面提供的任何点,则应使用ApplicationContext。

作者: Miguel Ping 发布者: 28.10.2008 02:04

28

109411 作者的声誉

要添加到Miguel Ping所回答的内容,这里是文档的另一部分,它也回答了这个问题:

简短版本:使用ApplicationContext,除非你有充分的理由不这样做。对于那些正在寻找上述建议的“但为什么”更深入的人,请继续阅读。

(发布此信息适用于未来可能会阅读此问题的Spring新手)

作者: matt b 发布者: 28.10.2008 02:08

6

1933 作者的声誉

在大多数情况下,ApplicationContext是首选,除非您需要节省资源,例如在移动应用程序上。

我不确定依赖于XML格式,但我很确定ApplicationContext的最常见实现是XML,例如ClassPathXmlApplicationContext,XmlWebApplicationContext和FileSystemXmlApplicationContext。这是我用过的唯一三个。

如果您正在开发一个Web应用程序,可以说您需要使用XmlWebApplicationContext。

如果你希望你的bean知道Spring,你可以让它们为它实现BeanFactoryAware和/或ApplicationContextAware,这样你就可以使用BeanFactory或ApplicationContext并选择要实现的接口。

作者: Ryan Thames 发布者: 28.10.2008 09:02

12

4479 作者的声誉

我认为最好始终使用ApplicationContext,除非你像其他人已经说过的那样处于移动环境中。ApplicationContext具有更多功能,您肯定希望使用PostProcessors,如RequiredAnnotationBeanPostProcessor,AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor,它们将帮助您简化Spring配置文件,并且您可以在bean中使用@ Required,@ PostConstruct,@ Resource等注释。 。

即使您没有使用ApplicationContext提供的所有内容,最好还是使用它,然后如果您决定使用某些资源(如消息或后处理器)或其他模式来添加事务性建议等等,已经有一个ApplicationContext,不需要更改任何代码。

如果您正在编写一个独立的应用程序,请使用ClassPathXmlApplicationContext在main方法中加载ApplicationContext,并获取主bean并调用其run()(或任何方法)来启动您的应用程序。如果您正在编写Web应用程序,请使用web.xml中的ContextLoaderListener,以便它创建ApplicationContext,稍后您可以从ServletContext获取它,无论您使用的是JSP,JSF,JSTL,struts,Tapestry等。 。

另外,记住你可以使用多个Spring配置文件,你可以通过列出构造函数中的所有文件来创建ApplicationContext(或者在ContextLoaderListener的context-param中列出它们),或者你可以只加载一个主配置文件进口报表。您可以使用将Spring配置文件导入另一个Spring配置文件,这在以main方法编程创建ApplicationContext并仅加载一个Spring配置文件时非常有用。

作者: Chochos 发布者: 04.11.2008 06:39

17

181 作者的声誉

  1. ApplicationContext 是比较喜欢的方式 BeanFactory

  2. 在新的Spring版本BeanFactory中替换为ApplicationContext。但仍然BeanFactory存在向后兼容性

  3. ApplicationContext extends BeanFactory 并具有以下好处
    • 它支持短信的国际化
    • 它支持向已注册的听众发布事件
    • 访问URL和文件等资源
作者: srinivas reddy 发布者: 27.02.2010 12:04

45

2737 作者的声誉

对我来说,最主要的区别,选择BeanFactoryApplicationContext似乎是ApplicationContext将预先初始化所有的豆类。从春天文档

当实际创建bean时,Spring会尽可能晚地设置属性并解析依赖项。这意味着如果在创建该对象或其依赖项之一时出现问题,则在请求对象时,正确加载的Spring容器可以在以后生成异常。例如,bean因缺少属性或无效属性而抛出异常。这可能会延迟一些配置问题的可见性,这就是默认情况下ApplicationContext实现预先实例化单例bean的原因。以实际需要之前创建这些bean的一些前期时间和内存为代价,您会在创建ApplicationContext时发现配置问题,而不是更晚。您仍然可以覆盖此默认行为,以便单例bean将延迟初始化,而不是预先实例化。

鉴于此,我最初选择BeanFactory用于集成/性能测试,因为我不想加载整个应用程序来测试隔离的bean。但是 - 如果我错了,有人会纠正我 - BeanFactory不支持classpathXML配置。所以BeanFactoryApplicationContext每个都提供了我想要的关键功能,但两者都没有。

我可以说,文档中关于覆盖默认实例化行为的注释发生在配置中,并且它是每个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);
        }
    }

}
作者: Lyle 发布者: 28.02.2010 03:04

1

95 作者的声誉

请参阅Spring Docs中的此文档:

http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/beans.html#context-introduction-ctx-vs-beanfactory

5.15.1 BeanFactory或ApplicationContext?

除非您有充分理由不这样做,否则请使用ApplicationContext。

因为ApplicationContext包含BeanFactory的所有功能,所以通常建议使用BeanFactory,除了一些情况,例如在Applet中,内存消耗可能很关键,而一些额外的千字节可能会有所不同。但是,对于大多数典型的企业应用程序和系统,ApplicationContext是您要使用的。Spring 2.0及更高版本大量使用BeanPostProcessor扩展点(以实现代理等)。如果你只使用一个普通的BeanFactory,那么交易和AOP等相当数量的支持将不会生效,至少在没有你做一些额外步骤的情况下也是如此。这种情况可能会令人困惑,因为配置实际上没有任何问题。

作者: Vijayan Srinivasan 发布者: 27.04.2013 04:58

10

101 作者的声誉

ApplicationContext: 它加载在spring配置文件中配置的spring bean,并管理spring bean的生命周期和WHEN CONTAINER STARTS.It不会等到调用getBean(“springbeanref”)

BeanFactory 它加载在spring配置文件中配置的spring bean,当我们调用getBean(“springbeanref”)时管理spring bean的生命周期。所以当我们在spring bean生命周期开始时调用getBean(“springbeanref”)时。

作者: vinod 发布者: 04.06.2013 07:15

1

2022 作者的声誉

ApplicationContext是BeanFactory的一个大兄弟,这将是BeanFactory提供的所有东西以及许多其他东西。

除了标准的org.springframework.beans.factory.BeanFactory生命周期功能之外,ApplicationContext实现还检测并调用ApplicationContextAware bean以及ResourceLoaderAware,ApplicationEventPublisherAware和MessageSourceAware bean。

作者: Yasir Shabbir Choudhary 发布者: 26.02.2015 06:52

12

668 作者的声誉

  • BeanFactory:不支持基于注释的依赖注入。
  • ApplicationContext:支持基于注释的依赖注入。 - @ Autowired,@ PreDestroy
  • BeanFactory:不支持
  • ApplicationContext:应用程序上下文可以将事件发布到注册为侦听器的bean
  • BeanFactory:不支持访问消息包的方式(国际化(I18N)
  • ApplicationContext:支持国际化(I18N)消息。
  • BeanFactory:不支持。
  • ApplicationContext:支持许多企业服务,如JNDI访问,EJB集成,远程处理。
  • BeanFactory:默认情况下它支持Lazy加载
  • ApplicationContext:默认情况下支持Aggresive加载。
作者: JavaDev 发布者: 14.04.2015 01:54

4

10411 作者的声誉

Bean Factory与应用程序的特征矩阵源自spring docs

在此处输入图像描述

BeanFacotry和ApplicationContext的功能截图

作者: Lucky 发布者: 30.06.2015 01:30

5

1896 作者的声誉

BeanFactoryApplicationContext都是从spring IOC容器中获取bean的方法,但仍有一些区别。

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

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

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

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

区别

  1. BeanFactory在调用getBean()方法时实例化bean,而ApplicationContext在启动容器时实例化Singleton bean,它不等待调用getBean()。

  2. BeanFactory不支持国际化,但ApplicationContext提供了对它的支持。

  3. BeanFactoryApplicationContext之间的另一个区别是能够将事件发布到注册为侦听器的bean。

  4. 其中一个流行的实现的Bean工厂接口是XmlBeanFactory中,而流行的实现的一个ApplicationContext的接口是ClassPathXmlApplicationContext的

  5. 如果您使用自动布线并使用BeanFactory,则需要使用API 注册AutoWiredBeanPostProcessor,如果您使用的是ApplicationContext,则可以使用XML进行配置 。总之,BeanFactory可用于测试和非生产使用,但ApplicationContext是功能更丰富的容器实现,应该优于BeanFactory

  6. BeanFactory默认支持Lazy loading和ApplicationContext默认支持Aggresive加载。

作者: Divyesh Kanzariya 发布者: 15.01.2016 05:32

3

29 作者的声誉

基本上我们可以用两种方式创建spring容器对象

  1. 使用BeatFactory
  2. 使用ApplicationContext

两者都是接口

使用实现类,我们可以为spring容器创建对象

来到差异

Bean工厂

  1. 不支持基于注释的依赖注入。

  2. 不支持I18N

  3. 默认情况下它支持Lazy加载

  4. 它不允许配置多个配置文件。

例如:BeanFactory context = new XmlBeanFactory(new Resource(“applicationContext.xml”));

的ApplicationContext

  1. 支持基于注释的依赖注入.- @ Autowired,@ PreDestroy

  2. 支持I18N

  3. 默认情况下,支持Aggresive加载。

  4. 它允许配置多个配置文件。

例如:
ApplicationContext context = new ClasspathXmlApplicationContext(“applicationContext.xml”);

作者: Shravankumar Akirala 发布者: 18.01.2016 05:59

30

28254 作者的声誉

Spring提供了两种IOC容器,一种是XMLBeanFactory其他的ApplicationContext

+---------------------------------------+-----------------+--------------------------------+
|                                       | BeanFactory     |       ApplicationContext       |
+---------------------------------------+-----------------+--------------------------------+
| Annotation support                    | No              | Yes                            |
| BeanPostProcessor Registration        | Manual          | Automatic                      |
| implementation                        | XMLBeanFactory  | ClassPath/FileSystem/WebXmlApplicationContext|
| internationalization                  | No              | Yes                            |
| Enterprise services                   | No              | Yes                            |
| ApplicationEvent publication          | No              | Yes                            |
+---------------------------------------+-----------------+--------------------------------+

在此处输入图像描述

  • FileSystemXmlApplicationContext 豆通过完整的路径加载。
  • ClassPathXmlApplicationContext 通过CLASSPATH加载的Bean
  • XMLWebApplicationContextAnnotationConfigWebApplicationContextbean通过Web应用程序上下文加载。
  • AnnotationConfigApplicationContext 从基于Annotation的配置加载Spring bean。

例:

  ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);
  • ApplicationContext是由初始化的容器ContextLoaderListenerContextLoaderServlet以限定的web.xmlContextLoaderPlugin所限定struts-config.xml
作者: Premraj 发布者: 20.01.2016 02:29

1

99 作者的声誉

在实时场景中,Spring IOC Core容器(BeanFactory)和Advanced J2EE容器(ApplicationContext)之间的区别如下。

  1. <bean></bean>只有在调用.getBean()方法时,BeanFactory才会为spring.xml文件()中提到的bean(即POJO类)创建对象,但ApplicationContext会为所有bean创建对象(<bean></bean>如果其范围不是显式提到“Prototype”)在spring.xml中配置,同时加载spring.xml文件本身。

  2. BeanFactory :(懒惰的容器,因为它只在你从用户/主类显式调用时才为bean创建对象)

    /*
     * 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容器,因为在加载spring.xml文件时创建了所有单例bean的对象)

    ApplicationContext context = new ClassPathXmlApplicationContext("com/ioc/constructorDI/resources/spring.xml");
    
  3. 从技术上讲,建议使用ApplicationContext,因为在实时应用程序中,将在服务器本身启动应用程序时创建bean对象。这减少了用户请求的响应时间,因为对象已经可用于响应。

作者: Karthik Pon 发布者: 26.02.2016 01:19

3

59 作者的声誉

一个。bean工厂和应用程序上下文之间的一个区别是,当您调用getBean()方法时,前者仅实例化bean,而ApplicationContext在启动容器时实例化Singleton bean,它不等待调用getBean。

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

要么

ApplicationContext context = new ClassPathXmlApplicationContext{"spring_dao.xml","spring_service.xml};

您可以根据项目要求使用一个或多个xml文件。因为我在这里使用两个xml文件,即一个用于dao类的服务类的配置细节。这里ClassPathXmlApplicationContext是ApplicationContext的子代。

C。BeanFactory Container是基本容器,它只能创建对象并注入依赖项。但是我们不能附加其他服务,如安全性,事务,消息传递等,以提供我们使用ApplicationContext Container的所有服务。

d。BeanFactory不支持国际化,即i18n,但ApplicationContext提供了对它的支持。

即 BeanFactory Container不支持AutoScanning(基于支持注释的依赖注入)的功能,但ApplicationContext Container支持。

F。Beanfactory Container在请求时间之前不会创建bean对象。这意味着Beanfactory Container懒洋洋地加载bean。ApplicationContext Container仅在加载时创建Singleton bean的对象。这意味着有早期装载。

G。Beanfactory Container仅支持bean的两个范围(单例和原型)。但ApplicationContext Container支持所有bean范围。

作者: rajvineet 发布者: 06.01.2017 03:04

5

532 作者的声誉

BeanFactoryApplicationContext之间的区别如下:

  1. BeanFactory使用延迟初始化, ApplicationContext使用急切初始化。对于BeanFactory,在调用getBeans()方法时会创建bean,但是在创建ApplicationContext对象时,在ApplicationContext的情况下会预先创建bean。
  2. BeanFactory使用语法显式提供资源对象, ApplicationContext自己创建和管理资源对象。
  3. BeanFactory不支持国际化, ApplicationContext支持国际化。
  4. 使用BeanFactory基于注释的依赖注入不受支持, 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)beanFactory.getBean("triangle");

作者: Raman Gupta 发布者: 01.10.2017 04:19

0

2319 作者的声誉

我认为值得一提的是,从Spring 3开始,如果你想创建一个工厂,你也可以使用@configuration注释结合正确的@scope

@Configuration
public class MyFactory {

    @Bean
    @Scope("prototype")
    public MyClass create() {
        return new MyClass();
    }
}

Spring容器应使用@ComponentScan注释或xml配置显示您的工厂

来自baeldung网站的Spring bean范围文章

作者: Ronan Quillevere 发布者: 23.01.2018 01:00

0

766 作者的声誉

将BeanFactory用于非Web应用程序,因为它仅支持Singleton和Prototype bean范围。

虽然ApplicationContext容器支持所有bean范围,因此您应该将它用于Web应用程序。

作者: Arun Raaj 发布者: 21.04.2018 10:01

0

59 作者的声誉

综上所述:

ApplicationContext中包括了BeanFactory所有的功能。通常建议使用前者。

存在一些有限的情况,例如在移动应用程序中,内存消耗可能是关键的。

在那种情况下,使用更轻量级的BeanFactory是合理的。但是,在大多数企业应用程序中,ApplicationContext是您要使用的。

更多关于:

Spring中BeanFactory和ApplicationContext的区别 - 来自基础知识的java spring博客

作者: Zoltán Raffai 发布者: 07.07.2018 05:25
32x32