[轉]SpringMVC Controller介紹及經常使用註解

1、簡介

         在SpringMVC 中，控制器Controller 負責處理由DispatcherServlet 分發的請求，它把用戶請求的數據通過業務處理層處理以後封裝成一個Model ，而後再把該Model 返回給對應的View 進行展現。在SpringMVC 中提供了一個很是簡便的定義Controller 的方法，你無需繼承特定的類或實現特定的接口，只需使用@Controller 標記一個類是Controller ，而後使用@RequestMapping 和@RequestParam 等一些註解用以定義URL 請求和Controller 方法之間的映射，這樣的Controller 就能被外界訪問到。此外Controller 不會直接依賴於HttpServletRequest 和HttpServletResponse 等HttpServlet 對象，它們能夠經過Controller 的方法參數靈活的獲取到。爲了先對Controller 有一個初步的印象，如下先定義一個簡單的Controller ：

例1:

@Controller
public class MyController {

    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 須要放到 model 中的屬性名稱 " , " 對應的屬性值，它是一個對象 " );
       return modelAndView;
    }

} 

在上面的示例中，@Controller 是標記在類MyController 上面的，因此類MyController 就是一個SpringMVC Controller 對象了，而後使用@RequestMapping(「/showView」) 標記在Controller 方法上，表示當請求/showView.do 的時候訪問的是MyController 的showView 方法，該方法返回了一個包括Model 和View 的ModelAndView 對象。這些在後續都將會詳細介紹。

 

2、使用 @Controller 定義一個 Controller 控制器

例1所示@Controller 用於標記在一個類上，使用它標記的類就是一個SpringMVC Controller 對象。分發處理器將會掃描使用了該註解的類的方法，並檢測該方法是否使用了@RequestMapping 註解。@Controller 只是定義了一個控制器類，而使用@RequestMapping 註解的方法纔是真正處理請求的處理器，這個接下來就會講到。

   單單使用@Controller 標記在一個類上還不能真正意義上的說它就是SpringMVC 的一個控制器類，由於這個時候Spring 還不認識它。那麼要如何作Spring 才能認識它呢？這個時候就須要咱們把這個控制器類交給Spring 來管理。

這個時候有兩種方式能夠把MyController 交給Spring 管理，好讓它可以識別咱們標記的@Controller 。

   第一種方式是在SpringMVC 的配置文件中定義MyController 的bean 對象。

<bean class="com.host.app.web.controller.MyController"/>

   第二種方式是在SpringMVC 的配置文件中告訴Spring 該到哪裏去找標記爲@Controller 的Controller 控制器。

    < context:component-scan base-package = "com.host.app.web.controller" >
       < context:exclude-filter type = "annotation"
           expression = "org.springframework.stereotype.Service" />
    </ context:component-scan > 

注：

       上面 context:exclude-filter 標註的是不掃描 @Service 標註的類

3、使用 @RequestMapping 來映射 Request 請求與處理器

例1可使用@RequestMapping 來映射URL 到控制器類，或者是到Controller 控制器的處理方法上。當@RequestMapping 標記在Controller 類上的時候，裏面使用@RequestMapping 標記的方法的請求地址都是相對於類上的@RequestMapping 而言的；當Controller 類上沒有標記@RequestMapping 註解時，方法上的@RequestMapping 都是絕對路徑。這種絕對路徑和相對路徑所組合成的最終路徑都是相對於根路徑「/ 」而言的。

在這個控制器中，由於MyController 沒有被@RequestMapping 標記，因此當須要訪問到裏面使用了@RequestMapping 標記的showView 方法時，就是使用的絕對路徑/showView.do 請求就能夠了。

例2

@Controller
@RequestMapping ( "/test" ) public class MyController {
    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 須要放到 model 中的屬性名稱 " , " 對應的屬性值，它是一個對象 " );
       return modelAndView;
    }

} 

例2是在控制器上加了@RequestMapping 註解，因此當須要訪問到裏面使用了@RequestMapping 標記的方法showView() 的時候就須要使用showView 方法上@RequestMapping 相對於控制器MyController上@RequestMapping 的地址，即/test/showView.do 。

（一）使用 URI 模板

