Bean은 Spring Framework에서 어플리케이션의 중요 부분을 형성하고 Spring IoC Container에 의해 관리된다.

Spring IoC Container는 다음 두 가지 유형의 Container를 제공한다.

BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml"));

1.1.2.2.ApplicationContext

다음은 org.springframework.context.ApplicationContext 인터페이스의 대략적인 구조이다.

자주 사용되는 ApplicationContext의 구현 클래스는 아래와 같다.

• XmlWebApplicationContext - 웹 기반의 Spring 어플리케이션을 작성할 때 내부적으로 사용

• FileSystemXmlApplicationContext - 파일 시스템에 위치한 XML 설정 파일을 읽어들이는 ApplicationContext

• FileSystemXmlApplicationContext - 파일 시스템에 위치한 XML 설정 파일을 읽어들이는 ApplicationContext

ApplicationContext 구현 클래스를 아래와 같이 사용할 수 있다.

ApplicationContext context = new FileSystemXmlApplicationContext("c:/beans.xml”);

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml”);

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="…" class="…">
    <!-- collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions go here -->
</beans>

<beans>
    <import resource="services.xml"/>
    <import resource="resources/messageSource.xml"/>
    <import resource="/resources/themeSource.xml"/>

    <bean id="bean1" class="…"/>
    <bean id="bean2" class="…"/>
</beans>

비즈니스 레이어와 프리젠테이션 레이어에서 Spring Bean에 접근하는 방법에는 여러 가지가 있다.

각 클래스 사이의 의존관계를 빈 설정(Bean Definition)정보를 바탕으로 컨테이너가 자동적으로 연결해주는 것을 말한다. 컨테이너가 의존관계를 자동적으로 연결시켜주기 때문에 개발자들이 컨테이너 API를 이용하여 의존관계에 관여할 필요가 없게 되어 컨테이너 API에 종속되는 것을 줄일 수 있고 개발자들은 단지 Bean 설정파일(저장소 관리 파일)에서 의존 관계가 필요하다는 정보를 추가하기만 하면 된다. 이는 Setter Injection과 Constructor Injection 형태로 구분한다.

public class MovieServiceImpl implements MovieService {
    public void setMovieDao(MovieDao movieDao) {
        this.movieDao = movieDao;
    }
    중략... 
}

<bean id="coreMovieService"
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl">
    <property name="movieDao" ref="coreMovieDao" />
</bean>
	
<bean id="coreMovieDao" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieDao">
</bean>

public class MovieServiceImpl implements MovieService {
    MovieDao movieDao;
    public MovieServiceImpl(MovieDao movieDao) {
        super(movieDao);
        this.movieDao = movieDao;}
        중략...
}

<bean id="coreMovieService" 
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl">
    <constructor-arg ref="coreMovieDao"/>
</bean>
        
<bean id="coreMovieDao" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieDao">
    중략...
</bean>

<bean id="coreMovieService" 
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl">
    <constructor-arg type="org.anyframe.plugin.core.moviefinder.service.BeanA" ref="beanA"/>
    <constructor-arg type="org.anyframe.plugin.core.moviefinder.service.BeanB" ref="beanB"/>
</bean>

<bean id="coreMovieService"
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl">
    <constructor-arg index="0" ref="beanA" /> 
    <constructor-arg index="1" ref="beanB" /> 
</bean>

Bean Property와 생성자의 인자는 다른 관리 Bean(협력자), 또는 인라인으로 정의된 값을 참조할 수 있다. Spring의 XML-기반의 설정 메타데이터는 이러한 목적을 위한 <property> 와 <constructor-arg> 내에서 많은 수의 하위 태그를 지원한다.

<!-- 코드 1 -->
<property name="myProperty"><value>hello</value></property>

<!-- 코드 2 -->
<property name="myProperty" value="hello"/> 

1.2.2.2.혼합된 Property 명(Compound Property) - shortcut 기능 제공

복합적인 형태의 Property 정의가 가능하다. 마지막 Property명을 제외한 나머지 Property는 null이 아니어야 함에 유의하도록 한다.

<bean id="foo" class="foo.Bar">
    <property name="fred.bob.sammy" value="123" />
</bean>

위 예제에서 foo bean은 bob Property를 가지는 fred Property를 가진다. 그리고 bob Property는 sammy Property를 가지고 마지막 sammy Property는 123값으로 셋팅된다. 이렇게 되도록 하기 위해서는 foo의 fred Property, 그리고 fred의 bob Property는 bean이 생성된 후에 null이 아니어야만 한다. 그렇지 않으면 NullPointerException이 던져질 것이다.

'depends-on' 속성은 Bean 이전에 초기화되어야 하는 하나 이상의 Bean을 명시적으로 강제하기 위해 사용된다. 다음은 depends-on 속성이 설정되어 있는 context-core.xml 파일의 일부이다.

<bean id="coreMovieService"
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl" 
    autowire="byType" depends-on="coreMovieDao">
</bean>

다중 bean에 의존성을 표시할 필요가 있다면 아래의 예와 같이 콤마, 공백 그리고 세미콜론과 같은 모든 유효한 구분자를 사용하여 'depends-on'속성의 값으로 bean 이름 목록을 정의할 수 있다. 그러나 이 ‘depends-on’ 속성을 사용하게 될 상황은 매우 드물다.

<bean id="beanOne" class="SampleBean" depends-on="manager,accountDao">
    <property name="manager" ref="manager" />
</bean>

<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />

위의 예제는 beanOne Bean이 생성되기 이전에 manager Bean이 생성되어 특정 서버를 구동시켜놓거나 특정 리소스에 대한 작업을 수행해놓고 있어야 beanOne Bean이 정상적으로 동작하므로 강제적으로 manager Bean을 초기화시킨다.

기본적으로 Spring IoC Container가 Start될 때 singleton Bean에 대해서는 모두 인스턴스화한다.

- 특정 singleton Bean을 Container가 Start될 때 인스턴스화 시키지 않고 처음 Bean 요청이 들어왔을 때 인스턴스화 시키고자 하면 ‘lazy-init’ 속성을 설정한다. 다음은 Lazy Instantiation 속성이 설정되어 있는 파일인 context-core.xml 파일의 일부이다.

<bean id="coreMovieDao" 
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieDaoImpl" lazy-init="true"/>
<bean id="coreMovieService" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl"/>

- 모든 Bean들에 대해서 기본적으로 Lazy 인스턴스화 시키고자 하면 ‘default-lazy-init’ 속성을 설정하면 된다.

<beans default-lazy-init="true">
    <!-- no beans will be eagerly pre-instantiated -->
</beans>

Spring IoC Container는 Bean들 사이의 관계를 autowire 할 수 있다. 이것은 BeanFactory의 내용을 조사함으로써 Spring이 자동적으로 협력자(다른 bean)를 분석하는 것이 가능하다는 것을 의미한다. autowiring을 사용하면 명백하게 많은 양의 타이핑을 줄이고 Property나 생성자의 인자를 명시할 필요를 줄이거나 제거하는 것이 가능해진다. XML-기반의 설정 메타데이터를 사용할 때, Bean정의를 위한 autowire 모드는 <bean>의 autowire 속성을 사용하면 된다. <bean>의 autowire 속성에 정의할 수 있는 값은 다음과 같다.

다음은 Autowiring 속성이 설정되어 있는 context-core.xml 파일의 일부이다.

<bean id="coreMovieService"
    class="org.anyframe.plugin.core.moviefinder.servicce.impl.MovieServiceImpl" 
    autowire="byType" depends-on="coreMovieDao">
</bean>

<bean id="bean" class="sample.TestBean” autowire-candidate="false" />

해당 Bean에 설정된 모든 Property들(Primitive Type/Collection 및 Bean 참조)이 제대로 설정되었는지 확인한다.

Singleton Bean이 Prototype Bean을 참조해야 할 경우 <lookup-method>를 설정한다. 다음은 Lookup Method Injection을 이용하여 참조 관계를 정의한 context-core.xml 의 일부이다.

<bean id="coreMovieService"
    class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl">
    <!-- method injection -->
    <lookup-method name="getMovieDao" bean="coreMovieDao"/> 		
</bean>

<!-- change scope from singleton to prototype (non singleton) -->
<bean id="coreMovieDao" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieDao" scope="prototype"/>

해당 lookup 메소드는 다음과 같이 MovieDao 리턴하는 형태로 메소드를 구현하도록 한다.

public class MovieServiceImpl … {
    public MovieDao getMovieDao(){
        // do nothing - this method will be overrided by Spring Container
        return null;
    }
    중략...
}

이미 존재하는 기존의 메소드를 수정하지 않은 상태에서 메소드의 기능을 변경하고자 할 때 <replaced-method>를 이용한다. 사용 예제는 다음과 같다.

Spring Framework에서 지원하는 5가지 Scope에 따라 Bean의 인스턴스 생성 메커니즘이 결정된다. 서비스 Scope은 설계, 개발 단계에서 결정하기 어려우므로, 기본적으로는 Default Scope인 Singleton으로 개발하고, 추후 해당 서비스의 성격에 따라 Scope을 정의하는 것이 좋다.

1.4.1.1.Singleton

Singleton Scope은 기본 Scope으로 여러 개의 요청에 대해 하나의 Bean 인스턴스를 생성하여 제공한다. 따라서 Client Request마다 유지해야 하는 Data가 있다면, Singleton Scope의 서비스는 적합하지 않다. 다음은 Singleton Scope의 속성 정의 예시이다.

<bean id="coreMovieService" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl" 
        scope="singleton”>
    <property name="coreMovieDao" ref="coreMovieDao" />
</bean>
<bean id="coreMovieDao" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieDao”>
    중략...
</bean>

위와 같이 singleton scope을 정의 할 수 있지만 scope의 기본 설정값이 singleton이므로 따로 정의해야 할 필요가 없다.

1.4.1.2.Prototype

Prototype Scope은 요청시마다 Bean 인스턴스를 생성하여 제공한다. 따라서 여러 Client가 동시에 한 Bean 인스턴스에 접근할 수 없다. 다음은 Prototype Scope의 속성 정의 예시이다.

<bean id="coreMovieService" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServieImpl"
        scope="prototype”>
    <property name="coreMovieDao" ref="coreMovieDao" />
</bean>

※ 일반적으로 인스턴스의 Singleton 여부를 판단하기 위해서 전역변수의 존재 여부를 이용한다. 즉, 전역변수가 존재하지 않은 인스턴스의 경우에는 Singleton, 전역변수가 존재하는 경우에는 Prototype 으로 정의할 수 있다. 그러나 해당 전역변수가 read-only인지 writable 가능한지에 따라서 이 같은 구분은 변경될 수 있다. 따라서 인스턴스를 Singleton으로 생성할지 Prototype으로 생성할지에 대한 여부에 대해서는 개발자들이 해당 Scope의 인스턴스가 메모리에서 어떻게 사용되는지를 이해하는 것이 가장 좋다.

• Singleton

  - Shared objects with no state

  - Shared object with read-only state

  - Shared object with shared state : 이 경우에는 Synchronization을 적절하게 사용하여 동시성을 제어하도록 해야 한다.

  - High throughput objects with writable state : 일반적으로 Object Pooling과 같은 기능을 사용하는 것을 예로 들 수 있다. 인스턴스를 생성하는데 많은 비용이 발생하거나 무수히 많은 인스턴스를 관리할 필요가 있는 경우에는 Object Pooling을 사용하고 Pooling 대상이 되는 인스턴스는 Singleton으로 사용할 수 있다. 이 경우에도 Writable State에 변경이 발생할 때 Synchronization을 적절하게 사용해야 한다.

• Prototype

  - Objects with writable state

  - Objects with private state

<!-- 신규 Scope 정의를 위한 클래스를 정의하고, 
org.springframework.beans.factory.config.Scope 인터페이스를 implement한다.-->
<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
<!-- CustomScopeConfigurer를 이용하여 Custom Scope 등록  -->
    <property name="scopes">
        <map>
            <entry key="thread">
            <bean class="com.foo.ThreadScope"/>
            </entry>
        </map>
    </property>
</bean>

<!-- Custom Scope 사용 -->
<bean id="bar" class="x.y.Bar" scope="thread">
    <property name="name" value="Rick"/>
    <aop:scoped-proxy/>
</bean>

Bean의 Life Cycle은 다음 그림에서와 같이 Initialization, Activation, Destruction으로 구성된다.

1.4.2.1.Initialization

Spring Container는 아래 그림에서 보여지는 여러 과정을 통해 구동된다. Spring Bean 클래스가 아래 그림에서 보여지는 각각의 인터페이스들을 구현하였을 때 각각의 메소드들이 호출된다.

Spring Framework에서 지원하는 Life Cycle 메소드를 그대로 사용할 경우 특정한 인터페이스를 구현해야 하므로, 해당 코드가 Spring Framework에 의존적일 수 있게 된다. 즉, 위 그림에서 제시하고 있는 Life Cycle 메소드를 사용하기 위해서는 Spring Bean 클래스에서 해당 Life Cycle 인터페이스 클래스를 구현해줘야 한다. 예를 들어, ApplicationContextAware 인터페이스 클래스를 구현한 Spring Bean에서는 setApplicationContext(ApplicationContext context) 메소드를 작성하고, Spring Bean 내부에서 ApplicationContext를 이용하여 ApplicationContext에서 제공하는 메소드를 호출할 수 있다.

public class IoCServiceImpl1 implements IoCService1, 
    ApplicationContextAware {
    public void setApplicationContext (ApplicationContext context){
        IoCService2 iocService2 = (IoCService2)context.getBean("IoCService2");
    }
}

또다른 예로 MessageSourceAware 인터페이스 클래스의 경우, Spring Container에 정의된 MessageSource를 얻기 위해 사용될수 있다. MessageSourceAware 인터페이스 클래스를 구현한 Spring Bean에서 setMessages(MessageSource messages) 메소드를 작성하여 MessageSource에 접근할 수 있다.

public class IoCServiceImpl1 implements IoCService1, MessageSourceAware {
    private MessageSource messageSource;
    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }
}

이와는 달리 Bean 속성(init-method, destroy-method) 정의를 통해 특정 인터페이스에 대한 구현없이 별도 Life Cycle 메소드를 정의할 수도 있다. 다음은 init-method 속성이 정의된 context-core.xml 의 일부이다.

<bean id="coreMovieService"
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl" 
        init-method="movieInitialize" destroy-method="movieDestroy" parent="parent">
</bean>

모든 Bean에 대한 초기화 method 설정은 <beans>의 default-init-method 속성을 이용하도록 한다.

1.4.2.2.Destruction

Destruction 단계에서는 BeanFactory와 ApplicationContext가 동일하게 동작한다.

다음은 destroy-method 속성이 정의된 context-core.xml 의 일부이다.

<bean id="coreMovieService"
        class="org.anyframe.plguin.core.moviefinder.service.impl.MovieServiceImpl" 
        init-method="movieInitialize" destroy-method="movieDestroy"
        parent="parent">
</bean>

모든 Bean의 소멸자 method 설정은 <beans>의 default-destroy-method 속성을 이용한다.

Bean 정의는 여러 속성 정보들, 생성자 인자, Property 값을 포함하여 많은 양의 설정 정보를 포함한다. 자식 Bean은 부모 정의로부터 설정 정보를 상속하여 정의한다. 그러므로 값을 오버라이드하거나 다른 것을 추가할 수 있다. 상속 관계를 이용하여 Bean을 정의하는 것은 XML 파일의 양을 줄일 수 있으므로 템플릿 형태의 부모 Bean을 정의하는 것은 유용하다. XML 기반의 속성 정의시 자식 Bean은 부모 Bean을 명시하기 위해 'parent' 속성을 사용해야 한다.

다음은 Bean 상속이 표현되어 있는 context-core.xml 의 일부이다.

<!-- register parent bean that has a dependency with coreMovieDao bean -->
<bean id="parent" abstract="true">
    <property name="coreMovieDao" ref="coreMovieDao" />	
</bean>

<bean id="coreMovieService" 
        class="org.anyframe.plugin.core.moviefinder.service.impl.MovieServiceImpl" 
        init-method="movieInitialize" destroy-method="movieDestroy" 
        parent="parent">
</bean>

Stereotype Annotation을 사용하여 Bean을 정의하면 XML에 따로 Bean 정의를 명시하지 않아도 Spring Container가 Bean을 인식하고 관리할 수 있다. 단, 자동 인식이 되기 위해서는 서비스 속성 정의 XML 내에 <context:component-scan/> 을 정의해 주어야 한다. 이 설정을 추가하면 Spring Container는 클래스패스 상에 존재하는 클래스들을 스캔하여 Stereotype Annotation이 정의된 클래스들 Bean으로 인식하고 자동으로 등록한다.

<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:schemalLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <context:component-scan base-package="org.anyframe.plugin" />	                            
</beans>

<context:component-scan />을 정의한 경우 Annotation 인식을 위한 설정 <context:annotation-config/> 을 별도로 추가하지 않아도 된다.

다음은 서비스 레이어의 구성 요소인 MovieServiceImpl 클래스에 대해 @Service라는 Stereotype Annotation을 사용한 예이다.

@Service
public class MovieServiceImpl implements MovieService {
	@Inject
	@Named("coreMovieDao")
	private MovieDao movieDao;
}

위 예제에서는 해당 클래스의 클래스명(소문자로 시작)이 Bean name으로 셋팅되어 해당 Bean을 찾을 때 movieServiceImpl 이라는 문자열을 사용해야 한다.

MovieService service = (MovieServiceImpl) context.getBean("movieServiceImpl");

해당 Annotation에 속성을 부여하면, 원하는 Bean name을 지정하는 것 또한 가능하다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
	@Inject
	@Named("coreMovieDao")
	private MovieDao movieDao;
}

이 경우에 해당되는 Bean을 찾기 위해서는 속성으로 정의한 Name을 활용해야 한다.

MovieService service = (MovieServiceImpl) context.getBean("movieServiceImpl")

<context:component-scan>의 여러 속성들을 이용하면 검색 대상의 범위를 조정하여 자동으로 검색되어 Bean으로 등록되는 클래스들을 filtering 할 수 있다. base-package 속성은 <context:component-scan> 내에 정의 가능한 속성으로 검색 대상 패키지를 정의하는 용도로 사용된다. 이외에도 <context:component-scan> 은 하위 element로 <context:include-filter>, <context:exclude-filter>를 가질 수 있는데, 다양한 Filter Type(type)에 해당하는 표현식(expression)을 정의함으로써 이에 해당하는 클래스들을 포함 또는 제외시킬 수가 있다. 다음은 <context:include-filter>, <context:exclude-filter> 사용 예이다.

<context:component-scan base-package="org.anyframe.plugin">
    <context:include-filter type="regex" expression=".*Stub.*Repository">
    <context:exclude-filter type="annotation" 
        expression="org.springframework.stereotype.Repository"/>
</context:component-scan>

정의 가능한 Filter Type은 4가지이며, 다음과 같다.

Spring Framework에서는 Bean의 인스턴스 생성 메커니즘 에 따라 5가지 Scope 을 제공하는데 이러한 Bean Scope을 정의하기 위해서는 다음과 같이 @Scope을 사용하도록 한다.

@Scope("prototype")
@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
	@Inject
	@Named("coreMovieDao")
	private MovieDao movieDao;
}

Spring의 @Autowired와 동일한 역할을 수행하는 표준 Annotation이다. 단, @Autowired와 달리 'required' 속성을 가지고 있지 않다. 또한 @Named와 같이 사용하였을 경우 정의된 Bean 이름을 이용하여 Injection이 수행된다. 다음은Core Plugin 설치로 추가된 서비스 클래스 ~/moviefinder/service/impl/MovieServiceImpl.java의 일부로써 @Inject를 사용한 예이다.

@Service("movieServiceImpl")
@Transactional(rollbackFor = { Exception.class }, propagation = Propagation.REQUIRED)
public class MovieServiceImpl implements MovieService {

    @Inject
    @Named("coreMovieDao")
    private MovieDao movieDao;

    // ...	
}

@Autowired는 Spring에 종속적이긴 하지만, 적용할 수 있는 위치가 @Resource나 @Inject보다 다양하고, 정밀한 Dependency Injection이 필요한 경우에 유용하다.

다음은 @Autowired를 사용한 예이다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
     @Autowired
     MovieDao movieDao;
}

@Autowired 적용 위치 별로 사용 예를 들면 다음과 같다.

기본적으로 @Autowired가 적용된 참조 관계는 반드시 해당 빈이 존재해야 하지만, required 속성을 false로 설정하는 경우에는 해당되는 Bean을 찾지 못하더라도 에러가 발생하지 않는다.

@Service
public MovieServiceImpl implements MovieService {
    @Autowired(required=false)
    private MovieDao movieDao;
}

또한, @Resource에서 설명했던 바와 같이 @Autowired도 BeanFactory, ApplicationContext, ResourceLoader, ApplicationEventPublisher, MessageSource 인터페이스와 하위 인터페이스들을 별도 설정 없이 바로 사용할 수 있게 해준다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
    @Autowired
    ApplicationContext context;
}

@Resource는 Bean name을 지정하여 Dependency Injection을 하고자 하는 경우에 사용한다. @Resource는 name이라는 속성을 가지고 있어서, Spring Container가 @Resource로 정의된 요소에 injection하기 위한 Bean을 검색할 때, name 속성에 지정한 이름을 검색할 Bean Name으로 사용한다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
    @Resource
    MessageSource messageSource;
    @Resource (name="movieDao")
    MovieDao movieDao;

명시적으로 name 속성에 이름을 지정하지 않는 경우, 검색할 Bean Name은 다음과 같은 규칙을 따른다.

해당하는 Bean Name으로 injection할 Bean을 찾지 못했을 경우에는 @Autowired 처럼 Bean의 type으로 검색한다.

@Resource를 이용하면 BeanFactory, ApplicationContext, ResourceLoader, ApplicationEventPublisher, MessageSource 인터페이스와 하위 인터페이스들을 별도 설정 없이 바로 사용 가능하다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
    @Resource
    ApplicationContext context;
}

type-driven injection의 경우 Spring Container가 해당 Bean을 찾을 때 객체의 type을 기준으로 검색을 수행하게 된다. 이와 같은 경우 동일한 type의 Bean이 여러 개 검색되었을 때 injection 대상이 되는 Bean을 결정하기 위한 세밀한 제어가 필요하며 이 때 @Qualifier를 사용할 수 있다.

@Service("movieServiceImpl")
public class MovieServiceImpl implements MovieService {
    @Autowired
    @Qualifier("sports")
    Movie sportsMovie;
}

<?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-3.0.xsd
                http://www.springframework.org/schema/context 
                http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        				
    <context:annotation-config/>

    <bean class="org.anyframe.sample.di.qualifier.moviefinder.domain.Movie">
        <qualifier value="sportsMovie"/>
        <!-- inject any dependencies required by this bean -->
    </bean>
    <bean class="org.anyframe.sample.di.qualifier.moviefinder.domain.Movie">
         <qualifier value="livingMovie"/>
         <!-- inject any dependencies required by this bean -->
    </bean>

    <bean id="movieServiceImpl" 
        class="org.anyframe.sample.di.qualifier.moviefinder.service.MovieServiceImpl"/>
</beans>

//...
import javax.inject.Qualifier;

@Target( { ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface DaoQualifier {
    public abstract String type() default "query";
}

@Named
@DaoQualifier(type = "hibernate")
public class MovieDaoHibernateImpl implements MovieDao {
    // ...
}

@Named
@DaoQualifier
public class MovieDaoQueryImpl implements MovieDao {
    // ...
}

@Named
public class MovieServiceImpl implements MovieService {

    @Inject
    @DaoQualifier(type = "hibernate")
    private MovieDao hibernateMovieDao;

    @Inject
    @DaoQualifier
    private MovieDao queryMovieDao;
	
    // ...	
}

JSR-303에서 제공하는 인터페이스로, 참조하고자 하는 Bean을 직접 Inject하지 않고 Inject 대상이 되는 클래스 타입 T에 대해 Provider<T> 형태로 Inject한다. javax.inject.Provider를 통해 Injection을 수행하는 경우 Spring에서는 DefaultListableBeanFactory 내의 DependencyProvider라는 구현체의 get() 메소드를 이용하여 Generic Type으로 제공된 T 타입의 새로운 인스턴스를 전달해주도록 하고 있다. 따라서, Singleton Bean에서 Prototype Bean을 참조하고자 할 때 적용할 수 있다.

다음은 Provider<T> 형태로 특정 Bean을 참조한 예이다.

@Named
public class MovieServiceImpl implements MovieService {
    @Inject
    private Provider<MovieDao> movieDaoFactory;

    public Movie get(String movieId) throws Exception {
        // get movieDao instance calling get()
        return movieDaoFactory.get().get(movieId);
    }
}

위의 코드에서는 Provider 타입의 movieDaoFactory 객체를 통해 get() 메소드를 호출할 때마다 새로운 MovieDao 인스턴스를 전달받게 될 것이다.

특정 Bean을 참조하는 경우 직접 Inject하지 않고 Provider<T> 형태로 Inject하였을 때 다음과 같은 이점을 제공한다. (출처: JSR-330 Dependency Injection for Java 1.0 Final Release for Documentation)

위에서 언급한 JSR-330 provider 샘플 코드는 본 섹션 내의 다운로드 - anyframe-sample-di-provider를 통해 다운로드받을 수 있다.

@Inject / @Autowired / @Resource를 비교하면 다음과 같다.

JSR-250 표준 Annotation으로 Bean 초기화시 필요한 작업을 담은 메소드에 대해 정의한다. @PostConstruct를 사용하기 위해서는 클래스패스 내에 jsr250-api.jar 파일이 추가되어 있어야 한다.

@PostConstruct
// 메소드명은 자유롭게 정의할 수 있다.
public void initialize() {
    // ...
}

JSR-250 표준 Annotation으로 Bean 소멸시 필요한 작업을 담은 메소드에 대해 정의한다. @PreDestroy를 사용하기 위해서는 클래스패스 내에 jsr250-api.jar 파일이 추가되어 있어야 한다.

@PreDestroy
// 메소드명은 자유롭게 정의할 수 있다.
public void dispose() {
    // ...
}

앞에서 설명한 바와 같이, Spring 2.5에서 bean lifecycle을 관리할 수 있는 방법은 다음과 같이 세가지가 있다.

위의 3가지 방법이 동시에 존재하는 경우(예를 들어, 3가지 방법이 각각 정의된 클래스가 Parent-child 관계를 가지는 경우), 실행되는 순서는 다음과 같다.

Initialization 메소드

Destroy 메소드

@Bean Annotation은 'name'이라는 속성 정보를 가지고 있다. name 속성에 대해 값을 부여하는 경우 이 값이 해당 Bean의 이름이 된다.

@Bean(name="movieFinderImpl")
public MovieFinder movieFinder() {
    return new MovieFinderImpl(movieDao);
}

@Bean을 이용하여 정의된 Bean들에 대해서도 XML이나 Annotation 기반의 Bean들과 동일하게 기본 Lifecycle 관리가 가능하다. 즉, 해당 Bean이 @PreDestroy, @PostConstruct와 같은 JSR-250 Annotation을 포함하고 있거나 Spring의 InitializingBean, DisposableBean 등과 같은 인터페이스르 구현하였을 경우 Spring Container에 의해 해당 Bean의 Lifecycle이 관리된다. 이 외에도 @Bean은 'init-method', 'destroy-method'라는 속성 정보를 가질 수 있어서 속성값을 부여하는 경우 초기화/소멸화시에 정의된 메소드가 실행된다. 이것은 <bean/>의 init-method, destroy-method와 동일한 역할을 수행한다.

@Bean(initMethod = "initialize", destroyMethod = "destroy")
public MovieFinder movieFinder() {
    return new MovieFinderImpl(movieDao);
}

위 코드에 의하면 'movieFinder'라는 Bean의 초기화 시점에는 MovieFinderImpl.initialize(), 소멸화 시점에는 MovieFinderImpl.destroy() 메소드가 각각 실행될 것이다.

Spring Container는 시작 시점에 모든 Singleton Bean을 미리 로딩함으로써, 그 Bean이 필요할 때 즉시 사용될 수 있도록 보장해준다. 그러나 Container 시작 시점에 특정 Singleton Bean을 인스턴스화 시키지 않고 처음으로 해당 Bean에 대해 요청이 들어왔을 때 인스턴스화 시키기 위해서는 @Lazy 설정을 부여해 주어야 한다. 이것은 <bean/>의 lazy-init과 동일한 역할을 수행한다.

@Bean
@Lazy
public MovieFinder movieFinder() {
    return new MovieFinderImpl(movieDao);
}

@Bean과 함께 @Scope 정의를 추가하는 경우 해당 Bean에 대해 특정 Scope을 부여할 수 있다. @Scope을 부여하지 않는 경우 기본적으로 Singleton Scope이 적용된다.

@Bean
@Scope("prototype")
public MovieFinder movieFinder() {
    return new MovieFinderImpl(movieDao);
}

또한 request, session, globalSession Scope의 Bean에 대한 요청시 전달될 AOP Proxy 객체를 만들기 위해서 'proxyMode'라는 속성값을 추가적으로 부여할 수 있다. 'proxyMode'는 기본적으로 ScopedProxyMode.NO로 지정되며 ScopedProxyMode.TARGET_CLASS 또는 ScopedProxyMode.INTERFACES으로 정의 가능하다. 이것은 <bean/> 하위의 <aop:scoped-proxy/>와 동일한 역할을 수행한다.

@Bean
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public MoviePreferences moviePreferences() {
    return new MoviePreferences();
}

@Bean
public MovieFinder movieFinder() {
    return new MovieFinderImpl(moviePreferences);
}

Bean 사이에 참조 관계가 성립될 경우 기본적으로 Injection은 참조하려는 Bean에 해당하는 메소드를 호출함으로써 이루어진다.

@Configuration
public class MovieFinderConfig {
    @Bean
    public MovieFinder movieFinder() {
        return new MovieFinderImpl(movieDao());
    }
    
    @Bean
    public MovieDao movieDao() {
        return new MovieDao();
    }    
}

'movieFinder' Bean이 'movieDao' Bean을 참조하고 있다라고 가정해 보자. 이를 Java 기반의 Configuration으로 표현하기 위해서는 위의 코드에서와 같이 movieFinder() 메소드 내에서 MovieFinderImpl 인스턴스 생성시 movieDao()라는 메소드를 호출함으로써 'movieDao' Bean을 Injection 할 수 있다. 또는 MovieFinderImpl 객체의 setter를 호출할 때 movieDao() 호출 결과를 전달함으로써 'movieDao' Bean을 Injection할 수도 있을 것이다.

@Configuration
public class MovieFinderConfig {
    @Bean
    public MovieFinder movieFinder() {
        MovieFinderImpl movieFinder = new MovieFinderImpl();
        movieFinder.setMovieDao(movieDao());
        return movierFinder;
    }
    
    @Bean
    public MovieDao movieDao() {
        return new MovieDao();
    }    
}

참조 대상 Bean이 XML/Annotation 기반으로 정의되었거나 다른 Configuration 클래스에 정의된 경우 Spring에서 Dependency Injection 처리를 위해 지원하는 Annotation(@Inject, @Autowired, @Resource)을 그대로 적용할 수도 있다.

@Configuration
public class MovieDaoConfig {

    @Bean
    public MovieDao movieDao() {
        MovieDao movieDao = new MovieDao();
        return movieDao;
    }
}

해당 Bean 이전에 초기화되어야 하는 하나 이상의 Bean을 명시적으로 강제하기 위해서는 @DependsOn을 활용할 수 있다. 이것은 <bean/>의 depends-on와 동일한 역할을 수행한다.

@Configuration
public class MovieFinderConfig {
    @Bean
    public MovieService movieService(){
        return new MovieServiceImpl();
    }

    @Bean
    @DependsOn(value = { "movieService" })		
    public MovieFinder movieFinder() {
        return new MovieFinderImpl(movieDao());
    }

    // ...
}

위 코드에 의하면 @DependsOn 속성 부여에 의해 'movieFinder' Bean이 초기화되기 전에 'movieService' Bean이 초기화 될 것을 짐작할 수 있다.

동일한 Type을 가지는 Bean이 여러개 정의되어 있어서 Type Injection 대상이 되는 Bean이 여러개 식별되었을 경우 @Primary를 부여한 Bean이 우선적으로 Injection 후보가 된다. 이것은 <bean/>의 primary와 동일한 역할을 수행한다.

@Configuration
public class MovieDaoConfig {
    @Bean
    public MovieDao defaultMovieDao() {
        return new MovieDaoImpl();
    }

    @Bean
    @Primary
    public MovieDao anotherMovieDao() {
        return new AnotherMovieDaoImpl();
    }
}

위와 같이 Configuration을 정의한 경우 @Autowired MovieDao movieDao;와 같은 코드에 의해 Injection되는 Bean은 @Primary 속성을 부여한 'anotherMovieDao' Bean이 될 것이다.

Setter injection과 Constructor injection을 사용할 경우, 기본적으로 Singleton Bean은 참조하는 Bean들을 Singleton 형태로 유지하게 된다. 그런데 Singleton Bean이 Non Singleton Bean(즉, Prototype Bean)과 참조 관계가 있을 경우에는 다음과 같이 처리해야 한다.

다음은 Singleton Bean('movieFinder')에서 Non Singleton Bean('movieDao')에 대한 참조가 이루어질 수 있도록 하기 위해 정의된 Configuration 클래스의 내용이다.

@Configuration
public class MovieFinderConfig {
    @Bean
    @Scope("prototype")
    public MovieDao movieDao() {
        return new MovieDaoImpl();
    }

    @Bean
    public MovieFinder movieFinder() {
        return new MovieFinderImpl() {
            protected MovieDao getMovieDao() {
                return movieDao();
            }
        };
    }
}

위 Configuration 클래스에서 언급한 MovieFinderImpl 클래스는 다음과 같은 모습을 취할 것이다.

public abstract class MovieFinderImpl implements MovieFinder {
    protected abstract MovieDao getMovieDao();

    public List<Movie> getPagingList(Movie movie, int pageIndex) 
        throws Exception{
        return getMovieDao().getPagingList(movie, pageIndex);
    }
}

Java 기반 Configuration 정의시 @Value와 함꼐 Spring Expression Language를 정의하면 Expression 처리 결과를 Bean의 인스턴스 생성시 반영하는 것도 가능하다.

@Configuration
public class MovieFinderConfig {
    private @Value("${jdbc.url}") String dbUrl;
    private @Value("${jdbc.username}") String userName;
    private @Value("${jdbc.password}") String password;

    @Bean
    public MovieDao movieDao() {
        return new MovieDaoImpl(dbUrl, userName, password);
    }
}

@Import 정의시 다른 @Configuration 클래스를 속성값으로 부여해주면 현재 @Configuration 클래스에서 다른 @Configuration 클래스 내에 정의된 @Bean 정보를 참조할 수 있게 된다. Import 대상이 되는 @Configuration 클래스가 다수일 경우 { } 내에 ','를 식별자로 하여 클래스를 명시해주면 된다. @Import는 <import/>와 동일한 역할을 수행한다.

@Configuration
@Import(value = { MovieDaoConfig.class })
public class MovieFinderConfig {
    @Autowired
    private MovieDao movieDao;

    @Bean
    public MovieFinder movieFinder() {
        return new MovieFinderImpl(movieDao);
    }
}

@Configuration
public class MovieDaoConfig {
    // ...

    @Bean
    public MovieDao movieDao() {
        MovieDao movieDao = new MovieDao();
        return movieDao;
    }
}

위에서 언급한 @Configuration MovieFinderConfig 클래스는 MovieDaoConfig 클래스를 @Import하고 있어서 이 클래스 내에 정의된 Bean 'movieDao'를 참조할 수 있게 된다. 다른 @Configuration 클래스 내에 정의된 @Bean을 참조하기 위해서는 @Autowired를 사용하고 있음을 알 수 있다. @Inject, @Resource를 사용하는 것 또한 가능하다.

@ImportResource 정의시 XML 속성 파일의 위치를 속성값으로 부여해주면 현재 @Configuration 클래스에서 XML 내에 정의된 Bean 정보를 참조할 수 있게 된다. Import 대상이 되는 XML 파일이 다수일 경우 @Import와 동일한 형태로 { } 내에 ','를 식별자로 하여 XML 파일명을 명시해주면 된다.

@Configuration
public class MovieDaoConfig {

    @Bean
    public MovieDao movieDao() {
        MovieDao movieDao = new MovieDao();
        return movieDao;
    }
}

위 코드에서는 다른 XML 내에 정의된 Bean을 참조하기 위해 @Autowired를 사용하고 있음을 알 수 있다. @Inject, @Resource를 사용하는 것 또한 가능하다.

XML/Annotation 기반에서 Spring Container를 시작시키기 위해서는 XmlWebApplicationContext, FileSystemXmlApplicationContext, ClassPathXmlApplicationContext와 같은 구현체를 활용했었다.

String[] locations = new String[] { "classpath:spring/context-*.xml" };
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(locations, false);
context.refresh();

그러나 @Configuration 클래스를 인식할 수 있도록 하기 위해서는 AnnotationConfigApplicationContext 구현체를 이용하여 Spring Container를 시작시켜야 한다. 인식해야 할 @Configuration 클래스가 다수일 경우 해당되는 클래스들을 입력 인자의 값으로 정의해주면 된다.

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MovieFinderConfig.class, ...);

또는 AnnotationConfigApplicationContext의 Default Constructor를 호출하여 인스턴스를 생성한 뒤 인식 대상이 되는 @Configuration 클래스들을 register할 수도 있다.

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(MovieFinderConfig.class, ...);
context.register(...);
context.refresh();

Spring Container가 Annotation 기반의 Bean을 검색할 수 있게 하기 위해 정의한 <context:component-scan/>과 유사하게 AnnotationConfigApplicationContext을 이용하여 특정 패키지 하위에 대한 scan도 가능하다. 이렇게 하는 경우 해당 패키지 하위에 속한 모든 @Configuration 클래스가 검색되어 Container에 의해 처리된다.

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("org.anyframe.sample");
context.refresh();

웹어플리케이션에서 @Configuration 클래스를 인식하여 Spring Container를 시작시키기 위해서는 ContextLoaderListener Listener의 속성 정보인 contextClass, contextConfigLocation의 값을 입력해주면 된다. 이 때, contextClass는 AnnotationConfigWebApplicationContext로 정의해주고, 이를 통해 로드될 @Configuration 클래스들을 contextConfigLocation의 속성값으로 부여해주도록 한다.

<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>org.anyframe.samples.moviefinder.basic.config.MovieFinderConfig</param-value>
</context-param>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Crosscutting Concerns 모듈이 삽입되어 동작할 수 있는 실행 가능한 특정 위치를 말한다. 예를 들어 메소드가 호출되는 부분 또는 리턴되는 시점이 하나의 JoinPoint가 될 수 있다. 또 필드를 액세스하는 부분, 인스턴스가 만들어지는 지점, 예외가 던져지는 시점, 등이 대표적인 JoinPoint가 될 수 있다. 각각의 JoinPoint들은 그 전후로 Crosscutting Concerns의 기능이 AOP에 의해 자동으로 추가되어져서 동작할 수 있는 후보지가 되는 것이다.

Pointcut은 어느 JoinPoint를 사용할 것인지를 결정하는 선택 기능을 말한다. AOP가 항상 모든 모듈의 모든 JoinPoint를 사용할 것이 아니기 때문에 필요에 따라 사용해야 할 모듈의 특정 JoinPoint를 지정할 필요가 있다. 일종의 JoinPoint 선정 룰과 같은 개념으로 다음과 같은 Pattern Matching 방법들을 이용하여 룰을 정의할 수 있다.

Advice는 각 JoinPoint에 삽입되어져 동작할 수 있는 코드로 동작 시점은 pointcut에 Matching되는 JoinPoint 실행 전후이며 before, after, after returning, after throwing, around 중에서 선택 가능하다.

동작 시점별 Advice 정의 방법에 대해서는 매뉴얼 >> Spring >> AOP 하위의 Annotation based AOP , XML based AOP , AspectJ based AOP 를 참고하도록 한다.

AOP가 Core Concerns 모듈의 코드를 직접 건드리지 않고 필요한 기능이 작동하도록 하는 데는 Weaving 또는 CrossCutting이라고 불리는 특수한 작업이 필요하다. Core Concerns 모듈이 자신이 필요한 Crosscutting Concerns 모듈을 찾아 사용하는 대신에 AOP에서는 Weaving 작업을 통해 Core Concerns 모듈의 사이 사이에 필요한 Crosscutting Concerns 코드가 동작하도록 엮어지게 만든다. 이를 통해 AOP는 기존의 OOP로 작성된 코드들을 수정하지 않고도 필요한 Crosscutting Concerns 기능을 효과적으로 적용해 낼 수 있다.

Weaving은 기존의 자바 언어와 컴파일러에서는 쉽게 구현할 수 있는 방법이 아니었으며 본격적인 AOP 기술이 등장한 것은 1990년대 후반 제록스 PARC 연구소에서 그레거 킥제일(Gregor Kiczales)에 의해 AspectJ가 개발되면서라고 볼 수 있다.

Weaving을 처리하는 방법은 다음과 같이 3가지가 존재한다.

Aspect는 어디에서(Pointcut) 무엇을 할 것인지(Advice)를 합쳐놓은 것을 말한다. AspectJ와 같은 자바 언어를 확장한 AOP에서는 마치 자바의 클래스처럼 Aspect를 코드로 작성할 수 있다. 다음은 모든 클래스의 main 메소드 실행(pointcut main()) 후에 "Hello from AspectJ"라는 문자열을 남기는 (after returning advice) Aspect HelloFromAspectJ의 일부이다.

public aspect HelloFromAspectJ{
    // define pointcut
    pointcut main(): execution(public static void main(String[]));
    // define advice
    after() returning : main() {
        System.out.println("Hello from AspectJ!");
    }
}

Aspect 정의에 대한 자세한 설명은 매뉴얼 >> Spring >> AOP 하위의 Annotation based AOP , XML based AOP , AspectJ based AOP 를 참고하도록 한다.

@AspectJ(Annotation)이 적용된 클래스들을 로딩하여 해당 클래스에 정의된 Pointcut, Advice를 실행하기 위해서는 Spring 속성 정의 XML 파일에 다음과 같이 추가해주어야 한다.

<aop:aspectj-autoproxy/>

@Aspect를 이용하여 특정 클래스가 Aspect임을 나타낸다. 다음 LoggingAspect 에서는 @Aspect를 이용하여 해당 클래스가 Aspect임을 나타내고 있다.

@Aspect
public class LoggingAspect {
      //...
}

@Pointcut을 이용하여 해당 Aspect를 적용할 부분을 정의한다. (Pointcut 정의시에는 Pointcut Designator와 Pattern Matching 활용 방법 을 참고한다.) 다음은 PrintStringUsingAnnotation 의 Pointcut 정의 부분이다. @Pointcut을 "execution(* org.anyframe.sample..*Impl.*(..))"와 같이 정의하고, 해당 Pointcut에 대해 식별자로써 serviceMethod라는 메소드명을 부여하였다. 이것은 클래스명이 Impl로 끝나는 모든 메소드의 실행 부분이 Aspect을 적용할 Pointcut임을 의미한다. 해당 Pointcut은 serviceMethod()라는 이름으로 이용 가능하다.

@Pointcut("execution(* org.anyframe.sample..*Impl.*(..))")
public void serviceMethod(){}

다음에서는 Annotation을 이용하여 동작 시점별 Advice를 정의하는 방법에 대해 살펴보기로 한다.

@Before("serviceMethod()")
public void beforeLogging(JoinPoint thisJoinPoint) {
    Class<? extends Object> clazz = thisJoinPoint.getTarget().getClass();
    String methodName = thisJoinPoint.getSignature().getName();
    Object[] arguments = thisJoinPoint.getArgs();

    StringBuilder argBuf = new StringBuilder();
    StringBuilder argValueBuf = new StringBuilder();
    int i = 0;
    for (Object argument : arguments) {
        String argClassName = argument.getClass().getSimpleName();
        if (i > 0) {
            argBuf.append(", ");
        }
        argBuf.append(argClassName + " arg" + ++i);
        argValueBuf.append(".arg" + i + " : " + argument.toString() + "\n");
    }

    if (i == 0) {
        argValueBuf.append("No arguments\n");
    }

    StringBuilder messageBuf = new StringBuilder();
    messageBuf.append("before executing " + methodName + "(" + argBuf.toString() + ") method");
    messageBuf.append("\n-------------------------------------------------------------------------------\n");
    messageBuf.append(argValueBuf.toString());
    messageBuf.append("-------------------------------------------------------------------------------");

    Log logger = LogFactory.getLog(clazz);
    if (logger.isDebugEnabled()) {
        logger.debug(messageBuf.toString());
    }
}

@AfterReturning(pointcut = "serviceMethod()", returning = "retVal")
public void afterReturningExecuteGetMethod(JoinPoint thisJoinPoint, Object retVal) {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();
   
    System.out.println("AfterReturning Advice of PrintStringUsingAnnotation");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
}

@AfterThrowing(pointcut = "serviceMethod()", throwing = "exception")
public void transfer(JoinPoint thisJoinPoint, Exception exception) throws MovieFinderException {
    Object target = thisJoinPoint.getTarget();
    while (target instanceof Advised) {
    try {
        target = ((Advised) target).getTargetSource().getTarget();
    } catch (Exception e) {
        LogFactory.getLog(this.getClass()).error("Fail to get target object
                    from JointPoint.", e);
        break;
        }
    }
	
    String className = target.getClass().getSimpleName().toLowerCase();
    String opName = (thisJoinPoint.getSignature().getName()).toLowerCase();
    Log logger = LogFactory.getLog(target.getClass());

    if (exception instanceof MovieFinderException) {
        SalesException empEx = (SalesException) exception;
        logger.error(empEx.getMessage(), empEx);
        throw empEx;
    }
	
    if (exception instanceof BaseException) {
        BaseException baseEx = (BaseException) exception;
        logger.error(baseEx.getMessage(), baseEx);
        throw new SalesException(messageSource, "error." + className + "." + opName,
                        new String[] {}, exception);
    }		
	
    logger.error(messageSource.getMessage("error." + className + "."
                                        + opName, new String[] {}, "no messages",
                                        Locale.getDefault()),exception);
    throw new MovieFinderException(messageSource, "error." + className + "." + opName,
                     new String[] {}, exception);
}

@After("getMethods()")
public void afterExecuteGetMethod(JoinPoint thisJoinPoint) {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();
    
    System.out.println("After(finally) Advice of PrintStringUsingAnnotation");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
}

@Around("updateMethods()")
public Object aroundExecuteUpdateMethod(ProceedingJoinPoint thisJoinPoint) throws Throwable {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();
    
    System.out.println("Around Advice of PrintStringUsingAnnotation");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
   
    // before logic
    Object retVal = thisJoinPoint.proceed();
    // after logic
    
    return retVal;
}

이제 테스트코드 Main.java를 이용하여 앞서 언급한 Aspect들이 정상적으로 동작하는지 확인해 보도록 하자. 다음은 테스트코드 Main.java 의 main()메소드로 실제 movie에 대한 CRUD 로직을 수행함으로써 Befor Advice로 정의된 LoggingAspect가 제대로 수행되는지 확인할 수 있다.

public static void main(String[] args) throws Exception {
    Main main = new Main();
    // 1. initialize context
    main.setup();
    // 2. test
    main.manageMovie();
    // 3. close context
    main.teardown();
}

public void manageMovie() throws Exception {
    // 1. lookup aopMovieFinder, aopMovieService
    MovieFinder movieFinder = (MovieFinder) context.getBean("aopMovieFinder");
    MovieService movieService = (MovieService) context.getBean("aopMovieService");

    // 2. create a new movie
    Movie movie = getMovie();
    movieService.create(movie);
	
    // 3. get movie list
    Page movies = movieFinder.getPagingList(movie, 1);

    // 4. update movie
    movie.setTitle("Mission Impossible");
    movieService.update(movie);
	
    // 5. get movie 
    Movie result = movieService.get(movie.getMovieId());
	
    // 6. remove movie 
    movieService.remove(movie.getMovieId());
}

private Movie getMovie() throws Exception {
    Genre genre = new Genre();
    genre.setGenreId("GR-03");

    Movie movie = new Movie();
    movie.setMovieId("MV-99999");
    movie.setTitle("Shrek (2001)");
    movie.setActors("Shrek");
    movie.setDirector("Andrew Adamson");
    movie.setGenre(genre);
    movie.setReleaseDate(new Date());
    movie.setRuntime(new Long(90));
    movie.setTicketPrice(new Float(8000));
    movie.setNowPlaying("N");

    return movie;
}

첫번째 로직 movieService.create(movie); 실행시 Before Advice로 정의된 LoggingAspect 클래스가 적용되며, 콘솔창에 다음과 같은 실행 결과를 포함하게 된다.

before executing create(Movie arg1) method
-------------------------------------------------------------------------------
.arg1 : [actors=Shrek, director=Andrew Adamson, movieId=MV-99999, nowPlaying=N, 
posterFile=null, releaseDate=Mon Apr 18 13:40:42 KST 2011, runtime=90, ticketPrice=8000.0, 
title=Shrek (2001), genreId=GR-03]
-------------------------------------------------------------------------------

두번째 로직movieFinder.getPagingList(movie, 1); 실행시 Before Advice로 정의된 LoggingAspect 클래스가 적용되며, 콘솔창에 다음과 같은 실행 결과를 포함하게 된다.

before executing getPagingList(Movie arg1, Integer arg2) method
-------------------------------------------------------------------------------
.arg1 : [actors=Shrek, director=Andrew Adamson, movieId=MV-99999, nowPlaying=N, 
posterFile=null, releaseDate=Mon Apr 18 13:40:42 KST 2011, runtime=90, ticketPrice=8000.0, 
title=Shrek (2001), genreId=GR-03]
.arg2 : 1
-------------------------------------------------------------------------------

<aop:config>의 하위 태그인 <aop:aspect>를 이용하여 Aspect을 정의한다. 다음 context-aspect.xml 에서는 aop namespace를 이용하여 Aspect을 정의하고 있다.

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <bean id="methodLoggingAspect" class="org.anyframe.sample.aop.common.aspect.LoggingAspect" />
    <bean id="exceptionTransfer" class="org.anyframe.sample.aop.common.aspect.ExceptionTransfer">
        <property name="messageSource" ref="messageSource"/>
    </bean>
</beans>

Advice를 정의한 클래스를 Bean으로 정의해 두고, 해당 Bean을 <aop:config>내의 <aop:aspect> 에서 참조하는 형태로 Aspect을 정의할 수 있다.

<aop:pointcut> 내의 expression의 값에 Pointcut Designator와 Pattern Matching을 이용하여 pointcut을 정의한다. 그리고 id의 값에 식별자를 부여한다. (Pointcut 정의시에는 Pointcut Designator와 Pattern Matching 활용 방법 을 참고한다.)

<aop:pointcut id="serviceMethod" expression="execution(* org.anyframe.sample..*Impl.*(..))" />

이것은 클래스명이 Impl로 끝나는 모든 메소드의 실행 부분이 Aspect을 적용할 Pointcut임을 의미한다. 해당 Pointcut은 serviceMethod라는 이름으로 이용 가능하다.

다음에서는 XML 기반에서 동작 시점별로 Advice 정의 및 구현 방법에 대해 살펴보기로 한다.

<aop:before method="beforeLogging" pointcut-ref="serviceMethod"/>

public class LoggingAspect {
    public void beforeLogging(JoinPoint thisJoinPoint) {
        Class<? extends Object> clazz = thisJoinPoint.getTarget().getClass();
        String methodName = thisJoinPoint.getSignature().getName();
        Object[] arguments = thisJoinPoint.getArgs();

        StringBuilder argBuf = new StringBuilder();
        StringBuilder argValueBuf = new StringBuilder();
        int i = 0;
        for (Object argument : arguments) {
            String argClassName = argument.getClass().getSimpleName();
            if (i > 0) {
                argBuf.append(", ");
            }
            argBuf.append(argClassName + " arg" + ++i);
            argValueBuf.append(".arg" + i + " : " + argument.toString() + "\n");
        }

        if (i == 0) {
            argValueBuf.append("No arguments\n");
        }

        StringBuilder messageBuf = new StringBuilder();
        messageBuf.append("before executing " + methodName + "("+ argBuf.toString() + ") method");
        messageBuf.append("\n-------------------------------------------------------------------------------\n");
        messageBuf.append(argValueBuf.toString());
        messageBuf.append("-------------------------------------------------------------------------------");

        Log logger = LogFactory.getLog(clazz);
        if (logger.isDebugEnabled()) {
            logger.debug(messageBuf.toString());
        }
    }
}

<aop:after-returning method="afterReturningExecuteGetMethod" returning="retVal" 
     pointcut-ref="serviceMethod" />

public class PrintStringUsingXML {
	// ...
	
    public void afterReturningExecuteGetMethod(JoinPoint thisJoinPoint, Object retVal) {
        Class targetClass = thisJoinPoint.getTarget().getClass();
        Signature signature = thisJoinPoint.getSignature();
        String opName = signature.getName();
	
        System.out.println("AfterReturning Advice of PrintStringUsingXML");
        System.out.println("***" + targetClass + "." + opName + "()" + "***");
    }
	
    // ...
}

<aop:after-throwing throwing="exception" pointcut-ref="serviceMethod" method="transfer" />

public class ExceptionTransfer {

    private MessageSource messageSource;

    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }	

    public void transfer(JoinPoint thisJoinPoint, Exception exception) throws SalesException {
        Object target = thisJoinPoint.getTarget();
        while (target instanceof Advised) {
            try {
                target = ((Advised) target).getTargetSource().getTarget();
            } catch (Exception e) {
                LogFactory.getLog(this.getClass()).error(
                    "Fail to get target object from JointPoint.", e);
                break;
            }
        }

        String className = target.getClass().getSimpleName().toLowerCase();
        String opName = (thisJoinPoint.getSignature().getName()).toLowerCase();
        Log logger = LogFactory.getLog(target.getClass());

        if (exception instanceof SalesException) {
            SalesException empEx = (SalesException) exception;
            logger.error(empEx.getMessage(), empEx);
            throw empEx;
        }
		
        if (exception instanceof BaseException) {
            BaseException baseEx = (BaseException) exception;
            logger.error(baseEx.getMessage(), baseEx);
            throw new SalesException(messageSource, "error." + className + "."
                    + opName, new String[] {}, exception);
        }		

        logger.error(messageSource.getMessage("error." + className + "."
                + opName, new String[] {}, "no messages", Locale.getDefault()), exception);

        throw new SalesException(messageSource, "error." + className + "."
                + opName, new String[] {}, exception);
    }
}

<aop:after method="afterExecuteGetMethod" pointcut-ref="getMethods">

public class PrintStringUsingXML {
	// ...
	
    public void afterExecuteGetMethod(JoinPoint thisJoinPoint) {
        Class targetClass = thisJoinPoint.getTarget().getClass();
        Signature signature = thisJoinPoint.getSignature();
        String opName = signature.getName();

        System.out.println("After(finally) Advice of PrintStringUsingXML");
        System.out.println("***" + targetClass + "." + opName + "()" + "***");
    }
	
    // ...
}

<aop:around method="aroundExecuteUpdateMethod" pointcut-ref="updateMethods">

public class PrintStringUsingXML {
    // ...
	
    public Object aroundExecuteUpdateMethod(ProceedingJoinPoint thisJoinPoint)
            throws Throwable {
        Class targetClass = thisJoinPoint.getTarget().getClass();
        Signature signature = thisJoinPoint.getSignature();
        String opName = signature.getName();

        System.out.println("Around Advice of PrintStringUsingXML");
        System.out.println("***" + targetClass + "." + opName + "()" + "***");
        // before logic
        Object retVal = thisJoinPoint.proceed();
        // after logic
        return retVal;
    }
	
    // ...
}

AspectJ를 이용하기 위해서는 다음과 같은 사항에 대해 확인이 필요하다.

확장자가 aj인 파일을 생성하고, aspect을 이용하여 Aspect 클래스를 정의한다. 다음 LoggingAspect에서는 aspect를 이용하여 해당 클래스가 Aspect임을 나타내고 있다.

public aspect LoggingAspect {
    // ...
}

pointcut을 이용하여 해당 Aspect를 적용할 부분을 정의한다. (Pointcut 정의시에는 Pointcut Designator와 Pattern Matching 활용 방법 을 참고한다.) 다음은 LoggingAspect 의 Pointcut 정의 부분이다. pointcut을 "execution(execution(* org.anyframe.sample..*Impl.*(..)))"와 같이 정의하고, 해당 Pointcut에 대해 식별자로써 serviceMethod()라는 메소드명을 부여하였다. 이것은 클래스명이 GenericService로 끝나는 모든 메소드의 실행 부분이 Aspect을 적용할 Pointcut임을 의미한다. 해당 Pointcut은 serviceMethod()라는 이름으로 이용 가능하다.

pointcut serviceMethod(): execution(* org.anyframe.sample..*Impl.*(..));

다음에서는 AspectJ 기반에서 동작 시점별 Advice를 정의하는 방법에 대해 살펴보기로 한다.

before() : getMethods(){
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();

    System.out.println("Before Advice of PrintStringUsingAspctJ");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");		
}

after() returning(UserVO retVal) : getMethods()
 {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();

    System.out.println("AfterReturning Advice of PrintStringUsingAspctJ");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
}

after() throwing(Exception exception) : getMethods() {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();

    System.out.println("AfterThrowing Advice of PrintStringUsingAspctJ");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
}

after() : getMethods() {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();

    System.out.println("After(finally) Advice of PrintStringUsingAspctJ");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");		
}

Object around() : updateMethods() {
    Class targetClass = thisJoinPoint.getTarget().getClass();
    Signature signature = thisJoinPoint.getSignature();
    String opName = signature.getName();

    System.out.println("Around Advice of PrintStringUsingAspctJ");
    System.out.println("***" + targetClass + "." + opName + "()" + "***");
    // before logic
    Object retVal = proceed();
    // after logic
    return retVal;		
}

개발된 어플리케이션 테스트시 오류가 발생한 경우, 해당하는 메소드 로직 내에 입력값 확인을 위해 DEBUG 레벨의 로그를 추가하거나, System.out.println() 구문을 추가하게 되는데 이로 인해 핵심 비즈니스 로직과 섞이게 되어 코드 복잡도가 증가한다. 따라서 특정 메소드 호출시 전달하는 입력값 확인을 위한 별도 Aspect을 정의하여 활용하면 관련된 메소드 내에 입력값 확인을 위한 로직들을 제외시킬 수 있게 된다. 다음에서는 AOP의 대표적인 툴 중 @AspectJ(Annotation)를 이용하여 Logging Aspect를 생성하고 테스트해 보도록 할 것이다. Logging Aspect 적용 대상은 GenericService 이며, 모든 메소드 실행 전에 해당 메소드를 실행하기 위해 입력된 인자들의 값을 로그로 남기는 역할을 수행하게 될 것이다.

<aop:aspectj-autoproxy/>

@Aspect
@Service
public class LoggingAspect {

    @Pointcut("execution(* org.anyframe.sample..*Impl.*(..))")
    public void serviceMethod() {
    }

    @Before("serviceMethod()")
    public void beforeLogging(JoinPoint thisJoinPoint) {
        Class<? extends Object> clazz = thisJoinPoint.getTarget().getClass();
        String methodName = thisJoinPoint.getSignature().getName();
        Object[] arguments = thisJoinPoint.getArgs();

        StringBuilder argBuf = new StringBuilder();
        StringBuilder argValueBuf = new StringBuilder();
        int i = 0;
        for (Object argument : arguments) {
            String argClassName = argument.getClass().getSimpleName();
            if (i > 0) {
                argBuf.append(", ");
            }
            argBuf.append(argClassName + " arg" + ++i);
            argValueBuf.append(".arg" + i + " : " + argument.toString() + "\n");
        }

        if (i == 0) {
            argValueBuf.append("No arguments\n");
        }

        StringBuilder messageBuf = new StringBuilder();
        messageBuf.append("before executing " + methodName + "("+ argBuf.toString() + ") method");
        messageBuf.append("\n-------------------------------------------------------------------------------\n");
        messageBuf.append(argValueBuf.toString());
        messageBuf.append("-------------------------------------------------------------------------------");

        Log logger = LogFactory.getLog(clazz);
        if (logger.isDebugEnabled()) {
            logger.debug(messageBuf.toString());
        }
    }
}

[DEBUG] 2011-04-18 13:40:42 org.anyframe.sample.aop.moviefinder.service.impl.MovieServiceImpl 
before executing create(Movie arg1) method
-------------------------------------------------------------------------------
.arg1 : [actors=Shrek, director=Andrew Adamson, movieId=MV-99999, nowPlaying=N, 
posterFile=null, releaseDate=Mon Apr 18 13:40:42 KST 2011, runtime=90, ticketPrice=8000.0, 
title=Shrek (2001), genreId=GR-03]
-------------------------------------------------------------------------------
============ MovieDao : call create()==========

[DEBUG] 2011-04-18 13:40:42 org.anyframe.sample.aop.moviefinder.service.impl.MovieFinderImpl 
before executing getPagingList(Movie arg1, Integer arg2) method
-------------------------------------------------------------------------------
.arg1 : [actors=Shrek, director=Andrew Adamson, movieId=MV-99999, nowPlaying=N, 
posterFile=null, releaseDate=Mon Apr 18 13:40:42 KST 2011, runtime=90, ticketPrice=8000.0, 
title=Shrek (2001), genreId=GR-03]
.arg2 : 1
-------------------------------------------------------------------------------
============ MovieDao : call getPagingList()==========

[DEBUG] 2011-04-18 13:40:42 org.anyframe.sample.aop.moviefinder.service.impl.MovieServiceImpl 
before executing update(Movie arg1) method
-------------------------------------------------------------------------------
.arg1 : [actors=Shrek, director=Andrew Adamson, movieId=MV-99999, nowPlaying=N, 
posterFile=null, releaseDate=Mon Apr 18 13:40:42 KST 2011, runtime=90, ticketPrice=8000.0, 
title=Mission Impossible, genreId=GR-03]
-------------------------------------------------------------------------------
============ MovieDao : call update()==========

[DEBUG] 2011-04-18 13:40:42 org.anyframe.sample.aop.moviefinder.service.impl.MovieServiceImpl 
before executing get(String arg1) method
-------------------------------------------------------------------------------
.arg1 : MV-99999
-------------------------------------------------------------------------------
============ MovieDao : call update()==========

[DEBUG] 2011-04-18 13:40:42 org.anyframe.sample.aop.moviefinder.service.impl.MovieServiceImpl 
before executing remove(String arg1) method
-------------------------------------------------------------------------------
.arg1 : MV-99999
-------------------------------------------------------------------------------
============ MovieDao : call remove()==========

특정 비즈니스 로직 수행시 발생할 수 있는 Exception에 대한 로그 및 메시지 처리를 수행하기 위해 핵심 비즈니스 로직외에 Exception 처리 로직이 추가되어야 한다. 때문에 핵심 비즈니스 로직외에 매 로직마다 반복되는 try ~ catch 블럭으로 인해 코드가 복잡해진다. 만일 별도 Aspect을 통해 공통적으로 Exception들을 처리하게 하고, 각 비즈니스 로직에서 try ~ catch 블럭을 제거할 수 있다면 코드가 훨씬 간단해지고, 궁극적으로 개발자는 비즈니스 로직에만 집중할 수 있는 기반이 마련될 수 있을 것이다. 다음에서는 AOP 대표적인 툴 중 Spring AOP를 이용하여 XML 스키마 기반에서 ExceptionTransfer를 위한 Aspect를 생성하고 테스트해 보도록 할 것이다. ExceptionTransfer Aspect 적용 대상은 GenericService로 끝나는 클래스의 모든 메소드 실행시 Exception이 발생한 경우 이를 처리하기 위한 역할을 수행하게 될 것이다.

<aop:config>
    <aop:pointcut id="serviceMethod" expression="execution(execution(* org.anyframe.sample..*Impl.*(..))" />
    <aop:aspect ref="exceptionTransfer" order="1"> 
        <aop:after-throwing throwing="exception" pointcut-ref="serviceMethod" method="transfer" />					
    </aop:aspect>
</aop:config>

public class ExceptionTransfer {
    private MessageSource messageSource;

    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }	

    public void transfer(JoinPoint thisJoinPoint, Exception exception)
            throws SalesException {
        Object target = thisJoinPoint.getTarget();
        while (target instanceof Advised) {
            try {
                target = ((Advised) target).getTargetSource().getTarget();
            } catch (Exception e) {
                LogFactory.getLog(this.getClass()).error(
                        "Fail to get target object from JointPoint.", e);
                break;
            }
        }

        String className = target.getClass().getSimpleName().toLowerCase();
        String opName = (thisJoinPoint.getSignature().getName()).toLowerCase();
        Log logger = LogFactory.getLog(target.getClass());

        if (exception instanceof SalesException) {
            SalesException empEx = (SalesException) exception;
            logger.error(empEx.getMessage(), empEx);
            throw empEx;
        }
		
        if (exception instanceof BaseException) {
            BaseException baseEx = (BaseException) exception;
            logger.error(baseEx.getMessage(), baseEx);
            throw new SalesException(messageSource, "error." + className + "." + opName
                                ,new String[] {}, exception);
        }		

        logger.error(messageSource.getMessage("error." + className + "."
                + opName, new String[] {}, "no messages", Locale.getDefault()),	exception);

        throw new SalesException(messageSource, "error." + className + "."
                + opName, new String[] {}, exception);
    }
}

별도 성능 측정 툴없이도 Aspect을 통해 응답 속도가 중요시 되는 일부 메소드에 대해 개발 시점에 미리 메소드 수행에 걸리는 시간을 측정해 볼 수 있다. 따라서 개발시에 성능 저하의 요인이 되는 지점을 미리 파악하고 대처해 볼 수 있을 것이다.

다음에서는 AOP의 대표적인 툴 중 @AspectJ(Annotation)를 이용하여 SimpleProfiler Aspect를 생성하고 테스트해 보도록 할 것이다. SimpleProfiler Aspect 적용 대상은 UserService이며, 특정 메소드(add*) 실행에 소요되는 시간을 측정하고, 이를 콘솔에 남기는 역할을 수행하게 될 것이다.

<aop:aspectj-autoproxy/>

@Aspect
public class SimpleProfiler {
    @Pointcut("execution(* org.anyframe.sample.aop.movidfinder.service..*Impl.create*(..))")
    public void createMethods() {
    }
		
    @Around("createMethods()")
    public Object profile(ProceedingJoinPoint thisJoinPoint) throws Throwable {
        String className = thisJoinPoint.getSignature().getDeclaringTypeName();
        StopWatch stopWatch = new StopWatch("Profiling for [" + className + "]");
        try {
            stopWatch.start(thisJoinPoint.toShortString());
            return thisJoinPoint.proceed();
        } finally {
            stopWatch.stop();
            System.out.println(stopWatch.shortSummary());
        }
    }
}

StopWatch 'Profiling for [org.anyframe.sample.aop.moviefinder.service.impl.MovieServiceImpl]'
: running time (millis) = 1016

개발 표준이라 함은 각종 명명 표준 및 해당 프로젝트에서 기 검증한 소프트웨어 아키텍처 스타일에 맞춰 개발 작업을 수행할 수 있도록 가이드한다. 따라서, 개발자들이 개발 초기에 겪게 되는 혼선을 줄이고 비즈니스 로직에만 집중할 수 있도록 하며, 동일한 표준을 준수한 코드에 대해서는 유지보수 및 변경이 용이하다. 대부분의 프로젝트에서는 어플리케이션을 본격적으로 개발하기에 앞서 상당한 시간을 들여 해당 프로젝트에 적합한 개발 표준을 별도 문서로 정의하고 개발자들이 이를 준수하여 개발 작업을 수행할 것을 권장하나, 제대로 지켜지지 않고 있으며 이에 대한 검증 또한 한계가 있는게 사실이다.

만일 코드 컴파일시에 개발 표준을 적용할 수 있다면, 코딩시에 손쉽게 표준에 부적합한 코드를 인식하고 수정할 수 있게 될 것이다. 이를 위해 본 문서에서는 Design Rule을 declare error/warning 문으로 구성된 Aspect로 정의하고, 부적합 사항을 찾아 수정하는 방법에 대해 알아보기로 하자.

먼저, declare error/warning 문은 다음과 같이 정의하며, Pointcut Expression에 해당하는 JoinPoint가 있을 경우 정의된 메시지를 보여준다.

@DeclareWarning ("Pointcut Expressions")
static final String varialableName = "msg...";

다음은 Anyframe 기반 어플리케이션 개발시 가장 흔하게 볼 수 있는 일부 소프트웨어 아키텍처 그림이다.

해당 어플리케이션의 패키지는 com.sds.emp로 시작하며, 프리젠테이션 레이어는 com.sds.emp.서브모듈명.web, 비즈니스 레이어는 com.sds.emp.서브모듈명.service 내에 위치한다라고 가정하자.

정의 가능한 Design Rule은 크게 Interaction Rule , Naming Rule 로 구분해 볼 수 있으며, 이제부터 위 그림을 기반으로 Design Rule을 하나씩 정의해 보도록 하자.

다음은 Core Plugin 설치로 추가된 Spring 속성 정의 파일 context-transaction.xml의 일부로써 SpEL을 활용하여 dataSource Bean을 정의하고 있다. 클래스패스 상에 존재하는 context.properties 파일을 로드하여 contextProperties라는 이름의 Bean에서 관리하도록 정의해두고, dataSource Bean에서는 contextProperties Bean에 접근하여 driver, url, username, password에 대한 속성 정보를 추출함으로써 해당 Bean의 속성을 셋팅하고 있음을 알 수 있다.

<util:properties id="contextProperties" location="classpath:context.properties"/>
 	
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="#{contextProperties.driver}"/>
    <property name="url" value="#{contextProperties.url}"/>
    <property name="username" value="#{contextProperties.username}"/>
    <property name="password" value="#{contextProperties.password}"/>
</bean>

'systemProperties'는 SpEL에서 정의한 내부 변수명으로 시스템 변수의 값을 추출하고자 할 때 #{systemProperties[...]}와 같은 형태로 활용할 수 있다. 즉, 앞서 언급한 DB 속성 정보를 Driver, URL, UserName, Password라는 시스템 변수로 셋팅해 두었다면 다음과 같이 dataSource Bean의 속성 정의를 변경할 수 있을 것이다.

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="#{systemProperties['Driver']}"/>
    <property name="url" value="#{systemProperties['URL']}"/>
    <property name="username" value="#{systemProperties['UserName']}"/>
    <property name="password" value="#{systemProperties['Password']}"/>
</bean>

Spring에서 Annotation 기반으로 Bean을 정의할 때, XML과 달리 @Value라는 Annotation과 함께 Expression을 정의해 주어야 하며 @Value는 field, method, method/constructor argument에 적용할 수 있다.

다음은 Core Plugin 설치로 추가된 DAO 클래스 ~/service/impl/MovieDao.java의 일부로써 SpEL을 활용하여 MovieDao Bean의 pageSize, pageUnit 속성을 셋팅하고 있음을 알 수 있다. contextProperties Bean으로부터 'pageSize', 'pageUnit' 정보를 추출하여 해당하는 field의 값을 셋팅하고 이를 활용하게 될 것이다.

@Repository("coreMovieDao")
public class MovieDao extends SimpleJdbcDaoSupport {
    @Value("#{contextProperties['pageSize'] ?: 10}")
    int pageSize;

    @Value("#{contextProperties['pageUnit'] ?: 10}")
    int pageUnit;

    @Inject
    public void setJdbcDaoDataSource(DataSource dataSource) throws Exception {
        super.setDataSource(dataSource);
    }

    ...
}

위 코드에서는 Elvis Operator를 활용하여 Expression을 정의하고 있으며 contextProperties라는 이름의 Bean이 'pageSize' 값을 가지고 있지 않을 경우 기본값을 '10'으로 셋팅하도록 요구하고 있다.

Annotation 기반 Bean 정의시에도 XML과 마찬가지로 'systemProperties'를 활용하여 시스템 변수의 값을 추출할 수 있다.

정의된 문자열을 String, Date, Number, boolean, null 타입으로 변경하여 전달할 수 있다. String 타입의 경우 single quote(')를 사용하여 정의하도록 한다. 다음은 Spring ExpressionParser를 활용하여 다양한 문자열을 지정된 타입으로 변경해보는 로직을 포함한 테스트 메소드이다.

public void evaluateLiteralExpression() throws Exception {
    ExpressionParser parser = new SpelExpressionParser();
    String stringVal = (String) parser.parseExpression("'Hello Anyframe'").getValue();
    System.out.println("[Literal Expression] Evaluate 'Hello Anyframe' : " + stringVal);

    double doubleVal = (Double) parser.parseExpression("6.0221415E+23").getValue();
    System.out.println("[Literal Expression] Evaluate '6.0221415E' : " + doubleVal);

    Date dateVal = (Date) parser.parseExpression("'2010/07/05'").getValue(Date.class);
    System.out.println("[Literal Expression] Evaluate '2010/07/05' : " + dateVal);

    boolean booleanVal = (Boolean) parser.parseExpression("true").getValue();
    System.out.println("[Literal Expression] Evaluate 'true' : " + booleanVal);

    Object nullVal = parser.parseExpression("null").getValue();
    System.out.println("[Literal Expression] Evaluate null : " + nullVal);
}

위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Literal Expression] Evaluate 'Hello Anyframe' : Hello Anyframe
[Literal Expression] Evaluate '6.0221415E' : 6.0221415E23
[Literal Expression] Evaluate '2010/07/05' : Mon Jul 05 00:00:00 KST 2010
[Literal Expression] Evaluate 'true' : true
[Literal Expression] Evaluate null : null

Properties, Arrays, List, Map 등과 같은 객체가 가진 내부 객체 목록에 접근하기 위해 ['index'] 또는 ['key']와 같은 형태의 Expression을 정의할 수 있다. 또한 period(.)를 사용하면 내부 객체의 속성 정보에 접근할 수 있게 된다. (특정 객체의 속성 정보에 접근시 속성명의 첫번째 문자에 대해서는 Case Insensitive하다.) 다음은 Genre 객체 내에 포함된 java.util.ArrayList 타입의 movies로부터 첫번째 Movie 정보의 Title 값을 추출해 보는 테스트 메소드이다.

public void evaluateListExpression() throws Exception {
    Genre genre = getGenre();
    StandardEvaluationContext context = new StandardEvaluationContext(genre);

    ExpressionParser parser = new SpelExpressionParser();
    String title = parser.parseExpression("movies[0].Title").getValue(context, String.class);
    System.out.println("[List Expression] Movie title : " + title);
}

위 메소드에서 활용한 테스트 데이터 Genre가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 첫번째 Movie 정보의 Title 값인 'Shrek (2001)'이 출력될 것이다.

[List Expression] Movie title : Shrek (2001)

일반적인 Java Syntax를 활용하여 지정된 메소드를 실행시킬 수 있다. 다음은 Spring ExpressionParser를 활용하여 substring()이라는 메소드를 실행하는 테스트 로직의 일부이다.

ExpressionParser parser = new SpelExpressionParser();			
String c = parser.parseExpression("'abc'.substring(1)").getValue(String.class);

Expression이 위와 같이 정의된 경우 특정 문자열을 substring한 결과인 'bc'라는 결과값이 리턴될 것이다.

equal('=='), not equal('!='), less than('<'), less than or equal('<='), greater than('>'), and greater than or equal('>=') 등과 같은 Relational Operator를 활용할 수 있다. XML 문서 등에서의 <와 같은 사용으로 인한 문제를 피하기 위해서는 Relational Operators는 문자로도 표현할 수 있다. (case insensitive)

lt ('<'), gt ('>'), le ('<='), ge ('>='), 
eq ('=='), ne ('!='), div ('/'), mod ('%'), not ('!')

이 외에도 'instanceof'와 Regular Expression 기반의 'matches'도 지원한다. 다음은 Spring ExpressionParser를 활용하여 Relational Operator를 포함한 Expression을 실행하는 테스트 로직의 일부이다.

ExpressionParser parser = new SpelExpressionParser();
boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class);
boolean falseValue = parser.parseExpression("'xyz' instanceof T(int)").getValue(Boolean.class);
boolean trueValue = 
    parser.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

and, or, not 등과 같은 Logical Operator를 활용할 수 있다. 다음은 Spring ExpressionParser를 활용하여 Logical Operator를 포함한 Expression을 실행하는 테스트 로직의 일부이다.

ExpressionParser parser = new SpelExpressionParser();
boolean falseValue = parser.parseExpression("true and false").getValue(Boolean.class);
boolean trueValue = parser.parseExpression("true or false").getValue(Boolean.class);
boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

+, -, *, /, %, ^와 같은 Mathematical Operator를 활용할 수 있다. 다음은 Spring ExpressionParser를 활용하여 Mathematical Operator를 포함한 Expression을 실행하는 테스트 로직의 일부이다.

ExpressionParser parser = new SpelExpressionParser();
String testString = 
    parser.parseExpression("'test' + ' ' + 'string'").getValue(String.class);			
int two = parser.parseExpression("1 + 1").getValue(Integer.class);	
int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class);

Assignment Operator('=')를 활용하여 setter 메소드를 실행한 것과 동일하게 특정 객체의 속성값을 수정할 수 있다. 다음은 Assignment Operator를 활용하여 Genre 객체의 'Name' 값을 'Animation'으로 변경해보는 로직을 포함한 테스트 메소드이다.

public void evaluateAssignmentExpression() throws Exception {
    Genre genre = getGenre();
    StandardEvaluationContext context = new StandardEvaluationContext(genre);

    ExpressionParser parser = new SpelExpressionParser();
    String genreName = parser.parseExpression("Name = 'Animation'")
        .getValue(context, String.class);
    System.out.println("[Assignment Expression] Genre Name : " + genreName);
}

위 메소드에서 활용한 테스트 데이터 Genre가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 'Name' 값이 'Adventure'였으나 Assignment Operator를 활용하여 값을 변경하였으므로 위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Assignment Expression] Genre Name : Animation

특정 타입의 클래스를 표현하기 위해 'T' Operator를 활용할 수 있다. 또한 'T' Operator를 활용할 경우 특정 클래스의 static 메소드 호출이 가능하다. java.lang 패키지 하위의 클래스일 경우 패키지를 별도 명시하지 않아도 무방하다. 다음은 Spring ExpressionParser를 활용하여 'T' Operator를 포함한 Expression을 실행하는 테스트 로직의 일부이다.

ExpressionParser parser = new SpelExpressionParser();
Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);
Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

'new' Operator를 활용하여 특정 클래스의 Constructor를 호출할 수 있다. 클래스명은 fully qulified 형태로 기술해주어야 한다. (단, primitive 타입의 클래스, java.lang 패키지의 클래스는 제외) 다음은 'new' Operator를 활용하여 Genre 클래스의 Constructor를 호출하여 신규 Genre 객체를 생성해보는 로직을 포함한 테스트 메소드이다.

public void evaluateConstructorExpression() throws Exception {
    ExpressionParser parser = new SpelExpressionParser();
    Genre genre = parser.parseExpression(
        "new org.anyframe.sample.domain.Genre('GR-01', 'Action')")
        .getValue(Genre.class);
    System.out.println("[Constructor Expression] Genre Id : "
        + genre.getGenreId() + ", Genre Name : " + genre.getName());
}

위 메소드 실행 결과 Constructor 호출로 인해 신규 Genre 객체가 생성되었을 것이며 이 Genre 객체는 GenreId : 'GR-01', GenreName : 'Action'이라는 값을 갖고 있을 것이다. 따라서 위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Constructor Expression] Genre Id : GR-01, Genre Name : Action

StandardEvaluationContext의 setVariable() 메소드르 호출하여 변수를 정의하고, 정의된 변수를 #{변수명} 형태로 Spring Expression 내에서 활용할 수 있다. 다음은 'newName'이라는 변수의 값을 'Animation'으로 정의해두고 Genre 객체의 'Name' 속성값을 #newName을 활용하여 변경해보는 로직을 포함한 테스트 메소드이다.

public void evaluateVariablesExpression() throws Exception {
    Genre genre = getGenre();
    StandardEvaluationContext context = new StandardEvaluationContext(genre);
    context.setVariable("newName", "Animation");

    ExpressionParser parser = new SpelExpressionParser();
    parser.parseExpression("Name = #newName").getValue(context);
    System.out.println("[Variables Expression] Genre New Name : "
        + genre.getName());
}

위 메소드에서 활용한 테스트 데이터 Genre가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 'Name' 값이 'Adventure'였으나 #newName을 활용하여 값을 변경하였으므로 위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Variables Expression] Genre New Name : Animation

단, #this와 #root는 예약어로써 #this는 현재 evaluation 대상이 되는 객체를, #root는 Context에 셋팅된 Root 객체를 의미한다.

StandardEvaluationContext의 registerFunction() 메소드를 호출하여 특정 클래스의 메소드를 등록하고, 해당 메소드를 #{메소드명} 형태로 Spring Expression 내에서 활용할 수 있다. 다음은 org.springframework.util.StringUtils 클래스 내의 'capitalize'라는 메소드를 Spring Expression내에서 호출해보는 로직을 포함한 테스트 메소드이다.

public void evaluateFunctionExpression() throws Exception {
    StandardEvaluationContext context = new StandardEvaluationContext();
    context.registerFunction("capitalize", StringUtils.class
        .getDeclaredMethod("capitalize", new Class[] { String.class }));

    ExpressionParser parser = new SpelExpressionParser();
    String capitalizedString = parser.parseExpression(
        "#capitalize('hello anyframe')")
        .getValue(context, String.class);
    System.out.println("[Function Expression] Capitalized String : "
        + capitalizedString);
}

위 메소드 실행 결과 capitalize() 메소드의 인자로 정의된 'hello anyframe'이라는 문자열에 대해 첫번째 문자가 Capitalize되어 다음과 같이 출력될 것이다.

[Function Expression] Capitalized String : Hello anyframe

if-then-else 로직 수행을 위해 Ternary Operator를 활용할 수 있다. 다음은 Movie 객체의 getNowPlaying() 메소드 실행 결과값에 대해 Ternary Operator를 적용한 테스트 메소드이다.

public void evaluateTernaryOperatorExpression() throws Exception {
    Movie movie = getGenre().getMovies().get(0);
    StandardEvaluationContext context = new StandardEvaluationContext(movie);

    ExpressionParser parser = new SpelExpressionParser();
    String playing = parser.parseExpression(
        "getNowPlaying().equals('Y') ? 'playing' : 'not playing'")
        .getValue(context, String.class);
    System.out
        .println("[Ternary Operator Expression] Movie 'Shrek (2001)' is " + playing);
}

위 메소드에서 활용한 테스트 데이터 Movie가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 Movie 객체의 getNowPlaying()의 값이 'N'이므로 'not playing'이라는 문자열이 리턴될 것이다. 따라서 위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Ternary Operator Expression] Movie 'Shrek (2001)' is not playing

일반적으로 Ternary Operator를 활용하는 경우 다음과 같이 변수가 반복해서 표현되는 경우가 있다.

ticketPrice!=null ? ticketPrice :'8000'

Ternary Operator를 간략화한 형태인 Elvis Operator를 활용하면 Expression 정의가 단순해진다. (Groovy Language에서 사용되었으며 Elvis의 머리 모양과 닮았다 하여 Elvis Operator란 용어로 불리운다.)

ticketPrice ? :'8000'

다음은 Movie 객체의 getTicketPrice() 메소드 실행 결과값에 대해 Elvis Operator를 적용한 테스트 메소드이다.

public void evaluateElvisOperatorExpression() throws Exception {
    Movie movie = getGenre().getMovies().get(1);
    StandardEvaluationContext context = new StandardEvaluationContext(movie);

    ExpressionParser parser = new SpelExpressionParser();
    int ticketPrice = parser.parseExpression("getTicketPrice()?:'8000'")
        .getValue(context, Integer.class);
    System.out
        .println("[Elvis Operator Expression] The ticket-price of 'Shrek (2001)' is "
        + ticketPrice);
}

위 메소드에서 활용한 테스트 데이터 Movie가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 Movie 객체의 getTicketPrice()의 값이 셋팅되어 있지 않으므로 즉, Null 값을 가지므로 Elvis Operator 실행 결과 '8000'이라는 int 타입의 값이 리턴될 것이다. 따라서 위 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Elvis Operator Expression] The ticket-price of 'Shrek (2001)' is 8000

Groovy Language에서 사용된 Safe Navigation Operator는 Null 값을 가지는 객체를 대상으로 특정 메소드를 호출하거나 속성 정보에 접근하였을 경우 발생하는 NullPointerException을 방지하기 위해 활용 가능하다. 다음은 Movie 객체 내의 Genre가 Null 값을 가질 경우 Safe Navigation Operator를 활용하여 NullPointerException이 throw되는 것을 방지한 테스트 메소드이다.

public void evaluateSafeNavigationOperatorExpression() throws Exception {
    Movie movie = getGenre().getMovies().get(0);
    StandardEvaluationContext context = new StandardEvaluationContext(movie);

    ExpressionParser parser = new SpelExpressionParser();
    String name = parser.parseExpression("genre?.Name").getValue(context,
        String.class);
    System.out
        .println("[Save Navigation Operator Expression] The genre of 'Shrek (2001)' is "
        + name);

    movie.setGenre(null);
    name = parser.parseExpression("genre?.Name").getValue(context,
        String.class);
    System.out
        .println("[Safe Navigation Operator Expression] The genre of 'Shrek (2001)' is "
        + name);
}

위 메소드에서 활용한 테스트 데이터 Movie가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 첫번째 Expression ("genre?.Name")의 실행 결과는 'Adventure'가 될 것이다. 그리고 위 코드 중간에서 보는 바와 같이 Movie 객체 내의 Genre의 값을 Null로 변경한 후, 두번째 Expression ("genre?.Name")을 실행하였을 때에는 NullPointerException이 발생하지 않고 null 값이 리턴되어 실행 결과가 다음과 같이 출력될 것이다.

[Save Navigation Operator Expression] The genre of 'Shrek (2001)' is Adventure
[Safe Navigation Operator Expression] The genre of 'Shrek (2001)' is null

?[selectionExpression] 형태의 Expression을 활용하면 대상이 되는 Collection 객체로부터 정의된 조건에 해당하는 Sub Collection을 도출할 수 있다. 또한 ?^[selectionExpression]는 정의된 조건에 부합하는 첫번째 데이터를, ?$[selectionExpression]는 정의된 조건에 부합하는 마지막 데이터를 도출할 때 활용 가능하다. 다음은 Genre 객체 내의 java.util.ArrayList 유형의 movies로부터 Runtime 속성값이 90을 초과하는 Movie 정보를 추출하는 Collection Selection Expression을 포함하는 테스트 로직이다.

public void evaluateCollectionSelectionExpression() throws Exception {
    Genre genre = getGenre();
    StandardEvaluationContext context = new StandardEvaluationContext(genre);

    ExpressionParser parser = new SpelExpressionParser();
    List<Movie> movies = (List<Movie>) parser.parseExpression(
        "movies.?[Runtime > 90]").getValue(context);

    System.out.println("[Collection Selection Expression] Movie title is "
        + movies.get(0).getTitle());
}

위 메소드에서 활용한 테스트 데이터 Genre가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 Runtime 속성값이 '90'을 초과하는 Movie 객체는 1개이므로 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Collection Selection Expression] Movie title is Avatar

![projectionExpression] 형태의 Expression을 활용하면 대상이 되는 Collection 객체로부터 Expression에 해당하는 정보만을 추출하여 생성한 새로운 Collection을 전달받을 수 있다. 다음은 Genre 객체 내의 java.util.ArrayList 유형의 movies로부터 'title' 정보만을 추출하는 Collection Projection Expression을 포함하는 테스트 메소드이다.

public void evaluateCollectionProjectionExpression() throws Exception {
    Genre genre = getGenre();
    StandardEvaluationContext context = new StandardEvaluationContext(genre);

    ExpressionParser parser = new SpelExpressionParser();
    List<String> titleList = (List<String>) parser.parseExpression(
        "movies.![title]").getValue(context);

    System.out
        .println("[Collection Projection Expression] first movie title is "
            + titleList.get(0) + ", second movie title is " + titleList.get(1));
}

위 메소드에서 활용한 테스트 데이터 Genre가 [테스트 데이터 : Genre & Movies]의 형태로 구성되어 있을 경우 'title' 값만을 추출하여 전달받은 새로운 'titleList'는 2개의 Title을 가지고 있을 것이며 메소드 실행 결과는 다음과 같이 출력될 것이다.

[Collection Projection Expression] first movie title is Shrek (2001), second movie title is Avatar

Expression Template은 다수의 Evaluation Block과 정의된 문자열을 혼합할 수 있도록 지원한다. 각 Evaluation Block은 별도로 정의한 prefix, suffix로 구분지어 정의할 수 있다. Expression Template을 활용하기 위해서는 ExpressionParser.parseExpression() 메소드 호출시 첫번째 인자에는 Spring Expression, 두번째 인자에는 Expression Templating을 위한 ParserContext를 지정해 주어야 한다. Spring Framework에서는 기본적으로 활용할 수 있는 ParserContext로 org.springframework.expression.common.TemplateParserContext를 제공하며, TemplateParserContext는 '#{'을 prefix, '}'를 suffix 구분자로 지정하고 있음을 알 수 있다.

public class TemplateParserContext implements ParserContext {
    public String getExpressionPrefix() { return "#{"; }
    public String getExpressionSuffix() { return "}"; }
    public boolean isTemplate() { return true; }
}

따라서 다음과 같이 Expression이 정의된 경우 randomPhrase의 값은 'random number is ####'와 같은 형태가 될 것이다.

ExpressionParser parser = new SpelExpressionParser();
String randomPhrase = 
    parser.parseExpression("random number is #{T(java.lang.Math).random()}", 
    new TemplateParserContext()).getValue(String.class);

SpEL에서 지원하는 다양한 Expression 표현을 위해 활용된 Genre 객체는 getGenre() 메소드를 호출함으로써 얻어낼 수 있으며 Genre 객체는 다음과 같은 데이터를 포함하고 있다. 기본적으로 Genre는 기본 속성 정보 외에 java.util.ArrayList 유형의 Movie 목록을 포함하고 있다. 또한 Movie 객체는 기본 속성 정보 외에 관련된 Genre 객체를 포함하고 있다.

private Genre getGenre() {
    Genre genre = new Genre();
    genre.setGenreId("GR-02");
    genre.setName("Adventure");

    ArrayList<Movie> movies = new ArrayList<Movie>();

    Movie movie = new Movie();
    movie.setGenre(genre);
    movie.setMovieId("MV-000001");
    movie.setTitle("Shrek (2001)");
    movie.setActors("Shrek");
    movie.setDirector("Andrew Adamson");
    movie.setReleaseDate(new Date());
    movie.setRuntime(90);
    movie.setTicketPrice(8000);
    movie.setNowPlaying("N");
    movies.add(movie);

    movie = new Movie();
    movie.setGenre(genre);
    movie.setMovieId("MV-000002");
    movie.setTitle("Avatar");
    movie.setActors("Sigourney Weaver");
    movie.setDirector("James Cameron");
    movie.setReleaseDate(new Date());
    movie.setRuntime(100);
    movie.setNowPlaying("Y");
    movies.add(movie);

    genre.setMovies(movies);

    return genre;
}

다음은 JDBCDataSource의 속성 설정에 대한 예제이다.

다음은 DBCPDataSource의 속성 설정에 대한 예제이다.

다음은 C3P0DataSource의 속성 설정에 대한 예제이다.

다음은 JNDIDataSource의 속성 설정에 대한 예제이다. "jnditemplate" Bean에 JNDI Server에 대한 속성을 정의하고, "dataSource" Bean에서 "jnditemplate" Bean을 참조하여 Connection 객체를 얻어낼 수 있도록 하고 있다.

Spring 2.0 이후 버전에서는 jee Namespace 태그를 통해 JNDI 객체를 lookup 할 수 있는 간소한 설정을 지원한다. 아래에서는 jee:jndi-lookup 를 사용한 JNDIDataSource 설정이다.

JndiObjectFactoryBean 와 JndiTemplate 을 통한 설정에 비해 jee 태그를 사용하면 설정이 매우 간소하므로 이 방법을 사용할 것을 권고한다. jee schema 에 대한 상세 내용은 이곳을 참고하도록 한다.

다음에서는 Transaction 속성값으로 정의할 수 있는 Propagation Behavior와 Isolation Level에 보다 자세히 알아보기로 하자.

다음은 앞서 언급한 Annotation을 이용한 Transaction 관리 , XML 정의를 이용한 Transaction 관리 방법을 테스트해 보기 위해 동일한 로직으로 구성된 테스트 클래스의 일부이다. 각 테스트 클래스의 testUpdateMovieWithNotExistMovie() 메소드에서는 MovieService의 updateMovieList 메소드를 호출한다. updateMovieList 메소드의 첫번째 입력 인자는 신규 무비로 두번째 입력 인자는 수정할 무비로 인식된다. 따라서 첫번째 입력 인자를 신규 무비 정보로 하고 두번째 입력 인자를 존재하지 않는 무비ID를 가진 무비 정보로 전달하였을 경우 신규 무비를 성공적으로 등록하고 두번째 특정 무비 정보를 수정하려고 했을 때 해당 ID의무비가 존재하지 않아 수정에 실패하게 된다. MovieService의 updateMovieList 메소드에 대해 정의된 Transaction 속성에 의해 신규로 등록한 무비 정보가 rollback되지 않고 commit되어야 한다.

public void testUpdateMovieWithNotExistMovie() throws Exception {
    Movie newMovie = getMovie();
    String newMovieID = newMovie.getMovieId();
    Movie updateMovie = movieService.get("MV-00003");
    // 존재하지 않는 무비 ID로 변경
    updateMovie.setMovieId("MV-11111");
    updateMovie.setTitle("TEST Movie");
    
    try {
        // 신규 무비 정보와 수정 대상 무비 정보를 인자로 셋팅
        movieService.updateMovieList(newMovie, updateMovie);
        // 해당 메소드 수행시 에러가 발생하지 않으면 fail
        fail("fail to get user.");
    } catch (Exception e) {
        try {
            // 신규 무비의 ID로 무비 정보 조회
            Movie movie =  movieService.get(newMovieID);
            assertNotNull("fail to commit.", movie);
        } catch (Exception ie) {
            // 무비 정보 수정에 실패하였으나 Annotation 정의에 따라 
            // 신규 등록된 무비 정보는 commit되었어야 함.		
            fail("fail to trnasaction management.");
        }
    }
}

다음은 web.xml 파일에 DispatcherServlet을 정의한 모습이다.

<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

위와 같이 정의할 경우 서블릿의 이름은 'action'이 된다. DispatchserServlet은 디폴트로 '[servlet-name]-servlet.xml' 파일을 WebApplicationContext로 로드하므로, Web Contents Root 폴더 아래의 WEB-INF 폴더에서 'action-servlet.xml' 파일을 찾아 WebApplicationContext를 구성하게 될 것이다.

또한 위의 서블릿 매핑 설정으로 인해서 URL의 확장자가 ".do"인 모든 URL에 대한 요청은 DispatcherServlet이 처리하게 된다.

위에서 언급하였듯이 DispatcherServlet은 기본적으로 Web Contents Root 폴더 하위의 WEB-INF 폴더에 있는 [servlet-name]-servlet.xml 파일을 로딩하여 WebApplicationContext를 구성하게 되는데, 이를 임의의 위치에 존재하는 임의의 이름을 가진 파일 또는 다중의 파일로 정의하기 위해서는 아래와 같이 <servlet> 하위에 <init-param>을 이용하여 contextConfigLocations 라는 초기화 파라미터를 정의해 준다.

<init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/config/springmvc/common-servlet.xml, /config/springmvc/user-servlet.xml</param-value>
</init-param>

Front Controller인 DispatcherServlet으로 요청이 들어왔을 때, 그 요청을 실제로 어떤 Controller가 처리할 것인지는 Handler Mapping을 통해서 알아낼 수 있다. Spring MVC에서는 여러가지 Handler Mapping을 제공하는데, 그 중 대표적인 것들만 알아보도록 하겠다.

모든 MVC Framework에서는 요청을 처리한 후 돌아갈 View를 지정하기 위한 방법을 제공한다. Spring MVC에서는 특정 View 기술에 종속되지 않고 Model 데이터들을 보여줄 수 있도록 View Resolver를 제공한다. 앞에서 설명했듯이 핸들러(Controller)는 요청을 처리한 뒤 다시 DispatcherServlet에게 ModelAndView 객체를 넘겨준다. 이 때 ModelAndView는 View의 이름을 포함하고 있는데, 이 이름으로 실제 View를 찾아주는 역할을 하는 것이 View Resolver이다.

ViewResolver와 View는 Spring MVC에서 View 처리와 관련된 가장 중요한 인터페이스이다. ViewResolver는 View 이름과 실제 View를 매핑해준다. Spring MVC에서 제공하는 View Resolver에는 다음과 같은 것들이 있다.

사용하려는 View 기술에 따라 위와 같은 View Resolver를 적절히 선택해야 한다.

Spring 3 에서는 Annotation 기반의 Controller 처리를 위해 반드시 필요한 AnnotationMethodHandlerAdapter 등록 등의 Spring MVC 관련 설정을 간편하게 할 수 있도록 mvc 네임스페이스를 제공하기 시작했다. mvc 네임스페이스에서 제공하는 태그는 다음과 같이 3가지가 있다.

<context:component-scan/>은 해당 클래스패스 내에 @Component, @Service, @Repository, @Controller가 적용된 클래스를 모두 찾아서 Spring 컨테이너가 관리하는 컴포넌트로 등록하도록 하는 설정이다. 이와 같은 디폴트 동작 방식으로 Autodetection 기능 이용 시, 비즈니스와 프레젠테이션 레이어 간 Bean 정의 XML을 분리하여 관리하면서 <context:component-scan/>을 중복으로 설정하는 경우 다음과 같은 문제가 발생할 수 있다.

특정 클래스에 @Controller annotation을 적용하면 다른 클래스를 상속받거나 Servlet API를 사용하지 않아도 해당 클래스가 컨트롤러 역할을 수행하도록 정의할 수 있다.

다음은 @Controller를 사용하여 작성한 MovieController 클래스 파일의 일부이다.

@Controller
public class MovieController {
    // 중략
}

@RequestMapping annotation은 컨트롤러 클래스나 메소드가 특정 HTTP Request URL을 처리하도록 매핑하기 위해서 사용한다. 그래서 클래스 선언부에 @RequestMapping을 적용할 수도 있고(이하 Type-Level), 클래스의 메소드에 @RequestMapping을 적용할 수도 있다(이하 Method-Level). 예를 들어, Type-Level에 @RequestMapping("/movies")라고 정의하고, Method-Level에 @RequestMapping("/new") 라고 정의하면 @RequestMapping("/new")라고 정의한 메소드가 처리하는 URL 경로는 "/movies/new" 가 된다. @RequestMapping은 "/movies/*.do"와 같은 Ant 스타일 경로 패턴도 지원한다. @RequestMapping에는 URL 경로 외에도 HTTP method나 Request 파라미터 등을 추가하여 처리할 URL의 범위를 줄일 수 있다.

또한, Spring 3 부터 REST 스타일의 Web Application 개발을 위해서 URI templates을 지원하기 시작했다. Spring 3에서 추가된 REST 관련 기능들과 REST Style 웹 어플리케이션 개발에 대한 자세한 내용은 본 매뉴얼 Spring REST Plugin을 참고하기 바란다.

다음은 @RequestMapping을 사용하여 처리할 URL을 매핑한 코드예이다.

@Controller
@RequestMapping("/coreMovie.do")
public class MovieController {
    @RequestMapping(params="method=get")
    public String get(@RequestParam("movieId") String movieId, Model model) throws Exception {
        Movie movie = this.movieService.get(movieId);
        //...
        model.addAttribute(movie);
        return "coreViewMovie";
    }
}

@RequestMapping annotation에는 다음과 같은 상세 속성 정보를 부여하여 처리할 URL의 범위를 한정지을 수 있다.

@RequestMapping은 구현하는 컨트롤러 종류에 따라 아래와 같은 방식으로 사용할 수 있다.

기존에 SimpleFormController와 같은 컨트롤러 클래스를 상속받아서 컨트롤러를 작성할 때는, 상위클래스에 정의된 메소드를 override하여 구현하기 때문에 입력 argument 타입과 return 타입이 이미 정해져있다. 이에 반해 @RequestMapping을 적용하여 작성하는 핸들러 메소드는 다양한 argument 타입과 return 타입을 사용할 수 있다.

@Controller
@RequestMapping("/coreMovie.do")
public class EditMovieController {

    @RequestMapping(method = RequestMethod.GET)
    public String createView() {
        // 중략
        return coreViewMovie;
    }
    
    @RequestMapping(method = RequestMethod.POST)
    public String addMovie(HttpServletRequest request, @ModelAttribute("movie"),
            Movie movie, BindingResult result, SessionStatus status) throws Exception {
        // 중략
        return "redirect:/coreMovieFinder.do";
    }
}

@Controller
public class MovieController {

    @RequestMapping("/deleteMovie.do")
    public ModelAndView delete(@RequestParam("movieId") String movieId) {
        // 중략
        return "redirect:/coreMovieFinder.do";
    }

    @RequestMapping("/getMovie.do")
    public String get(@RequestParam("movieId") String movieId, ModelMap model) {
        // 중략
        model.addAttribute(movie);

        return "coreViewMovie";
    }
}

@RequestParam annotation은 HTTP Request parameter를 컨트롤러 메소드의 argument로 바인딩하는데 사용되며 ServletRequest.getParameter(java.lang.String name) 와 같은 역할을 한다. 다음은 @RequestParam annotation의 사용 예이다.

@RequestMapping("/updateMovie.do")
public String updateMovie(@RequestParam("movieId") String movieId,         
        @RequestParam("sellAmount") int sellAmount, @RequestParam("realImageFile") MultipartFile picturefile) {
    // 중략
    return "/listMovie.do";
}

@RequestParam을 적용한 파라미터는 반드시 HTTP Request에 존재해야 한다. 그렇지 않은 경우 다음과 같이 org.springframework.web.bind.MissingServletRequestParameterException이 발생한다.

 org.springframework.web.bind.MissingServletRequestParameterException:
				
Required java.lang.String parameter 'movieId' is not present

그러나 아래와 같이 @RequestParam의 required 속성을 false로 설정할 경우 HTTP Request에 파라미터가 존재하지 않아도 Exception이 발생하지 않는다.

@RequestMapping("/deleteMovie.do")
public String deleteMovie(@RequestParam(value="movieId", required="false") String movieId){
    // 중략
}

또한 defaultValue 속성을 이용하여 해당 파라미터가 존재하지 않을 경우 사용할 디폴트 값을 정의할 수 있다.

@RequestMapping("/movies.do")
public String findMovies(@RequestParam(value="pageIndex", defaultValue = "1") int pageIndex,
            Movies movies, BindingResult result, Model model) {
    // 중략
}

@RequestBody annotation은 HTTP Request Body를 컨트롤러 메소드의 argument로 바인딩하는데 사용된다. 다음은 @RequestBody annotation의 사용 예이다.

@RequestMapping(value = "/movies/add", method = RequestMethod.POST)
@ResponseBody
public String add(@RequestBody Movie movie) throws Exception {
    // 중략
}

Request Body의 내용을 메소드의 argument 객체로 전달하기 위해서는 HttpMessageConverter에 의해서 변환이 이루어져야만 한다. HttpMessageConverter는 HTTP Request body와 객체간, 그리고 객체와 HTTP Response body간의 변환을 담당한다. Spring 3 부터 AnnotationMethodHandlerAdapter가 @RequestBody를 지원하고, 다음의 HttpMessageConverter 들을 디폴트로 등록하도록 기능이 확장되었다.

@ResponseBody annotation은 핸들러 메소드가 리턴 값을 HTTP Response를 통해서 바로 전달할 경우에 사용할 수 있다. @ResponseBody가 적용되면 Model과 View를 리턴하여 ViewResolver를 통해 View를 찾는 등의 과정들은 거치지 않게 된다.

다음은 @ResponseBody annotation의 사용 예이다.

@RequestMapping(value = "/welcome", method = RequestMethod.GET)
@ResponseBody
public String welcome() {
    return "Welcome!";
}

위에서 설명했던 @RequestBody에서와 같이, 핸들러 메소드의 리턴값은 HttpMessageConverter를 통해 HTTP Response Body로 변환된다.

HttpEntity는 @RequestBody/@ResponseBody 같이 Request/Response Body 메세지를 처리할 수 있을 뿐만아니라, HTTP Header 값도 함께 다룰 수 있다. 일반적으로 RestTemplate을 사용한 REST 클라이언트를 구현할 때, 편리하게 사용될 수 있다.

@RequestMapping("/handle")
public HttpEntity<String> handle() {
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.set("MyResponseHeader", "MyValue");
    return new ResponseEntity<String>("Hello World", responseHeaders);
}

HttpEntity를 사용할 경우에도 역시 Request/Response Body 변환을 위해 HttpMessageConverter가 사용된다.

@ModelAttribute는 컨트롤러에서 다음과 같이 두 가지 방법으로 사용할 수 있다.

다음은 위에서 설명한 두가지 방법으로 @ModelAttribute를 사용한 예이다.

@Controller
@RequestMapping("/movie.do") 
public class MovieController {
    // 중략
    // 메소드 자체에 정의
    @ModelAttribute("genreList")
	public Collection<Genre> populateGenreList() throws Exception {
		return this.genreService.getDropDownGenreList();
	}

    // 메소드의 입력 argument에 정의
    @RequestMapping(params="method=add")
    public String add(@ModelAttribute("updatedMovie") Movie movie
                                , BindingResult result, SessionStatus status) throws Exception {
        // 중략
    }
}

@SessionAttributes는 Session에 저장하여 관리할 Model Attribute를 정의할 때 사용한다. Session에 저장하고자 하는 Model Attribute의 이름이나 타입을 @SessionAttributes의 속성에 정의해준다.

다음은 @SessionAttributes를 사용하여 Session에 저장하여 관리할 Model을 이름으로 정의한 예이다. 타입으로 정의할 경우 'types'라는 속성을 이용한다.

@Controller
@RequestMapping("/movie.do")
@SessionAttributes(value={"movie","genre"})
public class MovieController {
	// 중략
}

HTTP Cookie에 저장된 값을 핸들러 메소드에서 사용할 수 있도록 해주는 Annotation이다.

다음은 @CookieValue 사용하여 Cookie 값을 가져와 출력해보는 코드이다.

@RequestMapping("/displayHeaderInfo")
@ResponseBody
public String displayHeaderInfo(@CookieValue("JSESSIONID") String cookie,
		@RequestHeader("Accept-Encoding") String encoding,
		@RequestHeader("Accept") String accept) {
    StringBuilder sf = new StringBuilder();
    sf.append("JSESSIONID : " + cookie);
    sf.append("\n");
    sf.append("Accept-Encoding : " + encoding);
    sf.append("\n");
    sf.append("Accept : " + accept);
     
    return sf.toString();
}

HTTP Header에 저장된 값을 핸들러 메소드에서 사용할 수 있도록 해주는 Annotation이다.

위 @CookieValue 예제 코드에서 @RequestHeader가 사용된 모습을 확인할 수 있다.

Spring Form Tag를 사용하기 위해서는 spring-form.tld 파일이 필요하고 이는 spring-webmvc-x.x.x.jar 파일에 포함되어 있다. 이 폼 태그를 사용하기 위해서는 JSP 페이지에 taglib을 추가해줘야한다.

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<form>은 데이터 바인딩을 위해 태그 안에 바인딩 path를 지정해 줄 수 있다. path에 해당되는 값은 도메인 모델의 Bean 객체를 의미한다. 사용예는 다음과 같다.

<form:form commandName="user">
    userId : <form:input path="userId"/>
</form:form>

또한 Spring Form Tag를 이용하기 위해서는 각각의 입력 path값에 매칭될 트랜스퍼 오브젝트를 지정해 줘야하는데 <form>안에 commandName 속성으로 다음과 같이 지정해 줄 수 있다.

<% request.setAttribute("user", sample.services.UserVO())>

이러한 commandName의 기본값은 "command"이며 input값들과 매칭될 트랜스퍼 오브젝트를 request값으로 셋팅해줘야한다. 이 값은 SimpleFormController를 사용할 경우 formBackingObject()메소드에서 지정해 줄 수도있다.

protected Object formBackingObject(HttpServletRequest request)
    throws Exception {
    UserVO vo=new UserVO();
    request.setAttribute("user",vo);
    return new UserVO();
}

HTML의 <input>의 value가 text인 것을 기본 value로 갖는다. 이 태그의 예는 위의 <form> 예에서 볼 수 있다.

다음은 <checkbox>의 예이다. 마찬가지로 path에 트랜스퍼 오브젝트의 bean name을 매핑시켜주고 label속성을 이용하면 jsp페이지로 보여질 이름을 설정할 수 있다.

<form:checkbox path="hobby" value="listeningMusic" label="음악감상"/>
<form:checkbox path="hobby" value="study" label="공부"/>

※ 위 코드는 아래와 같은 화면을 출력한다.

위의 <checkbox>는 각각의 항목에 대해 작성해줘야 하지만 <checkboxes>를 사용하면 items속성을 이용해서 한줄로 나타내줄 수 있다. 이러한 items에 들어갈 값은 컨트롤러의 formBackingObject()메소드에서 Array, List, Map형태의 것들로 넘겨 줄 수 있다. Map의 key와 value쌍으로 넘겨줄 경우 key는 태그의 value값이 되고 value는 label명이 된다. (단, Array나 List로 넘길 경우 label은 value와 같은 값을 가지게 된다.) 다음은 그 예이다.

protected Object formBackingObject(HttpServletRequest request) throws Exception {
    UserVO vo=new UserVO();
    Map interest = new HashMap();
    interest.put("reading", "독서");
    interest.put("listeningMusic", "음악감상");
    interest.put("study", "공부");
    request.setAttribute("interest", interest);
    request.setAttribute("user",vo);
    return new UserVO();
}

<tr>
    <td>hobby :</td>
    <td><form:checkboxes path="hobby" items="${interest}" /></td>
</tr>

※ 위 코드는 아래와 같은 화면을 출력한다.

다음은 <radiobutton>의 예이다. <radiobutton> 또한 label 속성을 이용하여 label명을 설정해 줄 수 있다.

<tr>
    <td>Gender:</td>
    <td>Male: <form:radiobutton path="gender" value="M" label="남자"/> <br/>
        Female: <form:radiobutton path="gender" value="F" label="여자"/> </td>
</tr>

다음은 <radiobuttons>의 예이다. items 속성의 사용방법은 위의 <checkboxes>와 동일하다.

<tr>
    <td>Gender:</td>
    <td><form:radiobuttons path="gender" items="${genderOptions}"/></td>
</tr>

다음은 <password>의 예이다.

<tr>
    <td>password :</td>
    <td><form:password path="password" /></td>
</tr>

※ 위 코드는 아래와 같은 화면을 출력한다.

<select>도 위의 <checkboxes>나 <radiobuttons>처럼 items 속성을 이용하여 formBackingObject에서 넘겨주는 값으로 자동 매핑 시켜줄 수 있다.

protected Object formBackingObject(HttpServletRequest request)
                throws Exception {
    UserVO vo=new UserVO();
    Map address = new HashMap();
    address.put("seoul","서울");
    address.put("daegu","대구");
    address.put("busan","부산");
    request.setAttribute("address", address);
    request.setAttribute("user",vo);
    
	return new UserVO();
}

<tr>
    <td>주소</td>
    <td><form:select path="address" items="${address}" /></td>
</tr>

※ 위 코드는 아래와 같은 화면을 출력한다.

일반적인 <option>와 함께 아래와 같이 사용할 수도 있다.

다음은 <option>의 사용 예이다.

<tr>
    <td>주소</td>
    <td><form:select path="address">
        <form:option value="seoul" label="서울" />
        <form:option value="daegu" label="대구" />
        <form:option value="busan" label="부산" />
    </form:select></td>
</tr>

다음은 <options>의 사용예이다.

<tr>
    <td>주소</td>
    <td><form:select path="address">
        <form:options items="${address}" />
    </form:select></td>
</tr>

다음은 <textarea>의 사용 예이다.

<td>Note :</td>
<td><form:textarea path="comment" rows="3" cols="20"></form:textarea></td>

다음은 <hidden>의 사용 예이다.

<form:hidden path="userId" />

Spring MVC는 validatior에서 얻어진 메시지를 JSP페이지에서 쉽게 출력할 수 있도록 Spring Form 태그의 <form:errors>를 제공한다. 이는 생성한 validator를 통해 입력값의 유효성 체크 후 에러 메시지를 출력해주는데 자세한 사항은 본 매뉴얼 Spring MVC >> Validation >> Spring Validator의 <form:errors> 태그 사용을 참고한다.

생성한 Validator를 활용하기 위해서는 해당 Validator를 Inject하여 사용하거나 Controller 클래스 내에 @InitBinder 메소드를 정의하고 해당 메소드의 입력 인자로 전달된 Binder에 해당 Validator를 셋팅하여 활용할 수 있다.

Validation Error를 JSP 페이지에서 쉽게 출력하기 위해 Spring MVC에서 제공하는 form 태그 중 <form:errors> 태그를 사용할 수 있다. 이 태그를 사용하기 위해서는 다음과 같은 절차를 따르도록 한다.

JSR-303은 Bean Validation을 위한 표준을 정의하고 있으며 특정 어플리케이션을 구성하는 도메인 클래스에 대해 JSR-303 Annotation을 활용하여 Validation Constraints를 부여하게 되면 런타임시에 이를 기준으로 Validation Check가 이루어지게 된다. 다음은 JSR-303 Spec.에서 제시한 Annotation 목록이다.

다음은 Core Plugin 설치로 추가된 도메인 클래스 ~/domain/Movie.java의 일부로써 앞서 언급한 JSR-303 Annotation을 활용하여 Validation Constraint를 정의하고 있다. 예를 들어, title 속성은 Null 값을 가질 수 없으며 최소 1자리, 최대 50자리까지만 허용하며 runtime 속성값은 최대 180을 초과할 수 없고 정수부 3자리 소수부는 0자리를 허용하고 있음을 알 수 있다.

public class Movie implements Serializable {

    private static final long serialVersionUID = 1L;
	
    private String movieId;

    @NotNull
    @Size(min = 1, max = 50)
    private String title = "";
	
    @NotNull
    @Size(min = 1, max = 50)
    private String director;

    private Genre genre;

    @NotNull
    @Size(min = 5, max = 100)
    private String actors;

    @DecimalMax(value = "180")
    @Digits(integer=3, fraction=0)
    private int runtime;

    @DateTimeFormat(iso = ISO.DATE)
    @Future
    private Date releaseDate;

    @NumberFormat(pattern = "#,###")
    @Digits(integer=5, fraction=0)
    private int ticketPrice;

    private String posterFile;

    private String nowPlaying = "Y";

    // getter, setter ...
}

JSR-303 Spec.을 준수하는 모든 Annotation은 Annotation별 속성 외에 payload, groups, message라는 속성을 공통적으로 가진다. 각 속성이 가지는 의미에 대해 살펴보도록 하자.

JSR-303에서 기본적으로 제공하는 Annotation만으로 특정 도메인 클래스의 속성값에 대한 Validation Check가 수행되기 어려운 경우 프로젝트에 적합한 Custom Constraints를 정의할 수 있다. Custom Constraints를 활용하기 위해서는 Custom Annotation과 Custom Validator 구현이 이루어져야 한다. 다음은 전화번호 속성에 대한 Validation Check를 위해 신규 정의한 Telephone.java 클래스의 일부이다.

@Target( { ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = TelephoneValidator.class)
@Size(min = 12, max = 13)
public @interface Telephone {
    String message() default "{org.anyframe.sample.validation.constraint.Telephone.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

위 코드에 의하면 @Telephone은 Method, Field에 대해 정의 가능하며 런타임시에 적용된다. 그리고 도메인 클래스 내에 @Telephone이 부여된 속성을 만나면 TelephoneValidator가 초기화되어 Validation Check를 수행할 것이다. 또한 @Size Annotation 정의가 추가되어 있어서 @Telephone은 기본적으로 Size에 대해서도 제약하게 된다. @Telephone은 JSR-303 Spec.에서 정의한 기본 속성(message, groups, payload) 외에 추가 속성을 포함하고 있지는 않다.

message 속성의 경우 기본값을 org.anyframe.sample.validation.constraint.Telephone.message으로 정의하고 있으므로 @Telephone에 대한 Validation Check 관련 Error가 발생한 경우 클래스패스 최상위의 ValidationMessages.properties 파일로부터 org.anyframe.sample.validation.constraint.Telephone.message을 key로 하는 메시지가 출력될 것이다. 다음은 ValidationMessages.properties 파일의 내용이다.

org.anyframe.sample.validation.constraint.Telephone.message=must match "0000-000(or 0000)-0000" (max 13)

다음은 @Telephone Annotation에 대해 Validation Check를 수행할 TelephoneValidator.java 파일의 일부이다. 다음 코드에서와 같이 Custom Validator는 javax.validation.ConstraintValidator 인터페이스를 implements해야 하며 Validation Check 로직을 수행할 isValid()라는 메소드를 구현해주어야 한다.

public class TelephoneValidator implements ConstraintValidator<Telephone, String> {
    private java.util.regex.Pattern pattern = java.util.regex.Pattern
        .compile("^[0-9]\\d{2}-(\\d{3}|\\d{4})-\\d{4}$");

    public void initialize(Telephone annotation) {
    }

    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null || value.length() == 0) {
            return true;
        }
        Matcher m = pattern.matcher(value);
        return m.matches();
    }
}

TelephoneValidator는 Regular Expression을 이용하여 전화번호에 대한 패턴을 정의해 두고 이 패턴과 동일하지 않을 경우 Validation Error를 발생하게 된다.

다음은 앞서 정의한 @Telephone 정의를 포함하고 있는 도메인 클래스 Movie.java 파일의 일부이다.

public class Movie implements Serializable {

    private static final long serialVersionUID = 1L;
    
    private String movieId;

    @Telephone
    private String telephone;			

    // ...
}

위에서 언급한 Custom Constraint 샘플 코드는 본 섹션 내의 다운로드 - anyframe-sample-validation- custom를 통해 다운로드받을 수 있다.

Spring MVC 2.5 이전에서는 앞서 언급한 바와 같이 Spring Validator를 구현하고 이를 특정 Controller의 Validator로 직접 지정해 주어야만 Validation Check가 이루어졌었다. 그러나 Spring 3 이후부터는 Controller 메소드의 입력 인자에 대해 @Valid라는 Annotation을 부여함으로써 해당 메소드 호출 전에 자동적으로 Validation Check가 이루어질 수 있도록 지원한다. 다음은 Core Plugin 설치로 추가된 ~/core/moviefinder/web/MovieController.java 클래스 내에 정의된 create() 메소드의 일부이다.

@RequestMapping(params = "method=create")
public String create(..., @Valid Movie movie, BindingResult results, ...) throws Exception {

    if (results.hasErrors()) {
        return "coreViewMovie";
    }
    
    // ...
}

위 메소드의 경우, 사용자의 입력값을 Movie 객체로 매핑할 때 Validation Check가 이루어지게 되고 결과값은 BindingResult 객체에 담겨지게 된다. 따라서 입력 인자로 전달된 BindingResult 객체 내에 Validation Error가 존재하는 경우 입력 화면으로 되돌아가도록 로직을 구성하면 된다.

또한 Spring에서 제공하는 <form:errors>를 활용하면 Validation Error를 입력 화면에 표현해 줄 수 있게 된다. 다음은 Core Plugin 설치로 추가된 webapp/WEB-INF/jsp/core/moviefinder/movie/form.jsp 파일의 일부로 title, director 필드에 입력된 값이 유효하지 않을 경우 <form:errors>를 이용하여 표현해 줄 수 있도록 정의하고 있음을 알 수 있다.

<tr>
    <td width="150" class="ct_td"><spring:message code="movie.title" />&nbsp;*</td>
    <td bgcolor="D6D6D6" width="1"></td>
    <td class="ct_write01">
        <form:input path="title" cssClass="ct_input_g" cssErrorClass="text medium error" size="40" maxlength="50" />
        <form:errors path="title" cssClass="errors" />
    </td>
</tr>
<tr>
    <td height="1" colspan="3" bgcolor="D6D6D6"></td>
</tr>
<tr>
    <td width="150" class="ct_td"><spring:message code="movie.director" />&nbsp;*</td>
    <td bgcolor="D6D6D6" width="1"></td>
    <td class="ct_write01">
        <form:input path="director" cssClass="ct_input_g" cssErrorClass="text medium error" size="40" maxlength="50" />
        <form:errors path="director" cssClass="errors" />
    </td>
</tr>

끝으로 선언적인 Validation Check를 위해서는 Validator 지정을 위한 속성 정의가 필요하다. Spring에서는 이를 위해 3가지 방법을 제공한다.

Spring에서는 Validation Check가 필요한 경우에 Hibernate Validator와 같은 JSR-303 Validator 구현체를 실행시킬 수 있도록 하기 위해 LocalValidatorFactoryBean 클래스를 제공한다. LocalValidatorFactoryBean은 클래스패스 내에 JSR-303 구현체와 관련된 라이브러리를 검색하여 Validator를 자동으로 검색해주는 역할을 수행한다. 따라서 LocalValidatorFactoryBean을 Bean으로 정의하고 특정 클래스에서 이 Bean을 참조하여 Validation Check를 수행하면 된다.

<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" />

@Service
public class MovieServiceImpl implements MovieService {
    /**Inject a reference to javax.validation.Validator if you prefer to work with the JSR-303 API directly.
     * Inject a reference to org.springframework.validation.Validator if your bean requires the Spring Validation API
     */
    @Inject
    private Validator validator;

    public void create(Movie movie){
        validator.validate(movie);
        // ...
    }
}

타입 변환시 호출되는 PropertyEditor의 메소드는 setValue()/getValue(), setAsText()/getAsText() 4가지 이다. PropertyEditorSupport를 상속받아서 setAsText()/getAsText() 메소드만 오버라이드하면 특정 타입 변환을 위한 PropertyEditor를 구현할 수 있다.

Spring에서 제공하고 있는 CustomBooleanEditor 코드를 조금 살펴보면, 아래와 같이 setAsText() 메소드에는 String값을 받아서 boolean값으로 변환하여 setValue() 해주는 로직이 구현되어 있고, getAsText() 메소드에는 getValue() 호출해서 가져온 값을 String으로 변환하여 리턴하는 로직이 구현되어 있다.

@Override
public void setAsText(String text) throws IllegalArgumentException {
    String input = (text != null ? text.trim() : null);
    if (this.allowEmpty && !StringUtils.hasLength(input)) {
        setValue(null);
    } else if (this.trueString != null && input.equalsIgnoreCase(this.trueString)) {
        setValue(Boolean.TRUE);
    } else if (this.falseString != null && input.equalsIgnoreCase(this.falseString)) {
        setValue(Boolean.FALSE);
    // 중략
    } else {
        throw new IllegalArgumentException("Invalid boolean value [" + text + "]");
    }
}

@Override
public String getAsText() {
    if (Boolean.TRUE.equals(getValue())) {
        return (this.trueString != null ? this.trueString : VALUE_TRUE);
    } else if (Boolean.FALSE.equals(getValue())) {
        return (this.falseString != null ? this.falseString : VALUE_FALSE);
    } else {
        return "";
    }
}

위에서 본 CustomBooleanEditor와 같이 Spring에서는 기본 타입에 대해서 이미 구현해놓은 여러가지 Build-in PropertyEditor들을 제공한다. Built-in PropertyEditor들은 모두 org.springframework.beans.propertyeditors 패키지 하위에 존재한다.

ClassEditor, FileEditor, InputStreamEditor, LocaleEditor, PropertiesEditor 등의 Built-in PropertyEditor들의 이름에서 볼 수 있듯이 Built-in PropertyEditor들은 변환할 타입에 'Editor'라는 이름을 붙인 클래스들이다. CustomNumberEditorr와 같이 사용자가 Customizing이 가능한 PropertyEditor에는 'Custom'이라는 접두어가 붙기도 한다. 이들은 모두 디폴트로 등록되어 내부적으로 사용되지만, CustomDateEditor와 StringTrimmerEditor는 디폴트로 등록되지 않기 때문에, 사용이 필요한 경우에는 반드시 직접 코드에서 등록해 주어야 한다.

기본적으로 Spring에서는 Built-in PropertyEditor들을 미리 등록해놓고 사용하고 있다. 이외에 추가로 Custom Editor 등록이 필요한 경우 따로 등록을 해주어야 하는데, 이 장에서는 Custom PropertyEditor를 어떻게 등록할 수 있는 지에 대해서 알아보도록 하겠다. Spring MVC에서 사용자가 추가로 개발한 Custom PropertyEditor를 등록하는 방법에는 아래와 같이 3가지가 있다.

PropertyEditor는 기본적으로 String과 특정 타입 간의 변환을 지원한다. PropertyEditor는 변환 과정 중에, 변환하려고 하는 Object나 String을 PropertyEditor 객체에 잠깐 저장하였다가 변환하기 때문에, 여러 Thread에서 동시에 사용하는 경우, 변환 도중에 가지고 있던 값이 변경되어 엉뚱한 변환 값을 전달할 수도 있다. 이런 이유에서 PropertyEditor는 Thread-Safe하지 않기 때문에, Sington Bean으로 사용하지 못하고 위에서 봤던 예제 코드에서 처럼 항상 'new'를 통해서 새로 생성해야 한다.

Spring 3에서는 Converter 구현을 위해서 다음과 같이 여러가지 API를 제공하고 있다.

Spring에서는 Converter도 PropertyEditor처럼 기본적인 타입들에 대해서 이미 구현해놓은 Built-in Converter들을 제공한다. Built-in Converter들은 모두 org.springframework.core.convert.support 패키지 하위에 존재한다.

사용자 필요에 의해서 추가로 개발한 Custom Converter들을 사용하려면 Converter도 역시 PropertyEditor처럼 등록이 필요하다. 한가지 다른 점은 각각의 Converter를 개별적으로 등록하는 것이 아니라, 모든 Converter를 가지고 변환 작업을 처리하는 ConversionService를 Bean으로 등록한 후, ConversionService Bean을 필요한 곳에서 Inject 받아서 사용한다는 것이다.

package org.springframework.core.convert;

public interface ConversionService {

    boolean canConvert(Class<?> sourceType, Class<?> targetType);
    
    <T> T convert(Object source, Class<T> targetType);
    
    boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);

    Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
}

실제 Run-time시에 Converter들의 변환 로직은 이 ConversionService에 의해서 실행된다. 기본적으로 Spring에서 사용되는 ConversionService 구현 클래스는 GenericConversionService이다. 대부분의 ConversionService 구현 클래스는 Converter 등록 기능을 가지고 있는 ConverterRegistry도 구현하고 있다.

앞서 PropertyEditor는 매번 new 키워드를 이용해서 매번 인스턴스를 새로 생성해야만 했기 때문에 개별 컨트롤러 적용방법과 전체 컨트롤러 적용방법이 달랐었지만, Converter의 경우는 모든 Converter들을 가지고 있는 ConversionService를 Singleton Bean으로 등록해서 사용하기 때문에 아래와 같이 개별 컨트롤러에서 사용하는 것과, WebBindingInitializer 구현클래스를 이용해서 전체 컨트롤러에서 적용하는 것이 차이가 없다.

@Inject
private ConversionService conversionService;

@InitBinder
public void initBinder(WebDataBinder binder) {
    binder.setConversionService(this.conversionService);
}

따라서 WebBindingInitializer를 구현한 클래스를 이용하여 하나의 설정으로 등록하는 것이 편리하다. Spring에서는 WebBindingInitializer를 직접 구현하지 않고 선언적인 설정만으로도 WebDataBinder의 설정을 초기화할 수 있게 해주는 ConfigurableWebBindingInitializer를 제공한다.

아래와 같이 설정하기만 하면 Custom Converter들이 추가된 ConversionService가 타입 변환 시에 사용될 것이다.

<!-- AnnotationMethodHandlerAdapter에 webBindingInitializer DI -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="webBindingInitializer" ref="webBindingInitializer" />
</bean>

<!-- 사용자가 변경한 conversionService를 WebBindingInitializer 구현체에 DI -->
<bean id="webBindingInitializer" class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
    <property name="conversionService" ref="conversionService" />
</bean>

<!-- Custom Converter들을 추가한 conversionService Bean 정의 -->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="org.anyframe.sample.moviefinder.StringToFilmRatingConverter" />
        	<bean class="org.anyframe.sample.moviefinder.FilmRatingToStringConverter" />
        </list>
    </property>
</bean>

위와 같은 복잡한 설정을 쉽고 간편하게 할 수 있도록 Spring 3에서는 mvc 네임스페이스를 제공한다.

<mvc:annotation-driven>에 대한 자세한 내용은 본 매뉴얼 Spring MVC >> Configuration에서 Configuration Simplification 내용을 참고하기 바란다.

Formatter를 개발하기 위해서는 위의 Formatter 인터페이스를 구현하여야 한다. print() 메소드에서 format을 적용하여 출력하는 로직을 구현하고, parse() 메소드에는 format이 적용된 String 값을 분석해서 객체 인스턴스로 변환하는 로직을 구현하면 된다. 위의 인터페이스 정의에서 볼 수 있듯이, Locale 정보도 함께 넘겨주기 때문에 Localization 적용도 쉽게 처리할 수 있다.

다음은 구현된 Formatter 예제 코드이다.

public final class DateFormatter implements Formtter<Date> {

    private String pattern;
    
    public DateFormatter(String pattern) {
        this.pattern = pattern;
    }
    
    public String print(Date date, Locale locale) {
        if (date == null) {
            return "";
        }
        return getDateFormat(locale).format(date);
    }

    public Date parse(String formatted, Locale locale) throws ParseException {
        if (formatted.length() == 0) {
            return null;
        }
        return getDateFormat(locale).parse(formatted);
    }

    protected DateFormat getDateFormat(Locale locale) {
        DateFormat dateFormat = new SimpleDateFormat(this.pattern, locale);
        dateFormat.setLenient(false);
        return dateFormat;
    }
}

Spring에서는 편의를 위해서 Formatter 역시 기본적인 Built-in Formatter를 제공하고 있다.

일반적으로는 위의 Formatter를 직접 사용하기 보다는 아래에서 살펴볼 Annotation 기반 Formatting 처리 방법, 특히 Spring에서 기본적으로 제공하는 Formatting 관련 Annotation 들을 주로 사용하게 될 것이다.

다음 섹션에서 살펴보겠지만, 구현된 Formatter는 특정 타입의 변환 시에 사용되도록 등록할 수도 있지만, 특정 Annotation이 적용된 필드의 타입 변환 시에 사용되도록 등록할 수도 있다.

Converter 영역에서, 등록된 Converter들을 가지고 실제 Run-time시에 타입 변환을 처리하는 역할을 담당하는 것이 GenericConversionService라면, Formatter에서 GenericConversionService와 같은 역할을 담당하는 것은 FormattingConversionService이다. FormattingConversionService는 GenericConversionService를 상속받고 있다.

위에서 살펴본 과정을 통해서 구현한 Formatter를 등록하는 방법은 Converter 등록과는 달리 불편하다. 설정으로 등록할 수 있는 방법은 아직 제공하고 있지 않고, FormattingConversionService를 초기화해주는 FormattingConversionServiceFactoryBean을 상속받은 클래스를 만들어서, installFormatters() 메소드를 오버라이드하여 Custom Formatter를 추가해야한다.

public class CustomFormattingConversionServiceFactoryBean extends FormattingConversionServiceFactoryBean {

    @Override
    protected void installFormatters(FormatterRegistry registry) {
        super.installFormatters(registry);
        
        // 필드 타입과 Formatter를 연결하여 등록하는 경우
        registry.addFormatterForFieldType(FilmRatings.class, new FilmRatingsFormatter());
        
        // Annotation과 Formatter를 연결하여 등록하는 경우
        registry.addFormatterForFieldAnnotation(new FilmRatingsFormatAnnotationFormatterFactory());
    }
}

이렇게 확장한 FormattingConversionServiceFactoryBean를 아래와 같이 Bean으로 등록하고, Converter에서처럼 ConfigurableWebBindingInitializer를 이용하여 컨트롤러에서 사용할 수 있도록 설정할 수도 있고,

<bean id="conversionService" class="org.anyframe.sample.format.CustomFormattingConversionServiceFactoryBean" />

<mvc:annotation-driven conversion-service="conversionService" />
    
<bean id="conversionService" class="org.anyframe.sample.format.CustomFormattingConversionServiceFactoryBean" />

<mvc:annotation-driven>만 설정해주면 기본적으로 제공하는 Built-in Converter와 Built-in Formatter, 그리고 Formatting관련 Annotation인 @DateTimeFormat, @NumberFormat을 사용할 수 있다.

LocaleResolver를 사용하여 locale을 바꾸고 싶을 때는 정의한 LocaleResolver를 injection 한 후 setLocale()메소드를 통해 locale을 변경해 줄 수 있다. 또한 resolveLocale(request)메소드를 사용하여 현재 request에 셋팅되어 있는 Locale을 알아낼 수 있다.

@Controller
public class UserController {
	@Inject
    LocaleResolver localeResolver;

    protected ModelAndView changeLocale(HttpServletRequest request
                            , HttpServletResponse response) throws Exception {
        //request parameter "locale"에 사용자가 설정한 locale을 가지고 온다.(ex> en, ko)
        Locale locale = new Locale(request.getParameter("locale"));
        //localeResolver에 locale 셋팅
        localeResolver.setLocale(request, response, locale);
        //셋팅된 locale 확인
        System.out.println("current locale from locale resolver ====== " + 
            localeResolver.resolveLocale(request));
        return new ModelAndView("/jsp/result.jsp");
    }

...생략...

HandlerMapping에 interceptor를 등록하여 특정 locale의 요청을 가로채서 특정 파라미터에 넘어 온 값으로 locale을 지정할 수 있다. 속성 정의 파일 내의 LocaleChaneInterceptor 정의 예는 다음과 같다.

<bean id="localeResolver"
      class="org.springframework.web.servlet.i18n.CookieLocaleResolver"/>
      
<bean id="localeChangeInterceptor"
      class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
    <property name="paramName" value="locale"/>
</bean>

<bean id="urlMapping"
      class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="interceptors">
        <list>
            <ref bean="localeChangeInterceptor"/>
        </list>
    </property>
    <property name="mappings">
        <value>/list.do=getUserListController</value>
    </property>
</bean>

위와 같이 설정한 경우, /list.do?locale=en 이라는 요청이 들어오면 어플리케이션의 Locale이 'English'로 변경된다.

사용자의 브라우저에서 보내진 request의 헤더에 accept-language부분에서 Locale을 읽어들인다. 사용자의 OS locale을 나타낸다.

<bean id="localeResolver"
	            class="org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver" />

AcceptHeaderLocaleResolver는 setLocale() method를 이용한 locale 변경이 불가능하다.