BeanFactory vs ApplicationContext

Saya cukup baru di Spring Framework, saya telah bermain-main dengannya dan menyatukan beberapa contoh aplikasi untuk keperluan mengevaluasi Spring MVC untuk digunakan dalam proyek perusahaan yang akan datang. Sejauh ini saya sangat menyukai apa yang saya lihat di Spring MVC, tampaknya sangat mudah digunakan dan mendorong Anda untuk menulis kelas yang sangat ramah uji unit.

Sama seperti latihan, saya menulis metode utama untuk salah satu proyek sampel / uji saya. Satu hal yang saya tidak jelas adalah perbedaan tepat antara BeanFactorydan ApplicationContext- mana yang tepat untuk digunakan dalam kondisi apa?

Saya mengerti itu ApplicationContextmeluas BeanFactory, tetapi jika saya hanya menulis metode utama yang sederhana, apakah saya memerlukan fungsionalitas tambahan yang ApplicationContextmenyediakan? Dan persisnya, apa fungsi tambahan yang ApplicationContextdisediakan?

Selain menjawab "yang harus saya gunakan dalam metode main ()", apakah ada standar atau pedoman sejauh mana implementasi yang harus saya gunakan dalam skenario seperti itu? Haruskah metode () utama saya ditulis bergantung pada konfigurasi kacang / aplikasi dalam format XML - apakah itu asumsi yang aman, atau apakah saya mengunci pengguna menjadi sesuatu yang spesifik?

Dan apakah jawaban ini berubah dalam lingkungan web - jika ada kelas saya yang perlu mengetahui Spring, apakah mereka lebih membutuhkan ApplicationContext?

Terima kasih atas bantuannya. Saya tahu banyak dari pertanyaan-pertanyaan ini mungkin dijawab dalam manual referensi, tetapi saya mengalami kesulitan menemukan kerusakan yang jelas dari kedua antarmuka ini dan pro / kontra dari masing-masing tanpa membaca melalui manual dengan sisir bergigi halus.

Dokumen musim semi sangat bagus dalam hal ini: 3.8.1. BeanFactory atau ApplicationContext? . Mereka memiliki tabel dengan perbandingan, saya akan memposting cuplikan:

Pabrik Kacang

• Instansiasi kacang / kabel

Konteks Aplikasi

• Instansiasi kacang / kabel
• Registrasi BeanPostProcessor otomatis
• Registrasi BeanFactoryPostProcessor otomatis
• Akses MessageSource yang nyaman (untuk i18n)
• Publikasi ApplicationEvent

Jadi, jika Anda memerlukan salah satu poin yang disajikan pada sisi Konteks Aplikasi, Anda harus menggunakan ApplicationContext.

Spring menyediakan dua jenis wadah IOC, satu adalah XMLBeanFactorydan yang lainnya 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 Kacang dimuat melalui jalur penuh.
• ClassPathXmlApplicationContext Kacang dimuat melalui CLASSPATH
• XMLWebApplicationContextdan AnnotationConfigWebApplicationContextkacang dimuat melalui konteks aplikasi web.
• AnnotationConfigApplicationContext Memuat kacang Spring dari konfigurasi berbasis Annotation.

contoh:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextadalah wadah yang diinisialisasi oleh ContextLoaderListeneratau ContextLoaderServletdidefinisikan dalam web.xmldan ContextLoaderPlugindidefinisikan dalam struts-config.xml.

Catatan : XmlBeanFactorysudah usang pada Spring 3.1 untuk DefaultListableBeanFactorydan XmlBeanDefinitionReader.

Bagi saya, perbedaan utama untuk memilih BeanFactorylebih ApplicationContexttampaknya bahwa ApplicationContextakan pra-instantiate semua biji. Dari yang semi docs :

Spring menetapkan properti dan menyelesaikan dependensi selambat mungkin, ketika kacang benar-benar dibuat. Ini berarti bahwa wadah Spring yang telah dimuat dengan benar nanti dapat menghasilkan pengecualian ketika Anda meminta objek jika ada masalah membuat objek itu atau salah satu dari dependensinya. Misalnya, kacang melempar pengecualian sebagai akibat dari properti yang hilang atau tidak valid. Visibilitas yang berpotensi tertunda ini dari beberapa masalah konfigurasi adalah mengapa implementasi ApplicationContext secara default pre-instantiate singleton beans Dengan mengorbankan beberapa waktu di muka dan memori untuk membuat kacang ini sebelum benar-benar dibutuhkan, Anda menemukan masalah konfigurasi saat ApplicationContext dibuat, tidak lebih baru. Anda masih bisa mengesampingkan perilaku default ini sehingga kacang singleton akan malas-inisialisasi, daripada pre-instantiated.

Mengingat ini, saya awalnya memilih BeanFactoryuntuk digunakan dalam tes integrasi / kinerja karena saya tidak ingin memuat seluruh aplikasi untuk menguji kacang yang terisolasi. Namun - dan seseorang mengoreksi saya jika saya salah - BeanFactorytidak mendukung classpathkonfigurasi XML. Jadi BeanFactorydan ApplicationContextmasing - masing memberikan fitur penting yang saya inginkan, tetapi tidak keduanya.

Hampir seperti yang saya tahu, catatan dalam dokumentasi tentang mengesampingkan perilaku instantiasi default terjadi dalam konfigurasi, dan itu per-kacang, jadi saya tidak bisa hanya menetapkan atribut "lazy-init" dalam file XML atau saya macet mempertahankan versi untuk pengujian dan satu untuk penerapan.

Apa yang akhirnya saya lakukan adalah memperluas ClassPathXmlApplicationContextdengan malas memuat kacang untuk digunakan dalam tes seperti:

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

}

Untuk menambahkan apa yang dijawab Miguel Ping, berikut adalah bagian lain dari dokumentasi yang menjawab ini juga:

Versi singkat: gunakan ApplicationContext kecuali Anda memiliki alasan yang sangat bagus untuk tidak melakukannya. Bagi Anda yang mencari sedikit lebih dalam mengenai 'tapi mengapa' dari rekomendasi di atas, terus membaca.

(memposting ini untuk pemula Musim Semi mendatang yang mungkin membaca pertanyaan ini)

1. ApplicationContext lebih disukai daripada BeanFactory

2. Dalam versi Spring baru BeanFactorydiganti dengan ApplicationContext. Tetapi masih BeanFactoryada untuk kompatibilitas ke belakang

3. ApplicationContext extends BeanFactory dan memiliki manfaat sebagai berikut
   • ini mendukung internasionalisasi untuk pesan teks
   • mendukung publikasi acara untuk pendengar terdaftar
   • akses ke sumber daya seperti URL dan file

ApplicationContext: Ini memuat kacang musim semi yang dikonfigurasikan dalam file konfigurasi pegas, dan mengelola siklus hidup kacang musim semi seperti dan KAPAN MULAI KONTAINER. Itu tidak akan menunggu sampai getBean ("springbeanref") dipanggil.

BeanFactory Ini memuat spring bean yang dikonfigurasikan dalam file konfigurasi pegas, mengelola siklus hidup bean spring ketika kita memanggil getBean ("springbeanref") . Jadi ketika kita memanggil getBean ("springbeanref") pada saat siklus hidup spring spring dimulai .

Saya pikir lebih baik untuk selalu menggunakan ApplicationContext, kecuali Anda berada di lingkungan seluler seperti yang sudah dikatakan orang lain. ApplicationContext memiliki lebih banyak fungsi dan Anda pasti ingin menggunakan PostProcessors seperti RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor dan CommonAnnotationBeanPostProcessor, yang akan membantu Anda menyederhanakan file konfigurasi Spring Anda, dan Anda dapat menggunakan anotasi seperti @Required, @Postcontruct, @rac sumber .

