BeanFactory против ApplicationContext

Spring предоставляет два типа контейнеров 9X_spring IOC: один - XMLBeanFactory, а другой - ApplicationContext.

	BeanFactory	ApplicationContext
Поддержка аннотаций	Нет	Да
Регистрация BeanPostProcessor	Руководство	Автоматически
Реализация	XMLBeanFactory	ClassPath / FileSystem / WebXmlApplicationContext
Интернационализация	Нет	Да
Корпоративные услуги	Нет	Да
Публикация ApplicationEvent	Нет	Да

• FileSystemXmlApplicationContext Компоненты загружаются по полному пути.
• ClassPathXmlApplicationContext Компоненты, загруженные через CLASSPATH
Компоненты
• XMLWebApplicationContext и AnnotationConfigWebApplicationContext загружаются через контекст веб-приложения.
• AnnotationConfigApplicationContext Загрузка компонентов Spring из конфигурации на основе аннотаций.

пример:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class); 

• ApplicationContext - это контейнер, инициализированный с помощью ContextLoaderListener или ContextLoaderServlet, определенных в web.xml и ContextLoaderPlugin, определенных в struts-config.xml.

Примечание.

На мой взгляд, основное отличие от выбора 9X_managed-bean BeanFactory вместо ApplicationContext заключается в том, что ApplicationContext будет предварительно 9X_applicationcontext создавать экземпляры всех компонентов. От 9X_managed-bean the Spring docs:

Spring устанавливает свойства и разрешает 9X_managed-bean зависимости как можно позже, когда компонент 9X_applicationcontext действительно создается. Это означает, что 9X_applicationcontext контейнер Spring, который загрузился правильно, может 9X_spring-java-config позже сгенерировать исключение, когда вы 9X_managed-bean запрашиваете объект, если есть проблема 9X_applicationcontext с созданием этого объекта или одной из его 9X_spring зависимостей. Например, компонент генерирует 9X_spring-config исключение в результате отсутствия или недопустимого 9X_spring свойства. Эта потенциально отложенная видимость 9X_spring-java-config некоторых проблем конфигурации является 9X_spring-framework причиной того, почему реализации ApplicationContext 9X_spring по умолчанию предварительно создают экземпляры 9X_spring-framework одноэлементных компонентов. За счет некоторого 9X_spring-config времени и памяти для создания этих bean-компонентов 9X_managed-bean до того, как они действительно понадобятся, вы 9X_spring-config обнаружите проблемы конфигурации при создании 9X_managed-bean ApplicationContext, а не позже. Вы по-прежнему 9X_spring-config можете переопределить это поведение по умолчанию, чтобы 9X_spring-config одноэлементные bean-компоненты выполняли 9X_applicationcontext ленивую инициализацию, а не создавались 9X_managed-bean заранее.

Учитывая это, я изначально выбрал 9X_spring-framework BeanFactory для использования в тестах интеграции / производительности, поскольку 9X_managed-bean я не хотел загружать все приложение для 9X_spring-framework тестирования изолированных компонентов. Однако 9X_applicationcontext - и кто-нибудь поправит меня, если я ошибаюсь 9X_spring-java-config - BeanFactory не поддерживает конфигурацию XML classpath. Итак, BeanFactory и 9X_applicationcontext ApplicationContext каждый из них предоставляет важную функцию, которую 9X_spring-java-config я хотел, но ни то, ни другое не помогло 9X_managed-bean обеими.

Насколько я могу судить, примечание 9X_applicationcontext в документации о переопределении поведения 9X_applicationcontext создания экземпляра по умолчанию имеет место 9X_spring-config в конфигурации, и это для каждого компонента, поэтому 9X_applicationcontext я не могу просто установить атрибут "lazy-init" в 9X_spring файле XML или Я застрял в поддержке одной 9X_spring версии для тестирования и одной для развертывания.

В 9X_spring-framework итоге я расширил ClassPathXmlApplicationContext на ленивую загрузку beans 9X_spring-java-config для использования в таких тестах:

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

