Spring annotation

FRAMEWORK/SPRING

Spring annotation

적외선 2014. 11. 10. 17:59

@Component
@Required
@Autowired
@Resource
@Scope
@PostConstruct
@PreDestroy
@Inject
@Service
@Repository
@Controller
@RequestMapping
@RequestParam
@SessionAttributes
@InitBinder

@ModelAttribute

@RequestBody
@ResponseBody

@PathVariable

@Component

패키지 : org.springframework.stereotype

버젼 : spring 2.5

개요 : <context:component-scan> 태그를 설정파일에 추가하면 해당 어노테이션이 적용된 클래스를 빈으로 등록하게 된다. 범위는 디폴트로 singleton이며 @Scope를 사용하여 지정할 수 있다.

설정위치: 클래스 선언부 위

추가설정 : XML 설정파일에 <context:component-scan>을 정의하고 적용할 기본 패키지를 base-package 속성으로 등록한다.

context:annotation-config 태그는 어노테이션과 관련해서 다음의 BeanPostProcessor를 함께 등록 한다.

- @Required(RequiedAnnotationBeanPostProcessor)

- @Autowired(AutowiredAnnotationBeanPostProcessor)

- @Resource, @PostConstruct, @PreDestory(CommonAnnotationBeanPostProcessor)

- @Configuration(ConfigurationClassPostProcessor)

* 그 외 Repository, Service, Controller 포함

예를 들어 <context:component-scan base-package="xxx" />에서 xxx패키지 하위에서

@Component로 선언된 클래스를 bean으로 자동 등록한다.

bean의 이름은 해당클래스명(첫글자는 소문자)이 사용된다.

<context:component-scan /> 요소에는 scoped-proxy 속성이 존재 한다.

scoped-proxy 속성은 <aop:scoped-poxy/> 요소처럼 WebApplicationContext 에서만 유효하며

"session", "globalSession", "request" 이외의 scope는 무시 되며 아래의 3가지 값을 설정 할 수 있다.

no : proxy를 생성하지 않는다.(기본값)

interfaces : JDK Dynamic Proxy를 이용한 Proxy 생성

targetClass : 클래스에 대해 프록시를 생성(CGLIB를 이용한 Proxy 생성)

사용 예 :

1

2

3

4

5

@Component
@Scope("prototype")   // 생략하면 싱글톤
public class Test {
       .....
}

- CGLIB

기존의 자바 클래스파일로부터 자바의 소스코드를 동적으로 생성하는 라이브러리(자바 소스 변경)

http://sourceforge.net/projects/cglib/

- 스캔 대상 클래스 범위 지정하기

<context:include-filter> 태그와 <context:exclude-filter> 태그를 사용하면 자동 스캔 대상에 포함시킬 클래스와 포함시키지 않을 클래스를 구체적으로 명시할 수 있다.

<context:component-scan base-package="spring.demo" scoped-proxy="no">

<context:include-filter type="regex" expression="*HibernateRepository"/>

<context:exclude-filter type="aspectj" expression="..*IBatisRepository"/>

</context:component-scan>

위와 같이 <context:include-filter> 태그와 <context:exclude-filter> 태그는 각각 type 속성과 expresseion 속성을 갖는데, type 속성에 따라 expression 속성에 올 수 있는 값이 달라지는데 type 속성에 입력 가능한 값을 다음과 같다

* Type 속성에 올 수 있는 값

annotation : 클랙스에 지정한 어노테이션이 적용됐는지의 여부

expression 속성에서는 "org.example.SomeAnnotation"와 같은 어노테이션 이름을 입력한다.

assignable : 클래스가 지정한 타입으로 할당 가능한지의 여부.

expression 속성에는 "org.exampleSomeClass" 와 같은 타입 이름을 입력한다.

regex : 클래스 이름이 정규 표현식에 매칭되는 지의 여부.

expression 속성에는 "org\.example\.Default.*" 와 같이 정규표현식을 입력한다.

aspectj : 클래스 이름이 AspectJ 의 표현식에 매칭되는 지의 여부.

expression 속성에는 "org.example..*Service+" 와 같이 AspectJ 의 표현식을 입력한다.

@Required

패키지 : org.springframework.beans.factory.annotation

버젼 : spring 2.0

Required 어노테이션은 필수 프로퍼티임을 명시하는 것으로 필수 프로퍼티를 설정하지 않을 경우

빈 생성시 예외를 발생시킨다.

설정위치 : setter 메소드

추가설정 :

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" /> 클래스를 빈으로 등록시켜줘야 한다.

해당 설정 대신에<context:annotation-config> 태그를 사용해도 된다.

- 1단계 : 코드내에 프로퍼티 설정 메소드에 @Required 어노테이션을 붙인다.

import org.springframework.beans.factory.annotation.Required

public class TestBean {

private TestDao testDao;

@Required

public void setTestDao(TestDao testDao) {

this.testDao = testDao;

}

- 2단계 : 스프링 설정 파일에 RequiredAnnotationBeanPostProcessor 클래스를 빈으로 등록

</bean>

RequiredAnnotationBeanPostProcessor 클래스는 스프링 컨테이너에 등록된 bean 객체를 조사하여 @Required 어노테이션으로 설정되어 있는 프로퍼티의 값이 설정되어 있는지 검사하고 설정되어있지 않으면 bean 생성시 예외를 발생시킨다.

RequiredAnnotationBeanPostProcessor 클래스를 빈으로 등록하지 않고

<context:annotation-config> 다음과 같이 태그를 이용할 수도 있다.

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           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.1.xsd
              http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context-3.1.xsd">
 
      <context:annotation-config/>
 
    </beans>

@Autowired

패키지 : org.springframework.beans.factory.annotation

버젼 : spring 2.5

개요 : 오토 와이어링 어노테이션은 의존관계를 자동설정할 때 사용하며 타입을 이용하여 의존하는 객체를 삽입해 준다. 그러므로 해당 타입의 빈객체가 존재하지 않거나 또는 2개 이상 존재할 경우 스프링은 예외를 발생시키게 된다.

설정 위치 : 생성자, 필드, 메소드(setter메소드가 아니여도 된다)

추가설정 : <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" /> 클래스를 빈으로 등록시켜줘야 한다. 해당 설정 대신에 <context:annotation-config> 태그를 사용해도 된다.

옵션 : required - @Autowired어노테이션을 적용한 프로퍼티에 대해 설정할 필요가 없는 경우에 false값을 주며 이때 해당 프로퍼티가 존재하지 않더라도 스프링은 예외를 발생시키지 않는다.

@Autowired(required=false)로 선언한다. (기본값은 true)

특징 : byType으로 의존관계를 자동으로 설정할 경우 같은 타입의 빈이 2개 이상 존재하게 되면 예외가 발생하는데, Autowired도 이러한 문제가 발생한다. 이럴 때 @Qualifier를 사용하면 동일한 타입의 빈 중 특정 빈을 사용하도록 하여 문제를 해결할 수 있다.

@Autowired

@Qualifier("test")

private Test test;

● @Qualifier

패키지 : org.springframework.beans.factory.annotation

버젼 : spring 2.5

개요 : 콸리파이어 어노테이션은 @Autowired의 목적에서 동일 타입의 빈객체가 존재시 특정빈을 삽입할 수 있게 설정한다. @Qualifier("mainBean")의 형태로 @Autowired와 같이 사용하며 해당 <bean>태그에 <qualifire value="mainBean" /> 태그를 선언해주어야 한다. 메소드에서 두개이상의 파라미터를 사용할 경우는 파라미터 앞에 선언해야한다.

설정위치 : @Autowired 어노테이션과 함께 사용된다.

추가설정 : 동일타입의 빈객체 설정에서 <qualifier value="[alias명]" />를 추가해 준다.

옵션 : name - alias명

사용 예 :

1

2

3

4

5

6

7

<bean id="user2" class="com.sp4.UserImpl">
    <property name="name" value="스프링"/>
    <property name="age" value="20"/>
    <property name="tel" value="000-0000-0000"/>
</bean>
 
<bean id="userService1" class="com.sp4.UserService"/>

public class UserService {
    @Autowired
    @Qualifier("user2")
    private User user;
 
    public String result() {
        return user.getData();
    }
}

@Resource

개요 : 자바 6버전 및 JEE5 버전에 추가된 것으로 어플리케이션에서 필요로 하는 자원을 자동 연결할 때 사용 한다. 스프링 2.5 부터 지원하는 어노테이션으로 스프링에서는 의존하는 빈 객체를 전달할 때 사용하다.

@Autowired 와 같은 기능을 하며 @Autowired와 차이점은 @Autowired는 타입으로(by type), @Resource는 이름으로(by name)으로 연결시켜준다는 것이다.

설정위치 : 프로퍼티, setter 메소드

추가설정 : <bean class="org.springframework.beans.factory.annotation.CommonAnnotationBeanPostProcessor"/> 클래스를 빈으로 등록시켜줘야 한다. 해당 설정 대신에 <context:annotation-config> 태그를 사용해도 된다.

옵션 : name

name속성에 자동으로 연결될 빈객체의 이름을 입력한다.

@Resource(name="testDao")

CommonAnnotationBeanPostProcessor 클래스를 설정파일에 빈객체로 등록하여 어노테이션을 적용시킨다.

</bean>

사용 예 :

public class UserService {
        @Resource(name="user2")
    private User user;  
        //UserImpl user2 = new UserImpl();
        //User user = user2;
 
    public void setUser(User user) {
        this.user = user;
    }
    public String result() {
        return user.getData();
    }
}

@Scope

패키지 : org.springframework.beans.factory.annotation

개요 : 스프링은 기본적으로 빈의 범위를 "singleton" 으로 설정한다. "singleton" 이 아닌 다른범위를 지정하고 싶다면 @Scope 어노테이션을 이용하여 범위를 지정한다.

설정 : prototype, singleton, request, session, globalSession

사용 예 - 1

1

2

3

4

5

@Component
@Scope(value="prototype")
public class Worker {
         :
}

사용 예 - 2

1

2

3

4

5

@Component
@Scope(value="prototype", proxyMode=ScopedProxyMode.TARGET_CLASS)
public class Worker {
        :
}

@PostConstruct

패키지 : javax.annotation

버젼 : jdk1.6, spring 2.5

개요 : 의존하는 객체를 설정한 이후에 초기화 작업을 수행하기 위해 사용

설정위치 : 초기화 작업 수행 메소드

추가설정 : CommonAnnotationBeanPostProcessor 클래스를 빈으로 등록시켜줘야 한다. 해당 설정 대신에 <context:annotation-config> 태그를 사용해도 된다.

사용 예 :

1

2

3

4

@PostConstruct
public void init() {
    System.out.println("객체 생성 후 내가 먼저 실행된다.");
}

@PreDestroy

패키지 : javax.annotation

버젼 : jdk1.6, spring 2.5

개요 : 컨테이너에서 객체를 제거하기 전에 해야할 작업을 수행하기 위해 사용

설정위치 : 해당 작업 메소드

추가설정 : CommonAnnotationBeanPostProcessor 클래스를 빈으로 등록시켜줘야 한다. 해당 설정 대신에 <context:annotation-config> 태그를 사용해도 된다.

@Inject

개요 : JSR-330 표준 Annotation으로 Spring 3 부터 지원하는 Annotation이다. 특정 Framework에 종속되지 않은 어플리케이션을 구성하기 위해서는 @Inject를 사용할 것을 권장한다. @Inject를 사용하기 위해서는 클래스 패스 내에 JSR-330 라이브러리인 javax.inject-x.x.x.jar 파일이 추가되어야 함에 유의해야 한다.

@Service

개요 : @Service를 적용한 Class는 비지니스 로직이 들어가는 Service로 등록이 된다.

Controller에 있는 @Autowired는 @Service("xxxService")에 등록된 xxxService와 변수명이 같아야 하며

Service에 있는 @Autowired는 @Repository("xxxDao")에 등록된 xxDao와 변수명이 같아야 한다.

@Service("helloService")

public class HelloServiceImpl implements HelloService {

@Autowired

private HelloDao helloDao;

public void hello() {

System.out.println("HelloServiceImpl :: hello()");

helloDao.selectHello();

}

helloDao.selectHello(); 와 같이 @Autowired를 이용한 객체를 이용하여 Dao 객체를 호출한다.

사용 예 :

@Service("test2.testService") 
//괄호 속 문자열은 식별자를 의미한다.
//괄호를 생략할 경우 클래스명 그대로 사용한다. 
//따라서 ,같은 클래스명이 존재 할 시 같은 식별자가 생성되기때문에 에러가 발생한다.
public class TestService {
    public String result(int num1, int num2, String oper) {
String str = null;
         
if(oper.equals("+")){
...
생략
...
        return str;
    }
}

@Resouce로 연결

@Resource(name="test2.testService") 
//name에 필요한 것은 @Service("test2.testService") <- 여기서 괄호 속 문자열, 즉 식별자
private TestService service; 
//TestService service = new TestService(); 라고 하는것과 같은 식
     
@RequestMapping(value="/test2/oper.action", method={RequestMethod.GET})
public String form() throws Exception {
    return "test2/write";
}

@Repository

패키지 : org.springframework.stereotype

버젼 : spring 2.0

개요 : 레포지 토리 어노테이션은 일반적으로 DAO에 사용되며 DB Exception을 DataAccessException으로 변환한다.

사용 예 :

@Repository("bbs.boardDAO")
public class BoardDAO {
    private SqlSession sqlSession;
     
    public int insertBoard(Board dto) throws Exception {
        ...
    }
}

1

2

3

4

5

6

public class BoardServiceImpl implements BoardService {
    @Resource(name="bbs.boardDAO")
    private BoardDAO dao;
 
    public int insertBoard(Board dto){}
}

@Controller

패키지 : org.springframework.stereotype

버젼 : spring 2.5

개요 : spring MVC의 Controller 클래스 선언을 단순화시켜준다. 스프링 컨트롤러,

서블릿을 상속할 필요가 없으며, @Controller로 등록된 클래스 파일에 대한 bean을 자동으로 생성해준다.

Controller로 사용하고자 하는 클래스에 @Controller 지정해 주면 component-scan으로 자동 등록된다.

- xml 설정

<context:component-scan base-package="han.*"/>

- java

package han.test;

import org.springframework.stereotype.Controller;

@Controller

public class SpringC {

}

※ 컨트롤러 메서드의 파라미터 타입

파라미터 타입	설명
HttpServletRequest , HttpServletResponse, HttpSession	서플릿 API
java.util.Locale	현재 요청에 대한 Locale
InputStream, Reader	요청 컨텐츠에 직접 접근할 때 사용
OutputStream, Writer	응답 컨텐츠를 생성할 때 사용
@PathVariable 어노테이션 적용 파라미터	URI 템플릿 변수에 접근할 때 사용
@RequestParam 어노테이션 적용 파라미터	HTTP 요청 파라미터를 매핑
@RequestHeader 어노테이션 적용 파라미터	HTTP 요청 헤더를 매핑
@CookieValue 어노테이션 적용 파라미터	HTTP 쿠키 매핑
@RequestBody 어노테이션 적용 파라미터	HTTP 요청의 몸체 내용에 접근할 때 사용, HttpMessage Converter를 이용해서 HTTP 요청 데이터를 해당 타입으로 변환한다.
Map, Model, ModelMap	뷰에 전달할 모델 데이터를 설정할 때 사용
커맨드 객체	HTTP 요청 파라미터를 저장한 객체. 기본적으로 클래스 이름을 모델명으로 사용. @ModelAttribute 어노테이션을 사용하여 모델명을 설정할 수 있다.
Errors, BindingResult	HTTP 요청 파라미터를 커맨드 객체에 저장한 결과. 커맨드 객체를 위한 파라미터 바로 다음에 위치
SessionStatus	폼 처리를 완료 했음을 처리하기 위해 사용. @SessionAttribute 어노테이션을 명시한 session 속성을 제거하도록 이벤트를 발생시킨다.

설명 보기

※ 컨트롤러 메서드의 리턴 타입

리턴타입	설명
ModelAndView	뷰 정보 및 모델 정보를 담고 있는 ModelAndView 객체
Model	뷰에 전달할 객체 정보를 담고 있는 Model을 리턴한다. 이때 뷰 이름은 요청 URL로부터 결정된다. (RequestToViewNameTranslator를 통해 뷰 결정)
Map	뷰에 전달할 객체 정보를 담고 있는 Map을 리턴한다. 이때 뷰 이름은 요청 URL로부터 결정된다. (RequestToViewNameTranslator를 통해 뷰 결정)
String	뷰 이름을 리턴한다.
View 객체	View 객체를 직접 리턴. 해당 View 객체를 이용해서 뷰를 생성한다.
void	메서드가 ServletResponse나 HttpServletResponse 타입의 파라미터를 갖는 경우 메서드가 직접 응답을 처리한다고 가정한다. 그렇지 않을 경우 요청 URL로부터 결정된 뷰를 보여준다. (RequestToViewNameTranslator를 통해 뷰 결정)
@ResponseBody 어노테이션 적용	메서드에서 @ResponseBody 어노테이션이 적용된 경우, 리턴 객체를 HTTP 응답으로 전송한다. HttpMessageConverter를 이용해서 객체를 HTTP 응답 스트림으로 변환한다.

설명 보기

@RequestMapping

개요 : RequestMapping annotation은 url을 class 또는 method와 mapping 시켜주는 역활을 한다. annotation을 쓰지 않을때 지정했던 Controller등록을 위한 url bean 설정을 생략 할 수 있다. class에 하나의 url mapping을 할 경우, class위에 @RequestMapping("/url")을 지정하며

, GET 또는 POST 방식 등의 옵션을 줄 수 있다. 해당되는 method가 실행된 후, return 페이지가 따로 정의되어 있지 않으면 RequestMapping("/url")에서 설정된 url로 다시 돌아간다.

● 상세 속성 정보

- value

: "value='/getMovie.do'"와 같은 형식의 매핑 URL 값이다. 디폴트 속성이기 때문에 value만 정의하는 경우에는 'value='은 생략할 수 있다.

예 : @RequestMapping(value={"/addMovie.do", "/updateMovie.do" })

"/addMovie.do", "/updateMovie.do" 두 URL 모두 처리한다.

- method

: GET, POST, HEAD 등으로 표현되는 HTTP Request method에 따라 requestMapping을 할 수 있다. 'method=RequestMethod.GET' 형식으로 사용한다. method 값을 정의하지 않는 경우 모든 HTTP Request method에 대해서 처리한다.

예 : @RequestMapping(method = RequestMethod.POST)

value 값은 클래스 선언에 정의한 @RequestMapping의 value 값을 상속받는다.

- params

: HTTP Request로 들어오는 파라미터 표현이다. 'params={"param1=a", "param2", "!myParam"}' 로 다양하게 표현 가능하다.

예 : @RequestMapping(params = {"param1=a", "param2", "!myParam"})

HTTP Request에 param1과 param2 파라미터가 존재해야하고 param1의 값은 'a'이어야하며, myParam이라는 파라미터는 존재하지 않아야한다. 또한, value 값은 클래스 선언에 정의한 @RequestMapping의 value 값을 상속받는다.

- headers

: HTTP Request의 헤더 값이다.'headers="someHader=someValue"', 'headers="someHader"', 'headers="!someHader"' 로 다양하게 표현 가능하다. Accept나 Content-Type 같은 헤더에 대해서 media type 표현 시 '*' 도 지원한다.

예 : @RequestMapping(value="/movie.do", headers="content-type=text/*")

HTTP Request에 Content-Type 헤더 값이 "text/html", "text/plain" 모두 매칭이 된다. 또한, Type-Level, Method-Level에서 모두 사용할 수 있는데, Type-Level에 정의된 경우, 하위의 모든 핸들러 메소드에서도 Type-Level에서 정의한 헤더값 제한이 적용된다.

- produces

: 확인중. 명시하지 않아도 큰 문제는 발생하지 않는것으로 보인다. 다음처럼 설정할 경우 클라이언트는 json타입의 값을 받게 된다.

@RequestMapping(value="...", produces = "application/json")

@RequestBody

public HashMap<String, String> testMethod(Model model) {

HashMap<String, String> map = new HashMap<String, String>();

map.put("code", "0");

return map;

}

사용 예 :

@Controller
@RequestMapping("/han/test/*")
public class HelloController {
 
@RequestMapping(method=RequestMethod.GET, value="go")
public returntype getMethodName(){
    :
}
 
@RequestMapping(method=RequestMethod.POST, value="go2")
public returntype getMethodName2(){
    :
}
 
@Controller("mainController")
@RequestMapping(value="/main.action")
public class MainController {
      
    @RequestMapping(method=RequestMethod.GET)
    public String method() {
        return ".mainLayout";
    }
}

@RequestParam

개요 : RequestParam annotation은 key=value 형태로 화면에서 넘어오는 파라미터를 맵핑 된 메소드의

파라미터로 지정해 준다. 주로 get 방식으로 들어오는 request에서 사용한다.

아래에서 xxx/editBlog.do?blogId=3 과 같이 접근할 때, editBlogHandler 메소드의 파라미터인 blogId에는

3이 셋팅된다. 필수 요건이 아닐 경우, @RequestParam(value="id", required="false")와 같이 옵션을

주고 사용할 수 있다.

@Controller
public class BlogController {
    // 중간생략
     
    @RequestMapping("/editBlog")
    public ModelMap editBlogHandler(@RequestParam("blogId") int blogId) {
        blog = blogService.findBlog(blogId); 
        return new ModelMap(blog);
    }
  
    // 중간생략
}

@RequestMapping(value="/...", method={RequestMethod.GET, RequestMethod.POST})
public String submit(HttpServletRequest req
        , @RequestParam(value="num1") int num1
        , @RequestParam(value="num2") int num2
        , @RequestParam(value="oper") String oper) throws Exception {
    ...  //value : form객체가 넘겨줄 값의 name
}
 
//@RequestParam 어노테이션이 적용된 파라미터는 기본적으로 필수 파라미터이다.
//따라서, 명시한 파라미터가 존재하지 않을 경우 400 에러가 발생한다.
//여기서 파라미터에 값이 있을수도 없을수도 있는 로직을 구현하려면 다음처럼 작성한다.
 
@RequestMapping(value="/...", method={RequestMethod.GET, RequestMethod.POST})
public String submit(HttpServletRequest req
        , @RequestParam(value="num1", defaultValue = "0") int num1
        , @RequestParam(value="num2", defaultValue = "0") int num2
        , @RequestParam(value="oper", required=false) String oper) throws Exception {
    ...
}

사용 예 :

파라미터를 각각 지정하는것이 번거롭다면 다음처럼 작성한다:

1

2

3

4

5

@RequestMapping("/faqDetail")
public String faqDetail(@RequestParam HashMap<String, String> map) {
     
    return "board/faq/faqDetail";
}

이렇게 작성하면 뷰에서 전달된 파라미터는 모두 하나의 컬렉션으로 전달된다.

@SessionAttributes

개요 : SessionAttribute annotation은 세션상에서 model의 정보를 유지하고 싶을 경우 사용 할 수 있다.

@Controller
@SessionAttributes("blog")
public class BlogController {
    // 중간생략
  
    @RequestMapping("/createBlog")
    public ModelMap createBlogHandler() {
        blog = new Blog();
        blog.setRegDate(new Date());
        return new ModelMap(blog);
    }
  
    // 중간생략
}

@InitBinder

개요 : WebDataBinder를 초기화하는 method를 지정 할 수 있는 설정을 제공한다.

일반적으로 WebDataBinder는 annotation handler 메소드의 command 와 form 객체 인자를 조작하는데 사용된다.

InitBinder 메소드가 필수적으로 반환값을 가질 필요는 없으며, 일반적으로 이런 경우에 void를 선언한다. 특별한 인자는 WebdataBinder와 WebRequest또는 Locale의 조합으로 이루어지며, 이러한 조건이 만족되면 context-specific editors를 등록하는것이 허용된다.

WebdataBinder : WebDataBinder는 web request parameter를 javaBean 객체에 바인딩하는 특정한 DataBinder이다. WebDataBinder는 웹 환경이 필요하지만, Servlet API에 의존적이지 않다. servlet API에 의존적인 ServletRequestDataBinder와 같이 특정한 DaraBinder를 위한 더많은 base class를 제공한다.

RequestMapping : RequestMapping annotation은 web request를 특정한 handler class와 handler method에 mapping하는 역활을 수행한다. 대응하는 handlerMapping(for type level annotation)과 HandlerAdapter(for method level annotation)가 dispatch에 존재한다면, @RequestMapping이 처리된다.

WebRequest : WebRequest는 웹 요청에 대한 Generic interface이다. 주로 일반 request metadata에 generic web request interceptors의 접근을 허용하여 metadata에 대한 처리를 하기 위한 것이지 request 자체를 처리하기 위한 것은 아니다.

Annotation 기반 Controller 에서 ServletContext 구하기 :

@Controller
@RequestMapping("/common/download")
public class DownloadController {
    @Autowired
    private ServletContext sc;
 
    @RequestMapping
    public ModelAndView download(@RequestParam("filePath") String filePath) throws Exception {
        String path = sc.getRealPath(filePath);
        return new ModelAndView("common.download", "downloadFile", new File(path));
    }
}

@ModelAttribute

● 파라미터에 지정하는 경우

화면에서 전달된 model을 파라미터 객체의 프로퍼티와 매핑한다.

public class MyModel {
    private String title;
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public String getTitle() {
        return this.title;
    }
}

@RequestMapping(value = "/titleSubmit")
public String titleSubmit(@ModelAttribute MyModel params) throws Exception {
 
    params.getTitle();
 
    // 생략
    // ...
}

~~● 메서드 혹은 리턴타입에 지정하는 경우~~

~~컨트롤러에서 뷰에 전달할 일종의 공통 모델을 설정한다.~~

~~예를 들어 다음과 같은 TestController가 존재할 때 :~~

@Controller
@RequestMapping("/sample")
public class TestController {
 
    @ModelAttribute("modelTest")
    public String[] refModelTest() {
        return new String[] {"하나", "둘", "셋"};
    }
 
    ... 
}

~~@ModelAttribute 어노테이션이 적용된 메소드가 리턴하는 값은 Request객체에 전달된다.~~

~~전달 범위는 해당 메소드가 존재하는 컨트롤러 전체에 해당된다. (전역변수가 되는 셈)~~

~~EL을 적용해 접근할 땐 다음처럼 작성한다 :~~

1

2

3

4

5

6

7

<table>
    <tr>
        <c:forEach var="entity" items="${modelTest}">
            <td>${entity}</td>
        </c:forEach>
    </tr>
</table>

@RequestBody

@RequestBody 어노테이션이 적용된 파라미터는 HTTP Request body의 내용이 전달된다.

참고페이지

http://java.ihoney.pe.kr/283

1

2

3

4

5

6

7

@RequestMapping(value="/test")
public void penaltyInfoDtlUpdate(@RequestBody String body,
        HttpServletRequest req, HttpServletResponse res,
        Model model, HttpSession session) throws Exception  {
 
    System.out.println(body);   
}

@ResponseBody

컨트롤러가 응답할 값 혹은 객체를 HTTP Response body로 전달한다.

참고페이지

http://ismydream.tistory.com/140

클라이언트로 JSON 객체를 전달할 때 유용하다. 메서드에 @ResponseBody를 적용한 후 객체를 리턴하면 그 값은 VIEW를 통해 전달되는 것이 아니라 HTTP ResponseBody에 직접 쓰여진다. 보통 AJAX를 처리할 메서드에 적용한다. 이 경우 클라이언트 스크립트의 AJAX 옵션 설정에 주의해야 한다. ($.ajax()의 경우라면 받는 데이터를 JSON으로 파싱하도록 dataType: "json" 옵션 추가)

1

2

3

4

5

6

7

@RequestMapping("/getVocTypeList")
@ResponseBody
public ArrayList<Object> getVocTypeList() throws Exception {
     
    HashMap<String, Object> vocData = gvocInf.searchVocTypeList();
    return (ArrayList<Object>) vocData.get("data");
}

HashMap 객체를 리턴하면 JSON은 Map형태로 변환되며, 위처럼 ArrayList로 리턴할 경우엔 배열의 형태로 변환된다.

@PathVariable

URL의 일부를 파라미터 혹은 변수로 사용한다.

package com.sp.ex;
 
@Controller("ex.exController")
public class ExController{
    @RequestMapping(value="/blog/{userId}/main.action", method=RequestMethod.GET)
    public String main(HttpServletRequest req
                       , @PathVariable String userId) throws Exception  {
 
        req.setAttribute("userId", userId);
        return "restful/result";
    }
}

출처 - http://noritersand.tistory.com/156

저작자표시 비영리