Что такое applicationcontext когда он создается

Введение в текст Spring ClassPathXmlApplicationContext

Краткое руководство с введением в ClassPathXmlApplicationContext, которое охватывает API, жизненный цикл и интернационализацию с примерами.

1. Обзор

Ядро Spring Framework-это, проще говоря, контейнер IoC, используемый для управления бобами.

В Spring есть два основных типа контейнеров – фабрика бобов и Контекст приложения. Первый обеспечивает основные функциональные возможности, которые представлены здесь ; последний является надмножеством первого и наиболее широко используется.

2. Основное использование

2.1. Инициализация контейнера и управление бобами

ClassPathXmlApplicationContext может загружать конфигурацию XML из пути к классу и управлять ее компонентами:

У нас есть Студент класс:

Мы настраиваем Студент был в classpathxmlapplicationcontext-example.xml и добавьте его в путь к классу:

Теперь мы можем использовать ClassPathXmlApplicationContext для загрузки конфигурации XML и получения компонента Student :

2.2. Несколько конфигураций XML

Иногда мы хотим использовать несколько конфигураций XML для инициализации контейнера Spring. В этом случае нам просто нужно добавить несколько местоположений конфигурации при построении ApplicationContext :

3. Дополнительные Возможности

3.1. Изящно Закройте Пружинный контейнер МоК

Когда мы используем контейнер Spring IoC в веб-приложении, веб-реализации Spring ApplicationContext будут корректно завершать работу контейнера при закрытии приложения, но если мы используем его в не веб-среде, такой как автономное настольное приложение, мы должны самостоятельно зарегистрировать крюк завершения работы в JVM, чтобы убедиться, что контейнер Spring IoC корректно завершается и вызывает методы destroy для освобождения ресурсов.

Давайте добавим метод destroy() в класс Student :

Теперь мы можем настроить этот метод как метод уничтожения student bean:

Теперь мы зарегистрируем крюк выключения:

3.2. Интернационализация С Источником Сообщений

Вот пример использования разных языков с Источником сообщений :

Настройте MessageSource bean в classpathxmlapplicationcontext-internationalization.xml :

Затем давайте получим диалоговые слова разных языков с помощью MessageSource :

4. Ссылка на текст приложения

У нас есть Курс класс с именем:

У нас есть Учитель класс, который собирает свои курсы в соответствии с фасолью контейнера:

Давайте настроим курс боб и учитель был в classpathxmlapplicationcontext-example.xml :

Затем – протестируйте инъекцию курсов свойства:

Давайте изменим класс Учитель на этот:

Затем запустите этот тест, и мы увидим, что результат тот же.

5. Заключение

Источник

Разница между BeanFactory и ApplicationContext

Узнайте о существенных различиях между ApplicationContext Spring и BeanFactory на практических примерах

1. Обзор

В этом кратком руководстве мы поймем существенные различия между этими двумя контейнерами IOC с практическими примерами.

2. Ленивая загрузка против Нетерпеливая Загрузка

2.1. Ленивая Загрузка С BeanFactory

Предположим, у нас есть одноэлементный боб класс с именем Student с одним методом:

Давайте проверим инициализацию нашего Student bean, где мы вручную вызываем метод getBean() :

Здесь компонент Student успешно загружается. Следовательно, BeanFactory загружает боб только тогда, когда это необходимо.

2.2. Нетерпеливая Загрузка С Помощью ApplicationContext

Теперь давайте использовать ApplicationContext вместо BeanFactory.

Мы определим только ApplicationContext, и он мгновенно загрузит все компоненты, используя стратегию нетерпеливой загрузки:

Здесь, в Студент объект создается, даже если мы не вызывали getBean() метод.

3. Функции корпоративного приложения

ApplicationContext расширяет BeanFactory в более ориентированном на фреймворк стиле и предоставляет несколько функций, подходящих для корпоративных приложений.

4. Автоматическая регистрация BeanFactoryPostProcessor и BeanPostProcessor

ApplicationContext автоматически регистрирует BeanFactoryPostProcessor и BeanPostProcessor при запуске. С другой стороны, BeanFactory не регистрирует эти интерфейсы автоматически.

4.1. Регистрация в BeanFactory

Чтобы понять, давайте напишем два класса.

Кроме того, мы настроили оба класса в нашем ioc-container-difference-example.xml файл конфигурации:

Давайте рассмотрим тестовый случай, чтобы проверить, регистрируются ли эти два класса автоматически во время запуска:

Теперь давайте рассмотрим тестовый случай, который вручную добавляет их в Бобовый завод :

4.2. Регистрация в ApplicationContext

Как мы уже отмечали ранее, ApplicationContext регистрирует оба класса автоматически без написания дополнительного кода.

Давайте проверим это поведение в модульном тесте:

Также стоит отметить, что если вы используете обычный BeanFactory, то такие функции, как транзакции и AOP, не вступят в силу (по крайней мере, без написания дополнительных строк кода). Это может привести к путанице, потому что в конфигурации ничего не будет выглядеть неправильно.

5. Заключение

В этой статье мы рассмотрели ключевые различия между ApplicationContext и BeanFactory на практических примерах.

Источник

Spring ApplicationContext

Узнайте об интерфейсе ApplicationContext в Spring и о том, как настроить компоненты в некоторых наиболее распространенных типах ApplicationContext.

1. Обзор

2. Интерфейс ApplicationContext

Одной из основных особенностей пружинного каркаса является контейнер IoC (Инверсия управления). Контейнер Spring IoC отвечает за управление объектами приложения. Он использует инъекцию зависимостей для достижения инверсии управления.

3. Что такое Весенняя Фасоль?

Итак, должны ли мы настроить все объекты нашего приложения как Spring beans? Ну, как лучшая практика, мы не должны этого делать.

Кроме того, как правило, мы не должны настраивать мелкозернистые объекты домена в контейнере. Обычно ответственность за создание и загрузку объектов домена лежит на DAO и бизнес-логике.

Итак, давайте определим простой класс Java, который мы будем использовать в качестве компонента Spring в этом уроке:

4. Настройка бобов в контейнере

Как мы знаем, основная задача ApplicationContext заключается в управлении бобами.

4.1. Конфигурация на основе Java

Во-первых, мы начнем с конфигурации на основе Java, поскольку это самый новый и наиболее предпочтительный способ настройки компонентов. Он доступен с весны 3.0 и далее.

Конфигурация Java обычно использует @Bean -аннотированные методы в классе @Configuration . Аннотация @Bean в методе указывает, что метод создает пружинный компонент. Кроме того, класс с аннотацией @Configuration указывает, что он содержит конфигурации компонентов Spring.

Итак, давайте теперь создадим класс конфигурации, чтобы определить наш Account Service класс как Spring bean:

4.2. Конфигурация на основе аннотаций

Spring 2.5 представила конфигурацию на основе аннотаций в качестве первого шага для включения конфигураций компонентов в Java.

Примечательно, что мы также используем эти аннотации с конфигурацией на основе Java. Кроме того, Spring продолжает добавлять новые возможности к этим аннотациям с каждым выпуском.

Итак, теперь давайте рассмотрим простой пример этой конфигурации.

Во-вторых, мы создадим класс User Service и определим его как Spring bean, используя аннотацию @Component :

А затем мы напишем простой тестовый случай для проверки этой конфигурации:

4.3. Конфигурация на основе XML

Наконец, давайте рассмотрим конфигурацию на основе XML. Это традиционный способ настройки бобов весной.

5. Типы ApplicationContext

5.1. Аннотацияconfigapplicationcontext

Итак, давайте рассмотрим простой пример использования контейнера AnnotationConfigApplicationContext с нашей конфигурацией на основе Java:

5.2. аннотацияconfigwebapplicationcontext

Мы можем использовать этот класс при настройке прослушивателя Spring ContextLoaderListener servlet или Spring MVC DispatcherServlet в web.xml файл.

Кроме того, начиная с Spring 3.0 и далее, мы также можем программно настроить этот контейнер контекста приложения. Все, что нам нужно сделать, это реализовать интерфейс WebApplicationInitializer :

5.3. XmlWebApplicationContext

5.4. Файловая система xmlapplicationcontext

Например, давайте посмотрим, как мы можем создать этот контейнер Spring и загрузить компоненты для нашей конфигурации на основе XML:

5.5. ClassPathXmlApplicationContext

Итак, давайте рассмотрим пример использования этого класса:

6. Дополнительные возможности ApplicationContext

6.1. Разрешение сообщений

Мы можем использовать StaticMessageSource для программного добавления сообщений в источник. Однако он поддерживает базовую интернационализацию и больше подходит для тестов, чем для производственного использования.

Теперь давайте посмотрим, как мы можем использовать Источник сообщений для чтения сообщений из файла свойств.

Сначала мы создадим файл messages.properties в пути к классу:

Во-вторых, мы добавим определение компонента в наш класс Account Config :

В-третьих, мы введем MessageSource в службу учетных записей :

Наконец, мы можем использовать метод GetMessage в любом месте службы Account для чтения сообщения:

6.2. Обработка событий

7. Заключение

Источник

Русские Блоги

Поговорим о BeanFactory и ApplicationContext во фреймворке Spring

Spring описывает отношения зависимости между Bean и Bean через файл конфигурации и использует функцию отражения Java для создания экземпляра Bean и установления отношения зависимости между Beans. Контейнер IoC Sprig также предоставляет расширенные услуги, такие как кэширование экземпляра компонента, управление жизненным циклом, прокси-сервер экземпляра компонента, публикация событий и загрузка ресурсов на основе выполнения этих основных задач.

