@Controller

在SpringMVC 中，控制器Controller 負責處理由DispatcherServlet 分發的請求，它把使用者請求的資料經過業務處理層處理之後封裝成一個Model ，然後再把該Model 返回給對應的View 進行展示。在SpringMVC 中提供了一個非常簡便的定義Controller 的方法，你無需繼承特定的類或實現特定的介面，只需使用@Controller 標記一個類是Controller ，然後使用@RequestMapping 和@RequestParam 等一些註解用以定義URL 請求和Controller 方法之間的對映，這樣的Controller 就能被外界訪問到。此外Controller 不會直接依賴於HttpServletRequest 和HttpServletResponse 等HttpServlet 物件，它們可以通過Controller 的方法引數靈活的獲取到。

@Controller 用於標記在一個類上，使用它標記的類就是一個SpringMVC Controller 物件。分發處理器將會掃描使用了該註解的類的方法，並檢測該方法是否使用了@RequestMapping 註解。@Controller 只是定義了一個控制器類，而使用@RequestMapping 註解的方法才是真正處理請求的處理器。單單使用@Controller 標記在一個類上還不能真正意義上的說它就是SpringMVC 的一個控制器類，因為這個時候Spring 還不認識它。那麼要如何做Spring 才能認識它呢？這個時候就需要我們把這個控制器類交給Spring 來管理。有兩種方式：

　　（1）在SpringMVC 的配置檔案中定義TestController 的bean 物件。

　　（2）在SpringMVC 的配置檔案中告訴Spring 該到哪裡去找標記為@Controller 的Controller 控制器。

<!--方式一-->
<bean class="com.tian.app.web.controller.TestController"/>
<!--方式二-->
< context:component-scan base-package = "com.tian.app.web" />//路徑寫到controller的上一層(掃描包詳解見下面淺析)
 

@RequestMapping

RequestMapping是一個用來處理請求地址對映的註解，可用於類或方法上。用於類上，表示類中的所有響應請求的方法都是以該地址作為父路徑。

RequestMapping註解有六個屬性，下面我們把她分成三類進行說明（下面有相應示例）。

1、 value， method；

value： 指定請求的實際地址，指定的地址可以是URI Template 模式（後面將會說明）；

method： 指定請求的method型別， GET、POST、PUT、DELETE等；

2、consumes，produces

consumes： 指定處理請求的提交內容型別（Content-Type），例如application/json, text/html;

produces: 指定返回的內容型別，僅當request請求頭中的(Accept)型別中包含該指定型別才返回；

3、params，headers

params： 指定request中必須包含某些引數值是，才讓該方法處理。

headers： 指定request中必須包含某些指定的header值，才能讓該方法處理請求。

@Resource和@Autowired

@Resource和@Autowired都是做bean的注入時使用，其實@Resource並不是Spring的註解，它的包是javax.annotation.Resource，需要匯入，但是Spring支援該註解的注入。

1、共同點

兩者都可以寫在欄位和setter方法上。兩者如果都寫在欄位上，那麼就不需要再寫setter方法。

2、不同點

（1）@Autowired

@Autowired為Spring提供的註解，需要匯入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

public class TestServiceImpl {    // 下面兩種@Autowired只要使用一種即可
    @Autowired
    private UserDao userDao; // 用於欄位上
    
    @Autowired
    public void setUserDao(UserDao userDao) { // 用於屬性的方法上
        this.userDao = userDao;
    }
}

@Autowired註解是按照型別（byType）裝配依賴物件，預設情況下它要求依賴物件必須存在，如果允許null值，可以設定它的required屬性為false。如果我們想使用按照名稱（byName）來裝配，可以結合@Qualifier註解一起使用。如下：

public class TestServiceImpl {

@[email protected]("userDao")
private UserDao userDao; 

}
（2）@Resource

@Resource預設按照ByName自動注入，由J2EE提供，需要匯入包javax.annotation.Resource。@Resource有兩個重要的屬性：name和type，而Spring將@Resource註解的name屬性解析為bean的名字，而type屬性則解析為bean的型別。所以，如果使用name屬性，則使用byName的自動注入策略，而使用type屬性時則使用byType自動注入策略。如果既不制定name也不制定type屬性，這時將通過反射機制使用byName自動注入策略。

public class TestServiceImpl {    // 下面兩種@Resource只要使用一種即可
    @Resource(name="userDao")
    private UserDao userDao; // 用於欄位上
    
    @Resource(name="userDao")
    public void setUserDao(UserDao userDao) { // 用於屬性的setter方法上
        this.userDao = userDao;
    }
}

注：最好是將@Resource放在setter方法上，因為這樣更符合面向物件的思想，通過set、get去操作屬性，而不是直接去操作屬性。

@Resource裝配順序：

①如果同時指定了name和type，則從Spring上下文中找到唯一匹配的bean進行裝配，找不到則丟擲異常。

②如果指定了name，則從上下文中查詢名稱（id）匹配的bean進行裝配，找不到則丟擲異常。

③如果指定了type，則從上下文中找到類似匹配的唯一bean進行裝配，找不到或是找到多個，都會丟擲異常。

④如果既沒有指定name，又沒有指定type，則自動按照byName方式進行裝配；如果沒有匹配，則回退為一個原始型別進行匹配，如果匹配則自動裝配。

@Resource的作用相當於@Autowired，只不過@Autowired按照byType自動注入。

@ModelAttribute和 @SessionAttributes

代表的是：該Controller的所有方法在呼叫前，先執行此@ModelAttribute方法，可用於註解和方法引數中，可以把這個@ModelAttribute特性，應用在BaseController當中，所有的Controller繼承BaseController，即可實現在呼叫Controller時，先執行@ModelAttribute方法。

@SessionAttributes即將值放到session作用域中，寫在class上面。

具體示例參見下面：使用 @ModelAttribute 和 @SessionAttributes 傳遞和儲存資料

@PathVariable

用於將請求URL中的模板變數對映到功能處理方法的引數上，即取出uri模板中的變數作為引數。如：

@Controller  public class TestController {  
     @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)  
     public String getLogin(@PathVariable("userId") String userId,  
         @PathVariable("roleId") String roleId){  
         System.out.println("User Id : " + userId);  
         System.out.println("Role Id : " + roleId);  
         return "hello";  
     }  
     @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
     public String getProduct(@PathVariable("productId") String productId){  
           System.out.println("Product Id : " + productId);  
           return "hello";  
     }  
     @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}",  
           method = RequestMethod.GET)  
     public String getRegExp(@PathVariable("regexp1") String regexp1){  
           System.out.println("URI Part 1 : " + regexp1);  
           return "hello";  
     }  
}

@requestParam

@requestParam主要用於在SpringMVC後臺控制層獲取引數，類似一種是request.getParameter("name")，

它有三個常用引數：

• defaultValue = "0", 

• required = false, 

• value = "isApp"；

defaultValue 表示設定預設值，required 銅過boolean設定是否是必須要傳入的引數，value 值表示接受的傳入的引數型別。

@ResponseBody

作用： 該註解用於將Controller的方法返回的物件，通過適當的HttpMessageConverter轉換為指定格式後，寫入到Response物件的body資料區。

使用時機：返回的資料不是html標籤的頁面，而是其他某種格式的資料時（如json、xml等）使用；

@Component

稍微細心的人就能看到在@controller、@service、@repository註解上是有這個註解的。很多人把他們的關係稱之為派生或者擴充套件

 

 

@component （把普通pojo例項化到spring容器中，相當於配置檔案中的 
<bean id="testObject" class="com.tian.TestObject"/>）
泛指各種元件，就是說當我們的類不屬於各種歸類的時候（不屬於@Controller、@Services等的時候），我們就可以使用@Component來標註這個類。@component 註解的類，都會把這些類納入進spring容器中進行管理。

@Repository

用於註解dao層，在daoImpl類上面註解。

注：
1、使用 @RequestMapping 來對映 Request 請求與處理器

方式一、通過常見的類路徑和方法路徑結合訪問controller方法

方式二、使用uri模板

@[email protected] ( "/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;
    }
} 

URI 模板就是在URI 中給定一個變數，然後在對映的時候動態的給該變數賦值。如URI 模板http://localhost/app/{variable1}/index.html ，這個模板裡面包含一個變數variable1 ，那麼當我們請求http://localhost/app/hello/in... 的時候，該URL 就跟模板相匹配，只是把模板中的variable1 用hello 來取代。這個變數在SpringMVC 中是使用@PathVariable 來標記的。在SpringMVC 中，我們可以使用@PathVariable 來標記一個Controller 的處理方法引數，表示該引數的值將使用URI 模板中對應的變數的值來賦值。

程式碼中我們定義了兩個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 方法。如：

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

當@RequestParam中沒有指定引數名稱時，Spring 在程式碼是debug 編譯的情況下會預設取更方法引數同名的引數，如果不是debug 編譯的就會報錯。

2、使用 @RequestMapping 的一些高階用法

（1）params屬性

@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屬性

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

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

（3）headers屬性

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

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

3、 @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 標記的方法執行之前執行。

4、使用 @ModelAttribute 和 @SessionAttributes 傳遞和儲存資料

SpringMVC 支援使用 @ModelAttribute 和 @SessionAttributes 在不同的模型（model）和控制器之間共享資料。 @ModelAttribute 主要有兩種使用方式，一種是標註在方法上，一種是標註在 Controller 方法引數上。

當 @ModelAttribute 標記在方法上的時候，該方法將在處理器方法執行之前執行，然後把返回的物件存放在 session 或模型屬性中，屬性名稱可以使用 @ModelAttribute(“attributeName”) 在標記方法的時候指定，若未指定，則使用返回型別的類名稱（首字母小寫）作為屬性名稱。關於 @ModelAttribute 標記在方法上時對應的屬性是存放在 session 中還是存放在模型中，我們來做一個實驗，看下面一段程式碼。

@[email protected] ( "/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 中的。看下面的程式碼：@[email protected] ( "/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”) 來指定，若未指定，則使用引數型別的類名稱（首字母小寫）作為屬性名稱。

5、@PathVariable和@RequestParam的區別

請求路徑上有個id的變數值，可以通過@PathVariable來獲取 @RequestMapping(value = "/page/{id}", method = RequestMethod.GET) 
@RequestParam用來獲得靜態的URL請求入參 spring註解時action裡用到。

簡介：

handler method 引數繫結常用的註解,我們根據他們處理的Request的不同內容部分分為四類：（主要講解常用型別）

A、處理requet uri 部分（這裡指uri template中variable，不含queryString部分）的註解： @PathVariable;

B、處理request header部分的註解： @RequestHeader, @CookieValue;

C、處理request body部分的註解：@RequestParam, @RequestBody;

D、處理attribute型別是註解： @SessionAttributes, @ModelAttribute;

（1）、@PathVariable

當使用@RequestMapping URI template 樣式對映時， 即 someUrl/{paramId}, 這時的paramId可通過 @Pathvariable註解繫結它傳過來的值到方法的引數上。

示例程式碼：

@Controller  @RequestMapping("/owners/{ownerId}")  
public class RelativePathUriTemplateController {  
  
  @RequestMapping("/pets/{petId}")  
  public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {      
    // implementation omitted   
  }  
} 

上面程式碼把URI template 中變數 ownerId的值和petId的值，繫結到方法的引數上。若方法引數名稱和需要繫結的uri template中變數名稱不一致，需要在@PathVariable("name")指定uri template中的名稱。

（2） @RequestHeader和@CookieValue

@RequestHeader 註解，可以把Request請求header部分的值繫結到方法的引數上。

示例程式碼：

這是一個Request 的header部分：

Host localhost:8080 
Accept text/html,application/xhtml+xml,application/xml;q=0.9 
Accept-Language fr,en-gb;q=0.7,en;q=0.3 
Accept-Encoding gzip,deflate 
Accept-Charset ISO-8859-1,utf-8;q=0.7,*;q=0.7 
Keep-Alive 300

@RequestMapping("/displayHeaderInfo.do")  
public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,  
                              @RequestHeader("Keep-Alive") long keepAlive)  {  
}  

上面的程式碼，把request header部分的 Accept-Encoding的值，繫結到引數encoding上了， Keep-Alive header的值繫結到引數keepAlive上。

@CookieValue 可以把Request header中關於cookie的值繫結到方法的引數上。

例如有如下Cookie值：

　　JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

@RequestMapping("/displayHeaderInfo.do")  
public void displayHeaderInfo(@CookieValue("JSESSIONID") String cookie)  {  
} 

即把JSESSIONID的值繫結到引數cookie上。

（3）@RequestParam,和@RequestBody

@RequestParam

A） 常用來處理簡單型別的繫結，通過Request.getParameter() 獲取的String可直接轉換為簡單型別的情況（ String--> 簡單型別的轉換操作由ConversionService配置的轉換器來完成）；因為使用request.getParameter()方式獲取引數，所以可以處理get 方式中queryString的值，也可以處理post方式中 body data的值；

B）用來處理Content-Type: 為 application/x-www-form-urlencoded編碼的內容，提交方式GET、POST；

C) 該註解有兩個屬性： value、required； value用來指定要傳入值的id名稱，required用來指示引數是否必須繫結；

示例程式碼：

@Controller  @RequestMapping("/pets")  @SessionAttributes("pet")  public class EditPetForm {  
    @RequestMapping(method = RequestMethod.GET)   public String setupForm(@RequestParam("petId") int petId, ModelMap model) {  
       Pet pet = this.clinic.loadPet(petId);  
   model.addAttribute("pet", pet);  
   return "petForm";  
   }
} 

@RequestBody

該註解常用來處理Content-Type: 不是application/x-www-form-urlencoded編碼的內容，例如application/json, application/xml等；

它是通過使用HandlerAdapter 配置的HttpMessageConverters來解析post data body，然後繫結到相應的bean上的。

因為配置有FormHttpMessageConverter，所以也可以用來處理 application/x-www-form-urlencoded的內容，處理完的結果放在一個MultiValueMap<String, String>裡，這種情況在某些特殊需求下使用，詳情檢視FormHttpMessageConverter api;

示例程式碼：

@RequestMapping(value = "/something", method = RequestMethod.PUT)  
public void handle(@RequestBody String body, Writer writer) throws IOException {  
  writer.write(body);  
} 

（4）@SessionAttributes,和@ModelAttribute

@SessionAttributes:

該註解用來繫結HttpSession中的attribute物件的值，便於在方法中的引數裡使用。

該註解有value、types兩個屬性，可以通過名字和型別指定要使用的attribute 物件；

示例程式碼：

@Controller  @RequestMapping("/editPet.do")  @SessionAttributes("pet")  
public class EditPetForm {  
    // ...   } 
@ModelAttribute

該註解有兩個用法，一個是用於方法上，一個是用於引數上；

用於方法上時： 通常用來在處理@RequestMapping之前，為請求繫結需要從後臺查詢的model；

用於引數上時： 用來通過名稱對應，把相應名稱的值繫結到註解的引數bean上；要繫結的值來源於：

A） @SessionAttributes 啟用的attribute 物件上；

B） @ModelAttribute 用於方法上時指定的model物件；

C） 上述兩種情況都沒有時，new一個需要繫結的bean物件，然後把request中按名稱對應的方式把值繫結到bean中。

用到方法上@ModelAttribute的示例程式碼：

@ModelAttribute  public Account addAccount(@RequestParam String number) {  
    return accountManager.findAccount(number);  
} 

這種方式實際的效果就是在呼叫@RequestMapping的方法之前，為request物件的model裡put（“account”， Account）。

用在引數上的@ModelAttribute示例程式碼：

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)  
public String processSubmit(@ModelAttribute Pet pet) {  
     
} 

首先查詢 @SessionAttributes有無繫結的Pet物件，若沒有則查詢@ModelAttribute方法層面上是否綁定了Pet物件，若沒有則將URI template中的值按對應的名稱繫結到Pet物件的各屬性上。

6、< context:component-scan base-package = "" />淺析
component-scan 預設掃描的註解型別是 @Component，不過，在 @Component 語義基礎上細化後的 @Repository, @Service 和 @Controller 也同樣可以獲得 component-scan 的青睞

有了<context:component-scan>，另一個<context:annotation-config/>標籤根本可以移除掉，因為已經被包含進去了

另外<context:annotation-config/>還提供了兩個子標籤

1. <context:include-filter> //指定掃描的路徑

2. <context:exclude-filter> //排除掃描的路徑

<context:component-scan>有一個use-default-filters屬性，屬性預設為true,表示會掃描指定包下的全部的標有@Component的類，並註冊成bean.也就是@Component的子註解@Service,@Reposity等。

這種掃描的粒度有點太大，如果你只想掃描指定包下面的Controller或其他內容則設定use-default-filters屬性為false，表示不再按照scan指定的包掃描，而是按照<context:include-filter>指定的包掃描，示例：

<context:component-scan base-package="com.tian" use-default-filters="false">
<context:include-filter type="regex" expression="com.tian.*"/>

//注意後面要寫.*
</context:component-scan>
當沒有設定use-default-filters屬性或者屬性為true時，表示基於base-packge包下指定掃描的具體路徑

<context:component-scan base-package="com.tian" >
        <context:include-filter type="regex" expression=".controller.*"/>
        <context:include-filter type="regex" expression=".service.*"/>
        <context:include-filter type="regex" expression=".dao.*"/>
</context:component-scan>

效果相當於：

<context:component-scan base-package="com.tian" >
        <context:exclude-filter type="regex" expression=".model.*"/>
</context:component-scan>

 

更多內容請關注微信訂閱號，掃描關注回覆 福利  有阿里大牛springboot視訊教程