BeanFactory vs ApplicationContext

Tôi khá mới mẻ với Spring Framework, tôi đã chơi xung quanh nó và kết hợp một vài ứng dụng mẫu với mục đích đánh giá Spring MVC để sử dụng trong một dự án công ty sắp tới. Cho đến nay tôi thực sự thích những gì tôi thấy trong Spring MVC, có vẻ rất dễ sử dụng và khuyến khích bạn viết các lớp rất thân thiện với bài kiểm tra.

Cũng giống như một bài tập, tôi đang viết một phương pháp chính cho một trong các dự án mẫu / thử nghiệm của mình. Một điều tôi không rõ ràng là sự khác biệt chính xác giữa BeanFactoryvà ApplicationContext- phù hợp để sử dụng trong điều kiện nào?

Tôi hiểu điều đó ApplicationContextmở rộng BeanFactory, nhưng nếu tôi chỉ viết một phương thức chính đơn giản, tôi có cần thêm chức năng ApplicationContextcung cấp không? Và chính xác loại chức năng bổ sung nào ApplicationContextcung cấp?

Ngoài việc trả lời "tôi nên sử dụng phương thức main () nào", còn có tiêu chuẩn hay hướng dẫn nào về việc tôi nên sử dụng phương pháp nào trong kịch bản như vậy không? Phương thức main () của tôi có nên được viết để phụ thuộc vào cấu hình bean / ứng dụng ở định dạng XML không - đó có phải là một giả định an toàn hay tôi đang khóa người dùng vào một cái gì đó cụ thể?

Và câu trả lời này có thay đổi trong môi trường web không - nếu bất kỳ lớp nào của tôi cần biết về Spring, họ có nhiều khả năng cần ApplicationContextkhông?

Cảm ơn vì bất kì sự giúp đỡ. Tôi biết rất nhiều câu hỏi trong số này có thể được trả lời trong tài liệu tham khảo, nhưng tôi gặp khó khăn trong việc tìm ra sự phân chia rõ ràng của hai giao diện này và những ưu / nhược điểm của mỗi giao diện mà không cần đọc hướng dẫn bằng lược chải răng.

Các tài liệu mùa xuân là tuyệt vời về điều này: 3.8.1. BeanFactory hay ApplicationContext? . Họ có một bảng so sánh, tôi sẽ đăng một đoạn:

Nhà máy đậu

• Bean tức thời / hệ thống dây điện

Bối cảnh ứng dụng

• Bean tức thời / hệ thống dây điện
• Đăng ký BeanPostProcessor tự động
• Đăng ký BeanFactoryPostProcessor tự động
• Truy cập MessageSource thuận tiện (cho i18n)
• Ứng dụng xuất bản

Vì vậy, nếu bạn cần bất kỳ điểm nào được trình bày ở phía Bối cảnh ứng dụng, bạn nên sử dụng ApplicationContext.

Spring cung cấp hai loại container IOC, một là XMLBeanFactoryvà một là 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 Đậu được nạp qua đường dẫn đầy đủ.
• ClassPathXmlApplicationContext Đậu được nạp qua CLASSPATH
• XMLWebApplicationContextvà AnnotationConfigWebApplicationContextđậu được tải thông qua bối cảnh ứng dụng web.
• AnnotationConfigApplicationContext Đang tải đậu mùa xuân từ cấu hình dựa trên chú thích.

thí dụ:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextlà container được khởi tạo bởi một ContextLoaderListenerhoặc ContextLoaderServletđược xác định trong mộtweb.xml và ContextLoaderPluginđược xác định trong struts-config.xml.

Lưu ý : XmlBeanFactorylà bị phản đối như của mùa xuân 3,1 ủng hộ DefaultListableBeanFactoryvà XmlBeanDefinitionReader.

Đối với tôi, sự khác biệt chính để lựa chọn BeanFactorytrên ApplicationContextcó vẻ là rằng ApplicationContextsẽ sẵn thuyết minh tất cả các loại đậu. Từ các tài liệu mùa xuân :

