BeanFactory ve ApplicationContext

Spring Framework için oldukça yeniyim, onunla oynuyorum ve bir sonraki şirket projesinde kullanmak için Spring MVC'yi değerlendirmek amacıyla birkaç örnek uygulamayı bir araya getiriyorum. Şimdiye kadar Spring MVC'de gördüğüm şeylerden gerçekten hoşlanıyorum, kullanımı çok kolay görünüyor ve çok birim test dostu sınıflar yazmaya teşvik ediyor.

Bir alıştırma olarak, örnek / test projelerimden biri için ana bir yöntem yazıyorum. Hakkında belirsiz olduğum bir şey BeanFactoryve ApplicationContext- arasındaki kesin farklar - hangi koşullarda hangi koşullarda kullanılmaya uygun?

Anlıyorum ApplicationContextuzanır BeanFactory, ama sadece basit bir ana yöntem yazıyorum, ben ekstra işlevsellik gerekiyor ApplicationContextsağlar? Ve tam olarak ne tür ekstra işlevsellik ApplicationContextsağlıyor?

"Bir main () yönteminde hangisini kullanmalıyım" yanıtı vermenin yanı sıra, böyle bir senaryoda hangi uygulamayı kullanmam gerektiğine dair standartlar veya yönergeler var mı? Ana () yöntemimin XML biçiminde olması gereken fasulye / uygulama yapılandırmasına bağlı olarak yazılması gerekir mi - bu güvenli bir varsayım mı yoksa kullanıcıyı belirli bir şeye kilitliyor muyum?

Ve bu cevap bir web ortamında değişiyor mu - sınıflarımdan herhangi birinin Bahar'ın farkında olması gerekiyorsa, daha çok ihtiyaç duyuyorlar ApplicationContextmı?

Herhangi bir yardım için teşekkürler. Bu soruların çoğunun muhtemelen referans kılavuzunda cevaplandığını biliyorum, ancak bu iki arayüzün ve her birinin artılarını / eksilerini ince dişli bir tarakla kılavuzu okumadan net bir şekilde bulmakta zorlanıyorum.

Bahar belgeleri bu konuda harika: 3.8.1. BeanFactory veya ApplicationContext? . Karşılaştırma ile bir tablo var, ben bir snippet göndereceğim:

Fasulye Fabrikası

• Fasulye örnekleme / kablolama

Uygulama Bağlamı

• Fasulye örnekleme / kablolama
• Otomatik BeanPostİşlemci kaydı
• Otomatik BeanFactoryPostİşlemci kaydı
• Kaynak erişimi (i18n için)
• ApplicationEvent yayını

Dolayısıyla, Uygulama Bağlamı tarafında sunulan noktalardan herhangi birine ihtiyacınız varsa, ApplicationContext'i kullanmalısınız.

Yay, IOC kabın iki çeşit biri XMLBeanFactoryve diğeri 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 Fasulye tam yol boyunca yüklü.
• ClassPathXmlApplicationContext CLASSPATH aracılığıyla yüklenen fasulye
• XMLWebApplicationContextve AnnotationConfigWebApplicationContextweb uygulaması bağlamında yüklenen fasulye.
• AnnotationConfigApplicationContext Ek açıklama tabanlı yapılandırmadan bahar fasulyeleri yükleniyor.

misal:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextbir ile başlatıldı kaptır ContextLoaderListenerveya ContextLoaderServletbir tanımlandığı web.xmlve ContextLoaderPlugintanımlanan struts-config.xml.

Not : XmlBeanFactorybir kullanımdan kaldırılmış lehine Bahar 3.1 itibariyle DefaultListableBeanFactoryve XmlBeanDefinitionReader.

Bana göre seçmek için temel fark BeanFactoryüzerinde ApplicationContextolduğu görülmektedir ApplicationContextönceden örneği oluşturulmaz fasulye tüm. Gönderen Bahar docs :