Bahkan jika Anda tidak menggunakan semua hal yang ditawarkan ApplicationContext, lebih baik tetap menggunakannya, dan kemudian jika Anda memutuskan untuk menggunakan beberapa hal sumber daya seperti pesan atau pemroses pos, atau skema lain untuk menambahkan saran transaksional dan semacamnya, Anda sudah memiliki ApplicationContext dan tidak perlu mengubah kode apa pun.

Jika Anda menulis aplikasi mandiri, muat ApplicationContext dalam metode utama Anda, menggunakan ClassPathXmlApplicationContext, dan dapatkan kacang utama dan aktifkan menjalankannya () (atau metode apa pun) untuk memulai aplikasi Anda. Jika Anda menulis aplikasi web, gunakan ContextLoaderListener di web.xml sehingga itu menciptakan ApplicationContext dan Anda nanti bisa mendapatkannya dari ServletContext, terlepas dari apakah Anda menggunakan JSP, JSF, JSTL, struts, Tapestry, dll. .

Juga, ingat Anda dapat menggunakan beberapa file konfigurasi Spring dan Anda dapat membuat ApplicationContext dengan mendaftar semua file dalam konstruktor (atau daftar mereka dalam konteks-param untuk ContextLoaderListener), atau Anda bisa memuat file konfigurasi utama yang memiliki pernyataan impor. Anda dapat mengimpor file konfigurasi Spring ke file konfigurasi Spring lainnya dengan menggunakan <import resource = "otherfile.xml" /> yang sangat berguna ketika Anda secara pemrograman membuat ApplicationContext dalam metode utama dan memuat hanya satu file konfigurasi Spring.

Untuk sebagian besar, ApplicationContext lebih disukai kecuali jika Anda perlu menghemat sumber daya, seperti pada aplikasi seluler.

Saya tidak yakin tentang tergantung pada format XML, tapi saya cukup yakin implementasi yang paling umum dari ApplicationContext adalah yang XML seperti ClassPathXmlApplicationContext, XmlWebApplicationContext, dan FileSystemXmlApplicationContext. Hanya itulah tiga yang pernah saya gunakan.

Jika Anda mengembangkan aplikasi web, aman untuk mengatakan Anda harus menggunakan XmlWebApplicationContext.

Jika Anda ingin agar kacang Anda menyadari Spring, Anda dapat meminta mereka mengimplementasikan BeanFactoryAware dan / atau ApplicationContextAware untuk itu, sehingga Anda dapat menggunakan BeanFactory atau ApplicationContext dan memilih antarmuka mana yang akan diterapkan.

Perbedaan antara BeanFactory dan ApplicationContext adalah sebagai berikut:

1. BeanFactory menggunakan inisialisasi malas tetapi ApplicationContext menggunakan inisialisasi bersemangat. Dalam kasus BeanFactory, kacang dibuat ketika Anda memanggil metode getBeans (), tetapi kacang dibuat di muka dalam kasus ApplicationContext ketika objek ApplicationContext dibuat.
2. BeanFactory secara eksplisit menyediakan objek sumber daya menggunakan sintaks tetapi ApplicationContext membuat dan mengelola objek sumber daya sendiri.
3. BeanFactory tidak mendukung internasionalisasi tetapi ApplicationContext mendukung internasionalisasi.
4. Dengan injeksi ketergantungan berbasis anotasi BeanFactory tidak didukung tetapi injeksi ketergantungan berbasis anotasi didukung di ApplicationContext.

Menggunakan BeanFactory:

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

Menggunakan ApplicationContext:

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

BeanFactory dan ApplicationContext keduanya adalah cara untuk mendapatkan kacang dari wadah IOC musim semi Anda tetapi masih ada beberapa perbedaan.

BeanFactory adalah wadah aktual yang instantiate, mengkonfigurasi, dan mengelola sejumlah kacang. Kacang ini biasanya berkolaborasi satu sama lain, dan karenanya memiliki ketergantungan di antara mereka. Ketergantungan ini tercermin dalam data konfigurasi yang digunakan oleh BeanFactory.

BeanFactory dan ApplicationContext keduanya adalah antarmuka Java dan ApplicationContext meluas BeanFactory. Keduanya adalah konfigurasi menggunakan file konfigurasi XML. Singkatnya BeanFactory menyediakan fitur dasar Pembalikan Kontrol ( IoC ) dan Ketergantungan Injeksi ( DI ) sementara ApplicationContext menyediakan lanjutan fitur fitur .

BeanFactory diwakili oleh antarmuka " org.springframework.beans.factory " Di mana BeanFactory, yang di dalamnya terdapat beberapa implementasi.

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

PERBEDAAN

1. BeanFactory instantiate bean ketika Anda memanggil metode getBean () sementara ApplicationContext instantiate Singleton bean ketika wadah dimulai, Tidak perlu menunggu getBean () dipanggil.

2. BeanFactory tidak memberikan dukungan untuk internasionalisasi tetapi ApplicationContext menyediakan dukungan untuk itu.

3. Perbedaan lain antara BeanFactory vs ApplicationContext adalah kemampuan untuk mempublikasikan acara ke kacang yang terdaftar sebagai pendengar.

4. Salah satu implementasi populer antarmuka BeanFactory adalah XMLBeanFactory, sedangkan salah satu implementasi populer antarmuka ApplicationContext adalah ClassPathXmlApplicationContext .

5. Jika Anda menggunakan pengkabelan otomatis dan menggunakan BeanFactory daripada Anda harus mendaftar AutoWiredBeanPostProcessor menggunakan API yang dapat Anda konfigurasi dalam XML jika Anda menggunakan ApplicationContext . Singkatnya BeanFactory tidak apa-apa untuk pengujian dan penggunaan non produksi, tetapi ApplicationContext lebih mengutamakan implementasi fitur kontainer dan lebih disukai daripada BeanFactory.

6. BeanFactory secara default mendukung pemuatan Malas dan ApplicationContext secara default mendukung pemuatan Aggresive .

Matriks Fitur Bean Factory vs Konteks Aplikasi yang bersumber dari dokumen musim semi

_{Cuplikan layar fitur BeanFacotry dan ApplicationContext}

Sebuah. Satu perbedaan antara pabrik kacang dan konteks aplikasi adalah bahwa mantan hanya kacang instantiate ketika Anda memanggil metode getBean () sementara ApplicationContext instantiates kacang Singleton ketika wadah dimulai, Tidak menunggu getBean dipanggil.

b.

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

atau

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

Anda dapat menggunakan satu atau lebih file xml tergantung pada kebutuhan proyek Anda. Karena saya di sini menggunakan dua file xml yaitu satu untuk detail konfigurasi untuk kelas layanan lainnya untuk kelas dao. Di sini ClassPathXmlApplicationContext adalah anak dari ApplicationContext.

c. BeanFactory Container adalah wadah dasar, itu hanya dapat membuat objek dan menyuntikkan Ketergantungan. Tetapi kami tidak dapat melampirkan layanan lain seperti keamanan, transaksi, pengiriman pesan, dll. Untuk menyediakan semua layanan yang kami harus gunakan ApplicationContext Container.

d. BeanFactory tidak memberikan dukungan untuk internasionalisasi yaitu i18n tetapi ApplicationContext menyediakan dukungan untuk itu.

e. BeanFactory Container tidak mendukung fitur AutoScanning (Support ketergantungan berbasis Annotation Injection), tetapi ApplicationContext Container mendukung.

