BeanFactory vs ApplicationContext

https://stackoverflow.com/questions/243385

04-07-2019
|

Pergunta

Eu sou muito novo para o Spring Framework, eu fui brincar com ele e colocar algumas amostras de aplicativos em conjunto para fins de avaliação Spring MVC para uso em um próximo projeto da empresa. Até agora eu realmente gosto do que eu vejo em Spring MVC, parece muito fácil de usar e incentiva-lo a classes de escrita que são muito amigável unidade teste.

Apenas como um exercício, eu estou escrevendo um método principal para um dos meus projetos de amostra / teste. Uma coisa que eu estou a ponto claro é as diferenças exatas entre BeanFactory e ApplicationContext - o que é apropriado para usar em que condições

Eu entendo que ApplicationContext estende BeanFactory, mas se eu só estou escrevendo um método main simples, eu preciso a funcionalidade extra que ApplicationContext fornece? E exatamente que tipo de funcionalidade extra faz ApplicationContext fornecer?

Além de responder "que eu deveria usar um método main ()", existem normas ou orientações, tanto quanto cuja implementação eu deveria usar em tal cenário? Deve meu método main () ser gravados de acordo com a configuração de feijão / aplicativo para ser em formato XML - é que uma suposição segura, ou estou bloqueando o usuário em algo específico

E essa mudança resposta em um ambiente web -? Se algum dos meus classes necessárias para estar ciente de Primavera, eles são mais propensos a necessidade ApplicationContext

Obrigado por qualquer ajuda. Eu conheço um monte dessas perguntas provavelmente são respondidas no manual de referência, mas eu estou tendo um tempo difícil encontrar uma discriminação clara destas duas interfaces e as vantagens / desvantagens de cada um sem ler através do manual com um pente fino.

Solução

Os docs Primavera são grandes neste: 3.8.1. BeanFactory ou ApplicationContext? . Eles têm uma tabela com uma comparação, vou postar um trecho:

Bean Factory

Feijão instanciação / fiação

Aplicação Contexto

Feijão instanciação / fiação
Registro de BeanPostProcessor automática
Registro de BeanFactoryPostProcessor automática
Acesso MessageSource conveniente (para i18n)
publicação ApplicationEvent

Então, se você precisar de qualquer um dos pontos apresentados no lado o contexto do aplicativo, você deve usar ApplicationContext.

Outras dicas

Para mim, a principal diferença de escolher BeanFactory sobre ApplicationContext parece ser que ApplicationContext irá pré-instanciar todos os feijões. De o Spring docs :

Spring define as propriedades e resolve dependências o mais tarde possível, quando o bean é realmente criado. Isto significa que um recipiente de mola que tem colocado correctamente pode depois gerar uma excepção ao solicitar um objecto, se houver um problema de criar esse objecto ou uma das suas dependências. Por exemplo, o feijão lança uma exceção, como resultado de uma propriedade ausente ou inválido. Essa visibilidade potencialmente atrasada de alguns problemas de configuração é por isso que applicationContext implementações de padrão singleton beans-instanciar pré. Ao custo de algum tempo inicial e memória para criar estes feijões antes que eles são realmente necessários, você descobre problemas de configuração quando o ApplicationContext é criado, não mais tarde. Você ainda pode substituir esse comportamento padrão para que os grãos únicas irá lazy-initialize, ao invés de ser pré-instanciado.

Diante disso, I inicialmente escolheu BeanFactory para uso em testes de integração / desempenho desde que eu não queria carregar todo o aplicativo para testar os feijões isolados. No entanto - e alguém me corrija se eu estiver errado - BeanFactory não suporta a configuração XML classpath. Então BeanFactory e ApplicationContext cada fornecer uma característica crucial que eu queria, mas também não ambos.

Perto quanto eu posso dizer, a nota na documentação sobre a substituição comportamento instanciação padrão ocorre na configuração, e é por feijão, por isso não pode apenas definir o atributo "lazy-init" no arquivo XML ou Eu estou preso a manutenção de uma versão dela para o teste e um para a implantação.

O que eu acabei fazendo foi estendendo ClassPathXmlApplicationContext ao feijão carga preguiçosamente para uso em testes assim:

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

}

Spring fornece dois tipos de recipiente COI, um é XMLBeanFactory e outro é 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                            |
+---------------------------------------+-----------------+--------------------------------+