Контекст приложения (com.springframework.context.ApplicationContext) основан на BeanFactory и предоставляет больше функций, ориентированных на приложения. Он обеспечивает поддержку интернационализации и систему событий каркаса, упрощая создание практических приложений.

1 BeanFactory

1.1 Архитектура классов

Существует множество реализаций BeanFactory. В версиях до Spring 3.2 наиболее часто используется XmlBeanFactory, который теперь является устаревшим. Рекомендуется использовать XmlBeanDefinitionReader и DefaultListableBeanFactory.

Интерфейс BeanFactory находится наверху дерева структуры класса. Его основным методом является getBean (String beanName), который возвращает объект Bean с определенным именем из контейнера. Функции BeanFactory постоянно расширяются с помощью других интерфейсов.

1.2 Инициализация

Затем мы настраиваем Bean People в файле конфигурации Spring, затем загружаем файл конфигурации через BeanFactory и запускаем контейнер Ioc.

Файл конфигурации Spring:

Затем используйте DefaultListableBeanFactory и XmlBeanDefinitionReader для запуска контейнера Ioc:

XmlBeanDefinitionReader загружает информацию о конфигурации Spring через Resource и запускает контейнер Ioc, а затем вы можете получить Bean через BeanFactory # getBean (name). Инициализация компонента происходит при его первом вызове. Для одноэкземплярных bean-компонентов BeanFactory кэширует экземпляр Bean, поэтому второе использование метода getBean () будет напрямую получать экземпляр Bean из кеша контейнера IoC.

Примечание: При инициализации BeanFactory для него должна быть предоставлена ​​структура журнала.Обычно используется Log4J, то есть файл конфигурации Log4J предоставляется в пути к классам, так что контейнер Spring можно запустить в обычном режиме.

2 ApplicationContext

ApplicationContext является производным от BeanFactory и предоставляет множество практических функций приложения. В BeanFactory многие функции должны быть реализованы программно, а в ApplicationContext они могут быть реализованы через конфигурацию.

2.1 Архитектура класса ApplicationContext

2.1.1 Конфигурация XML

При инициализации ApplicationContext выберите класс реализации ApplicationContext в соответствии с путем к файлу конфигурации.

Вы также можете указать набор файлов конфигурации, и Spring автоматически интегрирует содержимое нескольких файлов конфигурации:

Примечание. ClassPathXmlApplicationContext и FileSystemXmlApplicationContext также могут явно указывать путь с префиксом типа ресурса.

2.1.2 Конфигурация аннотации класса

Spring поддерживает настройку на основе аннотаций классов.Основная функция происходит из подпроекта Spring под названием JavaConfig. В настоящее время JavaConfig обновлен до части основной инфраструктуры Spring. POJO с аннотацией @Configuration может предоставить информацию о конфигурации Bean, требуемую Spring.

По сравнению с методом конфигурации XML, метод конфигурации, основанный на аннотации класса, позволяет разработчикам управлять процессом инициализации компонента, поэтому он более гибкий.

Конфигурация компонента на основе аннотаций класса должна использовать AnnotationConfigApplicationContext для запуска контейнера Spring:

2.1.3 Конфигурация Groovy DSL

Spring 4.x поддерживает использование Groovy DSL для настройки компонентов, с помощью которых может быть реализована сложная и гибкая логика конфигурации.

Сначала введите Groovy в pom.xml:

Затем добавьте файл конфигурации:

Наконец, используйте GenericGroovyApplicationContext для запуска контейнера:

2.2 Архитектура класса WebApplicationContext

WebApplicationContext предназначен для веб-приложений. Он позволяет загружать файл конфигурации из пути относительно корневого веб-каталога для завершения работы по инициализации. Ссылку на ServletContext можно получить из WebApplicationContext. Весь объект контекста веб-приложения будет помещен в качестве атрибута в ServletContext, чтобы веб-приложение могло Для доступа к контексту Spring Spring предоставляет метод getWebApplicationContext (ServletContext src) для WebApplicationContextUtils для получения экземпляра WebApplicationContext из ServletContext.

В среде приложений, отличных от веб-приложений, Bean имеет только две области: одноэлементную и прототипную. В WebApplicationContext он добавляет к Бину еще три области: запрос, сеанс и глобальный сеанс.

WebApplicationContext расширяет ApplicationContext. WebApplicationContext определяет константу ROOT_WEB_APPLICATION_ CONTEXT_ATTRIBUTE. Когда контекст запускается, экземпляр WebApplicationContext использует эту константу в качестве ключа и помещается в список атрибутов ServletContext. Таким образом, мы можем напрямую получить WebApplicationContext из веб-контейнера с помощью следующего оператора:

ConfigurableWebApplicationContext расширяет WebApplicationContext, что позволяет создавать экземпляр WebApplicationContext через конфигурацию, и определяет два важных метода:

2.3 Инициализировать контекст WebApplicationContext

WebApplicationContext требуется экземпляр ServletContext, у него должен быть веб-контейнер, чтобы завершить начальную работу. Мы можем настроить самозапускающийся сервлет или определить прослушиватель веб-контейнера (ServletContextListener) в web.xml. С помощью одного из этих двух элементов мы можем запустить контекст веб-приложения Spring.

нота: Все версии веб-контейнеров поддерживают самозапускающийся сервлет, но только веб-контейнеры Servlet 2.3 и выше поддерживают слушателей веб-контейнеров. Но некоторые веб-контейнеры являются исключением, например Weblogic 8.1, WebSphere 5.x, Oracle OC4J 9.0 и так далее.

Spring предоставляет прослушиватель сервлетов и веб-контейнеров для запуска WebApplicationContext:
* org.springframework.web.context.ContextLoaderServlet。
* org.springframework.web.context.ContextLoaderListener。

2.3.1 XML-метод

Давайте запустим WebApplicationContext с помощью ContextLoaderListener:

ContextLoaderListener получает местоположение файла конфигурации Spring через параметр контекста веб-контейнера contextConfigLocation. Вы можете указать несколько файлов конфигурации, и вы можете использовать запятые, пробелы или двоеточия для их разделения. Для путей к файлам без префикса типа ресурса WebApplicationContext будет по умолчанию использовать эти пути как корневой путь развертывания в Интернете. Конечно, вы также можете использовать конфигурацию пути с префиксом типа ресурса, например здесь classpath*:spring-*.xml 。

Если вы находитесь в веб-контейнере с низкой версией, который не поддерживает прослушиватели контейнеров, мы можем использовать ContextLoaderServlet для завершения работы по запуску, поскольку Spring 4 больше не поддерживает этот класс, поэтому мы не будем его повторять.

Поскольку WebApplicationContext должен использовать журнал, мы помещаем файл конфигурации Log4J в путь к классам WEB-INF / classes, чтобы механизм Log4J мог запускаться плавно. Если файл конфигурации Log4J находится в другом месте, вы должны указать расположение файла конфигурации Log4J в web.xml. Spring предоставляет два класса реализации, аналогичные запуску WebApplicationContext для включения механизма Log4J: Log4jConfigServlet (больше не поддерживается в Spring4) и Log4jConfigListener. Независимо от того, какой метод используется, необходимо убедиться, что информация о конфигурации Log4J может быть загружена до загрузки файла конфигурации Spring.

нота: Log4jConfigListener должен быть помещен перед ContextLoaderListener, чтобы гарантировать, что первый запускается первым, завершает загрузку файла конфигурации Log4J и инициализирует механизм Log4J, а затем запускает последний.

2.3.2 Метод аннотации

Вы также можете использовать аннотированный Java-класс @Configuration для предоставления информации о конфигурации:

В это время, если ContextLoaderListener находит параметр контекста contextClass, он будет использовать AnnotationConfigWebApplicationContext, указанный параметром, для инициализации контейнера. Класс реализации инициализирует контейнер в соответствии с информацией о конфигурации, предоставленной классом конфигурации @Configuration, указанным параметром contextConfigLocation.

2.3.3 Groovy DSL способ

Вы также можете использовать метод Groovy DSL, принцип аналогичен методу аннотации.

2.4 родительско-дочерний контейнер

Через интерфейс HierarchicalBeanFactory контейнер IoC Spring может установить иерархическую систему контейнеров «родитель-потомок». Дочерний контейнер может получить доступ к Bean в родительском контейнере, но родительский контейнер не может получить доступ к Bean дочернего контейнера. Внутри контейнера идентификатор bean-компонента должен быть уникальным, но дочерний контейнер может иметь bean-компонент с тем же идентификатором, что и родительский контейнер. Иерархия родительско-дочерних контейнеров повышает масштабируемость и гибкость контейнерной архитектуры Spring, поэтому третьи стороны могут программно добавлять один или несколько дочерних контейнеров специального назначения к существующему контейнеру для обеспечения некоторых дополнительных функций.

Spring использует характеристики родительско-дочерних контейнеров для достижения многих возможностей.Например, в Spring MVC Бин уровня представления расположен в дочернем контейнере, а Бины бизнес-уровня и уровня сохраняемости расположены в родительском контейнере. Таким образом, Бин уровня представления может относиться к бизнес-уровню и Бину уровня сохраняемости, но Бин бизнес-уровня и Бин уровня сохраняемости не может видеть Бин уровня представления.

Источник