Yay, fasulye gerçekte oluşturulduğunda özellikleri ayarlar ve bağımlılıkları mümkün olduğunca geç çözer. Bu, doğru şekilde yüklenen bir Bahar kapsayıcısının, o nesneyi veya bağımlılıklarından birini oluştururken bir sorun olduğunda bir nesne isteğinde bulunduğunuzda daha sonra bir istisna oluşturabileceği anlamına gelir. Örneğin, fasulye eksik veya geçersiz bir özellik nedeniyle bir istisna atar. Bazı yapılandırma sorunlarının bu potansiyel olarak gecikmiş görünürlüğü, ApplicationContext uygulamalarının neden varsayılan olarak önceden tekil çekirdekler oluşturduğudur. Bu çekirdeklerin gerçekten ihtiyaç duyulmadan önce oluşturulması için belirli bir zaman ve bellek pahasına, daha sonra değil, ApplicationContext oluşturulduğunda yapılandırma sorunlarını keşfedersiniz. Yine de bu varsayılan davranışı geçersiz kılabilirsiniz, böylece tekli çekirdekler önceden başlatılmak yerine tembel olarak başlatılır.

Bu göz önüne alındığında, başlangıçta BeanFactoryentegrasyon / performans testlerinde kullanmayı seçtim çünkü izole edilmiş çekirdekleri test etmek için tüm uygulamayı yüklemek istemedim. Ancak - ve yanılıyorsam birisi beni düzeltiyor - XML yapılandırmasını BeanFactorydesteklemiyor classpath. Yani BeanFactoryve ApplicationContexther istediğim çok önemli bir özelliği sağlayan, ama ikisi de beraber yaptık.

Anlayabildiğim gibi, varsayılan örnekleme davranışını geçersiz kılma hakkındaki belgelerdeki not yapılandırmada gerçekleşir ve bu fasulye başınadır, bu yüzden XML dosyasındaki "tembel init" özniteliğini ayarlayamıyorum veya test için bir sürüm ve dağıtım için bir sürüm korunmuş.

Ne kadar sona erdi ClassPathXmlApplicationContextböyle testlerde kullanılmak üzere tembel fasulye yüklemek için uzanan oldu:

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

}

Miguel Ping'in yanıtlarını eklemek için , dokümantasyonda buna cevap veren başka bir bölüm daha var :

Kısa sürüm: Bunu yapmamak için gerçekten iyi bir nedeniniz yoksa bir ApplicationContext kullanın. Yukarıdaki tavsiyenin 'ama nedenine' göre biraz daha derinlik arayanlar için okumaya devam edin.

(bunu, bu soruyu okuyabilecek gelecekteki herhangi bir Bahar acemi için yayınlamak)

1. ApplicationContext daha çok tercih edilen yol BeanFactory

2. Yeni Bahar sürümleri BeanFactoryile değiştirilir ApplicationContext. Ancak BeanFactorygeriye dönük uyumluluk için hala var

3. ApplicationContext extends BeanFactory ve aşağıdaki faydaları vardır
   • metin mesajları için uluslararasılaştırmayı destekler
   • kayıtlı dinleyicilere olay yayınını destekler
   • URL'ler ve dosyalar gibi kaynaklara erişim

ApplicationContext: Yay yapılandırma dosyasında yapılandırılmış bahar fasulyelerini yükler ve bahar fasulyesinin yaşam döngüsünü ve KONTEYNER BAŞLARKEN gibi yönetir. GetBean ("springbeanref") çağrılıncaya kadar beklemez .

BeanFactory dediğimiz zaman bahar yapılandırma dosyasında yapılandırılmış yükler bahar fasulye, bahar fasulye yaşam döngüsünü yöneten ( "springbeanref") getBean oldu.February.Meanwhile çağırdığınızda ( "springbeanref") getBean bahar fasulye yaşam döngüsü başlar sırasında .

Başkalarının söylediği gibi mobil bir ortamda değilseniz, her zaman ApplicationContext'i kullanmak daha iyi olur. ApplicationContext daha fazla işlevselliğe sahiptir ve kesinlikle Bahar yapılandırma dosyalarınızı basitleştirmenize yardımcı olacak RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor ve CommonAnnotationBeanPostProcessor gibi PostProcessors'ları kullanmak istersiniz ve @Required, @PostConstruct, fasulye, @Res gibi ek açıklamaları kullanabilirsiniz. .

ApplicationContext'in sunduğu tüm şeyleri kullanmasanız bile, yine de kullanmak daha iyidir ve daha sonra mesajlar veya posta işlemcileri gibi bazı kaynak şeyleri veya işlem önerileri eklemek için diğer şemaları kullanmaya karar verirseniz, zaten bir ApplicationContext'e sahip olacak ve herhangi bir kodu değiştirmeniz gerekmeyecek.

Tek başına bir uygulama yazıyorsanız, bir ClassPathXmlApplicationContext kullanarak ApplicationContext'i ana yönteminize yükleyin ve ana fasulyeyi alın ve uygulamanızı başlatmak için run () (veya herhangi bir yöntem) çağırın. Bir web uygulaması yazıyorsanız, ApplicationContext'i oluşturması için web.xml dosyasında ContextLoaderListener kullanın ve JSP, JSF, JSTL, payandalar, Goblen vb. .

Ayrıca, birden çok Spring yapılandırma dosyası kullanabileceğinizi ve yapıcıdaki tüm dosyaları listeleyerek (veya ContextLoaderListener için bağlam parametresinde listeleyerek) ApplicationContext'i oluşturabileceğinizi veya yalnızca bir ana yapılandırma dosyası yükleyebileceğinizi unutmayın. ithalat beyanları. Bir Spring yapılandırma dosyasını başka bir Spring yapılandırma dosyasına, <import resource = "otherfile.xml" /> komutunu kullanarak ana yöntemde ApplicationContext'i program aracılığıyla oluşturduğunuzda ve yalnızca bir Spring config dosyası yüklediğinizde çok yararlı olabilir.

Çoğunlukla, bir mobil uygulama gibi kaynakları kaydetmeniz gerekmedikçe ApplicationContext tercih edilir.

XML biçimine bağlı olduğundan emin değilim, ancak ApplicationContext'in en yaygın uygulamaları ClassPathXmlApplicationContext, XmlWebApplicationContext ve FileSystemXmlApplicationContext gibi XML olanlar olduğundan eminim. Bunlar benim şimdiye kadar kullandığım üç.

Bir web uygulaması geliştiriyorsanız, XmlWebApplicationContext'i kullanmanız gerektiğini söyleyebiliriz.

Fasulyelerinizin Spring'den haberdar olmasını istiyorsanız, bunun için BeanFactoryAware ve / veya ApplicationContextAware uygulamalarını sağlayabilirsiniz, böylece BeanFactory veya ApplicationContext'i kullanabilir ve hangi arabirimin uygulanacağını seçebilirsiniz.

BeanFactory ve ApplicationContext arasındaki fark aşağıdaki gibidir:

1. BeanFactory tembel başlatma kullanır ancak ApplicationContext istekli başlatma kullanır. BeanFactory durumunda, getBeans () yöntemini çağırdığınızda fasulye oluşturulur, ancak ApplicationContext nesnesi oluşturulduğunda ApplicationContext durumunda fasulye önceden oluşturulur.
2. BeanFactory açıkça sözdizimi kullanarak bir kaynak nesnesi sağlar, ancak ApplicationContext kendi başına kaynak nesneleri oluşturur ve yönetir.
3. BeanFactory uluslararasılaştırmayı desteklemiyor ancak ApplicationContext uluslararasılaştırmayı destekliyor.
4. BeanFactory ile ek açıklama tabanlı bağımlılık enjeksiyonu desteklenmez ancak ek açıklama tabanlı bağımlılık enjeksiyonu ApplicationContext'te desteklenir.

BeanFactory Kullanımı:

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

ApplicationContext Kullanımı:

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

BeanFactory ve ApplicationContext'in her ikisi de bahar IOC kabınızdan fasulye almanın yollarıdır, ancak yine de bazı farklar vardır.

