Spring ApplicationContext

1. 개요

이 튜토리얼에서는 Spring ApplicationConext 인터페이스를 자세히 살펴볼 것 입니다.

2. ApplicationContext 인터페이스

Spring 프레임 워크의 주요 기능 중 하나는 IoC (Inversion of Control) 컨테이너입니다. Spring IoC 컨테이너는 애플리케이션의 객체를 관리하는 역할을합니다. 제어 반전을 달성하기 위해 종속성 주입을 사용합니다.

BeanFactoryApplicationContext 인터페이스 는 Spring IoC 컨테이너를 나타냅니다 . 여기서 BeanFactory 는 Spring 컨테이너에 액세스하기위한 루트 인터페이스입니다. Bean 관리를위한 기본 기능을 제공합니다.

반면에 ApplicationContextBeanFactory 의 하위 인터페이스입니다 . 따라서 BeanFactory의 모든 기능을 제공합니다 .

또한 더 많은 엔터프라이즈 별 기능을 제공 합니다 . 의 중요한 특징 의 ApplicationContext가 되어 , 국제화를 지원하는 이벤트를 게시하고, 애플리케이션 레이어 특정 컨텍스트, 메시지를 해결 . 이것이 우리가 기본 Spring 컨테이너로 사용하는 이유입니다.

3. Spring Bean이란?

ApplicationContext 컨테이너에 대해 자세히 알아보기 전에 Spring Bean에 대해 아는 것이 중요합니다. Spring에서 Bean은 Spring 컨테이너가 인스턴스화, 조립 및 관리하는 객체입니다 .

그렇다면 애플리케이션의 모든 객체를 Spring Bean으로 구성해야합니까? 글쎄, 모범 사례로서 우리는 그렇게해서는 안됩니다.

Spring 문서에 따라 일반적으로 서비스 계층 객체, ​​데이터 액세스 객체 (DAO), 프레젠테이션 객체, Hibernate SessionFactories, JMS 큐 등과 같은 인프라 객체에 대한 빈을 정의해야 합니다.

또한 일반적으로 컨테이너에 세분화 된 도메인 개체를 구성해서는 안됩니다. 일반적으로 도메인 개체를 만들고로드하는 것은 DAO 및 비즈니스 논리의 책임입니다.

이제이 튜토리얼에서 Spring bean으로 사용할 간단한 Java 클래스를 정의 해 보겠습니다.

