springMVC知識點總結

● <context:compnent-scan> 
Xml代碼   

<!-- 切記，這不是必需的！除非你把註解的 Controller 一個個的註冊到容器中。相信大家還是喜歡用 context:compnent-scan 吧。不要認爲在 Spring MVC 中才提到 context:component-scan，就認爲它只能掃描 @Controller。component-scan 默認掃描的註解類型是 @Component，不過，在 @Component 語義基礎上細化後的 @Repository, @Service 和 @Controller 也同樣可以獲得 component-scan 的青睞 -->  
<context:component-scan base-package="org.zachary.spring3.anno.web" />  

● HandlerMapping 
Xml代碼 

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">  
  <description>  
  這點是必需的還是非必需的呢？  
  如果定義了 DefaultAnnotationHandlerMapping，它就可以將請求來的 url 和被註解了 @RequesMapping 的指進行匹配。當然，說這句話的前提是定義 DefaultAnnotationHandlerMapping 的優先級比定義了其它的 HandlerMapping 的優先級要高(如果定義了其它的話)。  
  如果沒有定義 DefaultAnnotationHandlerMapping，並不代表不能映射到相應的 handler 上。因爲如果你定義了其它的 HandlerMapping，請求過來的 url 和註解了的 @RequestMapping 裏的值正好能匹配上，那麼沒有 DefaultAnnotationHandlerMapping，@Controller 一樣可以如魚得水的被捕獲到。  
  當然，如果你要使用基於註解的 @Controller，最好還是老老實實地註冊 DefaultAnnotationHandlerMapping。  
  </description>  
</bean>  

● HandlerAdaptor 
Xml代碼  

Xml代碼   
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">  
  <description>  
  和上面的 HandlerMapping 一樣，是必需的還是非必需的呢？  
  Spring MVC 中，如果我們沒有註冊任何 HandlerAdaptor 到容器中，注意，我說的是任何。那麼 DispatcherServlet 將啓用後備的幾個默認使用的 HandlerAdaptor 實現，包括：  
  org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter  
  org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter  
  org.springframework.web.servlet.mvc.AnnotationMethodHandlerAdaptor  
  
   看見沒，如果我們沒有註冊任何的 HandlerAdaptor，框架會準備 AnnotationMethodHandlerAdaptor 的。可是由於某些原因，我們需要爲某些 HandlerAdaptoer 進行一些定製化，即在容器中註冊了某個 HandlerAdaptor，那麼很抱歉，框架只會啓用你註冊的那個，而框架本身準備的不會被啓用。所以，你一旦爲某個 HandlerMapping 進行了定製化，請別忘了把其它的 HandlerAdaptor 也註冊進來，即便這些不需要定製化。否則的話，後果你是可以想象的。當然，除非你確保你真的只需要那一個你註冊進容器的 HandlerAdaptor，否則，我再囉嗦一遍，別忘了把其它的 HandlerAdaptor 也註冊進來。  
  </description>  
</bean>  

  好了，有了以上幾點準備工作，我們就可以開始基於註解的 Controller 之旅了。下面我們來一個一個註解的來講解。 

● @Controller 
Java代碼 

/** 
 * @Controller，類級別上的註解。我們定義的類可以只是一個 javabean，不需要實現任何接口。標註了 
 * @Controller，藉助 <context:component-scan>，框架能自動識別到這就是一個 Controller 
 */  
@Controller  
public class MyController {  
  // ......  
} 

● @RequestMapping 
Java代碼  

/** 
 * @RequestMapping 可以出現在類級別上，也可以出現在方法上。如果出現在類級別上，那請求的 url 爲 類級別 
 * 上的 @RequestMapping + 方法級別上的 @RequestMapping，否則直接取方法級上的 @RequestMapping。 
 * 類級別的 @RequestMapping 不是必需的。 
 */  
@Controller  
@RequestMapping("/my")  
public class MyController {  
    
  /** 
   * 由於類級別上定義了 @RequestMapping，那麼想匹配到這個方法來處理請求，url 必須爲 /my/somelist。 
   * 如果沒有定義類級別上的 @RequestMapping，url 爲 /somelist 即可。同時，請求方法必須爲 POST 
   */  
  @RequestMapping(value="/somelist", method=RequestMethod.POST);  
  public String getSomeList() {...}  
  