Beans FileSystemXmlApplicationContext carregado através do caminho completo.
feijões ClassPathXmlApplicationContext carregadas por meio do CLASSPATH
XMLWebApplicationContext e AnnotationConfigWebApplicationContext feijão carregado através do contexto de aplicação web.
AnnotationConfigApplicationContext Carregando de configuração baseada anotação.

exemplo:

  ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

ApplicationContext é inicializado o recipiente por uma ou ContextLoaderListener ContextLoaderServlet definido em uma web.xml e ContextLoaderPlugin definido em struts-config.xml.

Nota : XmlBeanFactory é deprecated na Primavera de 3.1 em favor da DefaultListableBeanFactory e XmlBeanDefinitionReader.

Para adicionar para o que Miguel Ping respondeu, aqui é outra seção da documentação que responde a esta assim:

A versão curta: use um ApplicationContext menos que você tenha uma boa razão para não fazê-lo. Para aqueles de vocês que estão à procura de um pouco mais de profundidade quanto ao 'mas por que' da recomendação acima, manter a leitura.

(postando isso por quaisquer novatos futuro Primavera que pode ler esta pergunta)

ApplicationContext é muito mais preferido do que BeanFactory

Na nova versão Primavera BeanFactory é substituído por ApplicationContext. Mas ainda existe BeanFactory para compatibilidade com versões anteriores

ApplicationContext extends BeanFactory e tem os seguintes benefícios

suporta internacionalização para mensagens de texto

suporta publicação evento para os ouvintes registrados

o acesso aos recursos, tais como URLs e arquivos

Eu acho que é melhor usar sempre ApplicationContext, a menos que você está em um ambiente móvel, como alguém já disse. ApplicationContext tem mais funcionalidade e você definitivamente quer usar os pós-processadores, como RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor e CommonAnnotationBeanPostProcessor, que ajudarão a simplificar seus arquivos de configuração Spring, e você pode usar anotações como @Required, @PostConstruct, @Resource, etc em seus feijões .

Mesmo se você não usar todas as ofertas coisas applicationContext, é melhor usá-lo de qualquer maneira, e, em seguida, mais tarde, se você decidir usar algum material de recursos, como mensagens ou pós-processadores, ou outro esquema para adicionar conselhos transacionais e tal, você já terá uma ApplicationContext e não será necessário alterar nenhum código.

Se você estiver escrevendo um aplicativo independente, carregar o ApplicationContext em seu método principal, usando um ClassPathXmlApplicationContext, e obter o feijão principal e invocar a sua run () (ou qualquer outro método) para iniciar a sua aplicação. Se você estiver escrevendo um aplicativo web, use o ContextLoaderListener em web.xml para que ele cria o ApplicationContext e mais tarde você pode obtê-lo a partir do ServletContext, independentemente de você estiver usando JSP, JSF, JSTL, Struts, Tapestry, etc .

Além disso, lembre-se que você pode usar vários arquivos de configuração da Primavera e você pode criar o ApplicationContext listando todos os arquivos no construtor (ou listá-las no context-param para o ContextLoaderListener), ou você pode apenas carregar uma configuração principal arquivo que tem instruções de importação. Você pode importar um arquivo de configuração do Spring em outro arquivo de configuração do Spring usando o que é muito útil quando você programaticamente criar o ApplicationContext no método principal e coloque apenas o arquivo de configuração de um Primavera.

ApplicationContext: Ele carrega feijão primavera configurados no arquivo de configuração primavera, e gerencia o ciclo de vida do feijão de primavera como e quando o recipiente STARTS.It não vai esperar até getBean ( "springbeanref") é chamado.

BeanFactory Ele carrega feijão primavera configurados no arquivo de configuração primavera, gerencia o ciclo de vida do feijão de primavera, quando chamamos o getBean ( "springbeanref") .Assim quando chamamos o getBean ( "springbeanref") no momento da primavera de feijão começa ciclo de vida.

Para a maior parte, é o preferido ApplicationContext menos que você precisa para economizar recursos, como em um aplicativo móvel.

Eu não tenho certeza sobre dependendo do formato XML, mas eu tenho certeza que as implementações mais comuns de ApplicationContext são os XML como ClassPathXmlApplicationContext, XmlWebApplicationContext e FileSystemXmlApplicationContext. Esses são os únicos três que já usei.

Se o seu desenvolvimento de uma aplicação web, é seguro dizer que você vai precisar usar XmlWebApplicationContext.

Se você quer que seus grãos para estar ciente de Primavera, você pode tê-los implementar BeanFactoryAware e / ou ApplicationContextAware para isso, então você pode usar qualquer BeanFactory ou ApplicationContext e escolha qual interface de implementar.

BeanFactory e ApplicationContext ambos são maneiras de obter grãos de sua primavera COI recipiente, mas ainda existem algumas diferenças.

BeanFactory é o recipiente real que instancia, configura e gere uma série de feijão de. Esses grãos são tipicamente colaborar uns com os outros, e, portanto, têm dependências entre si. Estas dependências são reflectidas nos dados de configuração utilizados pelo BeanFactory.

BeanFactory e ApplicationContext ambos são interfaces Java e ApplicationContext estende BeanFactory. Ambos são de configuração usando arquivos de configuração XML. Em suma BeanFactory fornece Inversão básico de controle ( IoC ) e Dependency Injection ( DI ) apresenta enquanto ApplicationContext fornece avançado apresenta.

A BeanFactory é representado pela interface " org.springframework.beans.factory " Onde BeanFactory, para a qual existem várias implementações.

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

DIFERENÇA

BeanFactory feijão instanciar quando você chamar getBean () método enquanto ApplicationContext instanciar Singleton feijão quando o recipiente é iniciado, ele não espera que getBean () para ser chamado.

BeanFactory não fornece suporte para a internacionalização, mas ApplicationContext fornece suporte para ele.

Outra diferença entre BeanFactory vs ApplicationContext é a capacidade de publicar evento para grãos que são registrados como ouvinte.

Um dos implementação popular de BeanFactory interface é XmlBeanFactory , enquanto um de implementação popular de ApplicationContext interface é ClassPathXmlApplicationContext .

Se você estiver usando fiação automático e usando BeanFactory que você precisa se registrar AutoWiredBeanPostProcessor usando API que você pode configurar em XML se você estiver usando ApplicationContext . Em resumo BeanFactory é OK para testar e uso não produção, mas ApplicationContext é mais rico em recursos implementação do container e deve ser favorecida em detrimento BeanFactory

BeanFactory por padrão o seu apoio preguiçoso carga e ApplicationContext por suporte padrão Aggresive carregamento.

Diferença entre BeanFactory e ApplicationContext são os seguintes:

BeanFactory usa inicialização lenta e ApplicationContext usa inicialização ansioso. Em caso de BeanFactory, feijão é criado quando você chamar getBeans () método, mas feijão é criado antecipadamente em caso de ApplicationContext quando o objeto ApplicationContext é criado.

BeanFactory fornecer explicitamente um objeto de recurso usando a sintaxe e ApplicationContext cria e gerencia objetos de recurso por conta própria.

BeanFactory apoio doesnt internatiolization e ApplicationContext suporta internacionalização.

Com a injeção de dependência com base BeanFactory anotação não é suportado e anotação injeção de dependência com base é suportado no ApplicationContext.

Usando BeanFactory:

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

Usando ApplicationContext:

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

Característica Matriz de Bean Factory vs Contexto Aplicação provenientes de docs primavera

_{Captura de tela de recursos do BeanFacotry e ApplicationContext}

Basicamente podemos criar objeto de recipiente primavera de duas maneiras

usando BeatFactory

usando ApplicationContext

ambos são as interfaces

usando classes de implementação, podemos criar o objeto de recipiente primavera

chegando às diferenças

BeanFactory

não suporta a anotação com base injeção de dependência.

O I18N não suporta

Por padrão o seu apoio preguiçoso de carga

não permite que configure a vários arquivos de configuração.

ex: BeanFactory context = new XmlBeanFactory (novo recurso ( "applicationContext.xml"));

ApplicationContext

Suporte anotação dependência baseada Injection.-@Autowired, @PreDestroy

I18N Suporte

o seu apoio default por carregamento agressivo.

que permitem configurar vários arquivos de configuração.

ex:
ApplicationContext contexto = new ClassPathXmlApplicationContext ( "applicationContext.xml");

a. Uma diferença entre a fábrica de feijão e contexto de aplicação é que o ex-feijão única instanciar quando você chamar getBean () método, enquanto ApplicationContext instancia Singleton feijão quando o recipiente é iniciado, ele não espera que getBean a ser chamado.

b.

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

ou

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

Você pode usar um ou mais arquivos xml dependendo da sua exigência projeto. Como eu estou aqui, usando dois arquivos xml ou seja, uma para detalhes de configuração para outros para as classes DAO classes de serviço. Aqui ClassPathXmlApplicationContext é filho de ApplicationContext.

c. BeanFactory Container é recipiente básico, ele só pode criar objetos e injetar dependências. Mas não pode anexar outros serviços como segurança, transações, mensagens etc. para fornecer todos os serviços que temos para usar ApplicationContext Container.

d. não BeanFactory não fornece suporte para internacionalização ou seja i18n mas ApplicationContext fornece suporte para ele.

e. não BeanFactory Container não suporta a funcionalidade de pesquisa automática (Suporte de anotação com base injeção de dependência), mas suportes ApplicationContext recipiente.

f. BeanFactory Container não irá criar um objeto de feijão até a hora do pedido. Significa BeanFactory contentores cargas feijão preguiçosamente. Enquanto ApplicationContext recipiente cria objectos de Singleton feijão no momento de carregar única. Isso significa que há carga precoce.

g. BeanFactory Container apoiar apenas dois âmbitos (únicas e protótipos) dos grãos. Mas ApplicationContext Container suporta todo o escopo feijão.

Consulte este documento a partir da Primavera 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 ou ApplicationContext?

Use um ApplicationContext menos que você tenha uma boa razão para não fazê-lo.

Porque o ApplicationContext inclui todas as funcionalidades do BeanFactory, recomenda-se geralmente sobre o BeanFactory, com exceção de algumas situações, como em um applet, onde o consumo de memória pode ser crítico e alguns kilobytes extras podem fazer a diferença. No entanto, para a maioria dos aplicativos e sistemas empresariais típicas, o ApplicationContext é o que você vai querer usar. Mola 2,0 e depois faz uso intensivo do ponto de extensão BeanPostProcessor (para efeito proxy e assim por diante). Se você usar apenas um BeanFactory simples, uma boa quantidade de apoio, tais como transações e AOP não terá efeito, pelo menos não sem alguns passos extra de sua parte. Esta situação pode ser confuso porque nada está realmente errado com a configuração.

ApplicationContext é um grande irmão de BeanFactory e isso tudo coisa que BeanFactory são fornecer além de muitas outras coisas.

Além de capacidades de ciclo de vida org.springframework.beans.factory.BeanFactory padrão, implementações applicationContext detectar e invoke ApplicationContextAware feijão, bem como ResourceLoaderAware, ApplicationEventPublisherAware e MessageSourceAware feijão.

Em um cenário em tempo real, a diferença entre o contêiner do Spring IOC Núcleo (BeanFactory) e recipiente J2EE Avançado (ApplicationContext) são os seguintes.

BeanFactory irá criar objetos para os grãos (ou seja, para as classes POJO) mencionados no arquivo spring.xml (<bean></bean>) somente quando você chamar o método .getBean (), mas que ApplicationContext cria os objetos para toda a feijão (<bean></bean> se o seu alcance não é explicitamente mencionada como "Prototype") configurado no spring.xml ao carregar o arquivo spring.xml si.

BeanFactory: (preguiçoso contêiner porque ele cria os objetos para os grãos somente quando você chamar explicitamente do usuário da classe / main)

/* * 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: (container Ansioso por causa de criar os objetos de todos os grãos únicas ao carregar o arquivo em si spring.xml)

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

Tecnicamente, usando ApplicationContext é recomendado porque em aplicações em tempo real, os objetos de feijão será criado enquanto o aplicativo está começando no próprio servidor. Isso reduz o tempo de resposta para a solicitação do usuário como os objetos já estão disponíveis para responder.

Eu acho que vale a pena mencionar que desde Spring 3, se você quiser criar uma fábrica, você também pode usar o @configuration anotação combinada com o bom @scope

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

Sua fábrica deve ser visível pelo contêiner do Spring usando o @ComponentScan anotação ou xml de configuração

Primavera feijão escopos a partir do site baeldung

fazer uso BeanFactory para aplicações não-web, porque ele suporta apenas Singleton e Protótipo de feijão-âmbitos.

Enquanto ApplicationContext recipiente suporta todos os feijão-âmbitos para que você deve usá-lo para aplicações web.

Em resumo:

O ApplicationContext inclui todas as funcionalidades do BeanFactory. É geralmente recomendado para usar o antigo.

Existem algumas situações limitadas, como em um aplicativo de Mobile, onde o consumo de memória pode ser crítico.

Em que cenários, pode ser justificável para usar o mais leve BeanFactory . No entanto, nas aplicações mais corporativas, o ApplicationContext é o que você vai querer usar.

Para mais informações, consulte o meu blog:

Diferença entre BeanFactory e ApplicationContext na Primavera - blog primavera O java desde o básico

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow