BeanFactory проти ApplicationContext

Я досить новачок у Spring Framework, я розігрувався з ним і складав кілька прикладних програм для оцінки оцінки Spring MVC для використання в майбутньому проекті компанії. Поки мені дуже подобається те, що я бачу у весняному MVC, здається дуже простим у використанні та рекомендує вам писати заняття, які дуже зручні для тестування.

Як вправу я пишу основний метод для одного зі своїх зразків / тестових проектів. Одне, що мені незрозуміло, - це точні відмінності між нимиBeanFactory і ApplicationContext- що доцільно використовувати в яких умовах?

Я розумію, що це ApplicationContextпоширюєтьсяBeanFactory , але якщо я просто пишу простий основний метод, чи потрібно мені додаткові функціональні можливості, які ApplicationContextнадають? І саме те, яку додаткову функціональність ApplicationContextзабезпечує?

На додаток до відповіді "який я повинен використовувати в основному () методі", чи існують якісь стандарти або вказівки щодо того, яку реалізацію я повинен використовувати в такому сценарії? Якщо мій основний () метод повинен бути записаний так, щоб він залежав від конфігурації біна / програми у форматі XML - це безпечне припущення, чи я блокую користувача в чомусь конкретному?

І чи змінюється ця відповідь у веб-середовищі - якщо будь-який з моїх занять потребує того, щоб знати про весну, чи швидше вони знадобляться ApplicationContext ?

Дякуємо за будь-яку допомогу. Я знаю, що багато цих питань, ймовірно, відповідають у довідковому посібнику, але мені важко знайти чітке розбиття цих двох інтерфейсів та плюси / мінуси кожного, не читаючи посібника за допомогою тонкозубного гребінця.

Весняні документи в цьому чудові: 3.8.1. BeanFactory або ApplicationContext? . У них є таблиця зі порівнянням, я опублікую фрагмент:

Фабрика бобів

• Екземпляр / проводка квасолі

Контекст програми

• Екземпляр / проводка квасолі
• Автоматична реєстрація BeanPostProcessor
• Автоматична реєстрація BeanFactoryPostProcessor
• Зручний доступ до повідомлення до джерела (для i18n)
• Публікація ApplicationEvent

Отже, якщо вам потрібен будь-який з пунктів, представлених на стороні контексту програми, вам слід скористатися ApplicationContext.

Весна пропонує два види контейнера МОК, один є, 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 Квасоля завантажується через КЛАССПАТ
• XMLWebApplicationContextі AnnotationConfigWebApplicationContextквасоля, завантажена через контекст веб-додатків.
• AnnotationConfigApplicationContext Завантаження ярих бобів із конфігурації на основі анотацій.

приклад:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextявляє собою контейнер, ініціалізований a ContextLoaderListenerабо ContextLoaderServletвизначений у a web.xmlі ContextLoaderPluginвизначений в struts-config.xml.

Примітка : XmlBeanFactoryце НЕ рекомендується з весни 3.1 на користь DefaultListableBeanFactoryі XmlBeanDefinitionReader.

Для мене головна відмінність вибрати BeanFactoryбільш , ApplicationContextздається, що ApplicationContextбуде попередньо Instantiate все боби. З тих пружинних документів :

Весна встановлює властивості та вирішує залежності як можна пізніше, коли боб фактично створений. Це означає, що контейнер Spring, який завантажився правильно, пізніше може створити виняток, коли ви запитуєте об'єкт, якщо є проблема створення цього об’єкта або однієї з його залежностей. Наприклад, bean видає виняток внаслідок відсутнього або недійсного властивості. Це потенційно затримує видимість деяких проблем із конфігурацією, тому реалізація ApplicationContext за замовчуванням попередньо інстанціює однофакторні боби. Ціною певного часу та пам'яті для створення цих бобів до того, як вони фактично потрібні, ви виявите проблеми з конфігурацією, коли буде створений ApplicationContext, а не пізніше. Ви все ще можете змінити цю поведінку за замовчуванням, щоб однояйцеві боби ліниво ініціалізувались, а не були попередньо встановлені.

З огляду на це, я спочатку вибрав BeanFactoryдля використання в тестах інтеграції / продуктивності, оскільки не хотів завантажувати всю програму для тестування ізольованих бобів. Однак - і хтось виправить мене, якщо я помиляюся - BeanFactoryне підтримує classpathконфігурацію XML. Отже, BeanFactoryі ApplicationContextкожен забезпечував важливу особливість, яку я хотів, але і те і інше не зробили.

Біля того, як я можу сказати, примітка в документації про переосмислення поведінки оригіналів за замовчуванням має місце в конфігурації, і це на базі, тому я не можу просто встановити атрибут "lazy-init" у файлі 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);
        }
    }

}

Щоб додати те, на що відповів Мігель Пінг, ось ще один розділ з документації, який відповідає на це:

Коротка версія: використовуйте ApplicationContext, якщо у вас немає поважної причини для цього. Для тих із вас, хто шукає трохи більше глибини щодо "але чому" вищезгаданої рекомендації, продовжуйте читати.

(розміщуємо це для будь-яких майбутніх весняних новачків, які можуть прочитати це питання)

1. ApplicationContext є більш кращим способом, ніж BeanFactory

2. У нових весняних версіях BeanFactoryзамінено на ApplicationContext. Але все ще BeanFactoryіснує для зворотної порівнянності

3. ApplicationContext extends BeanFactory і має такі переваги
   • він підтримує інтернаціоналізацію текстових повідомлень
   • він підтримує публікацію подій зареєстрованим слухачам
   • доступ до таких ресурсів, як URL-адреси та файли

ApplicationContext: Він завантажує весняні боби, налаштовані у файлі конфігурації весни, та керує життєвим циклом весняної квасолі як і КОЛИ КОНТАЙНЕРСЬКІ СТАРТИ. Він не чекатиме, поки викличе getBean ("springbeanref") .

BeanFactory Він завантажує пружинні боби , налаштовані в файлі конфігурації пружини, управляє життєвим циклом весняного бобу , коли ми називаємо getBean ( «springbeanref») .so , коли ми називаємо getBean ( «springbeanref») в момент початку весни бобів життєвого циклу .

Я думаю, що краще завжди використовувати ApplicationContext, якщо ви не перебуваєте в мобільному середовищі, як хтось уже сказав. ApplicationContext має більше функціональних можливостей, і ви, безумовно, хочете використовувати PostProcessors, такі як RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor та CommonAnnotationBeanPostProcessor, що допоможе вам спростити ваші весняні конфігураційні файли, і ви можете використовувати анотації, такі як @ReCon, .

Навіть якщо ви не використовуєте всі пропозиції, які пропонує ApplicationContext, краще все-таки використовувати їх, а потім пізніше, якщо ви вирішите використовувати деякі ресурси, такі як повідомлення або процесори публікації, або іншу схему, щоб додати трансакційні поради та інше, ви буде вже мати ApplicationContext і не потрібно буде змінювати будь-який код.

Якщо ви пишете автономну програму, завантажте ApplicationContext у своєму основному методі, використовуючи ClassPathXmlApplicationContext, і отримайте основний боб та викликайте його run () (або будь-який інший спосіб), щоб запустити додаток. Якщо ви пишете веб-додаток, використовуйте ContextLoaderListener в web.xml, щоб він створив ApplicationContext, і згодом ви зможете отримати його з ServletContext, незалежно від того, використовуєте ви JSP, JSF, JSTL, стійки, гобелен тощо. .

Крім того, пам’ятайте, що ви можете використовувати декілька файлів конфігурації Spring і ви можете або створити ApplicationContext, перерахувавши всі файли в конструкторі (або перерахувавши їх у контекст-парамі для ContextLoaderListener), або ви можете просто завантажити основний файл конфігурації, який має імпорт заяв. Ви можете імпортувати файл конфігурації Spring в інший файл конфігурації Spring, використовуючи <import resource = "otherfile.xml" />, що дуже корисно при програмному створенні ApplicationContext в основному методі та завантаженні лише одного конфігураційного файла Spring.

Здебільшого, ApplicationContext є кращим, якщо вам не потрібно економити ресурси, як, наприклад, у мобільному додатку.

Я не впевнений в залежності від формату XML, але я впевнений, що найбільш поширеними реалізаціями ApplicationContext є такі XML, як ClassPathXmlApplicationContext, XmlWebApplicationContext та FileSystemXmlApplicationContext. Це єдині три, які я коли-небудь використовував.

Якщо ви розробляєте веб-додаток, можна з упевненістю сказати, що вам потрібно буде використовувати XmlWebApplicationContext.

Якщо ви хочете, щоб ваші боби знали про весну, ви можете дозволити їм реалізувати для цього BeanFactoryAware та / або ApplicationContextAware, тож ви можете використовувати BeanFactory або ApplicationContext та вибрати інтерфейс для впровадження.

Різниця між BeanFactory та ApplicationContext є наступною:

1. BeanFactory використовує ледачу ініціалізацію, але ApplicationContext використовує прагнення до ініціалізації. У випадку BeanFactory, bean створюється при виклику методу getBeans (), але bean створюється наперед у випадку ApplicationContext, коли створюється об’єкт ApplicationContext.
2. BeanFactory явно надає ресурсний об'єкт за допомогою синтаксису, але ApplicationContext створює та керує ресурсними об'єктами самостійно.
3. BeanFactory не підтримує інтернаціоналізацію, але ApplicationContext підтримує інтернаціоналізацію.
4. З інжекцією залежності на основі аннотації не підтримується, але введення залежності на основі анотації підтримується в ApplicationContext.

Використання BeanFactory:

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

Використання ApplicationContext:

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

І BeanFactory, і ApplicationContext - це способи отримання бобів з вашого весняного контейнера МОК, але все ж є певна різниця.

BeanFactory - це фактичний контейнер, який створює , налаштовує та керує рядом файлів . Ці квасолі, як правило, співпрацюють між собою, і тому мають залежність між собою. Ці залежності відображаються в даних конфігурації, які використовує BeanFactory.

BeanFactory і ApplicationContext є інтерфейсами Java, а ApplicationContext розширює BeanFactory. Обидва вони налаштовані за допомогою файлів конфігурації XML. Коротше кажучи, BeanFactory забезпечує основні функції інверсії управління ( IoC ) та залежної інжекції ( DI ), тоді як ApplicationContext надає розширені функції.

BeanFactory представлений інтерфейсом " org.springframework.beans.factory ", де BeanFactory, для якого існує кілька реалізацій.

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

РІЗНАННЯ

1. BeanFactory instantiate bean, коли ви викликаєте метод getBean (), тоді як ApplicationContext інстанціює Singleton bean при запуску контейнера, він не чекає, коли викличе getBean ().

2. BeanFactory не підтримує інтернаціоналізацію, але ApplicationContext надає підтримку.

3. Ще одна відмінність між BeanFactory проти ApplicationContext - це можливість публікувати події для бобів, які зареєстровані як слухачі.

4. Однією з популярних реалізацій інтерфейсу BeanFactory є XMLBeanFactory, тоді як однією з популярних реалізацій інтерфейсу ApplicationContext є ClassPathXmlApplicationContext .

5. Якщо ви використовуєте автоматичну проводку та використовуєте BeanFactory, то вам потрібно зареєструвати AutoWiredBeanPostProcessor за допомогою API, який ви можете налаштувати в XML, якщо ви використовуєте ApplicationContext . Підсумовуючи, BeanFactory добре для тестування та невиробничого використання, але ApplicationContext є більш багатою функціональною реалізацією контейнерів і йому слід віддавати перевагу над BeanFactory

6. BeanFactory за замовчуванням його підтримки відкладеної завантаження і ApplicationContext за замовчуванням підтримки агресивні навантаження.

Матриця особливостей фабрики фасолі проти контексту додатків, що надходить із весняних документів

_{Знімок екрана з особливостями BeanFacotry та ApplicationContext}

