Bean工厂VS的ApplicationContextBean工厂VS的ApplicationCon

2019-05-09 06:27发布

站内文章 / 前端开发
69 0 0

我很新的Spring框架，我一直在玩弄它，并把几样应用程序一起用于评估的Spring MVC对即将到来的公司项目中使用的目的。 到目前为止，我真的很喜欢我在Spring MVC中所看到的，似乎很容易使用，并鼓励你写的是非常单元测试友好类。

只是作为一个练习，我写我的样品/测试项目的一个主要方法。 有一件事我不清楚的是之间的确切差异BeanFactory和ApplicationContext -这是适合在哪些条件使用？

我明白ApplicationContext扩展BeanFactory ，但如果我只是写一个简单的主要方法，我是否需要额外的功能， ApplicationContext规定？ 而就在什么样的额外功能，并ApplicationContext提供？

除了回答“应该我在main（）方法使用”，是否有任何标准或准则，据我应该在这种情况下使用哪种实现？ 如果我的main（）方法写入取决于豆/应用程序配置是XML格式 - 是一个安全的假设，还是我锁定用户到一些具体的事情？

而且确实在网络环境中，该答案的变化-如果要知道春季我的任何类别的需要，是他们可能更需要ApplicationContext ？

谢谢你的帮助。 我知道有很多这些问题的参考手册中可能回答，但我有一个很难找到这两个接口以及各自的利弊/利弊的明确的细分不读通用细齿梳的手册。

Answer 1:

弹簧的文档在此是伟大的： 3.8.1。 BeanFactory或者ApplicationContext的？ 。 他们有一个比较表，我会发布一个片段：

豆厂

  • 豆实例/配线

应用上下文

  • 豆实例/配线
  • 自动的BeanPostProcessor注册
  • 自动的BeanFactoryPostProcessor注册
  • 便捷的MessageSource访问（国际化）
  • 出版了ApplicationEvent

所以如果你需要任何提交应用程序上下文侧分的，你应该使用的ApplicationContext。



Answer 2:

对我来说，主要的不同选择BeanFactory过ApplicationContext似乎是ApplicationContext将预先初始化所有的豆类。 从春节文档 ：

春天设置属性和解决依赖越晚越好，实际创建时的豆。 这意味着，当你请求一个对象，如果有创建对象或它的一个依赖问题已正确加载Spring容器以后可以产生异常。 例如，bean抛出一个异常作为缺少或非法属性的结果。 这可能耽误了一些配置问题的知名度也是为什么默认实例化预单豆ApplicationContext实现。 在一些前期的时间和内存来创建这些bean是实际需要之前，他们的成本，你会发现配置问题创建ApplicationContext的时候，而不是以后。 你仍然可以覆盖此默认行为，使单豆类将懒惰初始化，而不是预先实例化。

鉴于此，我最初选择BeanFactory在集成/性能测试使用，因为我不想加载测试中分离豆整个应用程序。 但是-而有人纠正我，如果我错了- BeanFactory不支持classpath的XML配置。 所以BeanFactory和ApplicationContext每提供一个重要的特征，我想，但也没有两者。

近我可以告诉大家，有关重写默认实例化行为的文档中的说明发生在配置上，它每bean的，所以我不能只是设置了“懒惰初始化”属性的XML文件中或者我坚持维护测试和部署版本的它一个。

我落得这样做扩展什么ClassPathXmlApplicationContext懒洋洋地加载使用豆类，像这样的测试： 

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);
        }
    }

}


Answer 3:

春天提供两种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加载豆
  • XMLWebApplicationContext和AnnotationConfigWebApplicationContext通过Web应用程序上下文加载豆。
  • AnnotationConfigApplicationContext从基于注解配置加载的Spring bean。

例： 

  ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);
  • ApplicationContext是由初始化容器ContextLoaderListener或ContextLoaderServlet在限定web.xml和ContextLoaderPlugin中所定义struts-config.xml 。

注 ： XmlBeanFactory被弃用赞成作为春季3.1 DefaultListableBeanFactory和XmlBeanDefinitionReader 。



Answer 4:

要添加到什么米格尔·平回答，这里是从文档的另一部分 ，回答这个问题，以及：

短版：使用ApplicationContext的，除非你有一个很好的理由不这样做。 对于那些你正在寻找稍微更深度的“但为什么”上述建议的，请继续阅读。

（张贴这为今后的任何春新手谁可能读了这个问题）



Answer 5:

  1. ApplicationContext比更优选的方式BeanFactory

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

  3. ApplicationContext extends BeanFactory ，并具有以下优点
    • 它支持短信国际化
    • 它支持事件发布到注册的监听器
    • 对资源的访问，如URL和文件


Answer 6:

我认为这是最好经常使用的ApplicationContext，除非你在移动环境中是已被其他人说。 的ApplicationContext更多的功能，你一定要使用的后处理器等RequiredAnnotationBeanPostProcessor，AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor会，这将帮助您简化Spring配置文件，您可以使用注释，比如@Required，@PostConstruct，@资源，等你的bean中。

即使你不使用所有的东西ApplicationContext的报价，最好还是要用它，再后来，如果你决定使用一些资源的东西，如邮件或后置处理器，或其他架构添加事务建议和这样的，你已经将有一个ApplicationContext，将不需要修改任何代码。

如果你正在写一个独立的应用程序，加载的ApplicationContext在你的主要方法，使用的ClassPathXmlApplicationContext，并得到了主要的bean，并调用它的run（）（或其他方式）来启动你的应用程序。 如果你正在编写一个Web应用程序，使用的ContextLoaderListener在web.xml中，以便它创建一个ApplicationContext并且以后可以从ServletContext得到它，无论你使用JSP，JSF，JSTL，支柱，挂毯等。

此外，请记住您可以使用多个配置文件，您可以创建通过列出的所有文件在构造函数（或在的context-param为的ContextLoaderListener列出这些）ApplicationContext时，或者你可以加载具有主配置文件import语句。 您可以通过使用导入Spring配置文件到另一个Spring配置文件<进口来源=“otherfile.xml” />当你编程创建的主要方法ApplicationContext中，仅装入一个Spring配置文件，这是非常有用的。



Answer 7:

ApplicationContext的：它加载在Spring配置文件中配置的Spring bean，并管理的Spring bean的生命周期，当容器STARTS.It不会等到的getBean（“springbeanref”）被调用。

Bean工厂它加载在Spring配置文件中配置Spring bean的，管理的Spring bean的生命周期，当我们调用的getBean（“springbeanref”）。所以当我们调用的getBean在周期开始的Spring bean的生命的时候（“springbeanref”） 。



Answer 8:

在大多数情况下，ApplicationContext的优先，除非你需要节约资源，就像在一个移动应用程序。

我不知道这取决于XML格式，但我敢肯定的ApplicationContext最常见的实现方式是XML的，如与ClassPathXmlApplicationContext，XmlWebApplicationContext和FileSystemXmlApplicationContext来。 这些都是我用过的只有三个。

如果你开发一个Web应用程序，它可以安全地说，你需要使用XmlWebApplicationContext。

如果你希望你的豆子要注意春季的，你可以让他们实现了BeanFactoryAware和/或用于了ApplicationContextAware的是，这样你就可以使用的BeanFactory或者ApplicationContext并选择实现的接口。



Answer 9:

BeanFactory或者ApplicationContext的两个办法从你的Spring IoC容器得豆，但仍存在一定的差异。

Bean工厂是初始化，配置和管理许多bean的实际容器。 这些bean通常会彼此合作，因而它们之间的依赖关系。 这些依赖关系反映在被BeanFactory使用的配置数据。

BeanFactory或者ApplicationContext的都是Java接口和扩展的ApplicationContext Bean工厂。 他们两人都是使用XML配置文件配置。 在短的BeanFactory提供控制（IOC）的基本反转和依赖注入（DI）的功能，同时提供的ApplicationContext 高级功能。

一个BeanFactory由接口“org.springframework.beans.factory”哪里的BeanFactory，对于其中有多个实现方式表示。 

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

区别

  1. 当你调用getBean（）方法时，容器开始Bean工厂 bean的实例方法，而ApplicationContext的实例辛格尔顿豆，它不会等待的getBean（）被调用。

  2. Bean工厂并没有对国际化提供支持，但ApplicationContext中提供对它的支持。

  3. VS ApplicationContext的 BeanFactory的另一个区别在于发布事件被注册为收听豆能力。

  4. 一个流行的实现BeanFactory接口是XmlBeanFactory中 ，而流行的实现ApplicationContext的接口之一是ClassPathXmlApplicationContext的 。

  5. 如果您在使用自动布线和使用BeanFactory的比你需要使用API，你可以在XML中，如果您使用的ApplicationContext配置注册AutoWiredBeanPostProcessor。 综上所述Bean工厂是用于测试和非生产用途确定，但ApplicationContext的是功能更丰富容器实现的，应该在Bean工厂受到青睐

  6. 默认情况下，它支持延迟加载和ApplicationContext的默认支持Aggresive加载Bean工厂 。



Answer 10:

BeanFactory或者ApplicationContext的区别是以下几点：

  1. Bean工厂使用延迟初始化，但 ApplicationContext的使用急切初始化。 在BeanFactory中的情况下，当你调用getBeans（）方法创建的bean，但在创建ApplicationContext的对象时，豆腐中的ApplicationContext的情况下创建的前期。
  2. Bean工厂明确提供资源使用对象的语法，但 ApplicationContext中对自己创建和管理资源对象。
  3. Bean工厂犯规支持internatiolization 但 ApplicationContext中支持国际化。
  4. 随着Bean工厂基于注解的依赖注入不支持，但基于注释依赖注入在ApplicationContext的支持。

使用Bean工厂：

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");



Answer 11:

特点bean工厂的矩阵VS应用程序上下文从春天文档来源

的BeanFacotry和ApplicationContext的功能截图



Answer 12:

基本上，我们可以通过两种方式创建Spring容器对象

  1. 使用BeatFactory
  2. 使用的ApplicationContext

两者都是接口

使用实现类，我们可以创建Spring容器对象

来到差异

Bean工厂

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

  2. 不支持国际化

  3. 默认情况下，它支持延迟加载

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

例如：BeanFactory的上下文=新XmlBeanFactory中（新的资源（ “applicationContext.xml中”））;

的ApplicationContext

  1. 支持基于注解的依赖Injection.-@Autowired，@PreDestroy

  2. 支持国际化

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

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

例如：
ApplicationContext的上下文=新的ClassPathXmlApplicationContext（ “applicationContext.xml中”）;



Answer 13:

一个。 bean工厂和应用程序上下文之间的一个区别是，当你调用的getBean（）方法，而ApplicationContext的实例辛格尔顿豆当容器启动时，它不会等待的getBean被称为是前者只实例化的bean。

湾

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

要么

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

您可以根据您的项目需求使用一个或多个XML文件。 正如我在这里使用两个XML文件，即一个详细的配置信息用于其它的DAO类服务类。 这里的ClassPathXmlApplicationContext是ApplicationContext中的孩子。

C。 Bean工厂Container是基本的容器，它只能创建对象和注入依赖。 但是，我们不能附加其他服务，如安全性，事务，消息等提供所有我们使用的ApplicationContext集装箱的服务。

d。 Bean工厂不提供国际化，即国际化支持，但ApplicationContext中提供对它的支持。

即 BeanFactory的容器不支持自动扫描（支持基于注解的依赖注入）的功能，但ApplicationContext的容器支持。

F。 BeanFactory的集装箱不会创建一个bean对象，直到请求时间。 这意味着Bean工厂容器装载豆懒洋洋地。 虽然ApplicationContext的容器中仅载入的时间创建辛格尔顿bean的对象。 这意味着有初装。

G。 BeanFactory的集装箱只支持两个作用域（单例与原型）的豆类。 但是ApplicationContext的容器支持所有的豆类范围。



Answer 14:

请参阅从春文档此文档：

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将不会生效，至少在没有你做一些额外的步骤。 因为没有什么实际上是错误的配置，这种情况可能会造成混乱。



Answer 15:

ApplicationContext已Bean工厂的大哥哥，这将是Bean工厂都提供的东西以及许多其他的东西。

除了标准的org.springframework.beans.factory.BeanFactory生命周期的能力，ApplicationContext实现检测，并调用了ApplicationContextAware豆类以及ResourceLoaderAware，ApplicationEventPublisherAware和MessageSourceAware豆。



Answer 16:

在实时情景，是Spring IOC核心容器（Bean工厂）和高级J2EE容器（ApplicationContext的）之间的区别如下。

  1. Bean工厂将建立在spring.xml文件中提及的bean（即用于POJO类）对象（ <bean></bean> ），只有当你调用.getBean（）方法，但而ApplicationContext中创建的所有对象豆（ <bean></bean>如果其范围没有明确地为“原型”提及）在spring.xml配置在加载spring.xml文件本身。

  2. 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的：（因为在加载spring.xml文件本身创建所有的singleton bean的对象的渴望容器） 

     ApplicationContext context = new ClassPathXmlApplicationContext("com/ioc/constructorDI/resources/spring.xml");

  3. 从技术上讲，使用的ApplicationContext在实时应用，因为推荐的，而应用程序是在服务器本身入门将要创建的bean对象。 这减少了响应时间作为对象已经提供给响应所述用户请求。



Answer 17:

我认为这是值得一提的是，由于春季3，如果你想创建一个工厂，你也可以使用@configuration注释与适当的结合@scope 

@Configuration
public class MyFactory {

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

你的工厂应使用由Spring容器可见@ComponentScan注释或xml配置

从baeldung网站的Spring bean作用域文章



Answer 18:

因为它仅支持单例和原型豆范围不使用BeanFactory的非Web应用程序。

虽然ApplicationContext的容器不支持所有的豆范围，所以你应该使用它的Web应用程序。



Answer 19:

综上所述：

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

有一些有限的情况下，如移动应用程序，其中内存的消耗可能是至关重要的。

在这种情况下，它可以合理使用更轻便的BeanFactory。 然而，在大多数企业应用，ApplicationContext的是你将要使用的。

如需更多信息，请参见我的博客文章：

在Spring的BeanFactory和ApplicationContext的区别-从最基础的Java的春天博客



文章来源: BeanFactory vs ApplicationContext
标签： spring managed-bean applicationcontext
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~