URI 模板就是在URI 中給定一個變量，而後在映射的時候動態的給該變量賦值。如URI 模板http://localhost/app/{variable1}/index.html ，這個模板裏面包含一個變量variable1 ，那麼當咱們請求http://localhost/app/hello/index.html 的時候，該URL 就跟模板相匹配，只是把模板中的variable1 用hello 來取代。在SpringMVC 中，這種取代模板中定義的變量的值也能夠給處理器方法使用，這樣咱們就能夠很是方便的實現URL 的RestFul 風格。這個變量在SpringMVC 中是使用@PathVariable 來標記的。在SpringMVC 中，咱們可使用@PathVariable 來標記一個Controller 的處理方法參數，表示該參數的值將使用URI 模板中對應的變量的值來賦值。

例3

@Controller
@RequestMapping ( "/test/{variable1}" )
public class MyController {

    @RequestMapping ( "/showView/{variable2}" )
    public ModelAndView showView( @PathVariable String variable1, @PathVariable ( "variable2" ) int variable2) {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 須要放到 model 中的屬性名稱 " , " 對應的屬性值，它是一個對象 " );
       return modelAndView;
    }
} 

在例3的代碼中咱們定義了兩個URI 變量，一個是控制器類上的variable1 ，一個是showView 方法上的variable2 ，而後在showView 方法的參數裏面使用@PathVariable 標記使用了這兩個變量。因此當咱們使用/test/hello/showView/2.do 來請求的時候就能夠訪問到MyController 的showView 方法，這個時候variable1 就被賦予值hello ，variable2 就被賦予值2 ，而後咱們在showView 方法參數裏面標註了參數variable1 和variable2 是來自訪問路徑的path 變量，這樣方法參數variable1 和variable2 就被分別賦予hello 和2 。方法參數variable1 是定義爲String 類型，variable2 是定義爲int 類型，像這種簡單類型在進行賦值的時候Spring 是會幫咱們自動轉換的，關於複雜類型該如何來轉換在後續內容中將會講到。

   在上面的代碼中咱們能夠看到在標記variable1 爲path 變量的時候咱們使用的是@PathVariable ，而在標記variable2 的時候使用的是@PathVariable(「variable2」) 。這二者有什麼區別呢？第一種狀況就默認去URI 模板中找跟參數名相同的變量，可是這種狀況只有在使用debug 模式進行編譯的時候才能夠，而第二種狀況是明確規定使用的就是URI 模板中的variable2 變量。當不是使用debug 模式進行編譯，或者是所須要使用的變量名跟參數名不相同的時候，就要使用第二種方式明確指出使用的是URI 模板中的哪一個變量。

   除了在請求路徑中使用URI 模板，定義變量以外，@RequestMapping 中還支持通配符「* 」。以下面的代碼我就可使用/myTest/whatever/wildcard.do 訪問到Controller 的testWildcard 方法。

@Controller
@RequestMapping ( "/myTest" )
public class MyController {
    @RequestMapping ( "*/wildcard" )
    public String testWildcard() {
       System. out .println( "wildcard------------" );
       return "wildcard" ;
    }  
} 

 

（二）使用 @RequestParam 綁定 HttpServletRequest 請求參數到控制器方法參數

例4

    @RequestMapping ( "requestParam" )
   public String testRequestParam( @RequestParam(required=false) String name, @RequestParam ( "age" ) int age) {
       return "requestParam" ;
    } 

在上面代碼中利用@RequestParam 從HttpServletRequest 中綁定了參數name 到控制器方法參數name ，綁定了參數age 到控制器方法參數age 。值得注意的是和@PathVariable 同樣，當你沒有明確指定從request 中取哪一個參數時，Spring 在代碼是debug 編譯的狀況下會默認取更方法參數同名的參數，若是不是debug 編譯的就會報錯。此外，當須要從request 中綁定的參數和方法的參數名不相同的時候，也須要在@RequestParam 中明確指出是要綁定哪一個參數。在上面的代碼中若是我訪問/requestParam.do?name=hello&age=1 則Spring 將會把request請求參數name 的值hello 賦給對應的處理方法參數name ，把參數age 的值1 賦給對應的處理方法參數age 。

在@RequestParam 中除了指定綁定哪一個參數的屬性value 以外，還有一個屬性required ，它表示所指定的參數是否必須在request 屬性中存在，默認是true ，表示必須存在，當不存在時就會報錯。在上面代碼中咱們指定了參數name 的required 的屬性爲false ，而沒有指定age 的required 屬性，這時候若是咱們訪問/requestParam.do而沒有傳遞參數的時候，系統就會拋出異常，由於age 參數是必須存在的，而咱們沒有指定。而若是咱們訪問/requestParam.do?age=1 的時候就能夠正常訪問，由於咱們傳遞了必須的參數age ，而參數name 是非必須的，不傳遞也能夠。

（三）使用 @CookieValue 綁定 cookie 的值到 Controller 方法參數

例5

    @RequestMapping ( "cookieValue" )
    public String testCookieValue( @CookieValue ( "hello" ) String cookieValue, @CookieValue String hello) {
       System. out .println(cookieValue + "-----------" + hello);
       return "cookieValue" ;
    } 

在上面的代碼中咱們使用@CookieValue 綁定了cookie 的值到方法參數上。上面一共綁定了兩個參數，一個是明確指定要綁定的是名稱爲hello 的cookie 的值，一個是沒有指定。使用沒有指定的形式的規則和@PathVariable、@RequestParam 的規則是同樣的，即在debug 編譯模式下將自動獲取跟方法參數名同名的cookie 值。

（四）使用 @RequestHeader 註解綁定 HttpServletRequest 頭信息到Controller 方法參數

例6

@RequestMapping ( "testRequestHeader" )
public String testRequestHeader( @RequestHeader ( "Host" ) String hostAddr, @RequestHeader String Host, @RequestHeader String host ) {
    System. out .println(hostAddr + "-----" + Host + "-----" + host );
    return "requestHeader" ;
} 

在上面的代碼中咱們使用了 @RequestHeader 綁定了 HttpServletRequest 請求頭 host 到Controller 的方法參數。上面方法的三個參數都將會賦予同一個值，由此咱們能夠知道在綁定請求頭參數到方法參數的時候規則和 @PathVariable 、 @RequestParam 以及 @CookieValue 是同樣的，即沒有指定綁定哪一個參數到方法參數的時候，在 debug 編譯模式下將使用方法參數名做爲須要綁定的參數。可是有一點 @RequestHeader 跟另外三種綁定方式是不同的，那就是在使用 @RequestHeader 的時候是大小寫不敏感的，即 @RequestHeader(「Host」) 和 @RequestHeader(「host」) 綁定的都是 Host 頭信息。記住在 @PathVariable 、 @RequestParam 和 @CookieValue 中都是大小寫敏感的。

（五） @RequestMapping 的一些高級應用

在RequestMapping 中除了指定請求路徑value 屬性外，還有其餘的屬性能夠指定，如params 、method 和headers 。這樣屬性均可以用於縮小請求的映射範圍。

1.params屬性

例7

    @RequestMapping (value= "testParams" , params={ "param1=value1" , "param2" , "!param3" })
    public String testParams() {
       System. out .println( "test Params..........." );
       return "testParams" ;
    } 

在上面的代碼中咱們用@RequestMapping 的params 屬性指定了三個參數，這些參數都是針對請求參數而言的，它們分別表示參數param1 的值必須等於value1 ，參數param2 必須存在，值無所謂，參數param3 必須不存在，只有當請求/testParams.do 而且知足指定的三個參數條件的時候才能訪問到該方法。因此當請求/testParams.do?param1=value1&param2=value2 的時候可以正確訪問到該testParams 方法，當請求/testParams.do?param1=value1&param2=value2&param3=value3 的時候就不可以正常的訪問到該方法，由於在@RequestMapping 的params 參數裏面指定了參數param3 是不能存在的。

2.method屬性

例8

    @RequestMapping (value= "testMethod" , method={RequestMethod. GET , RequestMethod. DELETE })
    public String testMethod() {
       return "method" ;
    } 

在上面的代碼中就使用method 參數限制了以GET 或DELETE 方法請求/testMethod.do 的時候才能訪問到該Controller 的testMethod 方法。

3.headers屬性

例9

    @RequestMapping (value= "testHeaders" , headers={ "host=localhost" , "Accept" })
    public String testHeaders() {
       return "headers" ;
    } 

headers 屬性的用法和功能與params 屬性類似。在上面的代碼中當請求/testHeaders.do 的時候只有當請求頭包含Accept 信息，且請求的host 爲localhost 的時候才能正確的訪問到testHeaders 方法。

（六）以 @RequestMapping 標記的處理器方法支持的方法參數和返回類型