Чтобы добавить к тому, что ответил Мигель 9X_managed-bean Пинг, вот another section from the documentation, который также отвечает на этот 9X_managed-bean вопрос:

Краткая версия: используйте ApplicationContext, если 9X_spring-java-config у вас нет действительно веской причины не 9X_spring делать этого. Для тех из вас, кто хочет 9X_spring немного больше узнать о «но почему» приведенной 9X_spring-java-config выше рекомендации, продолжайте читать.

(опубликуйте 9X_spring-config это для всех будущих новичков Spring, которые 9X_spring могут прочитать этот вопрос)

1. ApplicationContext более предпочтителен, чем BeanFactory

2. В новых версиях 9X_applicationcontext Spring BeanFactory заменяется на ApplicationContext. Но все же BeanFactory существует 9X_applicationcontext для обратной совместимости

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

ApplicationContext: Он загружает компоненты Spring, настроенные 9X_spring-java-config в файле конфигурации Spring, и управляет 9X_applicationcontext жизненным циклом компонента Spring как и 9X_managed-bean WHEN CONTAINER STARTS. Он не будет ждать 9X_spring-framework вызова getBean ("springbeanref").

BeanFactory Он загружает компоненты Spring, настроенные 9X_spring-framework в файле конфигурации Spring, управляет жизненным 9X_applicationcontext циклом компонента Spring, когда мы вызываем 9X_spring-config getBean ("springbeanref"). Таким образом, когда мы вызываем getBean ("springbeanref") во время 9X_applicationcontext начала жизненного цикла фасоли весной.

Я думаю, что лучше всегда использовать ApplicationContext, если 9X_spring-framework только вы не работаете в мобильной среде, как 9X_spring-config уже сказал кто-то другой. ApplicationContext 9X_spring-java-config имеет больше функциональных возможностей, и 9X_managed-bean вы определенно хотите использовать такие 9X_spring-config PostProcessor, как RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor 9X_spring-java-config и CommonAnnotationBeanPostProcessor, которые 9X_spring-config помогут вам упростить ваши файлы конфигурации 9X_applicationcontext Spring, и вы можете использовать аннотации, такие 9X_applicationcontext как @Required, @PostConstruct, и т. Д. .

Даже 9X_spring если вы не используете все то, что предлагает 9X_applicationcontext ApplicationContext, все равно лучше использовать 9X_managed-bean его, а затем, если вы решите использовать 9X_managed-bean некоторые ресурсы, такие как сообщения или 9X_managed-bean почтовые процессоры, или другую схему для 9X_spring добавления транзакционных советов и у вас 9X_spring-config уже будет ApplicationContext, и вам не нужно 9X_spring будет изменять какой-либо код.

Если вы пишете 9X_spring-java-config автономное приложение, загрузите ApplicationContext 9X_spring в свой основной метод, используя ClassPathXmlApplicationContext, получите 9X_spring главный компонент и вызовите его run() (или 9X_spring-java-config любой другой метод) для запуска вашего приложения. Если 9X_spring вы пишете веб-приложение, используйте ContextLoaderListener 9X_managed-bean в web.xml, чтобы он создавал ApplicationContext, и 9X_applicationcontext вы могли позже получить его из ServletContext, независимо 9X_spring-framework от того, используете ли вы JSP, JSF, JSTL, struts, Tapestry 9X_spring и т. Д. .

Также помните, что вы можете использовать 9X_spring несколько файлов конфигурации Spring, и 9X_managed-bean вы можете либо создать ApplicationContext, перечислив 9X_spring все файлы в конструкторе (или перечислив 9X_spring-config их в параметре context для ContextLoaderListener), либо 9X_managed-bean вы можете просто загрузить основную конфигурацию 9X_spring-java-config файл, в котором есть операторы импорта. Вы 9X_spring-config можете импортировать файл конфигурации Spring 9X_spring-framework в другой файл конфигурации Spring с помощью 9X_applicationcontext , который очень полезен, когда вы программно 9X_spring-framework создаете ApplicationContext в основном методе 9X_spring-config и загружаете только один файл конфигурации 9X_spring-java-config Spring.