BeanFactory , bir dizi fasulyeyi başlatan, konfigüre eden ve yöneten gerçek konteynerdir. Bu fasulye tipik olarak birbirleriyle işbirliği yapar ve bu nedenle kendi aralarında bağımlılıklar gösterir. Bu bağımlılıklar BeanFactory tarafından kullanılan yapılandırma verilerine yansıtılır.

BeanFactory ve ApplicationContext'in her ikisi de Java arabirimleridir ve ApplicationContext BeanFactory'yi genişletir. Her ikisi de XML yapılandırma dosyalarını kullanan yapılandırmadır. Kısacası BeanFactory temel İnversiyon Kontrol ( IoC ) ve Bağımlılık Enjeksiyonu ( DI ) özelliklerini sunarken, ApplicationContext gelişmiş özellikler sunar.

Bir BeanFactory, " org.springframework.beans.factory " arabirimi ile temsil edilir. Burada BeanFactory, burada birden fazla uygulama vardır.

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

FARKI

1. BeanFactory getBean () yöntemini çağırdığınızda bean Bean örnek örneğini kapsayıcı başlatıldığında ApplicationContext instantiate Singleton fasulyesi, getBean () işlevinin çağrılmasını beklemez.

2. BeanFactory uluslararasılaşma için destek sağlamaz, ancak ApplicationContext destek sağlar.

3. BeanFactory ile ApplicationContext arasındaki diğer bir fark da olayı dinleyici olarak kaydedilen fasulyelere yayınlama yeteneğidir.

4. Popüler uygulanması biri BeanFactory arayüzüne olan XMLBeanFactory popüler uygulamalarından biridir iken ApplicationContext arayüzüne olan ClassPathXmlApplicationContext .

5. Otomatik kablolama kullanıyorsanız ve BeanFactory kullanıyorsanız, ApplicationContext kullanıyorsanız XML'de yapılandırabileceğiniz API kullanarak AutoWiredBeanPostProcessor'ı kaydettirmeniz gerekir . Özetle BeanFactory test ve üretim dışı kullanım için uygundur, ancak ApplicationContext daha zengin özelliklere sahip konteyner uygulamasıdır ve BeanFactory'e tercih edilmelidir.

6. BeanFactory varsayılan olarak Tembel yüklemeyi ve ApplicationContext'i varsayılan olarak Agresif yüklemeyi destekler .

Fasulye Fabrikası ve Bahar Dokümanlarından Kaynaklanan Uygulama Bağlamının Özellik Matrisi

_{BeanFacotry ve ApplicationContext özelliklerinin ekran görüntüsü}

a. Fasulye fabrikası ve uygulama bağlamı arasındaki bir fark, konteyner başlatıldığında ApplicationContext Singleton fasulyesini başlatırken getBean () yöntemini çağırdığınızda eski yalnızca somut fasulyeyi oluşturmasıdır, getBean'in çağrılmasını beklemez.

b.

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

veya

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

Proje gereksiniminize bağlı olarak bir veya daha fazla xml dosyası kullanabilirsiniz. Burada iki xml dosyası kullanıyorum, yani dao sınıfları için diğer servis sınıfları için yapılandırma ayrıntıları. Burada ClassPathXmlApplicationContext ApplicationContext öğesinin alt öğesidir.

c. BeanFactory Konteyner temel konteyner, sadece nesneler oluşturabilir ve Bağımlılıklar enjekte edebilir. Ancak, ApplicationContext Container'ı kullanmamız gereken tüm hizmetleri sağlamak için güvenlik, işlem, mesajlaşma vb. Diğer hizmetleri ekleyemeyiz.

d. BeanFactory, i18n gibi uluslararasılaştırma için destek sağlamaz, ancak ApplicationContext destek sağlar.

e. BeanFactory Container, Otomatik Tarama (Destek Ek Açıklama tabanlı bağımlılık Enjeksiyonu) özelliğini desteklemez, ancak ApplicationContext Container'ı destekler.

f. Beanfactory Container, istek süresine kadar bir fasulye nesnesi oluşturmaz. Beanfactory Container'ın fasulyeleri tembel olarak yüklediği anlamına gelir. ApplicationContext Container yalnızca yükleme sırasında Singleton fasulyesi nesneleri oluştururken. Bu, erken yükleme olduğu anlamına gelir.

g. Beanfactory Konteyner fasulyenin sadece iki kapsamını (singleton ve prototip) destekler. Ancak ApplicationContext Container tüm fasulye kapsamını destekler.

Temelde yay kabı nesnesi iki şekilde oluşturabiliriz

1. BeanFactory kullanarak.
2. ApplicationContext kullanarak.

ikisi de arayüzler,

uygulama sınıflarını kullanarak yaylı konteyner için nesne oluşturabiliriz

farklılıklara gelmek

Fasulye Fabrikası:

1. Ek Açıklama tabanlı bağımlılık Enjeksiyonunu desteklemez.

2. I18N'yi desteklemez.

3. Varsayılan olarak tembel yükleme desteği.

4. birden çok yapılandırma dosyasına yapılandırmaya izin vermez.

örnek: BeanFactory bağlamı = new XmlBeanFactory (new Resource ("applicationContext.xml"));

ApplicationContext

1. Ek Açıklama tabanlı bağımlılık Enjeksiyonunu destekleyin. --@ AutoWired, @PreDestroy

2. Destek I18N

3. Onun varsayılan olarak Agresif yükleme destekler.

4. Birden fazla yapılandırma dosyasının yapılandırılmasına izin verir.

ör .:
ApplicationContext context = new ClasspathXmlApplicationContext ("applicationContext.xml");

Spring Docs'tan bu dokümana bakın:

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

5.15.1 BeanFactory veya ApplicationContext?

Bunu yapmamak için iyi bir nedeniniz yoksa bir ApplicationContext kullanın.

ApplicationContext BeanFactory'nin tüm işlevlerini içerdiğinden, bellek tüketiminin kritik olabileceği ve fazladan birkaç kilobaytın fark yaratabileceği bir Applet gibi birkaç durum haricinde, genellikle BeanFactory üzerinden önerilir. Ancak, çoğu kurumsal uygulama ve sistem için, ApplicationContext kullanmak isteyeceğiniz şeydir. Spring 2.0 ve üstü BeanPostProcessor uzatma noktasını yoğun olarak kullanır (vekil sunucuyu etkilemek vb.). Yalnızca düz bir BeanFactory kullanıyorsanız, işlemler ve AOP gibi adil bir destek, en azından sizin tarafınızdan fazladan bir adım atılmadan etkili olmayacaktır. Yapılandırmada hiçbir şey yanlış olmadığı için bu durum kafa karıştırıcı olabilir.

ApplicationContext BeanFactory'nin ağabeyidir ve BeanFactory'nin sağladığı her şey artı birçok şey sağlar.

Standart org.springframework.beans.factory.BeanFactory yaşam döngüsü özelliklerine ek olarak, ApplicationContext uygulamaları ApplicationContextAware çekirdeklerinin yanı sıra ResourceLoaderAware, ApplicationEventPublisherAware ve MessageSourceAware çekirdeklerini algılar ve çağırır.

Gerçek zamanlı bir senaryoda, Spring IOC Core konteyneri (BeanFactory) ve Advanced J2EE konteyneri (ApplicationContext) arasındaki fark aşağıdaki gibidir.

1. BeanFactory, <bean></bean>yalnızca .getBean () yöntemini çağırdığınızda spring.xml dosyasında () belirtilen fasulye için (yani POJO sınıfları için) nesneler oluşturur, ancak ApplicationContext tüm çekirdekler için nesneleri ( <bean></bean>kapsamı değilse) oluşturur. açıkça "Prototip" olarak belirtilir) spring.xml dosyasını yüklerken spring.xml dosyasında yapılandırılır.