Spring thiết lập các thuộc tính và giải quyết các phụ thuộc càng muộn càng tốt, khi bean thực sự được tạo. Điều này có nghĩa là bộ chứa Spring được tải chính xác sau này có thể tạo ra một ngoại lệ khi bạn yêu cầu một đối tượng nếu có vấn đề tạo ra đối tượng đó hoặc một trong các phụ thuộc của nó. Ví dụ, bean ném một ngoại lệ là kết quả của một tài sản bị thiếu hoặc không hợp lệ. Điều này có khả năng bị trì hoãn khả năng hiển thị của một số vấn đề cấu hình là lý do tại sao việc triển khai ApplicationContext theo mặc định trước đậu đơn. Với chi phí của một số thời gian trả trước và bộ nhớ để tạo ra các bean này trước khi chúng thực sự cần thiết, bạn phát hiện ra các vấn đề cấu hình khi ApplicationContext được tạo, không phải sau này. Bạn vẫn có thể ghi đè hành vi mặc định này để các hạt đơn lẻ sẽ lười khởi tạo, thay vì được khởi tạo trước.

Vì điều này, ban đầu tôi đã chọn BeanFactorysử dụng trong các bài kiểm tra tích hợp / hiệu năng vì tôi không muốn tải toàn bộ ứng dụng để kiểm tra các hạt đậu bị cô lập. Tuy nhiên - và ai đó sửa tôi nếu tôi sai - BeanFactorykhông hỗ trợ classpathcấu hình XML. Vậy BeanFactoryvàApplicationContext mỗi cung cấp một tính năng quan trọng tôi muốn, nhưng cả hai đều không.

Gần như tôi có thể biết, ghi chú trong tài liệu về ghi đè hành vi khởi tạo mặc định diễn ra trong cấu hình và đó là per-bean, vì vậy tôi không thể chỉ đặt thuộc tính "lazy-init" trong tệp XML hoặc tôi bị mắc kẹt trong việc duy trì một phiên bản của nó để thử nghiệm và một phiên bản để triển khai.

Điều cuối cùng tôi làm là mở rộng ClassPathXmlApplicationContextđể tải đậu một cách lười biếng để sử dụng trong các thử nghiệm như vậy:

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

}

Để thêm vào những gì Miguel Ping đã trả lời, đây là một phần khác từ tài liệu cũng trả lời điều này:

Phiên bản ngắn: sử dụng ApplicationContext trừ khi bạn có lý do thực sự tốt để không làm như vậy. Đối với những bạn đang tìm kiếm chiều sâu hơn một chút về "nhưng tại sao" của khuyến nghị trên, hãy tiếp tục đọc.

(đăng bài này cho bất kỳ người mới nào trong mùa xuân trong tương lai có thể đọc câu hỏi này)

1. ApplicationContext là cách ưa thích hơn BeanFactory

2. Trong phiên bản Spring mới BeanFactoryđược thay thế bằng ApplicationContext. Nhưng vẫn BeanFactorytồn tại cho khả năng tương thích ngược

3. ApplicationContext extends BeanFactory và có những lợi ích sau
   • nó hỗ trợ quốc tế hóa cho tin nhắn văn bản
   • nó hỗ trợ xuất bản sự kiện cho người nghe đã đăng ký
   • truy cập vào các tài nguyên như URL và tệp

ApplicationContext: Nó tải các bean spring được cấu hình trong tệp cấu hình mùa xuân và quản lý vòng đời của bean spring như và KHI CONTAINER STARTS. Nó sẽ không đợi cho đến khi getBean ("springbeanref") được gọi.

BeanFactory Nó tải đậu mùa xuân được cấu hình trong tệp cấu hình mùa xuân, quản lý vòng đời của đậu mùa xuân khi chúng ta gọi getBean ("springbeanref") . Vì vậy, khi chúng ta gọi getBean ("springbeanref") tại thời điểm vòng đời của mùa xuân bắt đầu .

Tôi nghĩ sẽ tốt hơn khi luôn sử dụng ApplicationContext, trừ khi bạn ở trong môi trường di động như người khác đã nói. ApplicationContext có nhiều chức năng hơn và bạn chắc chắn muốn sử dụng PostProcessors như làAnAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor và CommonAnnotationBeanPostProcessor, sẽ giúp bạn đơn giản hóa các tệp cấu hình Spring của bạn, và bạn có thể sử dụng các tập tin cấu hình Spring của bạn, và bạn có thể sử dụng annot .