Различия между BeanFactory и ApplicationContext заключаются в следующем:

1. BeanFactory использует отложенную инициализацию, но ApplicationContext использует активную инициализацию. В случае BeanFactory bean создается при вызове метода getBeans(), но bean создается заранее в случае ApplicationContext при создании объекта ApplicationContext.
2. BeanFactory явно предоставляет объект ресурса с использованием синтаксиса, но ApplicationContext создает объекты ресурсов и управляет ими самостоятельно.
3. BeanFactory не поддерживает интернационализацию, но ApplicationContext поддерживает интернационализацию.
4. В BeanFactory внедрение зависимостей на основе аннотаций не поддерживается, но в 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"); 

9X_managed-bean

По большей части ApplicationContext предпочтительнее, если 9X_managed-bean вам не нужно экономить ресурсы, как в мобильном 9X_spring приложении.

Я не уверен в зависимости от 9X_applicationcontext формата XML, но уверен, что наиболее распространенными 9X_spring-framework реализациями ApplicationContext являются 9X_applicationcontext XML, такие как ClassPathXmlApplicationContext, XmlWebApplicationContext 9X_spring-config и FileSystemXmlApplicationContext. Это единственные 9X_managed-bean три, которые я когда-либо использовал.

Если 9X_spring-java-config вы разрабатываете веб-приложение, можно 9X_spring-config с уверенностью сказать, что вам понадобится 9X_spring-config XmlWebApplicationContext.

Если вы хотите, чтобы 9X_managed-bean ваши bean-компоненты знали о Spring, вы 9X_managed-bean можете заставить их реализовать для этого 9X_spring-config BeanFactoryAware и / или ApplicationContextAware, чтобы 9X_spring-java-config вы могли использовать BeanFactory или ApplicationContext 9X_managed-bean и выбрать, какой интерфейс реализовать.

В основном мы можем создать объект контейнера 9X_applicationcontext Spring двумя способами

1. с помощью BeanFactory.
2. с использованием ApplicationContext.

оба интерфейса,

используя 9X_spring-config классы реализации, мы можем создать объект 9X_spring для контейнера Spring

подходя к различиям

BeanFactory:

1. Не 9X_spring-java-config поддерживает внедрение зависимостей на основе 9X_spring-framework аннотаций.

2. Не поддерживает I18N.

3. По умолчанию 9X_spring поддерживается отложенная загрузка.

4. он не 9X_managed-bean позволяет настраивать несколько файлов конфигурации.

пример: BeanFactory 9X_spring-java-config context = new XmlBeanFactory (новый ресурс 9X_managed-bean ("applicationContext.xml"));

ApplicationContext

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

2. Поддержка 9X_spring-framework I18N

3. По умолчанию поддерживается агрессивная 9X_spring-config загрузка.

4. Позволяет настроить несколько файлов 9X_managed-bean конфигурации.

пример:
ApplicationContext 9X_spring-framework context = новый ClasspathXmlApplicationContext 9X_applicationcontext ("applicationContext.xml");

Матрица функций Bean Factory и контекст 9X_spring-java-config приложения sourced from spring docs

_{Снимок экрана с функциями BeanFacotry и ApplicationContext}

BeanFactory и ApplicationContext - оба способа получить beans из вашего 9X_spring весеннего контейнера IOC, но все же есть некоторая 9X_spring-config разница.

BeanFactory - это фактический контейнер, который 9X_spring создает, настраивает и управляет несколькими 9X_spring-framework компонентами. Эти bean-компоненты обычно 9X_spring-java-config взаимодействуют друг с другом и, следовательно, имеют 9X_spring-config зависимости между собой. Эти зависимости 9X_spring-java-config отражаются в данных конфигурации, используемых 9X_managed-bean BeanFactory.

BeanFactory и ApplicationContext являются интерфейсами Java, а 9X_spring-java-config ApplicationContext расширяет BeanFactory. Оба 9X_spring они настраиваются с использованием файлов 9X_spring-config конфигурации XML. Короче говоря, BeanFactory 9X_spring-framework предоставляет базовые функции инверсии управления 9X_managed-bean (IoC) и внедрения зависимостей (DI), в то время 9X_managed-bean как ApplicationContext предоставляет расширенные функции.

BeanFactory 9X_managed-bean представлен интерфейсом "org.springframework.beans.factory", где BeanFactory, для 9X_spring-config которого существует несколько реализаций.

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

РАЗНИЦА

1. BeanFactory создает 9X_spring экземпляр bean-компонента при вызове метода 9X_managed-bean getBean(), в то время как ApplicationContext создает 9X_spring-config экземпляр bean-компонента Singleton при 9X_managed-bean запуске контейнера. Он не ждет, пока getBean() называться.

2. BeanFactory не 9X_spring-framework поддерживает интернационализацию, но ApplicationContext обеспечивает 9X_spring ее.

3. Еще одно различие между BeanFactory и ApplicationContext - это возможность 9X_managed-bean публиковать событие в bean-компонентах, которые 9X_spring-framework зарегистрированы как прослушиватель.

4. Одной 9X_managed-bean из популярных реализаций интерфейса BeanFactory является 9X_spring-framework XMLBeanFactory, а одной из популярных реализаций интерфейса 9X_spring-config ApplicationContext является ClassPathXmlApplicationContext.

5. Если вы используете автоматическое 9X_spring подключение и используете BeanFactory, вам необходимо 9X_spring-config зарегистрировать AutoWiredBeanPostProcessor с помощью API, который 9X_spring-framework можно настроить в XML, если вы используете 9X_managed-bean ApplicationContext. Таким образом, BeanFactory подходит для тестирования 9X_applicationcontext и непроизводственного использования, но 9X_spring-java-config ApplicationContext является более многофункциональной реализацией 9X_applicationcontext контейнера, и ему следует отдавать предпочтение 9X_spring-config перед BeanFactory

   .

6. BeanFactory по умолчанию поддерживает ленивую загрузку, а 9X_managed-bean ApplicationContext по умолчанию поддерживает агрессивную загрузку.

а. Одно из различий между фабрикой компонентов 9X_spring-config и контекстом приложения состоит в том, что 9X_spring-java-config первый экземпляр компонента создается только 9X_spring при вызове метода getBean(), в то время 9X_spring-framework как ApplicationContext создает экземпляр 9X_spring-config компонента Singleton при запуске контейнера. Он 9X_applicationcontext не ждет вызова getBean.

б.

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

или

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

Вы можете использовать 9X_spring-config один или несколько XML-файлов в зависимости 9X_spring-framework от требований вашего проекта. Поскольку 9X_applicationcontext я здесь использую два файла xml, то есть 9X_spring-java-config один для деталей конфигурации для классов 9X_spring-java-config обслуживания, другой для классов dao. Здесь 9X_spring-java-config ClassPathXmlApplicationContext является 9X_spring-java-config дочерним по отношению к ApplicationContext.

в. BeanFactory 9X_managed-bean Container - это базовый контейнер, он может 9X_spring-java-config только создавать объекты и вводить зависимости. Но 9X_spring-config мы не можем присоединить другие сервисы, такие 9X_spring-framework как безопасность, транзакции, обмен сообщениями 9X_spring-java-config и т. Д., Чтобы предоставить все сервисы, которые 9X_managed-bean у нас есть, для использования ApplicationContext 9X_spring Container.

d. BeanFactory не поддерживает 9X_spring-config интернационализацию, то есть i18n, но ApplicationContext 9X_spring-config поддерживает ее.

e. Контейнер BeanFactory 9X_spring не поддерживает функцию автосканирования 9X_spring-config (поддержка внедрения зависимостей на основе 9X_spring аннотаций), но контейнер ApplicationContext 9X_spring-framework поддерживает.

е. Контейнер Beanfactory не 9X_spring будет создавать объект bean до времени запроса. Это 9X_spring-framework означает, что Beanfactory Container лениво 9X_spring-java-config загружает бобы. В то время как ApplicationContext 9X_managed-bean Container создает объекты bean-компонента 9X_spring-java-config Singleton только во время загрузки. Значит, идет 9X_spring-java-config ранняя загрузка.

г. Контейнер Beanfactory 9X_spring поддерживает только две области (singleton 9X_managed-bean и prototype) bean-компонентов. Но контейнер 9X_applicationcontext ApplicationContext поддерживает всю область 9X_spring-java-config действия bean-компонентов.

Мои шесть центов:

1. BeanFactory и ApplicationContext оба являются интерфейсамиs, где ApplicationContext расширяет BeanFactory. Итак, ApplicationContext — это дочерний интерфейс, а BeanFactory — родительский интерфейс. Другими словами, ApplicationContext имеет все функции BeanFactory и некоторые дополнительные функции, которых нет в BeanFactory.
2. BeanFactory загружает bean-компоненты по запросу, то есть отложенная загрузка, тогда как ApplicationContext загружает все bean-компоненты при запуске, то есть нетерпеливая загрузка.
3. BeanFactory не поддерживает аннотации, тогда как ApplicationContext поддерживает аннотации.
4. ApplicationContext имеет дополнительные функции, которых нет в BeanFactory: Интернационализация, публикация событий, функции AOP.
5. BeanFactory поддерживает только две области действияs — Singleton и Prototype, тогда как ApplicationContext поддерживает все области действия компонентов.
6. BeanFactory не регистрирует BeanFactoryPostProcessor и BeanPostProcessor автоматически, тогда как ApplicationContext автоматически регистрирует их.

9X_managed-bean

Обратитесь к этому документу из 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 9X_spring-framework BeanFactory или ApplicationContext?

Используйте 9X_applicationcontext ApplicationContext, если у вас нет веской 9X_applicationcontext причины для этого.

Поскольку ApplicationContext 9X_spring-config включает в себя все функциональные возможности 9X_applicationcontext BeanFactory, его обычно рекомендуется использовать 9X_managed-bean вместо BeanFactory, за исключением нескольких 9X_spring-java-config ситуаций, таких как апплет, где потребление 9X_applicationcontext памяти может быть критическим и несколько 9X_applicationcontext дополнительных килобайт могут иметь значение. Однако 9X_managed-bean для большинства типичных корпоративных приложений 9X_spring и систем ApplicationContext - это то, что 9X_spring-java-config вы захотите использовать. Spring 2.0 и более 9X_spring-framework поздние версии активно используют точку 9X_spring-java-config расширения BeanPostProcessor (для выполнения 9X_spring проксирования и т. Д.). Если вы используете 9X_applicationcontext только простой BeanFactory, значительная 9X_applicationcontext поддержка, такая как транзакции и АОП, не 9X_managed-bean вступит в силу, по крайней мере, без некоторых 9X_spring-config дополнительных шагов с вашей стороны. Эта 9X_spring-java-config ситуация может сбивать с толку, потому что 9X_managed-bean на самом деле с конфигурацией все в порядке.

ApplicationContext - это старший брат BeanFactory, и 9X_managed-bean это все, что предоставляет BeanFactory, а 9X_spring-config также многое другое.

В дополнение к стандартным 9X_managed-bean возможностям жизненного цикла org.springframework.beans.factory.BeanFactory, реализации 9X_applicationcontext ApplicationContext обнаруживают и вызывать 9X_managed-bean компоненты ApplicationContextAware, а также 9X_spring-config компоненты ResourceLoaderAware, ApplicationEventPublisherAware 9X_spring и MessageSourceAware.

В сценарии реального времени разница между 9X_spring контейнером Spring IOC Core (BeanFactory) и 9X_spring расширенным контейнером J2EE (ApplicationContext) заключается 9X_spring-framework в следующем.

1. BeanFactory будет создавать 9X_spring-config объекты для bean-компонентов (т. е. для 9X_applicationcontext классов POJO), упомянутых в файле spring.xml 9X_applicationcontext (), только когда вы вызываете метод .getBean(), но 9X_spring-config тогда как ApplicationContext создает объекты 9X_spring-framework для все компоненты (, если его область действия 9X_spring-config явно не указана как «Прототип»), настроенные 9X_spring-java-config в spring.xml при загрузке самого файла spring.xml.

2. BeanFactory: (Ленивый 9X_spring-java-config контейнер, потому что он создает объекты 9X_applicationcontext для bean-компонентов только тогда, когда 9X_managed-bean вы явно вызываете из пользовательского / основного 9X_spring класса)

   /* * 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: (Стремительный 9X_managed-bean контейнер из-за создания объектов всех одноэлементных 9X_managed-bean bean-компонентов при загрузке самого файла 9X_spring-config spring.xml)

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

3. Технически рекомендуется использовать 9X_managed-bean ApplicationContext, потому что в приложениях 9X_managed-bean реального времени объекты bean-компонентов 9X_spring-config будут созданы во время запуска приложения 9X_spring-framework на самом сервере. Это сокращает время ответа 9X_managed-bean на запрос пользователя, поскольку объекты 9X_spring-config уже доступны для ответа.

Мне нужно объяснить BeanFactory и ApplicationContext.

BeanFactory: BeanFactory 9X_spring-framework - это корневой интерфейс для доступа к контейнеру 9X_spring SpringBean. Существует базовое клиентское 9X_spring-java-config представление контейнера bean. Этот интерфейс 9X_applicationcontext реализуется классом объектов, который содержит 9X_spring-java-config количество определений bean-компонентов, и 9X_spring-framework каждое из них уникально идентифицируется 9X_applicationcontext по имени String
В зависимости от определения 9X_spring-java-config Бина фабрика вернет экземпляр, который может 9X_spring-java-config быть экземпляром содержащегося объекта или 9X_spring единственным совместно используемым экземпляром. Тип 9X_managed-bean возвращаемого экземпляра зависит от заводской 9X_spring-framework конфигурации компонента.
Обычно фабрика 9X_spring-java-config Bean загружает все определения всех beans, которые 9X_spring-framework хранятся в источнике конфигурации, например 9X_spring-framework XML ... и т. Д.

BeanFactory - это простейший 9X_managed-bean контейнер, обеспечивающий базовую поддержку 9X_spring внедрения зависимостей

Контекст приложения Контекст приложения 9X_spring - это центральный интерфейс с приложением 9X_applicationcontext Spring, который предоставляет информацию 9X_spring-framework о конфигурации приложению. Он реализует 9X_spring-framework интерфейс Bean Factory.

Контекст приложения 9X_spring-framework - это расширенный контейнер, в который добавляется 9X_spring-config расширенный уровень специфической для предприятия 9X_spring-config функциональности, такой как возможность 9X_spring разрешать текстовое сообщение из файла свойств 9X_managed-bean ... и т. д.

ApplicationContext обеспечивает:

Методы 9X_spring-java-config фабрики компонентов для доступа к компонентам 9X_applicationcontext приложения. Унаследовано от ListableBeanFactory. Возможность 9X_spring-config загружать файловые ресурсы обычным образом. Унаследовано 9X_spring-java-config от интерфейса ResourceLoader. Возможность 9X_spring-config публиковать события для зарегистрированных 9X_spring-java-config слушателей. Унаследовано от интерфейса ApplicationEventPublisher. Возможность 9X_spring разрешать сообщения, поддерживающие интернационализацию. Унаследовано 9X_spring от интерфейса MessageSource. Наследование 9X_spring-framework от родительского контекста. Определения 9X_spring-java-config в контексте потомка всегда будут иметь приоритет. Это 9X_spring-framework означает, например, что единственный родительский 9X_spring-framework контекст может использоваться всем веб-приложением, в 9X_spring-java-config то время как каждый сервлет имеет свой собственный 9X_applicationcontext дочерний контекст, который не зависит от 9X_applicationcontext контекста любого другого сервлета. В дополнение 9X_spring-framework к стандартным возможностям жизненного цикла 9X_spring-config BeanFactory, реализации ApplicationContext 9X_spring-java-config обнаруживают и вызывают компоненты ApplicationContextAware, а 9X_applicationcontext также компоненты ResourceLoaderAware, ApplicationEventPublisherAware 9X_spring-config и MessageSourceAware.