    /** 
     * 在方法級別使用 @RequestMapping 來限定請求處理的時候，可以指定兩個屬性。除了我們在上面剛使用過的 
     * method 屬性，還有一個 params 屬性。使用 params 屬性，可以達到與使用 
     * ParameterMethodNameResolver 作爲 MethodResolver的 MultiActionController 類似的功能。 
     * 
     * params 有兩種表達形式，這裏先說第一種："parameterName=parameterValue" 
     * 
     * 請求方法爲 GET 或 POST，且具有 hello 參數，且值爲 world 的請求才能匹配到該方法，如： 
     *   /my?hello=world 
     */  
    @RequestMapping(params="hello=world", method={RequestMethod.GET, RequestMethod.POST})  
    public String helloworld() {...}  
  
    /** 
     * 請求方法爲 GET 或 POST，且具有 hello 參數，且值爲 java 的請求才能匹配到該方法，如： 
     *   /my?hello=java 
     */  
    @RequestMapping(params="hello=java", method={RequestMethod.GET, RequestMethod.POST})  
    public String hellojava() {...}  
  
    /** 
     * params 屬性的另外一種表達形式爲："parameter" 
     * 
     * 請求方法爲 GET，且具有請求參數 java 即匹配此方法，而不管 java 參數的值是什麼，如： 
     *   /my?java=anything 
     */  
    @RequestMapping(params="java", method={RequestMethod.GET})  
    public String java() {...}  
  
    /** 
     * 請求方法爲 GET，且具有請求參數 cplusplus 即匹配此方法，而不管 cplusplus 參數的值是什麼，如： 
     *   /my?cplusplus=anything 
     */  
    @RequestMapping(params="cplusplus", method={RequestMethod.GET})  
    public String cplusplus() {...}  
  
    /** 
     * @RequestMapping 還有一個參數化 headers，它和 params 非常相似，也有兩種表達式，只不過它是對 
     * 請求頭做限制罷了。大家可以通過 telnet 或 http-client 來發類似的請求以檢驗。以 telnet 爲例： 
     *  
     * telnet localhost 8080 
     * POST /contextPath/my HTTP/1.1 
     * Host: localhost 
     * hello: world # 這個就是自定義請求頭，和標準的請求頭的寫法別無二致 
     * 【回車】 
     * 【回車】 
     */  
    @RequestMapping(headers="hello=world", method={RequestMethod.POST})  
    public String cplusplus() {...}  
}  

● @RequestParam(將請求參數綁定到方法參數) 
Java代碼   

@Controller  
@RequestMapping("/my")  
public class MyController {  
  
  /** 
   * 注意，這裏的方法有一個參數。若請求 url 爲 /my/test，會匹配此方法。這裏的方法的參數名爲 userId， 
   * 那麼請求參數中一定有名爲 userId 的參數，且值爲整數。這也是默認的綁定行爲，它是根據名稱匹配原則進行 
   * 的數據綁定。當請求中的參數名與方法名一致的時候，相應的參數值將被綁定到相應的方法參數上。 
   *  
   * 如果沒有傳遞 userId 參數，框架會傳入 null。可是這裏我們定義的是 primitive type，異常伺候！若 
   * 要解決此問題，需要將 primitive type 定義成相應的 wrapper type 即可，這裏使用 Integer 就行了。 
   * 
   * 如果傳遞了 userId 參數，但值不是整數，你叫 test 怎麼辦呢？這種情況下，框架藉助 PropertyEditor  
   * 數據類型轉換失敗，ExceptionResolver 會接手處理，請求是不會進入 test 方法的。 
   * 
   * 這種方式下，默認的綁定行爲需要我們嚴格遵守命名一致性原則。如果我們對此不滿，想自定義綁定關係，可以求 
   * 助於 @RequestParam。 
   */  
  @RequestMapping("/test")  
  public String test(int userId) { ... }  
  
  /** 
   * 當我們不想使用 userId 作爲方法的參數名，即不想使用默認的數據綁定方式。如果我們要使用 id 作爲方法 
   * 的參數，爲了保證名稱爲 userId 的請求參數可以綁定到新的名稱爲 id 的方法參數上，我們就可以使用  
   * @RequestParam 對這一參數進行標註。@RequestParam 只可以標註於方法參數上。 
   * 
   * 如果請求參數中有 age，和方法的參數名稱一致，故 age 參數不需要 @RequestParam 標註。如果沒有傳遞 
   * age，我們又不想定義成 Integer，很顯然框架會注入 null 值，報錯是必然的。這是由於 @RequestParam  
   * 的 required 屬性決定的，默認就是 true。如果我們定義成 false， 
   * 即 @RequestParam(required=false) int age 
   * 這個時候定義成 int 型的 age，即便請求參數沒有 age 參數，也是沒問題的。 
   * 
   * 同時，這裏還能綁定 Date 類型，User 對象類型等等。如 date=2011-01-01&userName=Tom&userAge=18 
   * 這裏，User 類的屬性需要爲 userName 和 userAge，以免和 age，name 混淆。所以，Spring MVC 對對象 
   * 的數據綁定就沒有 Struts2 做的那麼好了，Strtus2 可以這樣：user.age=18&user.name=Tom 
   */  
  @RequestMapping("/test2")  
  public String test2(@RequestParam("userId") int id, int age, Date date, User user) { ... }  
}  

● @PathVariable(將 url template 裏的參數綁定到方法參數) 
Java代碼  

@Controller  
@RequestMapping("/my")  
public class MyController {  
  
  /** 
   * @PathVariable 是 url 模板，需要和 @RequestMapping 配合起來使用，這是 Spring 3.0 之後引入的。 
   * 
   * 在這個例子中，請求的 url 必須滿足類似 /my/user/zhangsan/18 這樣的格式才能匹配方法。url 模板裏 
   * 的參數名和方法參數名的綁定規則和 @RequestParam 類似，這裏就不再贅述了。 
   * 
   * @PathVariable 和 @RequestParam 的區別在於： 
   *   @PathVariable 的 url：/my//user/zhangsan/18 
   *   @RequestParam 的 url：/my//user?nickname=zhangsan&age=18 
   */  
  @RequestMapping("/user/{nickname}/{age}");  
  public String getUserInfo(@PathVariable("nickname") String name, @PathVariable int age) {...}  
}  

● @RequestBody(將請求正文綁定到方法參數) 
Java代碼 

/** 
 * 來看一個 http 請求： 
 * (請求行) POST /my HTTP/1.1 
 * (請求頭) Host: localhost 
 * (請求頭) Content-Type: text/plain 
 * (請求頭) Content-Length: 5 
 * 
 * (請求體) hello 
 * 
 * 這裏的 hello，就是請求體，也稱 request message。若有請求體，則必須提供請求體的類型和長度，這些信 
 * 息是寫在請求頭裏的，即 Content-Type 和 Content-Length 
 */  
@Controller  
@RequestMapping("/my")  
public class MyController {  
  
  /** 
   * 我們定義的 body 的數據類型是 String，請求體嘛，肯定是 String。實際上，@RequestBody 是用於將請 
   * 求體的內容綁定到方法參數上，數據類型不一定是 String。Spring MVC 是通過 HttpMessageConverter 
   * 來完成這種轉換的。AnnotationMethodHandlerAdapter 默認註冊了一些 HttpMessageConverters： 
   *   ByteArrayHttpMessageConverter - converts byte arrays 
   *   StringHttpMessageConverter - converts strings 
   *   FormHttpMessageConverter - converts form data to/from MultiValueMap<String,String> 
   *   SourceHttpMessageConverter - convert to/from a javax.xml.transform.Source 
   *   MappingJacksonHttpMessageConverter - converts json 
   *   MarshallingHttpMessageConverter - convert to/from an object using the  
   *                                     org.springframework.oxm package. 
   * 
   * 正如上所述，HttpMessageConverter 用於從請求正文綁定到對象和把對象序列化成 String 予客戶端響應。 
   * 即 HttpMessageConverter is responsible for converting from the HTTP request message to 
   * an object and converting from an object to the HTTP response body 
   * 
   * 我們可以在 AnnotationMethodHandlerAdapter 定義任意多的 HttpMessageConverters。 
   * 
   * 既然 HttpMessageConverter 可以用於雙向 convert，這裏討論的是 @RequestBody，那這部分我們只講  
   * converting from the HTTP request message to an object。 
   * 
   * 假設我們只向 AnnotationMethodHandlerAdapter 注入了 MappingJacksonHttpMessageConverter 和 
   * MarshallingHttpMessageConverter。處理請求的方法有如下簽名： 
   *     public String test(@RequestBody User user) { ... } 
   * 
   * 不管請求正文的內容是什麼，對於客戶端和服務器而言，它們只是用文本來互相通信。把字符串轉爲 User 對 
   * 象，該用哪個 HttpMessageConverter 來完成此項工作呢？ 
   * 
   * 在定義 HttpMessageConverters 時，我們可以爲其指定 supportedMediaTypes。對於將請求正文轉爲對象 
   * 這個方向的操作，HttpMessageConverters 會從請求頭得到 Content-Type 頭信息，看其是否隸屬於其定義 
   * 的 supportedMediaTypes。若沒有匹配上，則會使用下一個 HttpMessageConverter 做同樣的判斷。只要 
   * 某個 HttpMessageConverter 支持請求頭中的 Content-Type，那麼就會應用此 HttpMessageConverter 
   * 來將 String 轉爲 Object。當然，若請求正文並沒有按照 Content-Type 所規定的格式來編寫，必然要收到 
   * 500 的響應。同時請注意，請求頭中還必須提供 Content-Length，否則拿不到請求正文。 
   * 
   * 如果所有的 HttpMessageConverters 中定義的 supportedMediaTypes 均不能匹配上 Content-Type 請 
   * 求頭中的類型，那麼就會收到 415 Unsupported Media Type 響應。 
   */  
  @RequestMapping("/user/body");  
  public String getBody(@RequestBody String body) {  
  
    // 這裏的 body 的內容就是 hello  
    System.out.println(body);  
    return null;  
  }  
}  

● @ResponseBody(將處理完請求後返回的對象綁定到響應正文) 
Java代碼   
/** 
 * 上面的 @RequestBody 講了 HttpMessageConverter 從請求正文到對象轉換的方向，現在來講講另外一個方 
 * 向，@ResponseBody，此時，HttpMessageConverter 用於將處理完請求後返回的對象序列化成字符串，即 
 * converting from an object to the HTTP response body. 
 */  
@Controller  
@RequestMapping("/my")  
public class MyController {  
  
  /** 
   * 該方法的返回類型是 User，並不符合含有 @RequestMapping 的註解所需的簽名方式。但它仍然是合法的，因 
   * 爲在返回類型前有 @ResponseBody 註解，此註解將告知框架，將 User 對象作爲影響正文返回？什麼？對象 
   * 作爲響應正文！所以，HttpMessageConverter 在這裏就起到作用了。這裏討論的是 @ResponseBody，所以 
   * 這裏我們只講 converting from an object to the HTTP response body。 
   * 
   * User 對象要轉成什麼樣的 String，或者說要轉成什麼格式的 String？這個時候需要從請求頭中獲得此信息 
   * 了，這裏，就是請求頭的 Accept 頭。Accept 頭可以使用逗號分隔定義多個類型，用以告知服務器我只接受 
   * 哪些類型的響應。AnnotationMethodHandlerAdapter 中同樣注入了多個 HttpMessageConverter，每個  
   * HttpMessageConverter 都可以定義各自的 supportedMediaTypes。這個時候該用哪個  
   * HttpMessageConverter 來完成對象到文本的序列化操作呢？ 
   * 
   * 遍歷 Accept 頭中的每種媒體類型，在定義的多個 HttpMessageConverters 中依次去匹配，若匹配上，就使 
   * 用該 HttpMessageConverter 來完成序列化操作，並且響應頭的 Content-Type 並不是請求頭 Accept 頭 
   * 的諸多類型中第一個被匹配的類型，而是匹配到的 HttpMessageConverter 定義的 supportedMediaTypes 
   * 中的第一個類型。 
   * 
   * 如果所有的 HttpMessageConverters 中定義的 supportedMediaTypes 均不能匹配上 Accept 請求頭中 
   * 的諸多的類型，那麼就會收到 406 Not Acceptable 響應。 
   */  
  @RequestMapping("/user")  
  public @ResponseBody User getUser() {  
    return new User(18, "Jack", "計算機");  
  }  
}  

● @ModelAttribute 
Java代碼   

/** 
 * @ModelAttribute 可以爲視圖渲染提供更多的模型數據，而不需要在處理請求的方法裏添加 ModelMap 或 
 * Model 類型的參數。 
 * 
 * @ModelAttribute 可以標註在方法(存數據)上，也可以標註在方法參數(取數據)上。 
 */  
@Controller  
@RequestMapping("/my")  
public class MyController {  
  
  /** 
   * 在處理該請求時，方法的返回類型是 User，貌似不符合返回類型的規範。由於這裏使用了 @ModelAttribute 
   * 註解，表示將返回的對象以 "user" 爲 key 放入模型數據裏。這裏的 key 值默認值是返回的數據類型首字母 
   * 小寫的結果。如果想自定義 key，可以寫成 @ModelAttribute("myAttribute")，那麼模型數據將會將  
   * User 對象綁定到 key 爲 "myAttribute" 上。 
   *  
   * jsp 裏可以這樣訪問模型裏的數據： 
   *   age: ${user.age} 
   *   name: ${user.name} 
   *   job: ${user.job} 
   * 
   * 當然，這裏只是提到了 @ModelAttribute 存數據的操作。 
   */  
  @RequestMapping("/user")  
  @ModelAttribute  
  public User getUser() {  
    return new User(18, "Jack", "計算機");  
  }  
    
  /** 
   * 這裏將 @ModelAttribute 標註在方法參數上，表示要從模型數據裏取 key 爲 "user" 的對象，綁定在方法 
   * 參數上。如果這樣做的話，其實你是得不到上面的那個請求放入的 User 對象，得到的是另外一個對象。其實 
   * 也好理解，這是兩個互相獨立的請求，作用域不一樣。要想達到我們的目的，即能夠從模型數據裏取數據，需要 
   * 求助於 @SessionAttributes 
   */  
  @RequestMapping("/user2")  
  public String showUser(@ModelAttribute User user) {  
    System.out.println(user);  
    return null;  
  }  
}  

● @SessionAttributes 
Java代碼   

/** 
 * @SessionAttributes 和 @ModelAttribute 類似，只不過 @SessionAttributes 是將數據存放於 session  
 * 中或從 session 中取數據。 
 * 
 * @SessionAttributes 只能應用在類型聲明上。比如下面的類的聲明中，只有屬性名爲 "the-attribute" 的數 
 * 據纔會納入到 session 的管理。 
 * 
 * @SessionAttributes 允許以屬性名名稱或者類型兩種方法，來表明將哪些數據通過 session 進行管理。這裏 
 * 我們使用的是指定屬性名稱的方式，但通過類型來指定也是可行的，如： 
 *   @SessionAttributes(types=User.class) 
 */  
@Controller  
@RequestMapping("/my")  
@SessionAttributes("the-attribute")  
public class MyController {  
  
  @RequestMapping("/getUser")  
  public String getUser(int userId, Model model) {  
    /** 
     * 注意，這裏將 User 對象添加到屬性名爲 "the-attribute" 上，所以 User 對象將納入到 session 的 
     * 管理。如果這裏添加的對象的屬性名不是 "the-attribute"，那麼它只會作用於當前請求，而不會納入到  
     * session 的管理中。 
     */  
    User user = userService.getUserById(userId);  
    model.addAtrribute("the-attribute", user);  
    return "userinfo";  
  }  
    
  /** 
   * 將模型裏的 "the-attribute" 爲 key 的對象綁定到 User 類上。由於在類級別上聲明瞭只有 "the- 
   * attribute" 的屬性名纔會納入到 session 的管理，所以就解決了在 @ModelAttribute 註解中講解中最 
   * 後提到的問題。 
   * 
   * 另外，這個方法還有兩個參數，BindingResult 和 SessionStatus。由於這裏有綁定數據的動作，我們可以 
   * 根據 BindingResult 對象獲得數據綁定結果以決定後繼流程該如何處理。SessionStatus 在這裏用於處理 
   * 完請求後，清空 session 裏的數據。 
   */  
  @RequestMapping("/updateUser")  
  public String updateUser(@ModelAttribute("the-attribute") User user,   
            BindingResult result, SessionStatus status) {  
  
    if (result.hasErrors) {  
      return "error";  
    }  
      
    userService.updateUser(user);  
    // 我們通過調用 status.setComplete() 方法，該 Controller 所有放在 session 級別的模型屬性數據  
    // 將從 session 中清空  
    status.setComplete();  
    return "redirect:getUser?userId=" + user.getId();  
  }  
}  

 Spring MVC 裏的大部分的註解，這裏基本上都講到了。日後隨着 Spring 的升級，我也會逐一補充新加的註解。其實，僅憑以上的註解，是可以構建一個足夠強大的 RESTFul Webservices 的了。 


        這裏，補充講下被標註了 @RequestMapping 註解的請求方法的簽名。使用 @RequestMapping 標註的 web 請求處理方法的簽名比較靈活，我們幾乎可以聲明並使用任何類型的方法參數。不過，以下幾種類型的方法參數將擁有更多語義，它們均來自框架內部(或者說 AnnotationMethodHandlerAdapter)所管理的對象引用： 
request/response/session
org.springframework.web.context.request.WebRequest。當前處理方法中獲得可用的 WebRequest 實例。
java.util.Locale。通過相應的 LocalResolver 所返回的對應當前 web 請求的 Locale。
java.io.InputStream/java.io.Reader。相當於 request.getInputStream() 或 request.getReader() 所獲得的對象引用。
java.io.OutputStream/java.io.Writer。相當於 response.getOutputStream() 或 response.getWriter() 所獲得的對象引用。
java.util.Map/org.springframework.ui.ModelMap。你現在可用對模型數據爲所欲爲了。
org.springframework.validation.Errors/org.springframework.validation.BindingResult。用於對 Command 對象進行數據驗證的 Errors 或者 BindingResult 對象。聲明這兩種類型的方法參數有一個限制，它們的聲明必須緊跟着 Command 對象的定義。其它類型的方法參數是沒有任何順序限制的。
org.springframework.web.bind.supportt.SessionStatus。SessionStatus 主要用於管理請求處理之後 Session 的狀態，比如清除 Session 中的指定的數據。


        基於註解的 Controller 的請求處理方法返回類型可以有如下 4 種形式(當然，前面提到的 @ResponseBody 和 @ModelAttribute 並沒下面所描述的返回類型，具體參見上面對各自注解的講解)： 
org.springframework.web.servlet.ModelAndView。這個不用多說，視圖信息和模型信息都能通過它返回。
java.lang.String。該類型返回值代表邏輯視圖名，模型數據需要以其它形式提供，比如爲處理方法聲明一個 ModelMap 類型的參數。注意，如果返回 null，並不代表向客戶端輸出空頁面(定向思維惹的禍)，這種情況下，框架會從請求路徑中提取視圖信息。如果返回 null 就是要表示方法內部已處理完請求，也不需要通知頁面，就是想僅僅返回空白頁面，唉，我還沒有想出來咋整。。。反正 writer.write("") 這樣寫可以，還得聲明一個 Writer 類型的方法參數。
org.springframework.ui.ModelMap。ModelMap 類型返回值只包含了模型數據信息而沒有視圖信息，框架將根據請求的路徑來提取視圖信息。
void。沒有任何返回值，視圖信息將從請求路徑中提取，模型數據需要通過其它形式提供。


        String 類型的返回值爲 null, 還有返回類型爲 ModelMap 和 void，從請求路徑中如何提取視圖信息呢？框架將截取請求路徑中的最後一個 / 後面的內容，並去掉後綴名，剩下來的內容就是視圖名。如請求路徑爲 /spring3/user/welcome，那麼視圖名是 welcome，/spring3/user/welcome.action 的視圖名也是 welcome。 


        接下來來講最後一個部分，請求參數到方法參數的綁定。這個在 @RequestParam 中已經講過，不過，這裏要講的是綁定複雜的對象。在 @RequestParam 中，我們這樣請求，date=2011-01-01 其實是綁定不到 Date 對象的。因爲不同的 Locale 處理日期的字符串的表達方式不一樣。總之，這部分涉及到字符串到對象的轉換，這很像 PropertyEditor，對吧？Spring MVC 中，可以爲某個 Controller 定製數據綁定，即在被標註了 @InitBinder 的方法裏寫綁定邏輯，方法名可以隨意，如： 
Java代碼   

/** 
 * 初始化方法不能有返回值，而且至少應該有一個類型爲 org.springframework.web.bind.WebDataBinder 的 
 * 方法參數。同時，一個典型的基於註解的 Controller 的處理方法可以使用的方法參數中，除了 Command 對象 
 * 以及相關的 Errors/BindingResult 對象作爲方法的參數外，都可以作爲初始化方法的參數。 
 * 
 * 這裏，我們沒有必要爲日期再定製自定義綁定規則，Spring 已經爲我們提供了 CustomDateEditor，這裏只是演 
 * 示如何提供自定義數據綁定規則。 
 * 
 * 這裏的 WebDataBinder，是不是很像 PropertyEditorRegistry？ 
 */  
@InitBinder  
public void initBinder(WebDataBinder binder) {  
  binder.registerCustomEditor(Date.class, new PropertyEditorSupport() {  
    
    final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");  
      
    @Override  
    public void setAsText(String text) throws IllegalArgumentException {  
      try {  
        Date date = sf.parse(text);  
        setValue(date);  
      } catch (ParseException e) {  
        Date data = sf.parse(text);  
        throw new IllegalArgumentException(e);  
      }  
    }  
  })  
}  

        在 Controller 裏使用 @InitBinder 標註的初始化方法只能對一個 Controller 對應的 WebBinder 做定製。如果想在整個應用中共享綁定規則，可以爲 AnnotationMethodHandlerAdapter 指定一個自定義的 org.springframework.web.bind.support.WebBindingInitializer 實例，這樣可以避免在每個 Controller 中都重複定義幾乎相同邏輯的 @InitBinder 的初始化方法。 
Java代碼  

public class MyBindingInitializer implements WebBindingInitializer {  
  
  public void initBinder(WebBinder binder, WebRequest request) {  
    binder.registerCustomEditor(SomeDataType.class, somePropertyEditor)  
    // 如果需要，這裏可以繼續註冊更多的 propertyEditor  
    // ......  
  }  
}  

Xml代碼 

<bean class=""org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter>  
  <property name="webBindingInitializer">  
    <bean class="...MyBindingInitializer" />  
  </property>  
</bean> 

結束該篇文章前，我們來看幾個容易混淆的用於簡化開發的配置： <mvc:annotation-driven />, <context:annotation-config/>, <context:component-scan />。 


        <mvc:annotation-driven /> 會做以下幾件事： 
向 spring 容器中註冊 DefaultAnnotationHandlerMapping。
向 spring 容器中註冊 AnnotationMethodHandlerAdapter。
配置一些 messageconverter。
解決了 @Controller 註解的使用前提配置，即 HandlerMapping 能夠知道誰來處理請求。
        <context:annotation-config /> 會做以下幾件事： 
向 spring 容器中註冊 AutowiredAnnotationBeanPostProcessor。
向 spring 容器中註冊 CommonAnnotationBeanPostProcessor。
向 spring 容器中註冊 PersistenceAnnotationBeanPostProcessor。
向 spring 容器中註冊 RequiredAnnotationBeanPostProcessor。
使用 <context:annotationconfig />之前，必須在 <beans> 元素中聲明 context 命名空間 <context:component-scan />。<context:component-scan /> 對包進行掃描，實現註解驅動 Bean 定義。即，將 @Controller 標識的類的 bean 註冊到容器中。
        <context:component-scan/>，不但啓用了對類包進行掃描以實施註解驅動 Bean 定義的功能，同時還啓用了註解驅動自動注入的功能（即還隱式地在內部註冊了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor）。因此當使用 <context:component-scan /> 後，除非需要使用PersistenceAnnotationBeanPostProcessor 和 RequiredAnnotationBeanPostProcessor 兩個 Processor 的功能（例如 JPA 等），否則就可以將 <context:annotation-config /> 移除了。
 
 小結：
Json格式的輸出
 1：使用@responseBody來設置輸出內容爲context body
 2：返回值設置爲ResponseEntity<?>類型，以返回context body
 3：使用ContentNegotiatingViewResolver來設置輸出爲json格式