Какой интерфейс используется для контекста приложения spring
Узнайте об интерфейсе ApplicationContext в Spring и о том, как настроить компоненты в некоторых наиболее распространенных типах ApplicationContext.
1. Обзор
В этом уроке мы подробно рассмотрим интерфейс Spring Applicationcontext .
2. Интерфейс ApplicationContext
Одной из основных особенностей пружинного каркаса является контейнер IoC (Инверсия управления). Контейнер Spring IoC отвечает за управление объектами приложения. Он использует инъекцию зависимостей для достижения инверсии управления.
Интерфейсы BeanFactory и ApplicationContext представляют контейнер Spring IoC . Здесь BeanFactory является корневым интерфейсом для доступа к контейнеру Spring. Он предоставляет основные функциональные возможности для управления бобами.
С другой стороны, ApplicationContext является подинтерфейсом BeanFactory . Следовательно, он предлагает все функции BeanFactory.
3. Что такое Весенняя Фасоль?
Итак, должны ли мы настроить все объекты нашего приложения как Spring beans? Ну, как лучшая практика, мы не должны этого делать.
Согласно документации Spring , в общем случае мы должны определить компоненты для объектов уровня обслуживания, объектов доступа к данным (DAO), объектов представления, объектов инфраструктуры, таких как Hibernate SessionFactories, Очереди JMS и так далее.
Кроме того, как правило, мы не должны настраивать мелкозернистые объекты домена в контейнере. Обычно ответственность за создание и загрузку объектов домена лежит на DAO и бизнес-логике.
Итак, давайте определим простой класс Java, который мы будем использовать в качестве компонента Spring в этом уроке:
4. Настройка бобов в контейнере
Как мы знаем, основная задача ApplicationContext заключается в управлении бобами.
Таким образом, приложение должно предоставить конфигурацию компонента контейнеру ApplicationContext . Таким образом, конфигурация компонента Spring состоит из одного или нескольких определений компонента. Кроме того, Spring поддерживает различные способы настройки компонентов.
4.1. Конфигурация на основе Java
Во-первых, мы начнем с конфигурации на основе Java, поскольку это самый новый и наиболее предпочтительный способ настройки компонентов. Он доступен с весны 3.0 и далее.
Конфигурация Java обычно использует @Bean -аннотированные методы в классе @Configuration . Аннотация @Bean в методе указывает, что метод создает пружинный компонент. Кроме того, класс с аннотацией @Configuration указывает, что он содержит конфигурации компонентов Spring.
Итак, давайте теперь создадим класс конфигурации, чтобы определить наш Account Service класс как Spring bean:
4.2. Конфигурация на основе аннотаций
Spring 2.5 представила конфигурацию на основе аннотаций в качестве первого шага для включения конфигураций компонентов в Java.
В этом подходе мы сначала включаем конфигурацию на основе аннотаций с помощью конфигурации XML. Затем мы используем набор аннотаций к нашим классам Java, методам, конструкторам или полям для настройки компонентов. Некоторые примеры этих аннотаций: @Component , @Controller , @Service , @Repository , @Autowired и @Qualifier .
Примечательно, что мы также используем эти аннотации с конфигурацией на основе Java. Кроме того, Spring продолжает добавлять новые возможности к этим аннотациям с каждым выпуском.
Итак, теперь давайте рассмотрим простой пример этой конфигурации.
Сначала мы создадим конфигурацию XML, user-bean-config.xml , чтобы включить аннотации:
Здесь тег annotation-config включает сопоставления на основе аннотаций . Кроме того, тег component-scan указывает Spring, где искать аннотированные классы.
Во-вторых, мы создадим класс User Service и определим его как Spring bean, используя аннотацию @Component :
А затем мы напишем простой тестовый случай для проверки этой конфигурации:
4.3. Конфигурация на основе XML
Наконец, давайте рассмотрим конфигурацию на основе XML. Это традиционный способ настройки бобов весной.
Очевидно, что при таком подходе мы выполняем все сопоставления bean в файле конфигурации XML .
Итак, давайте создадим файл конфигурации XML, account-bean-config.xml , и определить компоненты для нашего AccountService класса:
5. Типы ApplicationContext
Spring предоставляет различные типы ApplicationContext контейнеров, подходящих для различных требований. Это реализации интерфейса ApplicationContext . Итак, давайте рассмотрим некоторые из распространенных типов ApplicationContext .
5.1. Аннотацияconfigapplicationcontext
Во-первых, давайте посмотрим класс AnnotationConfigApplicationContext , который был представлен весной 3.0. Он может принимать классы, аннотированные @Configuration , @Component , и метаданные JSR-330 в качестве входных данных.
Итак, давайте рассмотрим простой пример использования контейнера AnnotationConfigApplicationContext с нашей конфигурацией на основе Java:
5.2. аннотацияconfigwebapplicationcontext
Мы можем использовать этот класс при настройке прослушивателя Spring ContextLoaderListener servlet или Spring MVC DispatcherServlet в web.xml файл.
Кроме того, начиная с Spring 3.0 и далее, мы также можем программно настроить этот контейнер контекста приложения. Все, что нам нужно сделать, это реализовать интерфейс WebApplicationInitializer :
5.3. XmlWebApplicationContext
Если мы используем конфигурацию на основе XML в веб-приложении , мы можем использовать класс XmlWebApplicationContext .
На самом деле настройка этого контейнера похожа только на класс AnnotationConfigWebApplicationContext , что означает, что мы можем настроить его в web.xml или реализовать интерфейс WebApplicationInitializer :
5.4. Файловая система xmlapplicationcontext
Мы используем класс FileSystemXMLApplicationContext для загрузки файла конфигурации Spring на основе XML из файловой системы или из URL-адресов. Этот класс полезен, когда нам нужно загрузить ApplicationContext программно. В общем, тестовые жгуты и автономные приложения-вот некоторые из возможных вариантов использования для этого.
Например, давайте посмотрим, как мы можем создать этот контейнер Spring и загрузить компоненты для нашей конфигурации на основе XML:
5.5. ClassPathXmlApplicationContext
В случае, если мы хотим загрузить файл конфигурации XML из пути к классу , мы можем использовать класс ClassPathXmlApplicationContext|/. Подобно FileSystemXMLApplicationContext, он полезен для тестовых жгутов, а также для контекстов приложений, встроенных в банки.
Итак, давайте рассмотрим пример использования этого класса:
6. Дополнительные возможности ApplicationContext
Сначала мы создадим файл messages.properties в пути к классу:
Во-вторых, мы добавим определение компонента в наш класс Account Config :
В-третьих, мы введем MessageSource в службу учетных записей :
Spring также предоставляет класс ReloadableResourceBundleMessageSource , который позволяет считывать файлы из любого расположения ресурсов Spring и поддерживает горячую перезагрузку файлов свойств пакета.
6.2. Обработка событий
ApplicationContext поддерживает обработку событий с помощью класса ApplicationEvent и интерфейса ApplicationListener . Он поддерживает встроенные события , такие как ContextStartedEvent , ContextStoppedEvent , ContextClosedEvent и RequestHandledEvent . Кроме того, он также поддерживает пользовательские события для бизнес-случаев использования.
7. Заключение
В этом уроке мы обсудили различные аспекты контейнера ApplicationContext весной. Мы видели различные примеры того, как настроить компоненты Spring в Applicationcontext . Кроме того, мы видели, как создавать и использовать различные типы ApplicationContext .
Контекст (а у него есть даже интерфейс — org.springframework.context.ApplicationContext ) — это некоторое окружение, в котором работает приложение на Spring Framework. Страшные аббревиатуры DI, IoC — это всё про него. Собственно, контекст создаёт и хранит экземпляры классов вашего приложения, определяет их зависимости друг с другом и автоматически их задаёт.
Безусловно, для того чтобы Spring создал контекст с экземплярами классов, ему нужно предоставить дополнительную информацию — мета-данные, из каких классов/объектов состоит ваше приложение, как они создаются, какие у них есть зависимости и т. д.
Итого: Spring Context + мета-данные = работающее приложение.
Где найти контекст?
Контекст является ключевой функциональностью Spring и лежит в maven-зависимости spring-context (на момент написания — org.springframework:spring-context:5.1.4.RELEASE ). Обычно эта зависимость является транзитивной для остальных проектов Spring. И если вы, например, подключаете spring-boot-starter, то она подключится автоматически, и не нужно думать про то, где её взять.
Но если вы хотите попробовать "голый" Spring, т. е. только ту часть, которая называется IoC-контейнер, то достаточно подключить лишь spring-context.
Итого: подключите org.springframework:spring-context:5.1.4.RELEASE .
Какие бывают контексты и как их создать?
У интерфейса ApplicationContext есть большое количество реализаций: — ClassPathXmlApplicationContext ; — FileSystemXmlApplicationContext ; — GenericGroovyApplicationContext ; — AnnotationConfigApplicationContext ; — и даже StaticApplicationContext ; — а также некоторые другие.
Они отличаются друг от друга именно тем, каким способом задаются мета-данные и где хранится эта конфигурация. Например: — ClassPathXmlApplicationContext — метаданные конфигурируются XML-файлом(-ами) и они лежат в classpath, т. е. в ресурсах модуля; — FileSystemXmlApplicationContext — метаданные тоже конфигурируются XML-файлом(-ами), но они находятся где-то в файловой системе, например, /etc/yourapp/spring-context.xml ; — AnnotationConfigApplicationContext — метаданные конфигурируются с помощью аннотаций прямо на классах.
Современным способом конфигурирования считаются аннотации ( AnnotationConfigApplicationContext ), дальше будем создавать именно их.
Приведём пример создания такого контекста в методе main:
Внутри конструктора как раз и происходит инициализация контекста из мета-данных. Как и полагается, в AnnotationConfigApplicationContext мета-данные конфигурируются аннотациями. Несложно заметить аннотацию @Configuration на Main -классе, и что он передаётся в конструктор контекста. Собственно, Main и есть описание метаданных.
Итого: создаём контекст.
В результате мы получили работающее приложение на Spring. Правда, пока ещё без бизнес-логики. А что же означает аннотация @ComponentScan , и как правильно определять и писать бины, мы узнаем в следующей части.
Следите за новостями, оставляйте комментарии и посмотрите программу курса «Разработчик на Spring Framework», вдруг захочется погрузится полностью!
Контекст (а у него есть даже интерфейс — оrg.springframework.context.ApplicationContext ) — это некоторое окружение, в котором работает приложение на Spring Framework . Страшные аббревиатуры DI, IoC — это всё про него. Собственно, контекст создаёт и хранит экземпляры классов вашего приложения, определяет их зависимости друг с другом и автоматически их задаёт.
Безусловно, для того чтобы Spring создал контекст с экземплярами классов, ему нужно предоставить дополнительную информацию — мета-данные, из каких классов/объектов состоит ваше приложение, как они создаются, какие у них есть зависимости и т. д.
Итого: Spring Context + мета-данные = работающее приложение .
Где найти контекст?
Контекст является ключевой функциональностью Spring и лежит в maven-зависимости spring-context (на момент написания — org.springframework:spring-context:5.1.4.RELEASE ). Обычно эта зависимость является транзитивной для остальных проектов Spring . И если вы, например, подключаете spring-boot-starter , то она подключится автоматически, и не нужно думать про то, где её взять.
Но если вы хотите попробовать "голый" Spring, т. е. только ту часть, которая называется IoC-контейнер , то достаточно подключить лишь spring-context .
Итого: подключите org.springframework:spring-context:5.1.4.RELEASE .
Какие бывают контексты и как их создать?
У интерфейса ApplicationContext есть большое количество реализаций:
— ClassPathXmlApplicationContext ;
— FileSystemXmlApplicationContext ;
— GenericGroovyApplicationContext ;
— AnnotationConfigApplicationContext ;
— и даже StaticApplicationContext ;
— а также некоторые другие.
Они отличаются друг от друга именно тем, каким способом задаются мета-данные и где хранится эта конфигурация. Например:
— ClassPathXmlApplicationContext — метаданные конфигурируются XML-файлом(-ами) и они лежат в classpath, т. е. в ресурсах модуля;
— FileSystemXmlApplicationContext — метаданные тоже конфигурируются XML-файлом(-ами), но они находятся где-то в файловой системе, например, /etc/yourapp/spring-context.xml ;
— AnnotationConfigApplicationContext — метаданные конфигурируются с помощью аннотаций прямо на классах.
Современным способом конфигурирования считаются аннотации ( AnnotationConfigApplicationContext ), дальше будем создавать именно их.
Приведём пример создания такого контекста в методе main :
Внутри конструктора как раз и происходит инициализация контекста из мета-данных. Как и полагается, в AnnotationConfigApplicationContext мета-данные конфигурируются аннотациями. Несложно заметить аннотацию @Configuration на Main -классе, и что он передаётся в конструктор контекста. Собственно, Main и есть описание метаданных.
Итого: создаём контекст .
В результате мы получили работающее приложение на Spring . Правда, пока ещё без бизнес-логики. А что же означает аннотация @ComponentScan , и как правильно определять и писать бины, мы узнаем в следующей части.
Следите за новостями, оставляйте комментарии и посмотрите программу курса «Разработчик на Spring Framework» , вдруг захочется погрузится полностью!
Изучение исходного кода Spring - интерфейс ApplicationContext
При использовании Spring нам часто нужно сначала получить объект ApplicationContext, а затем получить объект Bean, настроенный нами из этого объекта. ApplicationContext принадлежит org.springframework.context, является менеджером Bean в SpringFramework и обеспечивает поддержку многих функций SpringFramework.
На следующем рисунке показано представление класса UML, связанное с ApplicationContext в версии Spring-4.3.2.RELEASE (интерфейс светло-зеленый, класс светло-желтый):
Интерфейс серии BeanFactory:
BeanFactory является интерфейсом верхнего уровня Spring Management Beans. Это контейнер Bean, который управляет серией bean-компонентов. Каждый bean-компонент уникально идентифицируется именем типа String (или его именем id). Эти Bean-компоненты могут быть прототипами или одноэлементными. , Spring отстаивает использование Dependency Injection для сборки Beans. BeanFactory загружает определение Bean из «источника конфигурации». Источником конфигурации может быть файл XML, файл свойств или даже база данных.
Подынтерфейс HierarchicalBeanFactory объекта BeanFactory представляет собой иерархическую фабрику компонентов с атрибутом parentBeanFactory. При получении объекта Бина, если соответствующий бин не существует в текущем BeanFactory, будет получен доступ к его прямому parentBeanFactory, чтобы попытаться получить объект бина. Кроме того, вы можете переопределить одноименный компонент родительского BeanFactory в текущем BeanFactory.
ListableBeanFactory наследует BeanFactory и реализует метод перечисления для перечисления всех объектов bean в текущем BeanFactory без необходимости получать их один за другим по имени. Если объект ListableBeanFactory по-прежнему является HierarchicalBeanFactory, метод getBeanDefinitionNames () будет возвращать только объекты Bean в текущем BeanFactory и не будет запрашивать родительский BeanFactory.
Другие интерфейсы:
Интерфейс верхнего уровня синтаксического анализатора файла конфигурации, анализ файлов конфигурации для получения значений атрибутов и т. Д.
Укажите необходимую среду для запуска текущего приложения
Это держатель среды только с одним методом: Environment getEnvironment () используется для получения объекта Environment
ResourceLoader используется для загрузки файлов ресурсов из источника (например, InputStream и т. Д.). ResourcePatternResolver является подклассом ResourceLoader, который загружает ресурсы согласно шаблону пути.
Интерфейс ApplicationContext:
public interface ApplicationContext extends EnvironmentCapable,ListableBeanFactory, HierarchicalBeanFactory, MessageSource,
ApplicationEventPublisher, ResourcePatternResolver
Важным моментом является то, что интерфейс ApplicationContext наследует множество интерфейсов, интегрирует множество интерфейсных функций и одну и обеспечивает базовую функциональную поддержку для работы Spring.
В соответствии с «принципом единой ответственности» разработки программы, фактически, каждый интерфейс более высокого уровня является «единой ответственностью» и обеспечивает только определенный аспект функции, а интерфейс ApplicationContext наследует множество интерфейсов, что эквивалентно наличию функций многих интерфейсов.
Давайте посмотрим на его основные функции:
Подинтерфейс ApplicationContext:
Интерфейс ApplicationContext имеет два прямых подинтерфейса, а именно:
Посмотрите на эти два подчиненных интерфейса отдельно:
По названию интерфейса можно судить, что интерфейс настраивается! Сам интерфейс ApplicationContext доступен только для чтения, поэтому подинтерфейс ConfigurableApplicationContext предоставляет такие методы, как setID (), setParent () и setEnvironment () для настройки ApplicationContext.
Посмотрите на два других унаследованных интерфейса:
- Жизненный цикл: есть интерфейс start (), stop () и другие методы в интерфейсе жизненного цикла, которые используются для управления жизненным циклом контекста;
- Closeable: Closeable - это интерфейс, предоставленный стандартным JDK, используемый для окончательного закрытия компонента для освобождения ресурсов и т. Д .;
Этот интерфейс предоставляет getServletContext () только на основе исходного интерфейса для предоставления контекстной информации сервлету.
Здесь ConfigurableWebApplicationContext объединяет два вышеупомянутых интерфейса для обеспечения настраиваемого, управляемого и закрываемого WebApplicationContext.В то же время интерфейс добавляет setServletContext (), setServletConfig () и другие методы set для сборки WebApplicationContext.
Пока что интерфейсы, связанные с ApplicationContext, в основном были завершены. В итоге, есть два основных интерфейса:
Для обычных приложений используйте класс реализации интерфейса ConfigurableApplicationContext в качестве диспетчера компонентов, а для веб-приложений используйте класс реализации интерфейса ConfigurableWebApplicationContext в качестве диспетчера компонентов. Эти два интерфейса, структурно говоря, они являются унаследованными отношениями, с прикладной точки зрения они являются параллельными отношениями, обеспечивая сильную поддержку Spring в различных областях.
Дизайн класса реализации, связанный с ApplicationContext:
Spring - это превосходный фреймворк с хорошим структурным дизайном и интерфейсной абстракцией. Каждый из его интерфейсов является высоко абстрагированной функцией, специфичной для каждого модуля. При реальном использовании он эквивалентен предоставлению каждого класса реализации интерфейса в соответствии с интерфейсом. Организационная структура собрана для обеспечения полного обслуживания.Можно сказать, что освоение интерфейса Spring эквивалентно освоению большинства функций Spring.
Существует много классов реализации ApplicationContext. Однако различные функции интерфейса ApplicationContext были проанализированы выше. Далее будет проанализировано, как классы реализации ApplicationContext реализуют различные функции вышеуказанного интерфейса (PS. Из-за ограниченного пространства здесь только для того, чтобы указать, что вышеупомянутые функции находятся в классе реализации Что касается конкретного процесса реализации, каждая функция может использоваться для написания статьи отдельно, что здесь не будет подробно описано). Что касается класса реализации, который расширяет другие интерфейсы или наследует другие родительские классы, то это просто то, что класс реализации делает для расширения функций или для облегчения реализации вышеупомянутых интерфейсов. Он не оказывает никакого влияния или мало помогает на функции, абстрагируемые интерфейсом ApplicationContext. Поэтому опущено.
Взяв ClassPathXmlApplicationContext в качестве примера, его основное отношение наследования выглядит следующим образом:
Абстрактный класс верхнего уровня AbstractApplicationContext реализует интерфейс ConfigurableApplicationContext.
Согласно вышесказанному, родительский класс DefaultResourceLoader и интерфейс DisposableBean здесь опущены, и речь идет только об интерфейсе ConfigurableApplicationContext. Напомним основную функцию:
Затем вернемся к абстрактному классу верхнего уровня AbstractApplicationContext, который можно назвать классом с наибольшим количеством кода в структуре наследования ClassPathXmlApplicationContext, и большинство вышеперечисленных функций также реализованы в этом классе. Этот класс использует шаблон шаблонного метода для реализации большей части логики вышеупомянутых функций, а затем извлекает множество защищенных методов (или абстрактных методов) для подклассов для переопределения.
Реализация каждой функции перечислена следующим образом:
ConfigableМетоды, такие как setParent / setEnvironment, реализуются с помощью AbstractApplicationContext. Пример кода:
Lifecycle: AbstractApplicationContext имеет экземпляр LifecycleProcessor, который используется для управления собственным жизненным циклом. Методы жизненного цикла AbstractApplicationContext, такие как start и stop, будут делегированы для обработки LifecycleProcessor. Пример кода:
EnvironmentCapable: Реализовано AbstractApplicationContext, в котором содержится экземпляр ConfigurableEnvironment для реализации метода getEnvironment интерфейса EnvironmentCapable. Пример кода:
MessageSource: AbstractApplicationContext содержит экземпляр MessageSource и делегирует методы интерфейса MessageSource этому экземпляру для завершения. Пример кода:
ApplicationEventPublisher: Реализовано AbstractApplicationContext, если есть родительский ApplicationContext, событие также должно быть опубликовано в родительском ApplicationContext. Пример кода:
ResourcePatternResolver: AbstractApplicationContext содержит экземпляр ResourcePatternResolver, и методы этого интерфейса делегируются этому экземпляру для завершения. Пример кода:
ListableBeanFactory, HierarchicalBeanFactory: AbstractApplicationContext косвенно реализует эти два интерфейса, но не реализует никаких функций какой-либо BeanFactory. AbstractApplicationContext имеет экземпляр ConfigurableListableBeanFactory, и все функции BeanFactory делегируются этому экземпляру. Пример кода:
Метод getBeanFactory () класса AbstractApplicationContext является абстрактным методом, то есть подклассы предоставляют этот BeanFactory. Пример кода:
В системе наследования ClassPathXmlApplicationContext класс AbstractRefreshableApplicationContext реализует этот метод getBeanFactory (). Здесь метод getBeanFactory () создаст экземпляр DefaultListableBeanFactory в качестве возвращаемого значения.
резюме
Эта статья посвящена ApplicationContext из Spring Framework и анализирует институциональную систему и функциональную реализацию ApplicationContext. Интерфейс ApplicationContext наследует множество интерфейсов, которые могут удовлетворять общим функциональным требованиям «интерфейсно-ориентированного программирования» в приложениях. Абстрактный класс AbstractApplicationContext реализует простую и неизменяемую часть интерфейса ApplicationContext, а затем делегирует многие «легко изменяемые» функции некоторым из его переменных-членов через «комбинацию» и, наконец, использует шаблон метода шаблона, чтобы подкласс предоставил некоторые для родительского класса. Поддержка функций или установка замены вышеупомянутых переменных-членов родительского класса реализует принцип разработки «открыто для расширения и закрыто для изменения» и предоставляет Spring Framework гибкую и расширяемую поддержку архитектуры.
Читайте также: