Конфигурация контейнеров Java-кодом

Основные понятия: @Bean и @Configuration

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

Аннотация @Bean используется для указания того, что метод создает экземпляр, конфигурирует и инициализирует новый объект, которым будет управлять IoC-контейнер Spring. Для тех, кто знаком с XML-конфигурацией <beans/> из Spring, аннотация @Bean играет ту же роль, что и элемент <bean/>. Вы можете использовать методы, аннотированные @Bean, с любой аннотацией @Component из Spring. Однако чаще всего они используются с бинами, аннотированными @Configuration.

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

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

@Configuration
class AppConfig {
    @Bean
    fun myService(): MyService {
        return MyServiceImpl()
    }
}

Предшествующий класс AppConfig эквивалентен следующему XML-классу <beans/> из Spring:

<beans>
    <bean id="myService" class="com.acme.services.MyServiceImpl"/>
</beans>

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

Создание экземпляра контейнера Spring с помощью AnnotationConfigApplicationContext

Следующие разделы описывают AnnotationConfigApplicationContext, представленный в Spring 3.0. Эта универсальная реализация интерфейса ApplicationContext способна принимать на ввод не только классы, помеченные аннотацией @Configuration, но и обычные классы, аннотированные @Component, а также классы, аннотированные метаданными из JSR-330.

Если классы, помеченные аннотацией @Configuration, указаны в качестве входных данных, сам класс, аннотированный @Configuration, регистрируется как определение бина, а все объявленные в классе методы, помеченные аннотацией @Bean, также регистрируются как определения бина.

Если указаны классы, помеченные аннотацией @Component, или из JSR-330, они регистрируются как определения бинов, и предполагается, что метаданные внедрения зависимостей, такие как @Autowired или @Inject, используются в этих классах, где это необходимо.

Простая конструкция

Точно так же, как XML-файлы Spring используются в качестве входных данных при создании ClassPathXmlApplicationContext, вы можете использовать классы, аннотированные @Configuration, в качестве входных данных при создании AnnotationConfigApplicationContext. Это позволяет использовать контейнер Spring всецело без XML, как показано в следующем примере:

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
}

import org.springframework.beans.factory.getBean
fun main() {
    val ctx = AnnotationConfigApplicationContext(AppConfig::class.java)
    val myService = ctx.getBean<MyService>()
    myService.doStuff()
}

Как упоминалось ранее, AnnotationConfigApplicationContext не ограничивается работой только с классами, аннотированными @Configuration. Любой аннотированный @Component или JSR-330 класс может быть предоставлен в качестве входа в конструктор, как показано в следующем примере:

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(MyServiceImpl.class, Dependency1.class, Dependency2.class);
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
}

import org.springframework.beans.factory.getBean
fun main() {
    val ctx = AnnotationConfigApplicationContext(MyServiceImpl::class.java, Dependency1::class.java, Dependency2::class.java)
    val myService = ctx.getBean<MyService>()
    myService.doStuff()
}

В предыдущем примере предполагается, что MyServiceImpl, Dependency1 и Dependency2 используют аннотации внедрения зависимостей Spring, такие как аннотация @Autowired.

Построение контейнера программно с помощью register(Class<?>…​)

Вы можете создать AnnotationConfigApplicationContext с помощью конструктора без аргументов, а затем сконфигурировать его с помощью метода register(). Данный подход особенно полезен при программном построении AnnotationConfigApplicationContext. В следующем примере показано, как это сделать:

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AppConfig.class, OtherConfig.class);
    ctx.register(AdditionalConfig.class);
    ctx.refresh();
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
}

import org.springframework.beans.factory.getBean
fun main() {
    val ctx = AnnotationConfigApplicationContext()
    ctx.register(AppConfig::class.java, OtherConfig::class.java)
    ctx.register(AdditionalConfig::class.java)
    ctx.refresh()
    val myService = ctx.getBean<MyService>()
    myService.doStuff()
}

Включение сканирования компонентов с помощью scan(String…)

Чтобы включить сканирование компонентов, вы можете аннотировать свой класс с помощью @Configuration следующим образом:

@Configuration
@ComponentScan(basePackages = "com.acme") 
public class AppConfig  {
    // ...
}

1. Эта аннотация позволяет сканировать компоненты.

@Configuration
@ComponentScan(basePackages = ["com.acme"]) 
class AppConfig  {
    // ...
}

1. Эта аннотация позволяет сканировать компоненты.

<beans>
    <context:component-scan base-package="com.acme"/>
</beans>

В предыдущем примере пакет com.acme сканируется на поиск любых классов, аннотированных @Component, а эти классы регистрируются как определения бина Spring в контейнере. AnnotationConfigApplicationContext открывает метод scan(String…​) для предоставления такой же функциональности сканирования компонентов, как показано в следующем примере:

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.scan("com.acme");
    ctx.refresh();
    MyService myService = ctx.getBean(MyService.class);
}

fun main() {
    val ctx = AnnotationConfigApplicationContext()
    ctx.scan("com.acme")
    ctx.refresh()
    val myService = ctx.getBean<MyService>()
}

Поддержка веб-приложений с помощью AnnotationConfigWebApplicationContext

К варианту WebApplicationContext класса AnnotationConfigApplicationContext можно получить доступ при помощи AnnotationConfigWebApplicationContext. Вы можете использовать эту реализацию при настройке слушателя сервлета ContextLoaderListener из Spring, DispatcherServlet из Spring MVC и так далее. Следующий фрагмент web.xml конфигурирует типичное веб-приложение в Spring MVC (обратите внимание на использование context-параметров contextClass и init-параметров):

<web-app>
    <!-- Настройка ContextLoaderListener для использования AnnotationConfigWebApplicationContext
        вместо стандартного XmlWebApplicationContext -->
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    <!-- Местоположение конфигурации должно состоять из одного или нескольких разделенных запятыми или пробелами
        полных имен классов, аннотированных @Configuration. Полные имена пакетов также можно -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.acme.AppConfig</param-value>
    </context-param>
    <!-- Осуществляем начальную загрузку контекста корневого приложения, как обычно, используя ContextLoaderListener -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- Объявляем DispatcherServlet в Spring MVC, как обычно -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- Конфигурируем DispatcherServlet на использование AnnotationConfigWebApplicationContext
            вместо стандартного XmlWebApplicationContext -->
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>
        <!-- Опять же, местоположения конфигурации должны состоять из одного или нескольких разделенных запятыми или пробелами
            и полных имен классов, аннотированных @Configuration -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>com.acme.web.MvcConfig</param-value>
        </init-param>
    </servlet>
    <!-- сопоставьте все запросы для /app/* с сервлетом диспетчера -->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>
</web-app>