1. 支持的方法參數類型

         （1 ）HttpServlet 對象，主要包括HttpServletRequest 、HttpServletResponse 和HttpSession 對象。 這些參數Spring 在調用處理器方法的時候會自動給它們賦值，因此當在處理器方法中須要使用到這些對象的時候，能夠直接在方法上給定一個方法參數的申明，而後在方法體裏面直接用就能夠了。可是有一點須要注意的是在使用HttpSession 對象的時候，若是此時HttpSession 對象尚未創建起來的話就會有問題。

   （2 ）Spring 本身的WebRequest 對象。 使用該對象能夠訪問到存放在HttpServletRequest 和HttpSession 中的屬性值。

   （3 ）InputStream 、OutputStream 、Reader 和Writer 。 InputStream 和Reader 是針對HttpServletRequest 而言的，能夠從裏面取數據；OutputStream 和Writer 是針對HttpServletResponse 而言的，能夠往裏面寫數據。

   （4 ）使用@PathVariable 、@RequestParam 、@CookieValue 和@RequestHeader 標記的參數。

   （5 ）使用@ModelAttribute 標記的參數。

   （6 ）java.util.Map 、Spring 封裝的Model 和ModelMap 。 這些均可以用來封裝模型數據，用來給視圖作展現。

   （7 ）實體類。 能夠用來接收上傳的參數。

   （8 ）Spring 封裝的MultipartFile 。 用來接收上傳文件的。

   （9 ）Spring 封裝的Errors 和BindingResult 對象。 這兩個對象參數必須緊接在須要驗證的實體對象參數以後，它裏面包含了實體對象的驗證結果。

2. 支持的返回類型

         （1 ）一個包含模型和視圖的ModelAndView 對象。

   （2 ）一個模型對象，這主要包括Spring 封裝好的Model 和ModelMap ，以及java.util.Map ，當沒有視圖返回的時候視圖名稱將由RequestToViewNameTranslator 來決定。

   （3 ）一個View 對象。這個時候若是在渲染視圖的過程當中模型的話就能夠給處理器方法定義一個模型參數，而後在方法體裏面往模型中添加值。

   （4 ）一個String 字符串。這每每表明的是一個視圖名稱。這個時候若是須要在渲染視圖的過程當中須要模型的話就能夠給處理器方法一個模型參數，而後在方法體裏面往模型中添加值就能夠了。

   （5 ）返回值是void 。這種狀況通常是咱們直接把返回結果寫到HttpServletResponse 中了，若是沒有寫的話，那麼Spring 將會利用RequestToViewNameTranslator 來返回一個對應的視圖名稱。若是視圖中須要模型的話，處理方法與返回字符串的狀況相同。

   （6 ）若是處理器方法被註解@ResponseBody 標記的話，那麼處理器方法的任何返回類型都會經過HttpMessageConverters 轉換以後寫到HttpServletResponse 中，而不會像上面的那些狀況同樣當作視圖或者模型來處理。

   （7 ）除以上幾種狀況以外的其餘任何返回類型都會被當作模型中的一個屬性來處理，而返回的視圖仍是由RequestToViewNameTranslator 來決定，添加到模型中的屬性名稱能夠在該方法上用@ModelAttribute(「attributeName」) 來定義，不然將使用返回類型的類名稱的首字母小寫形式來表示。使用@ModelAttribute 標記的方法會在@RequestMapping 標記的方法執行以前執行。

（七）使用 @ModelAttribute 和 @SessionAttributes 傳遞和保存數據

SpringMVC 支持使用 @ModelAttribute 和 @SessionAttributes 在不一樣的模型和控制器之間共享數據。 @ModelAttribute 主要有兩種使用方式，一種是標註在方法上，一種是標註在 Controller 方法參數上。

當 @ModelAttribute 標記在方法上的時候，該方法將在處理器方法執行以前執行，而後把返回的對象存放在 session 或模型屬性中，屬性名稱可使用 @ModelAttribute(「attributeName」) 在標記方法的時候指定，若未指定，則使用返回類型的類名稱（首字母小寫）做爲屬性名稱。關於 @ModelAttribute 標記在方法上時對應的屬性是存放在 session 中仍是存放在模型中，咱們來作一個實驗，看下面一段代碼。

@Controller
@RequestMapping ( "/myTest" )
public class MyController {

    @ModelAttribute ( "hello" )
    public String getModel() {
       System. out .println( "-------------Hello---------" );
       return "world" ;
    }

    @ModelAttribute ( "intValue" )
    public int getInteger() {
       System. out .println( "-------------intValue---------------" );
       return 10;
    }

    @RequestMapping ( "sayHello" )
    public void sayHello( @ModelAttribute ( "hello" ) String hello, @ModelAttribute ( "intValue" ) int num, @ModelAttribute ( "user2" ) User user, Writer writer, HttpSession session) throws IOException {
       writer.write( "Hello " + hello + " , Hello " + user.getUsername() + num);
       writer.write( "\r" );
       Enumeration enume = session.getAttributeNames();
       while (enume.hasMoreElements())
           writer.write(enume.nextElement() + "\r" );
    }

    @ModelAttribute ( "user2" )
    public User getUser() {
       System. out .println( "---------getUser-------------" );
       return new User(3, "user2" );
    }
} 

當咱們請求 /myTest/sayHello.do 的時候使用 @ModelAttribute 標記的方法會先執行，而後把它們返回的對象存放到模型中。最終訪問到 sayHello 方法的時候，使用 @ModelAttribute 標記的方法參數都能被正確的注入值。執行結果以下所示：

 Hello world,Hello user210

       由執行結果咱們能夠看出來，此時 session 中沒有包含任何屬性，也就是說上面的那些對象都是存放在模型屬性中，而不是存放在 session 屬性中。那要如何才能存放在 session 屬性中呢？這個時候咱們先引入一個新的概念 @SessionAttributes ，它的用法會在講完 @ModelAttribute 以後介紹，這裏咱們就先拿來用一下。咱們在 MyController 類上加上 @SessionAttributes 屬性標記哪些是須要存放到 session 中的。看下面的代碼：

@Controller
@RequestMapping ( "/myTest" )
@SessionAttributes (value={ "intValue" , "stringValue" }, types={User. class })
public class MyController {

    @ModelAttribute ( "hello" )
    public String getModel() {
       System. out .println( "-------------Hello---------" );
       return "world" ;
    }

    @ModelAttribute ( "intValue" )
    public int getInteger() {
       System. out .println( "-------------intValue---------------" );
       return 10;
    }
   
    @RequestMapping ( "sayHello" )
    public void sayHello(Map<String, Object> map, @ModelAttribute ( "hello" ) String hello, @ModelAttribute ( "intValue" ) int num, @ModelAttribute ( "user2" ) User user, Writer writer, HttpServletRequest request) throws IOException {
       map.put( "stringValue" , "String" );
       writer.write( "Hello " + hello + " , Hello " + user.getUsername() + num);
       writer.write( "\r" );
       HttpSession session = request.getSession();
       Enumeration enume = session.getAttributeNames();
       while (enume.hasMoreElements())
           writer.write(enume.nextElement() + "\r" );
       System. out .println(session);
    }

    @ModelAttribute ( "user2" )
    public User getUser() {
       System. out .println( "---------getUser-------------" );
       return new User(3, "user2" );
    }
} 

在上面代碼中咱們指定了屬性爲 intValue 或 stringValue 或者類型爲 User 的都會放到 Session中，利用上面的代碼當咱們訪問 /myTest/sayHello.do 的時候，結果以下：

 Hello world,Hello user210

仍然沒有打印出任何 session 屬性，這是怎麼回事呢？怎麼定義了把模型中屬性名爲 intValue 的對象和類型爲 User 的對象存到 session 中，而實際上沒有加進去呢？難道咱們錯啦？咱們固然沒有錯，只是在第一次訪問 /myTest/sayHello.do 的時候 @SessionAttributes 定義了須要存放到 session 中的屬性，並且這個模型中也有對應的屬性，可是這個時候尚未加到 session 中，因此 session 中不會有任何屬性，等處理器方法執行完成後 Spring 纔會把模型中對應的屬性添加到 session 中。因此當請求第二次的時候就會出現以下結果：

 Hello world,Hello user210

user2

intValue

stringValue

當 @ModelAttribute 標記在處理器方法參數上的時候，表示該參數的值將從模型或者 Session 中取對應名稱的屬性值，該名稱能夠經過 @ModelAttribute(「attributeName」) 來指定，若未指定，則使用參數類型的類名稱（首字母小寫）做爲屬性名稱。

 

---

 

以上內容轉載來源:http://haohaoxuexi.iteye.com/blog/1753271#comments