Ngay cả khi bạn không sử dụng tất cả những thứ mà ApplicationContext cung cấp, dù sao thì vẫn nên sử dụng nó, và sau đó nếu bạn quyết định sử dụng một số nội dung tài nguyên như tin nhắn hoặc bộ xử lý bài hoặc lược đồ khác để thêm lời khuyên giao dịch và như vậy, bạn sẽ có ApplicationContext và sẽ không cần thay đổi bất kỳ mã nào.

Nếu bạn đang viết một ứng dụng độc lập, hãy tải ApplicationContext theo phương thức chính của bạn, sử dụng ClassPathXmlApplicationContext và lấy bean chính và gọi run () (hoặc bất kỳ phương thức nào) để khởi động ứng dụng của bạn. Nếu bạn đang viết một ứng dụng web, hãy sử dụng ContextLoaderListener trong web.xml để nó tạo ApplicationContext và sau đó bạn có thể lấy nó từ ServletContext, bất kể bạn đang sử dụng JSP, JSF, JSTL, struts, Tapestry, v.v. .

Ngoài ra, hãy nhớ rằng bạn có thể sử dụng nhiều tệp cấu hình Spring và bạn có thể tạo ApplicationContext bằng cách liệt kê tất cả các tệp trong hàm tạo (hoặc liệt kê chúng trong ngữ cảnh-param cho ContextLoaderListener) hoặc bạn chỉ có thể tải tệp cấu hình chính có báo cáo nhập khẩu. Bạn có thể nhập tệp cấu hình Spring vào một tệp cấu hình Spring khác bằng cách sử dụng <import resource = "otherfile.xml" /> rất hữu ích khi bạn lập trình tạo ApplicationContext theo phương thức chính và chỉ tải một tệp cấu hình Spring.

Đối với hầu hết các phần, ApplicationContext được ưu tiên trừ khi bạn cần lưu tài nguyên, như trên ứng dụng di động.

Tôi không chắc chắn về việc phụ thuộc vào định dạng XML, nhưng tôi khá chắc chắn rằng các triển khai ApplicationContext phổ biến nhất là các XML như ClassPathXmlApplicationContext, XmlWebApplicationContext và FileSystemXmlApplicationContext. Đó là ba cái duy nhất tôi từng sử dụng.

Nếu bạn đang phát triển một ứng dụng web, có thể nói rằng bạn sẽ cần sử dụng XmlWebApplicationContext.

Nếu bạn muốn các bean của bạn biết về Spring, bạn có thể yêu cầu chúng triển khai BeanFactoryAware và / hoặc ApplicationContextAware cho điều đó, vì vậy bạn có thể sử dụng BeanFactory hoặc ApplicationContext và chọn giao diện nào để thực hiện.

Sự khác biệt giữa BeanFactory và ApplicationContext như sau:

1. BeanFactory sử dụng khởi tạo lười biếng nhưng ApplicationContext sử dụng khởi tạo háo hức. Trong trường hợp BeanFactory, bean được tạo khi bạn gọi phương thức getBeans (), nhưng bean được tạo trả trước trong trường hợp ApplicationContext khi đối tượng ApplicationContext được tạo.
2. BeanFactory cung cấp rõ ràng một đối tượng tài nguyên bằng cú pháp nhưng ApplicationContext tự tạo và quản lý các đối tượng tài nguyên.
3. BeanFactory không hỗ trợ internatiolization nhưng ApplicationContext hỗ trợ quốc tế hóa.
4. Với tính năng tiêm phụ thuộc dựa trên chú thích BeanFactory không được hỗ trợ nhưng tiêm phụ thuộc dựa trên chú thích được hỗ trợ trong ApplicationContext.

Sử dụng BeanFactory:

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

Sử dụng ApplicationContext:

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

BeanFactory và ApplicationContext đều là những cách để lấy đậu từ thùng chứa IOC mùa xuân của bạn nhưng vẫn có một số khác biệt.

BeanFactory là bộ chứa thực tế khởi tạo, cấu hình và quản lý một số bean. Những hạt đậu này thường hợp tác với nhau và do đó có sự phụ thuộc giữa chúng. Các phụ thuộc này được phản ánh trong dữ liệu cấu hình được sử dụng bởi BeanFactory.