а. Однією з різниць між фабрикою біна та контекстом програми є те, що колишній лише екземплярний компонент при виклику методу getBean (), тоді як ApplicationContext інстанціює Singleton bean при запуску контейнера, він не чекає, коли виклик getBean.

б.

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

або

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

Ви можете використовувати один або декілька файлів xml залежно від вимог вашого проекту. Оскільки я тут, використовую два файли xml, тобто один для деталей конфігурації службових класів, інший для класів dao. Тут ClassPathXmlApplicationContext є дочіркою ApplicationContext.

c. Контейнер BeanFactory є основним контейнером, він може створювати лише об'єкти та вводити залежності. Але ми не можемо приєднати інші сервіси, такі як безпека, транзакції, обмін повідомленнями і т. Д., Щоб надати всі послуги, які ми маємо використовувати контейнер ApplicationContext.

г. BeanFactory не підтримує інтернаціоналізацію, тобто i18n, але ApplicationContext надає підтримку.

е. BeanFactory Container не підтримує функцію AutoScanning (Підтримка залежності на основі анотацій), але підтримує контейнер ApplicationContext.

f. Beanfactory Container не створить об'єкт bean до моменту запиту. Це означає, що контейнер Beanfactory контейнер ліниво завантажує. У той час як контейнер ApplicationContext створює об'єкти квасолі Singleton лише під час завантаження. Це означає, що відбувається раннє завантаження.

г. Контейнер Beanfactory підтримує лише дві області (однотонний та прототип) квасолі. Але ApplicationContext Container підтримує всю область бобів.

В основному ми можемо створити об'єкт весняного контейнера двома способами

1. використовуючи BeanFactory.
2. за допомогою ApplicationContext.

обидва є інтерфейсами,

за допомогою класів реалізації ми можемо створити об’єкт для весняного контейнера

приходячи до відмінностей

BeanFactory:

1. Не підтримує введення залежності на основі анотацій.

2. Не підтримує I18N.

3. За замовчуванням його підтримка ледачого завантаження.

4. це не дозволяє налаштувати кілька файлів конфігурації.

наприклад: контекст BeanFactory = новий XmlBeanFactory (новий ресурс ("applicationContext.xml"));

ApplicationContext

1. Підтримка залежності на основі анотацій Injection.-@Autowired, @PreDestroy

2. Підтримка I18N

3. Його За замовчуванням підтримує агресивне завантаження.

4. Це дозволяє налаштувати кілька файлів конфігурації.

напр .:
ApplicationContext контекст = новий ClasspathXmlApplicationContext ("applicationContext.xml");

Перегляньте цей документ із Spring 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 або ApplicationContext?

Використовуйте ApplicationContext, якщо у вас немає вагомих причин цього не робити.

Оскільки ApplicationContext включає всю функціональність BeanFactory, він, як правило, рекомендується використовувати BeanFactory, за винятком кількох ситуацій, наприклад, в аплеті, де споживання пам'яті може бути критичним і кілька зайвих кілобайт можуть змінити значення. Однак для більшості типових корпоративних додатків і систем саме ApplicationContext - це те, що ви хочете використовувати. Весна 2.0 і пізніші версії використовує точку розширення BeanPostProcessor (для того, щоб наблизитись тощо). Якщо ви використовуєте лише звичайний BeanFactory, неабияка підтримка, така як транзакції та AOP, не вступить у дію, принаймні не без додаткових кроків з вашого боку. Ця ситуація може бути заплутаною, оскільки насправді нічого не так з конфігурацією.

ApplicationContext - це великий брат BeanFactory, і це все, що BeanFactory надають, плюс багато інших речей.

Окрім стандартних можливостей життєвого циклу org.springframework.beans.factory.BeanFactory, реалізація ApplicationContext виявляє та викликає боби ApplicationContextAware, а також боби ResourceLoaderAware, ApplicationEventPublisherAware та MessageSourceAware.

У сценарії реального часу різниця між контейнером Spring IOC Core (BeanFactory) та контейнером Advanced J2EE (ApplicationContext) полягає в наступному.