public class AccountService { @Autowired private AccountRepository accountRepository; // getters and setters }

4. 컨테이너에서 빈 설정

아시다시피 ApplicationContext 의 기본 작업은 빈을 관리하는 것입니다.

따라서 애플리케이션은 Bean 구성을 ApplicationContext 컨테이너에 제공해야합니다 . 따라서 Spring Bean 구성은 하나 이상의 Bean 정의로 구성됩니다. 또한 Spring은 다양한 Bean 설정 방법을 지원합니다.

4.1. 자바 기반 구성

먼저, 가장 새롭고 가장 선호되는 Bean 구성 방법 인 Java 기반 구성으로 시작하겠습니다. Spring 3.0부터 사용할 수 있습니다.

Java 구성은 일반적으로 @Configuration 클래스 내에서 @Bean 주석이 달린 메소드를 사용합니다 . 메소드 의 @Bean 어노테이션은 메소드가 Spring Bean을 작성 함을 나타냅니다. 또한 @Configuration 주석이 달린 클래스 는 Spring Bean 구성이 포함되어 있음을 나타냅니다.

이제 AccountService 클래스를 Spring Bean으로 정의하는 구성 클래스를 작성해 보겠습니다 .

@Configuration public class AccountConfig { @Bean public AccountService accountService() { return new AccountService(accountRepository()); } @Bean public AccountRepository accountRepository() { return new AccountRepository(); } }

4.2. 주석 기반 구성

Spring 2.5는 Java에서 Bean 구성을 활성화하기위한 첫 번째 단계로 주석 기반 구성을 도입했습니다.

이 접근 방식에서는 먼저 XML 구성을 통해 주석 기반 구성을 활성화합니다. 그런 다음 Java 클래스, 메소드, 생성자 또는 필드에 대한 주석 세트를 사용하여 Bean을 구성합니다. 이러한 주석의 몇 가지 예는 @Component , @Controller , @Service , @Repository , @Autowired@Qualifier 입니다.

특히 이러한 주석을 Java 기반 구성과 함께 사용합니다. 또한 Spring은 각 릴리스마다 이러한 주석에 더 많은 기능을 계속 추가합니다.

이제이 구성의 간단한 예를 살펴 보겠습니다.

먼저 주석을 활성화하기 위해 XML 구성 인 user-bean-config.xml을 생성합니다 .

여기서, 주석 - 구성 태그는 주석 기반의 매핑을 할 수 있습니다 . 또한 component-scan 태그는 주석이 달린 클래스를 찾을 위치를 Spring에 알려줍니다.

둘째, UserService 클래스를 만들고 @Component 주석을 사용하여 Spring 빈으로 정의합니다 .

@Component public class UserService { // user service code }

그런 다음이 구성을 테스트하기위한 간단한 테스트 케이스를 작성합니다.

ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext/user-bean-config.xml"); UserService userService = context.getBean(UserService.class); assertNotNull(userService);

4.3. XML 기반 구성

Finally, let's take a look at XML-based configuration. It's the traditional way of configuring beans in Spring.

Obviously, in this approach, we do all bean mappings in an XML configuration file.

So, let's create an XML configuration file, account-bean-config.xml, and define beans for our AccountService class:

5. Types of ApplicationContext

Spring provides different types of ApplicationContext containers suitable for different requirements. These are implementations of the ApplicationContext interface. So, let's take a look at some of the common types of ApplicationContext.

5.1. AnnotationConfigApplicationContext

First, let's see the AnnotationConfigApplicationContext class, which was introduced in Spring 3.0. It can take classes annotated with @Configuration, @Component, and JSR-330 metadata as input.

So, let's see a simple example of using the AnnotationConfigApplicationContext container with our Java-based configuration:

ApplicationContext context = new AnnotationConfigApplicationContext(AccountConfig.class); AccountService accountService = context.getBean(AccountService.class);

5.2. AnnotationConfigWebApplicationContext

AnnotationConfigWebApplicationContextis a web-based variant of AnnotationConfigApplicationContext.

We may use this class when we configure Spring's ContextLoaderListener servlet listener or a Spring MVC DispatcherServlet, in a web.xml file.

Moreover, from Spring 3.0 onward, we can also configure this application context container programmatically. All we need to do is to implement the WebApplicationInitializer interface:

public class MyWebApplicationInitializer implements WebApplicationInitializer { public void onStartup(ServletContext container) throws ServletException { AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext(); context.register(AccountConfig.class); context.setServletContext(container); // servlet configuration } }

5.3. XmlWebApplicationContext

If we use the XML based configuration in a web application, we can use the XmlWebApplicationContext class.

As a matter of fact, configuring this container is like the AnnotationConfigWebApplicationContext class only, which means we can configure it in web.xml or implement the WebApplicationInitializer interface:

public class MyXmlWebApplicationInitializer implements WebApplicationInitializer { public void onStartup(ServletContext container) throws ServletException { XmlWebApplicationContext context = new XmlWebApplicationContext(); context.setConfigLocation("/WEB-INF/spring/applicationContext.xml"); context.setServletContext(container); // Servlet configuration } }

5.4. FileSystemXMLApplicationContext

We use the FileSystemXMLApplicationContext class to load an XML-based Spring configuration file from the file system or from URLs. This class is useful when we need to load the ApplicationContext programmatically. In general, test harnesses and standalone applications are some of the possible use cases for this.

For example, let's see how we can create this Spring container and load the beans for our XML-based configuration:

String path = "C:/myProject/src/main/resources/applicationcontext/account-bean-config.xml"; ApplicationContext context = new FileSystemXmlApplicationContext(path); AccountService accountService = context.getBean("accountService", AccountService.class);

5.5. ClassPathXmlApplicationContext

In case we want to load an XML configuration file from the classpath, we can use the ClassPathXmlApplicationContext class. Similar to FileSystemXMLApplicationContext, it's useful for test harnesses as well as for application contexts embedded within JARs.

So, let's see an example of using this class:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext/account-bean-config.xml"); AccountService accountService = context.getBean("accountService", AccountService.class);

6. Additional Features of ApplicationContext

6.1. Message Resolution

The ApplicationContext interface supports message resolution and internationalization by extending the MessageSource interface. Furthermore, Spring provides two MessageSource implementations, ResourceBundleMessageSource and StaticMessageSource.

We can use the StaticMessageSource to programmatically add messages to the source. However, it supports basic internationalization and is more suitable for tests than production use.

On the other hand, ResourceBundleMessageSource is the most common implementation of MessageSource. It relies on the underlying JDK's ResouceBundle implementation. It also uses the JDK's standard message parsing provided by MessageFormat.

Now, let's see how can we use the MessageSource to read the messages from a properties file.

First, we'll create the messages.properties file on the classpath:

account.name=TestAccount

Second, we'll add a bean definition in our AccountConfig class:

@Bean public MessageSource messageSource() { ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource(); messageSource.setBasename("config/messages"); return messageSource; }

Third, we'll inject the MessageSource in the AccountService:

@Autowired private MessageSource messageSource;

Finally, we can use the getMessage method anywhere in the AccountService to read the message:

messageSource.getMessage("account.name", null, Locale.ENGLISH);

Spring also provides the ReloadableResourceBundleMessageSource class, which allows for reading files from any Spring resource location and supports hot reloading of bundle property files.

6.2. Event Handling

ApplicationContext supports event handling with the help of the ApplicationEvent class and the ApplicationListener interface. It supports built-in events like ContextStartedEvent, ContextStoppedEvent, ContextClosedEvent, and RequestHandledEvent. Moreover, it also supports custom events for business use cases.

7. Conclusion

In this tutorial, we've discussed various aspects of the ApplicationContext container in Spring. We've seen different examples of how to configure Spring beans in an AppicationContext. Also, we've seen how to create and use different types of ApplicationContext.

항상 그렇듯이 전체 코드는 GitHub에서 사용할 수 있습니다.