Cả BeanFactory và ApplicationContext đều là giao diện Java và ApplicationContext mở rộng BeanFactory. Cả hai đều là cấu hình sử dụng các tệp cấu hình XML. Tóm lại, BeanFactory cung cấp các tính năng Đảo ngược điều khiển ( IoC ) và Tiêm phụ thuộc ( DI ) cơ bản trong khi ApplicationContext cung cấp các tính năng nâng cao .

BeanFactory được đại diện bởi giao diện " org.springframework.beans.factory " Trong đó BeanFactory, trong đó có nhiều triển khai.

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

SỰ KHÁC BIỆT

1. BeanFactory khởi tạo bean ngay lập tức khi bạn gọi phương thức getBean () trong khi ApplicationContext khởi tạo bean Singleton khi container được khởi động, Nó không đợi getBean () được gọi.

2. BeanFactory không cung cấp hỗ trợ cho quốc tế hóa nhưng ApplicationContext cung cấp hỗ trợ cho nó.

3. Một điểm khác biệt giữa BeanFactory so với ApplicationContext là khả năng xuất bản sự kiện tới các bean được đăng ký làm người nghe.

4. Một trong những triển khai phổ biến của giao diện BeanFactory là XMLBeanFactory trong khi một trong những triển khai phổ biến của giao diện ApplicationContext là ClassPathXmlApplicationContext .

5. Nếu bạn đang sử dụng hệ thống dây tự động và sử dụng BeanFactory thì bạn cần phải đăng ký AutoWiredBeanPostProcessor bằng API mà bạn có thể định cấu hình trong XML nếu bạn đang sử dụng dụng ApplicationContext . Tóm lại BeanFactory là OK để thử nghiệm và không sử dụng sản xuất nhưng ApplicationContext là tính năng triển khai vùng chứa nhiều tính năng hơn và nên được ưa chuộng hơn BeanFactory

6. BeanFactory theo mặc định hỗ trợ Lazy tải và ApplicationContext hỗ trợ mặc định Quá dữ bốc.

Ma trận tính năng của Bean Factory vs Bối cảnh ứng dụng có nguồn gốc từ tài liệu mùa xuân

_{Ảnh chụp màn hình các tính năng của BeanFacotry và ApplicationContext}

a. Một điểm khác biệt giữa bối cảnh nhà máy và bối cảnh ứng dụng là trước đây chỉ khởi tạo bean khi bạn gọi phương thức getBean () trong khi ApplicationContext khởi tạo bean Singleton khi container được khởi động, Nó không đợi getBean được gọi.

b.

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

hoặc là

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

Bạn có thể sử dụng một hoặc nhiều tệp xml tùy theo yêu cầu dự án của bạn. Vì tôi ở đây sử dụng hai tệp xml, tức là một để biết chi tiết cấu hình cho các lớp dịch vụ khác cho các lớp dao. Ở đây ClassPathXmlApplicationContext là con của ApplicationContext.

c. BeanFactory Container là container cơ bản, nó chỉ có thể tạo các đối tượng và tiêm Dependencies. Nhưng chúng tôi không thể đính kèm các dịch vụ khác như bảo mật, giao dịch, nhắn tin, v.v. để cung cấp tất cả các dịch vụ chúng tôi phải sử dụng ApplicationContext Container.

d. BeanFactory không cung cấp hỗ trợ cho quốc tế hóa, tức là i18n nhưng ApplicationContext cung cấp hỗ trợ cho nó.

e. BeanFactory Container không hỗ trợ tính năng AutoScanning (Hỗ trợ tiêm phụ thuộc dựa trên chú thích), nhưng ApplicationContext Container hỗ trợ.

f. Beanfactory Container sẽ không tạo đối tượng bean cho đến thời gian yêu cầu. Nó có nghĩa là Beanfactory Container tải đậu một cách lười biếng. Trong khi ApplicationContext Container tạo các đối tượng của Singleton bean tại thời điểm chỉ tải. Nó có nghĩa là có tải sớm.

g. Beanfactory Container chỉ hỗ trợ hai phạm vi (singleton & nguyên mẫu) của đậu. Nhưng ApplicationContext Container hỗ trợ tất cả các phạm vi đậu.

Về cơ bản chúng ta có thể tạo đối tượng container mùa xuân theo hai cách

1. sử dụng BeanFactory.
2. sử dụng ApplicationContext.

cả hai đều là giao diện

bằng cách sử dụng các lớp thực hiện, chúng ta có thể tạo đối tượng cho container mùa xuân

đến sự khác biệt

BeanFactory:

1. Không hỗ trợ tiêm phụ thuộc dựa trên chú thích.

2. Không hỗ trợ I18N.

3. Theo mặc định, nó hỗ trợ tải nhanh.

4. nó không cho phép cấu hình nhiều tập tin cấu hình.

ví dụ: BeanFactory bối cảnh = new XmlBeanFactory (Tài nguyên mới ("applicationContext.xml"));

Ứng dụng Nội dung

1. Hỗ trợ Chú thích dựa trên tiêm chích.-@Autowired, @PreDestroy

2. Hỗ trợ I18N

3. Theo mặc định, nó hỗ trợ tải Aggresive.

4. Nó cho phép cấu hình nhiều tập tin cấu hình.

ví dụ:
ApplicationContext bối cảnh = new ClasspathXmlApplicationContext ("applicationContext.xml");

Tham khảo tài liệu này từ Spring Docs:

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

5.15.1 BeanFactory hoặc ApplicationContext?

Sử dụng ApplicationContext trừ khi bạn có lý do chính đáng để không làm như vậy.

Vì ApplicationContext bao gồm tất cả các chức năng của BeanFactory, nên nó thường được đề xuất so với BeanFactory, ngoại trừ một vài tình huống như trong Applet nơi tiêu thụ bộ nhớ có thể rất quan trọng và một vài kilobyte có thể tạo ra sự khác biệt. Tuy nhiên, đối với hầu hết các ứng dụng và hệ thống doanh nghiệp điển hình, ApplicationContext là thứ bạn sẽ muốn sử dụng. Spring 2.0 trở lên sử dụng rất nhiều điểm mở rộng BeanPostProcessor (để thực hiện ủy quyền, v.v.). Nếu bạn chỉ sử dụng một BeanFactory đơn giản, một số lượng hỗ trợ hợp lý như giao dịch và AOP sẽ không có hiệu lực, ít nhất là không có một số bước bổ sung từ phía bạn. Tình huống này có thể gây nhầm lẫn vì không có gì thực sự sai với cấu hình.

ApplicationContext là một người anh lớn của BeanFactory và tất cả những điều mà BeanFactory được cung cấp cộng với nhiều thứ khác.

Ngoài các khả năng vòng đời org.springframework.beans.factory.BeanFactory tiêu chuẩn, các triển khai ApplicationContext phát hiện và gọi các bean ApplicationContextAware cũng như các ResourceLoaderAware, ApplicationEventPublisherAware và MessageSourceAware.

Trong kịch bản thời gian thực, sự khác biệt giữa bộ chứa Spring IOC Core (BeanFactory) và bộ chứa J2EE nâng cao (ApplicationContext) như sau.

1. BeanFactory sẽ tạo các đối tượng cho các bean (nghĩa là đối với các lớp POJO) được đề cập trong tệp spring.xml ( <bean></bean>) chỉ khi bạn gọi phương thức .getBean (), nhưng trong khi ApplicationContext tạo các đối tượng cho tất cả các bean ( <bean></bean>nếu phạm vi của nó không phải là được đề cập rõ ràng là "Nguyên mẫu") được định cấu hình trong tệp spring.xml trong khi tải chính tệp spring.xml.