f. Beanfactory Container tidak akan membuat objek bean hingga waktu permintaan. Ini berarti Beanfactory Container memuat kacang dengan malas. Sedangkan ApplicationContext Container menciptakan objek kacang Singleton pada saat memuat saja. Artinya ada loading awal.

g. Beanfactory Container hanya mendukung dua cakupan (tunggal & prototipe) dari kacang. Tapi ApplicationContext Container mendukung semua ruang lingkup kacang.

Pada dasarnya kita dapat membuat objek penampung pegas dengan dua cara

1. menggunakan BeanFactory.
2. menggunakan ApplicationContext.

keduanya adalah antarmuka,

menggunakan kelas implementasi kita dapat membuat objek untuk wadah musim semi

datang ke perbedaan

BeanFactory:

1. Tidak mendukung Injeksi ketergantungan berbasis Anotasi.

2. Tidak Mendukung I18N.

3. Secara default, dukungannya memuat Malas.

4. itu tidak memungkinkan mengkonfigurasi ke beberapa file konfigurasi.

ex: BeanFactory context = new XmlBeanFactory (Sumber Daya baru ("applicationContext.xml"));

ApplicationContext

1. Mendukung Injeksi Ketergantungan Berbasis Anotasi.-@Autowired, @PreDestroy

2. Mendukung I18N

3. Secara default mendukung pemuatan Aggresive.

4. Ini memungkinkan untuk mengkonfigurasi beberapa file konfigurasi.

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

Rujuk dokumen ini dari Spring Documents:

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

5.15.1 BeanFactory atau ApplicationContext?

Gunakan ApplicationContext kecuali Anda punya alasan kuat untuk tidak melakukannya.

Karena ApplicationContext mencakup semua fungsionalitas BeanFactory, umumnya direkomendasikan atas BeanFactory, kecuali untuk beberapa situasi seperti di Applet di mana konsumsi memori mungkin kritis dan beberapa kilobyte tambahan mungkin membuat perbedaan. Namun, untuk sebagian besar aplikasi dan sistem perusahaan, ApplicationContext adalah apa yang ingin Anda gunakan. Spring 2.0 dan yang lebih baru menggunakan titik ekstensi BeanPostProcessor (untuk memengaruhi proxy dan sebagainya). Jika Anda hanya menggunakan BeanFactory, jumlah dukungan yang adil seperti transaksi dan AOP tidak akan berlaku, setidaknya tidak tanpa beberapa langkah tambahan di pihak Anda. Situasi ini dapat membingungkan karena sebenarnya tidak ada yang salah dengan konfigurasi.

ApplicationContext adalah kakak dari BeanFactory dan ini semua yang disediakan oleh BeanFactory plus banyak hal lainnya.

Selain kemampuan org.springframework.beans.factory.BeanFactory siklus hidup standar, implementasi ApplicationContext mendeteksi dan memohon kacang ApplicationContextAware serta ResourceLoaderAware, ApplicationEventPublisherAware, dan kacang MessageSourceAware.

Dalam skenario real-time, perbedaan antara wadah Core IOC Spring (BeanFactory) dan wadah J2EE Advanced (ApplicationContext) adalah sebagai berikut.

1. BeanFactory akan membuat objek untuk kacang (yaitu, untuk kelas POJO) yang disebutkan dalam file spring.xml ( <bean></bean>) hanya ketika Anda memanggil metode .getBean (), tetapi sedangkan ApplicationContext membuat objek untuk semua kacang ( <bean></bean>jika cakupannya tidak secara eksplisit disebutkan sebagai "Prototipe") yang dikonfigurasi dalam spring.xml saat memuat file spring.xml itu sendiri.

2. BeanFactory: (Wadah malas karena itu menciptakan objek untuk kacang hanya ketika Anda secara eksplisit memanggil dari pengguna / kelas utama)

   /*
    * 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: (Wadah yang penuh semangat karena membuat objek dari semua kacang tunggal saat memuat file spring.xml itu sendiri)

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

3. Secara teknis, menggunakan ApplicationContext dianjurkan karena dalam aplikasi waktu nyata, objek bean akan dibuat ketika aplikasi memulai di server itu sendiri. Ini mengurangi waktu respons untuk permintaan pengguna karena objek sudah tersedia untuk merespons.

Saya pikir perlu disebutkan bahwa sejak Spring 3, jika Anda ingin membuat pabrik, Anda juga dapat menggunakan @configurationanotasi yang dikombinasikan dengan yang tepat.@scope

@Configuration
public class MyFactory {

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

Pabrik Anda akan terlihat oleh wadah Pegas menggunakan @ComponentScananotasi atau konfigurasi xml

Artikel lingkup kacang musim semi dari situs baeldung

gunakan BeanFactory untuk aplikasi non-web karena hanya mendukung Singleton dan Prototipe bean-scopes.

Sementara wadah ApplicationContext mendukung semua cakupan bean, jadi Anda harus menggunakannya untuk aplikasi web.

Singkatnya:

The ApplicationContext mencakup semua fungsi dari BeanFactory. Umumnya disarankan untuk menggunakan yang pertama.

Ada beberapa situasi terbatas seperti dalam aplikasi Seluler, di mana konsumsi memori mungkin kritis.

Dalam skenario itu, dapat dibenarkan untuk menggunakan BeanFactory yang lebih ringan . Namun, di sebagian besar aplikasi perusahaan, ApplicationContext adalah apa yang ingin Anda gunakan.

Untuk lebih lanjut, lihat posting blog saya:

Perbedaan antara BeanFactory dan ApplicationContext di Spring - Blog java spring dari dasar-dasarnya

Saya perlu menjelaskan BeanFactory & ApplicationContext.

BeanFactory: BeanFactory adalah antarmuka root untuk mengakses SpringBean Container. Ada pandangan klien dasar dari sebuah wadah kacang. Antarmuka itu diimplementasikan oleh kelas objek yang menampung jumlah definisi bean, dan masing-masing secara unik mengidentifikasi dengan nama String
Tergantung pada definisi Bean pabrik akan mengembalikan instance yang instance dapat berupa instance dari objek yang terkandung atau instance bersama tunggal. Jenis instance mana yang akan dikembalikan tergantung dari konfigurasi pabrik kacang.
Biasanya pabrik Bean akan memuat semua semua definisi kacang, yang disimpan dalam sumber konfigurasi seperti XML ... dll.

BeanFactory adalah wadah paling sederhana yang menyediakan dukungan dasar untuk Dependency Injection

Konteks Aplikasi aplikasi adalah antarmuka pusat dengan dalam aplikasi pegas yang menyediakan informasi konfigurasi ke aplikasi. Ini mengimplementasikan Bean Factory Interface.

Konteks aplikasi adalah wadah lanjutan yang menambah level muka dari fungsionalitas khusus perusahaan seperti kemampuan untuk menyelesaikan pesan teks dari file properti .... dll

ApplicationContext menyediakan:

Metode pabrik kacang untuk mengakses komponen aplikasi. Diwarisi dari ListableBeanFactory. Kemampuan untuk memuat sumber daya file secara umum. Diwarisi dari antarmuka ResourceLoader. Kemampuan untuk mempublikasikan acara ke pendengar terdaftar. Diwarisi dari antarmuka ApplicationEventPublisher. Kemampuan untuk menyelesaikan pesan, mendukung internasionalisasi. Diwarisi dari antarmuka MessageSource. Warisan dari konteks orang tua. Definisi dalam konteks turunan akan selalu menjadi prioritas. Ini berarti, misalnya, bahwa konteks orang tua tunggal dapat digunakan oleh seluruh aplikasi web, sementara setiap servlet memiliki konteks anak sendiri yang independen terhadap servlet lainnya. Selain kemampuan siklus hidup standar BeanFactory,