1. BeanFactory створить об’єкти для бобів (тобто для класів POJO), згаданих у файлі spring.xml ( <bean></bean>), тільки коли ви викликаєте метод .getBean (), але тоді як ApplicationContext створює об'єкти для всіх бобів ( <bean></bean>якщо його область не відповідає явно згадується як "прототип"), налаштований у spring.xml під час завантаження файлу spring.xml.

2. BeanFactory: (Ледачий контейнер, оскільки він створює об'єкти для квасолі лише тоді, коли ви явно телефонуєте від користувача / основного класу)

   /*
    * 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)

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

3. Технічно рекомендується використовувати ApplicationContext, оскільки в додатках у режимі реального часу об’єкти bean будуть створюватися під час запуску програми на самому сервері. Це скорочує час відповіді на запит користувача, оскільки об’єкти вже доступні для відповіді.

Я думаю, що варто згадати, що починаючи з весни 3, якщо ви хочете створити фабрику, ви також можете використовувати @configurationанотацію в поєднанні з належною@scope

@Configuration
public class MyFactory {

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

Ваша фабрика повинна бути видно контейнером Spring з використанням @ComponentScanпримітки або конфігурації xml

Стаття про сфери використання бобів на весняному майданчику з сайту baeldung

використовуйте BeanFactory для не-веб-додатків, оскільки він підтримує лише Singleton та Prototype bean-scopes.

У той час як контейнер ApplicationContext підтримує всі області діапазону, тому вам слід використовувати його для веб-додатків.

Підсумовуючи:

ApplicationContext включає в себе всі функціональні можливості BeanFactory. Зазвичай рекомендується використовувати перше.

Існує кілька обмежених ситуацій, таких як мобільний додаток, де споживання пам'яті може бути критичним.

У таких сценаріях може бути виправданим використання більш легкої BeanFactory . Однак у більшості корпоративних програм ApplicationContext - це те, що ви хочете використовувати.

Детальніше дивіться у моєму блозі:

Відмінність BeanFactory від ApplicationContext у весні - весна блогу java

Мені потрібно пояснити BeanFactory & ApplicationContext.

BeanFactory: BeanFactory є кореневим інтерфейсом для доступу до SpringBean Container. Існує базовий вигляд клієнта контейнера для bean. Цей інтерфейс реалізований класом об'єктів, який містить кількість визначень бобів, і кожне унікально ідентифікується за назвою String
Залежно від визначення Bean, фабрика поверне екземпляр, який може бути екземпляром об'єкта, що міститься, або одного спільного екземпляра. Який тип примірника буде повернутий, залежить від конфігурації фасолі бобів.
Зазвичай завод Bean завантажує все визначення бобів, яке зберігається у джерелі конфігурації, як XML ... тощо.

BeanFactory - це найпростіший контейнер, що забезпечує основну підтримку введення залежностей

Контекст програми програми - це центральний інтерфейс у весняній програмі, який надає інформацію про конфігурацію додатку. Він реалізує фабричний інтерфейс Bean.

Контекст програми - це контейнер заздалегідь, він додає попередній рівень специфічної для підприємства функціональності, наприклад, можливість вирішення текстового повідомлення з файлу властивостей .... тощо

ApplicationContext забезпечує:

Фабричні методи для доступу до компонентів програми. Успадковується від ListableBeanFactory. Можливість загального завантаження файлових ресурсів. Успадковується від інтерфейсу ResourceLoader. Можливість публікувати події зареєстрованим слухачам. Наслідується від інтерфейсу ApplicationEventPublisher. Можливість розв’язувати повідомлення, підтримуючи інтернаціоналізацію. Успадковується від інтерфейсу MessageSource. Спадкування від батьківського контексту. Визначення в контексті нащадків завжди матиме пріоритет. Це означає, наприклад, що один батьківський контекст може використовуватися всім веб-додатком, тоді як кожен сервлет має свій дочірній контекст, який не залежить від будь-якого іншого сервлета. Окрім стандартних можливостей життєвого циклу BeanFactory,