2. BeanFactory: (Container lười biếng vì nó tạo các đối tượng cho các bean chỉ khi bạn gọi rõ ràng từ người dùng / lớp chính)

   /*
    * 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: (Háo hức chứa vì tạo các đối tượng của tất cả các bean singleton trong khi tải chính tệp spring.xml)

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

3. Về mặt kỹ thuật, sử dụng ApplicationContext được khuyến nghị vì trong các ứng dụng thời gian thực, các đối tượng bean sẽ được tạo trong khi ứng dụng bắt đầu trong chính máy chủ. Điều này giúp giảm thời gian phản hồi cho yêu cầu của người dùng vì các đối tượng đã có sẵn để đáp ứng.

Tôi nghĩ điều đáng nói là kể từ Mùa xuân 3, nếu bạn muốn tạo một nhà máy, bạn cũng có thể sử dụng @configurationchú thích kết hợp với đúng@scope

@Configuration
public class MyFactory {

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

Nhà máy của bạn sẽ được hiển thị bởi bộ chứa Spring bằng cách sử dụng @ComponentScancấu hình chú thích hoặc xml

Bài viết về phạm vi đậu mùa xuân từ trang web baeldung

không sử dụng BeanFactory cho các ứng dụng không phải web vì nó chỉ hỗ trợ phạm vi bean Singleton và Prototype.

Trong khi ApplicationContext container hỗ trợ tất cả các phạm vi bean, do đó bạn nên sử dụng nó cho các ứng dụng web.

Tóm tắt:

các ApplicationContext bao gồm tất cả chức năng của BeanFactory. Nó thường được khuyến khích để sử dụng trước đây.

Có một số tình huống hạn chế như trong ứng dụng Di động, trong đó mức tiêu thụ bộ nhớ có thể rất quan trọng.

Trong trường hợp đó, có thể sử dụng BeanFactory nhẹ hơn . Tuy nhiên, trong hầu hết các ứng dụng doanh nghiệp, ApplicationContext là những gì bạn sẽ muốn sử dụng.

Để biết thêm, xem bài viết trên blog của tôi:

Sự khác biệt giữa BeanFactory và ApplicationContext trong Spring - Blog mùa xuân java từ những điều cơ bản

Tôi cần giải thích BeanFactory & ApplicationContext.

BeanFactory: BeanFactory là giao diện gốc để truy cập SpringBean Container. Có chế độ xem khách hàng cơ bản của một thùng chứa đậu. Giao diện đó được thực hiện bởi lớp đối tượng chứa số lượng định nghĩa bean và mỗi định nghĩa duy nhất bằng tên String
Tùy thuộc vào định nghĩa Bean, nhà máy sẽ trả về thể hiện đó có thể là thể hiện của đối tượng được chứa hoặc một cá thể được chia sẻ. Loại thể hiện nào sẽ được trả về tùy thuộc vào cấu hình bean bean.
Thông thường, nhà máy Bean sẽ tải tất cả các định nghĩa về bean, được lưu trữ trong nguồn cấu hình như XML ... vv.

BeanFactory là một container đơn giản nhất cung cấp hỗ trợ cơ bản cho Dependency Injection

Bối cảnh ứng dụng Bối cảnh ứng dụng là một giao diện trung tâm với ứng dụng mùa xuân cung cấp thông tin cấu hình cho ứng dụng. Nó thực hiện giao diện Bean Factory.

Bối cảnh ứng dụng là một thùng chứa trước tăng thêm chức năng cụ thể của doanh nghiệp, chẳng hạn như khả năng giải quyết tin nhắn văn bản từ tệp thuộc tính .... vv

Một ApplicationContext cung cấp:

Phương pháp nhà máy Bean để truy cập các thành phần ứng dụng. Kế thừa từ ListableBeanFactory. Khả năng tải tài nguyên tệp theo cách chung. Kế thừa từ giao diện ResourceLoader. Khả năng xuất bản các sự kiện cho người nghe đã đăng ký. Kế thừa từ giao diện ApplicationEventPublisher. Khả năng giải quyết tin nhắn, hỗ trợ quốc tế hóa. Kế thừa từ giao diện MessageSource. Kế thừa từ một bối cảnh cha mẹ. Các định nghĩa trong bối cảnh hậu duệ sẽ luôn được ưu tiên. Ví dụ, điều này có nghĩa là một bối cảnh cha mẹ đơn lẻ có thể được sử dụng bởi toàn bộ ứng dụng web, trong khi mỗi servlet có bối cảnh con riêng, độc lập với bối cảnh của bất kỳ servlet nào khác. Ngoài các khả năng vòng đời tiêu chuẩn của BeanFactory,