잊지 않겠습니다.

'code base'에 해당되는 글 2건

  1. 2013.09.12 21. Controller - Spring 3.x (1)
  2. 2013.09.09 8. ApplicationContext

* 사내 강의용으로 사용한 자료를 Blog에 공유합니다. Spring을 이용한 Web 개발에 대한 전반적인 내용에 대해서 다루고 있습니다.



기존 Spring 2.x 대의 Controller의 문제점을 해결하기 위한 수단으로 새로운 Controller Mapping 방법이 나오게 되었습니다. 이 방법은 지금 Spring Controller 부분의 표준으로 사용되고 있으며, 기존 코드를 완벽하게 대치하고 있습니다. 

기존 Spring 2.x 대의 Controller의 문제점은 다음과 같습니다.

1. 특정 interface를 반드시 상속받는 형태여야지 된다.
2. bean name을 이용한 method - url mapping이 된다.
3. POST/GET/DELTE/PUT/HEAD 와 같은 http method에 적합하지 않다.
4. url 당 1개의 Controller 객체가 생성되기 때문에 Enterprise 개발에 적합하지 않다.

기존에 Controller Interface를 구현해야지 되었으나, 3.0대의 @MVC는 annotation을 이용해서 @Controller로 객체의 meta 정보를 적는 것으로 해결이 가능합니다. 

다음과 같은 코드로 기존과 동일한 Controller가 구현 가능합니다. 

@Controller
public class HelloController {
    @Autowired
    private HelloString helloString;
    
    @RequestMapping(value="index", method=RequestMethod.GET)
    public String index(@RequestParam(value="name") String name, ModelMap model) {
        model.addAttribute("message", helloString.say(name));
        return "hello";
    }
}


기본적으로 @Controller를 이용, component-scan으로 bean으로 등록시켜서 사용 가능합니다. mapping 시킵니다. 그리고, 각 method에 Mapping url을 각각 지정해주는 방식으로 처리가 가능합니다. 여기서 return값에 주목할 점이 있습니다. 기존에는 return값으로 ViewAndModel을 보내줘야지 되었지만, 이제는 input값으로 Response에 보내질 model을 미리 준비해서 받는것 역시 가능합니다. 이 코드는 method의 in/out의 type을 강제하지 않고, 특정한 객체에 대한 상속을 피하고, URL에 대한 mapping을 한개의 class에서 처리 가능한, Spring의 특징 및 장점을 모두 갖는 코드라고 할 수 있습니다. 

URL mapping의 기본이 되는 RequestMapping 에 대해서 좀 더 알아보도록 하겠습니다.


@RequestMapping

String[] value
URL을 지정해주는 pattern입니다. 예를 들어 다음과 같은 pattern들을 지정해주는 것이 가능합니다.
1. @RequestMapping("/hello")
2. @RequestMapping({"/hello", "/hello2"})
3. @RequestMapping("/hello1")

Path변수를 지정해주는 것이 가능합니다. "/hello/{name}" 과 같이 method의 input을 url에 같이 실어 주는것이 가능합니다.
1. @RequestMapping("/hello/{name}")
2. @RequestMapping("/hello/{name}/{number}")

method
RequestMethod를 지정하는 것 역시 가능합니다. GET, POST, DELETE, PUT, HEAD가 사용 가능합니다. 역시 method도 Path와 동일하게 중복 설정이 가능합니다.

params
url 요청 파라미터의 유무에 따라 호출되는 method를 결정할 수 있습니다.
1. RequestMapping(value="/user/edit", params="type=admin")
2. RequestMapping(value="/user/edit", params="type=member")

이 두 url은 다음 실제 Url과 mapping 됩니다.
* /user/edit?type=admin
* /user/edit?type=member

method의 input값에 따라 method내에서의 if문을 만들지 않고 처리가 가능한 유용한 팁입니다.

headers
HTTP header정보에 따른 mapping역시 가능합니다. request type을 text/html, application/json 각각의 type에 따라 다른 method를 처리 가능합니다. 

RequestMapping과 method parameter와 결합

기본적으로 @Controller의 각 method는 다음과 같은 input parameter를 갖을 수 있습니다.

TypeAnnotationDescription
URL/POST parameter@RequestParamGET/POST/DELETE/PUT 등으로 호출될 때, 넘겨지는 Parameter값
Path value@PathVariableURL 에 포함된 특정 영역 문자열
Servlet-HttpServletRequest, HttpServletResponse를 직접 Handling 하는 기존 Servlet과 같은 코드 역시 사용 가능합니다.
Cookie@CookieValueCookie 값을 얻거나 설정할 수 있습니다.
Session@SessionAttributesSession 값을 얻거나 설정할 수 있습니다.
Body@RequestBodyRequest의 Body 부분을 모두 String으로 얻어내는 것이 가능합니다.

또한 Controller의 action method는 주로 4가지 형태의 Return Type을 사용하게 됩니다. 

1. String : view 이름을 return 합니다. 주로 JSP 또는 Veloctiy, Freemarker, tiles와 Html View를 호출 할 때 사용됩니다. String 형태를 보내줄 때는 일반적으로 ViewResolver라는 객체를 applicationContext.xml에 등록하는 것이 일반적입니다.
2. void : 아무것도 return 하지 않습니다. 이는 method의 이름을 String 형태로 return 하는 것과 동일한 결과를 갖습니다.
3. Object : REST 형태의 Return값을 사용할 때 이용됩니다. 대체적으로 Object에 대한 Body Response를 덩어내는 것을 주 목적으로 하고 있습니다.
4. ModelAndView : Spring 2.X 형태로 Model과 View를 return 하는 것이 가능합니다. 

여기서 ModelAndView 형태의 return값은 pdf, excel 과 같은 데이터를 다운받는 형태로 사용 가능합니다. 이 부분은 뒤에 View에서 다시 다루도록 하겠습니다. 


Spring 3.x를 이용한 Hello World


기본적으로 그 전에 만들었던 Spring 2.x의 Hello World와 유사한 코드가 만들어집니다. Spring 2.x대의 코드와 동일한 설정을 해서 project를 하나 만들도록 하겠습니다. 아니면 기존의 project를 다른 이름으로 copy 해서 import 해도 괜찮습니다.
간단하게 HelloController를 작성해보도록 하겠습니다. @Controller를 이용한 처리를 하더라도 Controller의 경우에는 Controller라는 이름을 붙여주는 것이 일반적입니다. 

@Controller
public class HelloController {
    @Autowired
    private HelloString helloString;
    @RequestMapping(value="/index", method=RequestMethod.GET)
    public String index(@RequestParam(value="name") String name, ModelMap model) {
        model.addAttribute("message", helloString.say(name));
        return "hello";
    }
}

아주 간단한 코드입니다. 기존과 다르게 String 형태로 return을 시켰습니다. 지금 코드 그대로면 webapp/hello 파일을 찾게 되고, 이건 에러가 발생하게 됩니다. 따라서 기본적으로 사용할 ViewResolver를 등록시켜줘야지 됩니다. 


  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean>

지금까지 등록된 bean과는 조금 다른 형태입니다. 지금까지는 id값을 가지고 있었지만, id나 name이 없는 bean 등록입니다. spring을 사용한 개발을 하다보면 이렇게 등록되는 경우가 왕왕 있습니다. 주로 Spring 내부에서 사용할 bean 또는 모든 applicationContext에서 하나만 존재할 bean 들의 경우 id/name을 갖지 않아도 됩니다. 
그리고, @Controller를 url에 mapping 해주는 과정을 해줘야지 됩니다. 이는 context:component-scan 을 이용해서 해주면 되고, applicationContext에는 다음과 같이 위치시키면 됩니다. 

  <context:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />

프로젝트의 구조를 잘 파악할 수 있어야지 됩니다. 지금 구성된 전체 Project의 구조는 다음과 같습니다.


web.xml을 구성해야지 됩니다. web.xml을 구성할 때, 앞으로 개발하기 좀 더 편하게 다음과 같은 설정을 추가하도록 하겠습니다. 모든 request에 .do가 붙는 경우에는 모두 spring에서 처리하도록 web.xml을 수정하도록 하겠습니다. 수정된 web.xml은 다음과 같이 구성됩니다. servlet-mapping에서 url-pattern이 구성된 방법을 확인해주세요. 이 pattern을 넣는것은 매우 중요한 의미를 갖습니다. .do가 아닌 .html과 잘 알려진 확장자 역시 처리가 가능합니다. 이러한 설정을 이용해서, spring을 통해서 작성된 web인지, 아니면 그냥 html인지 외부에서 착각을 유도하는 것도 가능합니다. 정부표준 프레임워크 등 대부분의 Framework에서는 .do를 사용하고 있습니다. 그리고 nhn에서는 .nhn을 붙여서 사용하고 있습니다. 다른 일반적인 file path들과 중복되지 않는 이름을 사용하는 것이 중요합니다. 


<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  version="3.0">
  <display-name>mvc.spring02</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

그리고, applicationContext.xml 파일은 다음과 같이 구성됩니다. 
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloString" class="com.xyzlast.mvc.spring02.entities.HelloString"></bean>
</beans>

마지막으로 spring-servlet.xml파일은 다음과 같이 구성됩니다.
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <context:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />
  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean></beans>

구성후 테스트 코드를 작성해보도록 하겠습니다. 테스트 코드 소스는 다음과 같습니다. 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/applicationContext.xml", "file:src/main/webapp/WEB-INF/controller-servlet.xml"})
@WebAppConfiguration
public class HelloControllerTest {
    @Autowired
    private WebApplicationContext context;
    private MockMvc mvc;

    @Before
    public void setUp() {
        mvc = webAppContextSetup(context).build();
        assertThat(mvc, is(not(nullValue())));
    }

    @Test
    public void index() throws Exception {
        MvcResult result = mvc.perform(get("/index").param("name", "ykyoon")).andExpect(status().isOk()).andReturn();
        Object model = result.getModelAndView().getModel().get("message");
        assertThat(model, is(not(nullValue())));
        String message = (String) model;
        assertThat(message.endsWith("ykyoon"), is(true));
    }
}

마지막으로 jetty를 추가 후, maven jetty:run을 이용해서 프로젝트를 구동해보시길 바랍니다.
구성된 project의 pom.xml은 다음과 같습니다.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.xyzlast</groupId>
  <artifactId>mvc.spring02</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>mvc.spring02 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>mvc.spring02</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.0</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
      <plugin>
      <plugin>
       <plugin>
            <groupId> org.eclipse.jetty</groupId>
            <artifactId>jetty-maven-plugin</artifactId>
        </plugin>
      </plugin>
    </plugins>
  </build>
</project>


확장자가 없는 URL

지금까지의 예시에서는 확장자를 하나씩 붙여서 처리했습니다. 이러한 확장자를 붙여서 처리하는 것은 DispatcherServlet에서 처리할 URL이 어떤 것인지 명확하게 결정해줄 수 있는 장점을 가지고 있습니다. 그렇지만, 이 방법은 조금 애매한 것이 사실입니다. W3C에서 표준한 URL 표준에서, 확장자는 URL을 통해서 얻고 싶은 Response의 protocol을 선택하는 형식입니다. 예를 들어서 다음 URL들의 해석은 다음과 같습니다. 

/shop/search.json?name=윤영권
/shop/search.html?name=윤영권
/shop/search.rss?name=윤영권
/shop/search.xml?name=윤영권

다음 4개의 url format은 json/html/rss/xml 형식으로 데이터를 얻어오는 것을 가정하고 있습니다. url의 extension에 dispatcher servlet 을 종속시키는 것은 이제 옛날 방법입니다. 이제는 모든 URL을 dispatcherServlet에 보내게 됩니다. 그리고 dispatcherServlet에서 해석 불가능한 request들은 servlet container에게 넘기는 방식으로 처리하는 것입니다. 

여기서 servlet spec에 대해서 한번 알아보도록 하겠습니다. SRV.11.2 Specification of Mappings 에서 servlet container는 다음과 같이 명령을 정의하고 있습니다. 

In theWeb application deployment descriptor, the following syntax is used to define mappings:
1. A string beginning with a ‘/’ character and ending with a ‘/*’ suffix is used for path mapping.
: '/'로 시작하고, '/*'로 끝나는 mapping의 경우에는 path mapping을 따르게 된다.
(path mapping : servlet container에서 정의되어 있는 mapping입니다.)
2. A string beginning with a ‘*.’ prefix is used as an extension mapping.
: *. 으로 시작하는 mapping의 경우에는 확장 mapping을 따르게 된다. 우리가 기존에 사용하는 것을 확인했던 *.do와 같은 방법입니다.
3. A string containing only the ’/’ character indicates the "default" servlet of the application. In this case the servlet path is the request URI minus the context path and the path info is null.
: '/'만 사용하게 되는 경우, 이는 application의 'default' servlet을 의미한다. 이 경우에는 request URI와 context Path가 완전히 일치하게 되고, servlet path는 null이 됩니다.
4. All other strings are used for exact matches only.
: 모든 request uri가 완전히 일치하는 경우

이 4가지 경우중에서 우리가 사용하게 되는 것은 3번으로 mapping을 설정하게 됩니다. 이는 결국에 원 servlet container의 default servlet의 목적을 바꿔버리는 결과를 가지고 옵니다. 이렇게 설정하는 경우, web.xml은 다음과 같이 설정할 수 있습니다. 

    <servlet-mapping>
        <servlet-name>controller</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

그리고 이렇게 설정하는 경우에 반드시 servlet-configuration에 다음과 같은 설정을 추가해줘야지 됩니다. 
<mvc:default-servlet-handler/>

앞으로 모든 url은 위와 같은 format으로 설정하게 될 것입니다. 

@Configuration을 이용한 DispatcherServlet 설정

Controller들을 선언하는 DispatcherServlet의 설정의 경우에는 DispatcherServletName + "-servlet.xml"의 형식으로 기본적으로 구성되게 됩니다. 이 설정을 @Configuration을 이용해서 변경해보도록 하겠습니다. 
먼저, 지금까지 구성된 spring-servlet.xml의 내용은 다음과 같습니다. 

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <context:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />
  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean>
  <mvc:default-servlet-handler />
</beans>

ViewResolver를 등록하고, default-servlet-handler를 등록하는 것 이외에는 설정이 거의 없습니다. spring-servlet.xml을 대치하는 @Configuration을 구성의 편의성을 높이기 위해서 Spring은 abstract class를 제공하고 있습니다. 이 코드를 시용하면 보다 더 쉽게 처리가 가능합니다. xml을 이용해서 설정하는 것보다 나중에는 훨씬 편한 설정을 제공하기 때문에, 이는 꼭 @Configuration을 이용해서 구성하기실 바랍니다. 훨씬 편합니다. 

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "com.xyzlast.mvc.spring02.controllers" })
public class ControllerConfiguration extends WebMvcConfigurerAdapter {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver internalResourceViewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setViewClass(JstlView.class);
        viewResolver.setPrefix("/WEB-INF/jsp/");
        viewResolver.setSuffix(".jsp");
        viewResolver.setOrder(1);
        return viewResolver;
    }
}

WebMvcConfigurerAdapter를 이용하는 경우, DefaultServletHandlerConfigurer 등 여러 항목들을 편하게 설정이 가능합니다. override가 가능한 method들이 주목할 만한 것들이 많습니다. 나중에 나올 initBinder, formatter 등의 설정 역시 위 class에서 가능하기 때문에 여간해서는 xml을 사용하지 않기를 바랍니다. 

마지막으로 web.xml을 구성하는 방법에 대해서 간단히 소개를 드린 내용을 정리해보도록 하겠습니다. 

@Configuration  + web.xml을 이용한 설정

@Configuration class를 이용한 설정을 web.xml에 반영하기 위해서는 web.xml의 기본 ContextLoader의 설정을 변경해야지 됩니다.  기본적으로 web.xml의 ContextLoaderListener는 XmlConfigWebApplicationContext를 설정하고 있습니다. 이를 AnnotationConfgWebApplicationContext로 변경해야지 됩니다. 그리고 child applicationContext 역시, DispatcherServlet의 contextClass를 XmlConfigWebApplicationContext로 변경하고 @Configuration class로 변경하는 것이 필요합니다. 변경되는 web.xml은 다음과 같이 구성됩니다. 

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.xyzlast.bookstore.domain.config.DomainConfiguration</param-value>
    </context-param>
    <servlet>
        <servlet-name>controller</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>com.xyzlast.bookstore.web.configs.WebMvcContexConfiguration</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>controller</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

객체를 넣어줄때는 package명까지 명확히 넣어줘야지 된다는 것을 잊지 말아주세요.

지금보시면 web.xml에 새로운 내용이 하나 더 추가가 되어서 보입니다. filter-mapping이 바로 그것인데요. 지금 사용한 Filter는 기본적으로 tomcat과 같은 web container는  ISO-8859-1 문자 포멧을 사용하게 됩니다. 이 포멧을 UTF-8로 사용하기 위한 기본 설정입니다. 우리나라에서는 꼭 해줘야지 되는 기본 설정입니다.


@Configuration + no web.xml을 이용한 설정 방법

web.xml이 아애 없이 개발하기 위해서는 web.xml을 대신할 객체를 만들어줘야지 됩니다. 
web.xml이 없는 경우, servlet container 즉 tomcat 또는 jetty는 자신이 가진 bin 중에서 spring 객체가 로드되면서 WebApplicationInitializer를 상속받은 객체가 있는지 확인하는 과정을 거치게 됩니다. 

이제 우리가 사용할 기본적인 WebApplicationInitializer 코드를 확인해보도록 하겠습니다. 
public class BookStoreWebApplicationInitializer implements WebApplicationInitializer {

    private static final String DISPATCHER_SERVLET_NAME = "dispatcher";

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        registerListener(servletContext);
        registerDispatcherServlet(servletContext);

        addEncodingFilter(servletContext);
    }

    private void registerListener(ServletContext servletContext) {
        AnnotationConfigWebApplicationContext rootContext = createContext(DomainConfiguration.class);
        ContextLoaderListener contextLoaderListener = new ContextLoaderListener(rootContext);
        servletContext.addListener(contextLoaderListener);
        servletContext.addListener(new RequestContextListener());
    }

    private void registerDispatcherServlet(ServletContext servletContext) {
        AnnotationConfigWebApplicationContext dispatcherContext = createContext(WebMvcContexConfiguration.class);
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(DISPATCHER_SERVLET_NAME,
                new DispatcherServlet(dispatcherContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }

    private AnnotationConfigWebApplicationContext createContext(final Class<?>... annotatedClasses) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(annotatedClasses);
        return context;
    }

    private void addEncodingFilter(ServletContext servletContext) {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceEncoding(true);
        FilterRegistration.Dynamic encodingFilterRestriction = servletContext.addFilter("characterEncodingFilter",
                encodingFilter);
        encodingFilterRestriction.addMappingForUrlPatterns(null, false, "/*");
    }
}

하나하나 코드에 대해서 확인해보도록 하겠습니다. WebApplicationInitializer를 상속받으면 기본적으로 onStartup method가 abstract로 구현체로 나오게 됩니다. 이 method는 web container가 application을 로드할 때 시작되는 method가 됩니다. 

code의 private method는 다음과 같습니다. 

# registerListener : root applicationContext를 로드하는 private method입니다.
# registerDispatcherServlet : child applicationContext를 로드하고, front controller인 dispatcher servlet을 로드하는 구문입니다. 
# addEncodingFilter : Filter 적용 코드입니다.

이 코드랑, 그 전에 작성된 web.xml과 한번 비교를 해보시길 바랍니다. 완전히 1:1로 matching이 되어서 동작하는 것을 볼 수 있습니다. 
개인적으로는 가장 선호하는 방법입니다. 

위 코드도 길다고 느껴지시나요? 
Spring 3.2를 사용하실 경우에는 더욱더 간단한 코드를 작성하는 것이 가능합니다. 다음과 같습니다. 

public class WebXmlConfiguration extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { DomainConfiguration.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebApp01Configuration.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

    @Override
    protected boolean isAsyncSupported() {
        return true;
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceEncoding(true);
        return new Filter[] { encodingFilter };
    }
}


@Configuration + WebApplicationInitializer + web.xml 을 이용하는 방법

이제 마지막 방법입니다.  만약에 WebApplicationInitializer를 상속받은 객체와 web.xml이 동시에 존재를 한다면 어떻게 동작을 할까요? 
정답은 web.xml이 먼저 적용되고, WebApplicationInitializer가 나중에 동작하게 됩니다. 이러한 구성을 사용하는 이유는 다음 항목들이 아직 WebApplicationInitializer에 구현되지 않았기 때문입니다. (servlet 3.0 규약에서 이 부분은 web.xml에서 빠져있습니다.) 

1. welcome-page
2. error-code

이 두가지를 구현하기 위해서는 반드시 web.xml을 사용해줘야지 됩니다.


저작자 표시 비영리 변경 금지
신고
Posted by xyzlast Y2K

8. ApplicationContext

Java 2013.09.09 10:57

* 사내 강의용으로 사용한 자료를 Blog에 공유합니다. Spring을 이용한 Web 개발에 대한 전반적인 내용에 대해서 다루고 있습니다.



Spring에서 ApplicationContext는 IoC, AOP를 설정하는 Container 또는 Configuration이라고 할 수 있습니다.
ApplicationContext는 

# bean의 집합
# bean에 대한 Map
# bean에 대한 정의
# AOP에 의한 bean의 확장에 대한 정의

를 포함하고 있습니다. ApplicationContext에 대해서 좀 더 깊게 들어가보도록 하겠습니다.


ApplicationContext

Application Context는 org.springframework.context.ApplicationContext interface를 상속받은 객체입니다. interface의 정의는 다음과 같습니다. 

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    String getId();
    String getApplicationName();
    String getDisplayName();
    long getStartupDate();
    ApplicationContext getParent();
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

ApplicationContext는 bean에 대한 집합이라고 했습니다. bean은 일반적으로 POJO class로 구성이 되게 됩니다. bean과 POJO의 정의는 다음과 같습니다. 


Java Bean
원 목적은 Servlet에서 Java 객체를 가지고 와서 사용하기 위해서 작성된 객체입니다. 매우 간단한 객체이고, 사용이 편리해야지 된다. 라는 것을 원칙으로 가지고 있습니다. 특징으로는

# property를 갖는다. (private 변수와 get/set method를 갖는다.)
# serialization이 가능하다.

라는 특징을 갖습니다. 그렇지만 두번째 특징인 serialization이 가능한 특징은 지금은 거의 사용되고 있지 않습니다. property를 갖는 java 객체라는 의미로 생각해주시면 됩니다. 줄여서 bean이라는 표현을 많이 사용합니다. 

POJO
Plan Old Java Object의 약자입니다. POJO 객체는 특정 기술과 Spec에 독립적인 객체로 만들어지는 것을 원칙으로 삼습니다. 자신이 속한 package에 속한 POJO 객체 이외에는 Java의 기본 객체만을 이용해서 작성하는 것이 원칙입니다. 또한, 확장성을 위해 자신이 속한 package의 POJO 객체가 아닌 POJO 객체의 interface를 속성으로 갖는 bean 객체로서 만들어지는 것이 일반적입니다. 지금까지 작성된 Book, User, UserHistory 객체의 경우에 POJO 객체라고 할 수 있습니다. 

bean에 대한 집합인 ApplicationContext는 다음과 같은 특징을 갖습니다.

1. bean id, name, alias로 구분이 가능한 bean들의 집합입니다.
2. life cycle을 갖습니다. (singleton, prototype)
3. property는 value 또는 다른 bean을 참조합니다.

ApplicationContext는 bean들의 집합적인 특징 뿐 아니라, bean들의 loading 도 역시 담당하고 있습니다. ApplicationContext의 정보는 일반적으로 xml을 이용하고 있지만, 지금까지 저희가 사용한 내용을 보셨듯이 annotation을 이용한 bean의 등록 역시 가능합니다. 이번에 사용한 내용 그대로, xml과 annotation을 혼용하는 것이 일반적입니다. 그리고 아직까지 한번도 사용안해본 xml을 전혀 사용하지 않는 ApplicationContext역시 가능합니다. 

먼저 ApplicationContext를 수동으로 만들어보는 것을 알아보겠습니다.

프로젝트를 만듭니다. 지금까지 구성하던것 처럼, maven-archetype-quickstart로 maven project를 하나 생성합니다. 생성된 project에 spring context 선언을 pom.xml에 추가합니다.

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>


Hello 객체와 Printer interface를 선언하고 ConsolePrinter 객체를 만들어보도록 합시다.

public class Hello {
    private String name;
    private Printer printer;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Printer getPrinter() {
        return printer;
    }
    public void setPrinter(Printer printer) {
        this.printer = printer;
    }
    public String sayHello() {
        return "Hello " + name;
    }
    public void print() {
        this.printer.print(sayHello());
    }
}

public interface Printer {
    void print(String message);
}

public class ConsolePrinter implements Printer {
    public void print(String message) {
        System.out.println(message);
    }
}


먼저, Spring에서 제공하는 StaticApplicationContext를 사용해서 ApplicationContext에 직접 bean을 등록하고 얻어보는 것을 해보도록 하겠습니다.

테스트 코드를 간단히 작성해보도록 하겠습니다.

    @Test
    public void registerApplicationContext() {
        StaticApplicationContext ac = new StaticApplicationContext();
        ac.registerSingleton("hello1", Hello.class);
        Hello hello = ac.getBean("hello1", Hello.class);
        assertNotNull(hello);
    }

 
이렇게 만들어진 ApplicationContext에서 hello1이라는 이름의 객체를 계속해서 얻어오는 것이 가능합니다. 하나 재미있는 것이 다음 코드입니다. 

    @Test
    public void registerApplicationContext() {
        StaticApplicationContext ac = new StaticApplicationContext();
        ac.registerSingleton("hello1", Hello.class);
        Hello hello = ac.getBean("hello1", Hello.class);
        assertNotNull(hello);
        Hello hello2 = ac.getBean("hello1", Hello.class);
        assertThat(hello, is(hello2));
    }

    @Test
    public void registerApplicationContextWithPrototype() {
        StaticApplicationContext ac = new StaticApplicationContext();
        ac.registerPrototype("hello1", Hello.class);
        Hello hello = ac.getBean("hello1", Hello.class);
        assertNotNull(hello);
        Hello hello2 = ac.getBean("hello1", Hello.class);
        assertThat(hello, is(not(hello2)));
    }

registerApplicationContext와 registerApplicationContextWithProtytype은 Hello 객체를 Singleton 또는 Prototype으로 등록하게 됩니다. Singleton은 ApplicationContext에 등록된 모든 객체들을 재사용하게 되는데, registerPrototype으로 등록된 객체들은 ApplicationContext에서 얻어낼 때마다 객체를 다시 생성해서 얻어내게 됩니다. 이는 xml의 설정에서 scope와 동일합니다. 위 코드는 다음 xml로 표현이 가능합니다. 

<bean id="hello1" class="com.xyzlast.ac.Hello" scope="singleton"/>
<bean id="hello2" class="com.xyzlast.ac.Hello" scope="prototype"/>


이제 bean에 대한 property를 설정하는 코드에 대해서 알아보도록 하겠습니다. Property를 설정하기 위해서는 BeanDefinition 객체를 사용해야지 됩니다. 테스트 코드를 보면서 간단히 확인해보도록 하겠습니다. 

   @Test
    public void registerBeanDef() {
        BeanDefinition helloDef = new RootBeanDefinition(Hello.class);
        helloDef.getPropertyValues().add("name", "ykyoon");
        helloDef.getPropertyValues().add("printer", new ConsolePrinter());
        StaticApplicationContext ac = new StaticApplicationContext();
        ac.registerBeanDefinition("hello1", helloDef);
        
        Hello hello = ac.getBean("hello1", Hello.class);
        assertNotNull(hello);
        assertThat(hello.sayHello(), is("Hello ykyoon"));
    }


ApplicationContext의 종류

spring에서는 십여개의 applicationContext를 제공하고 있습니다. 다음은 Spring에서 제공하는 applicationContext의 종류입니다. 





StaticApplicationContext
Test code에서 사용한 ApplicationContext입니다. 실 프로젝트에서는 절대로 사용되지 않는 ApplicationContext입니다. xml로딩 기능이나 그런것들도 없고, 테스트 코드에서 사용해보신 것과 같이 객체에 대한 IoC 기능의 테스트에서만 사용되는 객체입니다.

GenericApplicationContext
xml을 이용하는 ApplicationContext입니다. 우리가 만든 xml 파일과 동일한 xml을 이용한 ApplicationContext 구성이 가능합니다. 지금까지 사용한 Test code에서 사용된 ApplicationContext가 모두 GenericApplicationContext입니다.

GenericXmlApplicationContext
GenericApplicationContext의 확장판입니다. xml 파일의 경로가 생성자에 들어가 있어서, 좀더 편하게 xml을 로딩할 수 있는 장점 이외의 차이점은 없습니다.

WebApplicationContext
web project에서 사용되는 ApplicationContext입니다. web.xml의 org.springframework.web.context.ContextLoaderListener를 통해서 로드 및 생성이 됩니다.

이 4개의 ApplicationContext는 매우 자주 사용되는 형태입니다. 각각의 간단한 특징들만 알아두는것이 좋습니다.


ApplicationContext의 계층 구조


spring forum에서 가장 많이 나오는 질문들이 있습니다.
"bean 을 등록했는데, 사용할 수가 없어요."
Bean이 xml에 등록이 되어있으나, 사용하지 못하는 경우가 간간히 나옵니다. 그 이유는 Spring에 있는것이 아니라 Bean의 계층구조를 이해하지 못하고 Bean을 등록해서 사용하고 있기 때문입니다. 

ApplicationContext는 계층 구조를 가질 수 있습니다. 다음과 같은 구조화가 가능합니다.

여기서 주의할 점은 형제 node끼리는 bean을 검색할 수 없습니다. upper node에 있는 객체와 자신의 객체만을 사용할 수 있고, 형제 node에 있는 bean들은 검색할 수 없습니다. 그리고, upper node에 있는 bean 이름과 동일한 bean 이름을 갖는 객체를 선언하면, 자식의 node에 있는 객체로 덧씌워져 버립니다. 이런 계층구조 사이의 혼란한 bean 구조는 매우 힘든 버그를 발생시킬 수 있습니다. bean을 정의할 때, 이런 부분을 주의해야지 될 필요성이 있습니다. 

그럼, 이런 ApplicationContext간의 계층구조는 왜 만들게 되는지가 궁금해질 수 가 있습니다.
이 부분은 webApplicationContext를 만들때 이런 구조가 만들어집니다. Spring Web MVC를 사용하는 경우, Root ApplicationContext는 web.xml에 정의되고 로드됩니다. 그리고 Servlet을 정의하고 DispatcherServlet을 사용하면, DispatcherServlet에서 사용되는 child ApplicationContext가 로드가 되게 됩니다. Spring Web은 기본적으로 Front Controller Pattern을 사용하기 때문에 child ApplicationContext가 하나만 로드가 되는 것이 일반적이지만, 간혹 경우에 따라 child ApplicationContext를 여러개를 로드시켜야지 되는 때가 있습니다. 각 url에 따라 다른 Servlet을 사용하고 싶은 경우도 생길수 있으니까요. 그때는 여러개의 형제 ApplicationContext가 만들어지게 되고 이 ApplicationContext는 서로간에 bean을 사용할 수 없게 됩니다. 그리고, 각 ApplicationContext에서 따로 bean을 등록하는 경우에는 각각 다른 bean 정보를 갖게 됩니다. 

다음은 Web application에서 ApplicationContext의 기본 구조입니다.





ApplicationContext.xml의 등록 방법

applicationContext 의 등록방법은 spring에서 계속해서 발전되어가는 분야중 하나입니다. 총 3가지의 방법으로 나눌 수 있으며, 이 방법들은 같이 사용되는 것도 가능합니다. 

1. applicationContext.xml 을 이용하는 방법
bookDao를 이용할 때, 처음 사용한 방법입니다. bean을 선언하고, id값을 이용해서 사용하는 방법으로 이 방법은 가장 오랫동안 사용해왔기 때문에 많은 reference들이 존재합니다. 그렇지만, 객체가 많아질수록 파일의 길이가 너무나 길어지고 관리가 힘들어지는 단점 때문에 요즘은 잘 사용되지 않습니다. 

2. @annotation과 aplicationContext.xml을 이용하는 방법
@Component, @Repository, @Service, @Controller, @Value 등을 사용하고, component-scan 을 이용해서 applicationContext.xml에서 등록하는 방법입니다. 이 방법은 지금 가장 많이 사용되고 있는 방법입니다. applicationContext.xml의 길이가 적당히 길고, 구성하기 편하다는 장점을 가지고 있습니다. 
이 방법은 반드시 알아둬야지 됩니다. 지금 정부표준 프레임워크 및 대부분의 환경에서 이 방법을 사용하고 있습니다.

3. @Configuration을 이용한 applicationContext 객체를 이용하는 방법
Spring에서 근간에 밀고 있는 방법입니다. 이 방법은 다음과 같은 장점을 가지고 있습니다. 

1) 이해하기 쉽습니다. - xml에 비해서 사용하기 쉽습니다.
2) 복잡한 Bean 설정이나 초기화 작업을 손쉽게 적용할 수 있습니다. - 프로그래밍 적으로 만들기 때문에, 개발자가 다룰수 있는 영역이 늘어납니다.
3) 작성 속도가 빠릅니다. - eclipse에서 java coding 하는것과 동일하게 작성하기 때문에 작성이 용의합니다. 

그리고, 개인적으로는 2, 3번 방법을 모두 알아둬야지 된다고 생각합니다. 이유는 2번 방법의 경우, 가장 많이 사용되고 있다는 점이 가장 큰 장점입니다. 또한 아직 Spring의 하부 Project인, Spring Security를 비롯하여 Work Flow등은 아직 3번 방법을 지원하지 않습니다. (다음 버젼에서 지원 예정입니다.) 그래도 3번 방법을 알아야지 됩니다. 이유는 다음과 같습니다. 지금 Spring에서 밀고 있습니다. 그리고, 최근에 나온 외국 서적들이 모두 이 방법을 기준으로 책을 기술하고 있습니다. 마지막으로, 나중에 나올 web application의 가장 핵심인 web.xml이 없는 개발 방법이 servlet 3.0에서 지원되기 시작했습니다. Java 언어에서 xml을 이용한 설정 부분을 배재하는 분위기로 흘러가고 있다는 것이 제 개인적인 판단입니다. 

그럼, 이 3가지 방법을 모두 이용해서 기존의 BookStore를 등록하는 applicationContext를 한번 살펴보도록 하겠습니다.

applicationContext.xml만을 이용하는 방법
초기 Spring 2.5 이하 버젼에서 지원하던 방법입니다. 일명 xml 지옥이라고 불리우는 어마어마한 xml을 자랑했습니다. 최종적으로 만들어져 있는 applicationContext.xml의 구성은 다음과 같습니다. Transaction annotation이 적용되지 않기 때문에, Transaction에 대한 AOP code 까지 추가되는 엄청나게 긴 xml을 보여주고 있습니다.

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource" />
  </bean>
  <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
    destroy-method="close">
    <property name="driverClass" value="${connect.driver}" />
    <property name="jdbcUrl" value="${connect.url}" />
    <property name="username" value="${connect.username}" />
    <property name="password" value="${connect.password}" />
    <property name="idleConnectionTestPeriodInMinutes" value="60" />
    <property name="idleMaxAgeInMinutes" value="240" />
    <property name="maxConnectionsPerPartition" value="30" />
    <property name="minConnectionsPerPartition" value="10" />
    <property name="partitionCount" value="3" />
    <property name="acquireIncrement" value="5" />
    <property name="statementsCacheSize" value="100" />
    <property name="releaseHelperThreads" value="3" />
  </bean>
  <context:property-placeholder location="classpath:spring.properties" />
  <bean id="bookDao" class="com.xyzlast.bookstore02.dao.BookDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="userDao" class="com.xyzlast.bookstore02.dao.UserDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="historyDao" class="com.xyzlast.bookstore02.dao.HistoryDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="userService" class="com.xyzlast.bookstore02.services.UserServiceImpl">
    <property name="bookDao" ref="bookDao"/>
    <property name="userDao" ref="userDao"/>
    <property name="historyDao" ref="historyDao"/>
  </bean>
  <bean id="bookService" class="com.xyzlast.bookstore02.services.HistoryServiceImpl">
    <property name="bookDao" ref="bookDao"/>
    <property name="userDao" ref="userDao"/>
    <property name="historyDao" ref="historyDao"/>
  </bean>
  
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <bean id="transactionManagerAdvisor" class="com.xyzlast.bookstore02.utils.TransactionAdvisor">
    <property name="transactionManager" ref="transactionManager"/>
  </bean>
  
  <bean
    class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="beanNames">
      <list>
        <value>userService</value>
        <value>bookService</value>
      </list>
    </property>
    <property name="interceptorNames">
      <list>
        <value>transactionManagerAdvisor</value>
      </list>
    </property>
  </bean>
</beans>

@annotation + applicationContext.xml을 이용한 방법
@Repository, @Component, @Service를 이용해서 편한 방법을 제공합니다. 특히 component-scan과 @Autowired를 이용하면 위 applicationContext.xml을 효과적으로 줄일 수 있습니다. 

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource" />
  </bean>
  <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
    destroy-method="close">
    <property name="driverClass" value="${connect.driver}" />
    <property name="jdbcUrl" value="${connect.url}" />
    <property name="username" value="${connect.username}" />
    <property name="password" value="${connect.password}" />
    <property name="idleConnectionTestPeriodInMinutes" value="60" />
    <property name="idleMaxAgeInMinutes" value="240" />
    <property name="maxConnectionsPerPartition" value="30" />
    <property name="minConnectionsPerPartition" value="10" />
    <property name="partitionCount" value="3" />
    <property name="acquireIncrement" value="5" />
    <property name="statementsCacheSize" value="100" />
    <property name="releaseHelperThreads" value="3" />
  </bean>
  <context:property-placeholder location="classpath:spring.properties" />
  <context:component-scan base-package="com.xyzlast.bookstore02.dao" />
  <context:component-scan base-package="com.xyzlast.bookstore02.services" />
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

@annotation + @Configuration을 이용한 방법
이 방법은 xml을 아애 없애버릴 수 있습니다. xml이 제거된 ApplicationContext의 내용은 다음과 같습니다.
@Configuration
@PropertySource("classpath:spring.properties")
@ComponentScan(basePackages = {"com.xyzlast.bookstore02.dao", "com.xyzlast.bookstore02.services"})
@EnableTransactionManagement
public class BookStoreConfiguration {
    @Autowired
    private Environment env;

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        PropertySourcesPlaceholderConfigurer configHolder = new PropertySourcesPlaceholderConfigurer();
        return configHolder;
    }

    @Bean
    public DataSource dataSource() {
        BoneCPDataSource dataSource = new BoneCPDataSource();
        dataSource.setUsername(env.getProperty("connect.username"));
        dataSource.setPassword(env.getProperty("connect.password"));
        dataSource.setDriverClass(env.getProperty("connect.driver"));
        dataSource.setJdbcUrl(env.getProperty("connect.url"));
        dataSource.setMaxConnectionsPerPartition(20);
        dataSource.setMinConnectionsPerPartition(3);
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        JdbcTemplate template = new JdbcTemplate();
        template.setDataSource(dataSource());
        return template;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource());
        return transactionManager;
    }
}

지금까지 작성하던 xml과는 완전히 다른 모습의 ApplicationContext입니다. ApplicationContext Config 객체는 다음과 같은 특성을 갖습니다. 

1. @Configuration annotation을 갖는다.
2. bean으로 등록되는 객체는 method로 관리되고, @Bean annotation을 갖습니다.
3. method의 이름이 <bean id="">값과 매칭됩니다.
4. component-scan, property-place-holder의 경우, class의 annotation으로 갖습니다.
5. @EnableTransactionManagement와 같이 @Enable** 로 시작되는 annotation을 이용해서 전역 annotation을 구성합니다. 
6. Properties 파일을 사용하기 위해서는 반드시 static method로 PropertySourcesPlaceholderConfigurer를 return 시켜줘야지 됩니다.

앞으로 적용되는 모든 Project는 @Configuration을 이용한 3번 방법으로 구성하도록 하겠습니다. 그리고 xml 역시 같이 소개하도록 하겠습니다.

Summay

지금까지 사용하던 ApplicationContext에 대한 기본 개념을 정리해봤습니다. ApplicationContext는 Spring의 핵심 기능입니다. DI를 통한 IoC를 가능하게 하고, AOP에 대한 설정 등 모든 Spring에서 하는 일이 설정되어 있는 것이 ApplicaionContext라고 할 수 있습니다. 이에 대한 설정 및 구성을 명확하게 알아놓을 필요가 있습니다. 그리고, 내부에서 어떤 일을 해서 Spring에서 하는 이런 일들이 가능하게 되는지에 대한 이해가 필요합니다. 마지막으로 ApplicationContext를 구성하는 방법에 대해서 알아봤습니다. 제공되는 3가지 방법에 대해 자유자재로 사용할 수 있는 능력이 필요합니다.

감사합니다. 




저작자 표시 비영리 변경 금지
신고
Posted by xyzlast Y2K


티스토리 툴바