2. BeanFactory: (Sadece kullanıcı / ana sınıftan açıkça aradığınızda fasulye için nesneler oluşturduğu için tembel konteyner)

   /*
    * 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 dosyasının kendisini yüklerken tüm singleton çekirdeklerinin nesnelerini oluşturduğu için kapsayıcı istekli)

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

3. Teknik olarak, gerçek zamanlı uygulamalarda, uygulama sunucuda başlatılırken fasulye nesneleri oluşturulacağından ApplicationContext kullanılması önerilir. Bu, nesneler zaten yanıt vermeye hazır olduğundan, kullanıcı isteğinin yanıt süresini azaltır.

Bahar 3'ten beri, bir fabrika oluşturmak istiyorsanız, @configurationek açıklamaları uygun@scope

@Configuration
public class MyFactory {

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

Fabrikanız @ComponentScanek açıklama veya xml yapılandırmasını kullanarak Spring konteyner tarafından görülebilir olmalıdır

Baeldung sitesinden bahar fasulyesi kapsamları

yalnızca Singleton ve Prototip fasulye kapsamlarını desteklediğinden BeanFactory'yi web dışı uygulamalar için kullanın.

ApplicationContext kapsayıcısı tüm fasulye kapsamlarını desteklerken web uygulamaları için kullanmalısınız.

Özetle:

ApplicationContext BeanFactory tüm işlevleri kapsamaktadır. Genellikle öncekinin kullanılması önerilir.

Bellek tüketiminin kritik olabileceği Mobil uygulama gibi bazı sınırlı durumlar vardır.

Bu senaryolarda, daha hafif BeanFactory kullanmak haklı olabilir . Ancak, çoğu kurumsal uygulamada, ApplicationContext kullanmak istediğiniz .

Daha fazla bilgi için blog gönderime bakın:

İlkbaharda BeanFactory ve ApplicationContext arasındaki fark - Temel bilgilerden java bahar blogu

BeanFactory & ApplicationContext'i açıklamam gerekiyor.

BeanFactory: BeanFactory, SpringBean Container'a erişmek için kök arabirimdir. Bean konteynerin temel istemci görünümü vardır. Bu arabirim, fasulye tanımlarının sayısını tutan nesne sınıfı tarafından uygulanır ve her biri Dize adıyla benzersiz olarak tanımlanır
Bean tanımına bağlı olarak fabrika, bu örneğin içerilen nesnenin örneği veya tek bir paylaşılan örnek olabileceği örneğini döndürür. Hangi örnek türünün döndürüleceği fasulye fabrikası yapılandırmasına bağlıdır.
Normalde Bean fabrikası, XML ... vb. Gibi yapılandırma kaynağında depolanan tüm fasulye tanımlarını yükleyecektir.

BeanFactory, Bağımlılık Enjeksiyonu için temel desteği sağlayan en basit bir kaptır

Uygulama Bağlamı Uygulama bağlamı, yay uygulamasında uygulamaya yapılandırma bilgilerini sağlayan merkezi bir arabirimdir. Fasulye Fabrikası Arayüzünü uygular.

Uygulama bağlamı, metin iletisini özellik dosyasından çözme yeteneği gibi kuruluşa özgü işlevsellik eklemek için bir ileri kapsayıcıdır .... vb

Bir ApplicationContext şunları sağlar:

Uygulama bileşenlerine erişmek için fasulye fabrikası yöntemleri. ListableBeanFactory'den devralındı. Dosya kaynaklarını genel bir şekilde yükleme yeteneği. ResourceLoader arabiriminden devralındı. Kayıtlı dinleyicilere olay yayınlama yeteneği. ApplicationEventPublisher arabiriminden devralındı. Uluslararasılaşmayı destekleyerek mesajları çözme becerisi. MessageSource arabiriminden devralındı. Üst bağlamdan kalıtım. Torun bağlamındaki tanımlar her zaman öncelikli olacaktır. Bu, örneğin, tek bir üst bağlamın tüm bir web uygulaması tarafından kullanılabileceği anlamına gelirken, her sunucu uygulamasının, diğer herhangi bir sunucu uygulamasından bağımsız olan kendi alt içeriği vardır. Standart BeanFactory yaşam döngüsü özelliklerine ek olarak,