終於來到了基於註解的 Spring MVC 了。之前我們所講到的 handler，需要根據 url 並通過 HandlerMapping 來映射出相應的 handler 並呼叫相應的方法以響應請求。實際上，ControllerClassNameHandlerMapping, MultiActionController 和選擇恰當的 methodNameResolver(如 InternalPathMethodNameResolver) 就已經可以在很大程度上幫助我們省去不少的 XML 配置，誰讓 ControllerClassNameHandlerMapping 極度的擁抱了 Convention Over Configuration 呢。

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

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

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

1. /**
2.  * @Controller，類級別上的註解。我們定義的類可以只是一個 javabean，不需要實現任何介面。標註了
3.  * @Controller，藉助 <context:component-scan>，框架能自動識別到這就是一個 Controller
4.  */
5. @Controller
6. publicclass MyController {  
7. // ......
8. }  

1. /**
2.  * @RequestMapping 可以出現在類級別上，也可以出現在方法上。如果出現在類級別上，那請求的 url 為 類級別
3.  * 上的 @RequestMapping + 方法級別上的 @RequestMapping，否則直接取方法級上的 @RequestMapping。
4.  * 類級別的 @RequestMapping 不是必需的。
5.  */
6. @Controller
7. @RequestMapping("/my")  
8. publicclass MyController {  
9. /**
10.    * 由於類級別上定義了 @RequestMapping，那麼想匹配到這個方法來處理請求，url 必須為 /my/somelist。
11.    * 如果沒有定義類級別上的 @RequestMapping，url 為 /somelist 即可。同時，請求方法必須為 POST
12.    */
13. @RequestMapping(value="/somelist", method=RequestMethod.POST);  
14. public String getSomeList() {...}  
15. /**
16.      * 在方法級別使用 @RequestMapping 來限定請求處理的時候，可以指定兩個屬性。除了我們在上面剛使用過的
17.      * method 屬性，還有一個 params 屬性。使用 params 屬性，可以達到與使用
18.      * ParameterMethodNameResolver 作為 MethodResolver的 MultiActionController 類似的功能。
19.      *
20.      * params 有兩種表達形式，這裡先說第一種："parameterName=parameterValue"
21.      *
22.      * 請求方法為 GET 或 POST，且具有 hello 引數，且值為 world 的請求才能匹配到該方法，如：
23.      *   /my?hello=world
24.      */
25. @RequestMapping(params="hello=world", method={RequestMethod.GET, RequestMethod.POST})  
26. public String helloworld() {...}  
27. /**
28.      * 請求方法為 GET 或 POST，且具有 hello 引數，且值為 java 的請求才能匹配到該方法，如：
29.      *   /my?hello=java
30.      */
31. @RequestMapping(params="hello=java", method={RequestMethod.GET, RequestMethod.POST})  
32. public String hellojava() {...}  
33. /**
34.      * params 屬性的另外一種表達形式為："parameter"
35.      *
36.      * 請求方法為 GET，且具有請求引數 java 即匹配此方法，而不管 java 引數的值是什麼，如：
37.      *   /my?java=anything
38.      */
39. @RequestMapping(params="java", method={RequestMethod.GET})  
40. public String java() {...}  
41. /**
42.      * 請求方法為 GET，且具有請求引數 cplusplus 即匹配此方法，而不管 cplusplus 引數的值是什麼，如：
43.      *   /my?cplusplus=anything
44.      */
45. @RequestMapping(params="cplusplus", method={RequestMethod.GET})  
46. public String cplusplus() {...}  
47. /**
48.      * @RequestMapping 還有一個引數化 headers，它和 params 非常相似，也有兩種表示式，只不過它是對
49.      * 請求頭做限制罷了。大家可以通過 telnet 或 http-client 來發類似的請求以檢驗。以 telnet 為例：
50.      * 
51.      * telnet localhost 8080
52.      * POST /contextPath/my HTTP/1.1
53.      * Host: localhost
54.      * hello: world # 這個就是自定義請求頭，和標準的請求頭的寫法別無二致
55.      * 【回車】
56.      * 【回車】
57.      */
58. @RequestMapping(headers="hello=world", method={RequestMethod.POST})  
59. public String cplusplus() {...}  
60. }  

1. @Controller
2. @RequestMapping("/my")  
3. publicclass MyController {  
4. /**
5.    * 注意，這裡的方法有一個引數。若請求 url 為 /my/test，會匹配此方法。這裡的方法的引數名為 userId，
6.    * 那麼請求引數中一定有名為 userId 的引數，且值為整數。這也是預設的繫結行為，它是根據名稱匹配原則進行
7.    * 的資料繫結。當請求中的引數名與方法名一致的時候，相應的引數值將被繫結到相應的方法引數上。
8.    * 
9.    * 如果沒有傳遞 userId 引數，框架會傳入 null。可是這裡我們定義的是 primitive type，異常伺候！若
10.    * 要解決此問題，需要將 primitive type 定義成相應的 wrapper type 即可，這裡使用 Integer 就行了。
11.    *
12.    * 如果傳遞了 userId 引數，但值不是整數，你叫 test 怎麼辦呢？這種情況下，框架藉助 PropertyEditor 
13.    * 資料型別轉換失敗，ExceptionResolver 會接手處理，請求是不會進入 test 方法的。
14.    *
15.    * 這種方式下，預設的繫結行為需要我們嚴格遵守命名一致性原則。如果我們對此不滿，想自定義繫結關係，可以求
16.    * 助於 @RequestParam。
17.    */
18. @RequestMapping("/test")  
19. public String test(int userId) { ... }  
20. /**
21.    * 當我們不想使用 userId 作為方法的引數名，即不想使用預設的資料繫結方式。如果我們要使用 id 作為方法
22.    * 的引數，為了保證名稱為 userId 的請求引數可以繫結到新的名稱為 id 的方法引數上，我們就可以使用 
23.    * @RequestParam 對這一引數進行標註。@RequestParam 只可以標註於方法引數上。
24.    *
25.    * 如果請求引數中有 age，和方法的引數名稱一致，故 age 引數不需要 @RequestParam 標註。如果沒有傳遞
26.    * age，我們又不想定義成 Integer，很顯然框架會注入 null 值，報錯是必然的。這是由於 @RequestParam 
27.    * 的 required 屬性決定的，預設就是 true。如果我們定義成 false，
28.    * 即 @RequestParam(required=false) int age
29.    * 這個時候定義成 int 型的 age，即便請求引數沒有 age 引數，也是沒問題的。
30.    *
31.    * 同時，這裡還能繫結 Date 型別，User 物件型別等等。如 date=2011-01-01&userName=Tom&userAge=18
32.    * 這裡，User 類的屬性需要為 userName 和 userAge，以免和 age，name 混淆。所以，Spring MVC 對物件
33.    * 的資料繫結就沒有 Struts2 做的那麼好了，Strtus2 可以這樣：user.age=18&user.name=Tom
34.    */
35. @RequestMapping("/test2")  
36. public String test2(@RequestParam("userId") int id, int age, Date date, User user) { ... }  
37. }  

1. @Controller
2. @RequestMapping("/my")  
3. publicclass MyController {  
4. /**
5.    * @PathVariable 是 url 模板，需要和 @RequestMapping 配合起來使用，這是 Spring 3.0 之後引入的。
6.    *
7.    * 在這個例子中，請求的 url 必須滿足類似 /my/user/zhangsan/18 這樣的格式才能匹配方法。url 模板裡
8.    * 的引數名和方法引數名的繫結規則和 @RequestParam 類似，這裡就不再贅述了。
9.    *
10.    * @PathVariable 和 @RequestParam 的區別在於：
11.    *   @PathVariable 的 url：/my//user/zhangsan/18
12.    *   @RequestParam 的 url：/my//user?nickname=zhangsan&age=18
13.    */
14. @RequestMapping("/user/{nickname}/{age}");  
15. public String getUserInfo(@PathVariable("nickname") String name, @PathVariableint age) {...}  
16. }  

1. /**
2.  * 來看一個 http 請求：
3.  * (請求行) POST /my HTTP/1.1
4.  * (請求頭) Host: localhost
5.  * (請求頭) Content-Type: text/plain
6.  * (請求頭) Content-Length: 5
7.  *
8.  * (請求體) hello
9.  *
10.  * 這裡的 hello，就是請求體，也稱 request message。若有請求體，則必須提供請求體的型別和長度，這些信
11.  * 息是寫在請求頭裡的，即 Content-Type 和 Content-Length
12.  */
13. @Controller
14. @RequestMapping("/my")  
15. publicclass MyController {  
16. /**
17.    * 我們定義的 body 的資料型別是 String，請求體嘛，肯定是 String。實際上，@RequestBody 是用於將請
18.    * 求體的內容繫結到方法引數上，資料型別不一定是 String。Spring MVC 是通過 HttpMessageConverter
19.    * 來完成這種轉換的。AnnotationMethodHandlerAdapter 預設註冊了一些 HttpMessageConverters：
20.    *   ByteArrayHttpMessageConverter - converts byte arrays
21.    *   StringHttpMessageConverter - converts strings
22.    *   FormHttpMessageConverter - converts form data to/from MultiValueMap<String,String>
23.    *   SourceHttpMessageConverter - convert to/from a javax.xml.transform.Source
24.    *   MappingJacksonHttpMessageConverter - converts json
25.    *   MarshallingHttpMessageConverter - convert to/from an object using the 
26.    *                                     org.springframework.oxm package.
27.    *
28.    * 正如上所述，HttpMessageConverter 用於從請求正文繫結到物件和把物件序列化成 String 予客戶端響應。
29.    * 即 HttpMessageConverter is responsible for converting from the HTTP request message to
30.    * an object and converting from an object to the HTTP response body
31.    *
32.    * 我們可以在 AnnotationMethodHandlerAdapter 定義任意多的 HttpMessageConverters。
33.    *
34.    * 既然 HttpMessageConverter 可以用於雙向 convert，這裡討論的是 @RequestBody，那這部分我們只講 
35.    * converting from the HTTP request message to an object。
36.    *
37.    * 假設我們只向 AnnotationMethodHandlerAdapter 注入了 MappingJacksonHttpMessageConverter 和
38.    * MarshallingHttpMessageConverter。處理請求的方法有如下簽名：
39.    *     public String test(@RequestBody User user) { ... }
40.    *
41.    * 不管請求正文的內容是什麼，對於客戶端和伺服器而言，它們只是用文字來互相通訊。把字串轉為 User 對
42.    * 象，該用哪個 HttpMessageConverter 來完成此項工作呢？
43.    *
44.    * 在定義 HttpMessageConverters 時，我們可以為其指定 supportedMediaTypes。對於將請求正文轉為物件
45.    * 這個方向的操作，HttpMessageConverters 會從請求頭得到 Content-Type 頭資訊，看其是否隸屬於其定義
46.    * 的 supportedMediaTypes。若沒有匹配上，則會使用下一個 HttpMessageConverter 做同樣的判斷。只要
47.    * 某個 HttpMessageConverter 支援請求頭中的 Content-Type，那麼就會應用此 HttpMessageConverter
48.    * 來將 String 轉為 Object。當然，若請求正文並沒有按照 Content-Type 所規定的格式來編寫，必然要收到
49.    * 500 的響應。同時請注意，請求頭中還必須提供 Content-Length，否則拿不到請求正文。
50.    *
51.    * 如果所有的 HttpMessageConverters 中定義的 supportedMediaTypes 均不能匹配上 Content-Type 請
52.    * 求頭中的型別，那麼就會收到 415 Unsupported Media Type 響應。
53.    */
54. @RequestMapping("/user/body");  
55. public String getBody(@RequestBody String body) {  
56. // 這裡的 body 的內容就是 hello
57.     System.out.println(body);  
58. returnnull;  
59.   }  
60. }  

1. /**
2.  * 上面的 @RequestBody 講了 HttpMessageConverter 從請求正文到物件轉換的方向，現在來講講另外一個方
3.  * 向，@ResponseBody，此時，HttpMessageConverter 用於將處理完請求後返回的物件序列化成字串，即
4.  * converting from an object to the HTTP response body.
5.  */
6. @Controller
7. @RequestMapping("/my")  
8. publicclass MyController {  
9. /**
10.    * 該方法的返回型別是 User，並不符合含有 @RequestMapping 的註解所需的簽名方式。但它仍然是合法的，因
11.    * 為在返回型別前有 @ResponseBody 註解，此註解將告知框架，將 User 物件作為影響正文返回？什麼？物件
12.    * 作為響應正文！所以，HttpMessageConverter 在這裡就起到作用了。這裡討論的是 @ResponseBody，所以
13.    * 這裡我們只講 converting from an object to the HTTP response body。
14.    *
15.    * User 物件要轉成什麼樣的 String，或者說要轉成什麼格式的 String？這個時候需要從請求頭中獲得此資訊
16.    * 了，這裡，就是請求頭的 Accept 頭。Accept 頭可以使用逗號分隔定義多個型別，用以告知伺服器我只接受
17.    * 哪些型別的響應。AnnotationMethodHandlerAdapter 中同樣注入了多個 HttpMessageConverter，每個 
18.    * HttpMessageConverter 都可以定義各自的 supportedMediaTypes。這個時候該用哪個 
19.    * HttpMessageConverter 來完成物件到文字的序列化操作呢？
20.    *
21.    * 遍歷 Accept 頭中的每種媒體型別，在定義的多個 HttpMessageConverters 中依次去匹配，若匹配上，就使
22.    * 用該 HttpMessageConverter 來完成序列化操作，並且響應頭的 Content-Type 並不是請求頭 Accept 頭
23.    * 的諸多型別中第一個被匹配的型別，而是匹配到的 HttpMessageConverter 定義的 supportedMediaTypes
24.    * 中的第一個型別。
25.    *
26.    * 如果所有的 HttpMessageConverters 中定義的 supportedMediaTypes 均不能匹配上 Accept 請求頭中
27.    * 的諸多的型別，那麼就會收到 406 Not Acceptable 響應。
28.    */
29. @RequestMapping("/user")  
30. public@ResponseBody User getUser() {  
31. returnnew User(18, "Jack", "計算機");  
32.   }  
33. }  

1. /**
2.  * @ModelAttribute 可以為檢視渲染提供更多的模型資料，而不需要在處理請求的方法裡新增 ModelMap 或
3.  * Model 型別的引數。
4.  *
5.  * @ModelAttribute 可以標註在方法(存資料)上，也可以標註在方法引數(取資料)上。
6.  */
7. @Controller
8. @RequestMapping("/my")  
9. publicclass MyController {  
10. /**
11.    * 在處理該請求時，方法的返回型別是 User，貌似不符合返回型別的規範。由於這裡使用了 @ModelAttribute
12.    * 註解，表示將返回的物件以 "user" 為 key 放入模型資料裡。這裡的 key 值預設值是返回的資料型別首字母
13.    * 小寫的結果。如果想自定義 key，可以寫成 @ModelAttribute("myAttribute")，那麼模型資料將會將 
14.    * User 物件繫結到 key 為 "myAttribute" 上。
15.    * 
16.    * jsp 裡可以這樣訪問模型裡的資料：
17.    *   age: ${user.age}
18.    *   name: ${user.name}
19.    *   job: ${user.job}
20.    *
21.    * 當然，這裡只是提到了 @ModelAttribute 存資料的操作。
22.    */
23. @RequestMapping("/user")  
24. @ModelAttribute
25. public User getUser() {  
26. returnnew User(18, "Jack", "計算機");  
27.   }  
28. /**
29.    * 這裡將 @ModelAttribute 標註在方法引數上，表示要從模型資料裡取 key 為 "user" 的物件，繫結在方法
30.    * 引數上。如果這樣做的話，其實你是得不到上面的那個請求放入的 User 物件，得到的是另外一個物件。其實
31.    * 也好理解，這是兩個互相獨立的請求，作用域不一樣。要想達到我們的目的，即能夠從模型資料裡取資料，需要
32.    * 求助於 @SessionAttributes
33.    */
34. @RequestMapping("/user2")  
35. public String showUser(@ModelAttribute User user) {  
36.     System.out.println(user);  
37. returnnull;  
38.   }  
39. }  

1. /**
2.  * @SessionAttributes 和 @ModelAttribute 類似，只不過 @SessionAttributes 是將資料存放於 session 
3.  * 中或從 session 中取資料。
4.  *
5.  * @SessionAttributes 只能應用在型別宣告上。比如下面的類的宣告中，只有屬性名為 "the-attribute" 的數
6.  * 據才會納入到 session 的管理。
7.  *
8.  * @SessionAttributes 允許以屬性名名稱或者型別兩種方法，來表明將哪些資料通過 session 進行管理。這裡
9.  * 我們使用的是指定屬性名稱的方式，但通過型別來指定也是可行的，如：
10.  *   @SessionAttributes(types=User.class)
11.  */
12. @Controller
13. @RequestMapping("/my")  
14. @SessionAttributes("the-attribute")  
15. publicclass MyController {  
16. @RequestMapping("/getUser")  
17. public String getUser(int userId, Model model) {  
18. /**
19.      * 注意，這裡將 User 物件新增到屬性名為 "the-attribute" 上，所以 User 物件將納入到 session 的
20.      * 管理。如果這裡新增的物件的屬性名不是 "the-attribute"，那麼它只會作用於當前請求，而不會納入到 
21.      * session 的管理中。
22.      */
23.     User user = userService.getUserById(userId);  
24.     model.addAtrribute("the-attribute", user);  
25. return"userinfo";  
26.   }  
27. /**
28.    * 將模型裡的 "the-attribute" 為 key 的物件繫結到 User 類上。由於在類級別上聲明瞭只有 "the-
29.    * attribute" 的屬性名才會納入到 session 的管理，所以就解決了在 @ModelAttribute 註解中講解中最
30.    * 後提到的問題。
31.    *
32.    * 另外，這個方法還有兩個引數，BindingResult 和 SessionStatus。由於這裡有繫結資料的動作，我們可以
33.    * 根據 BindingResult 物件獲得資料繫結結果以決定後繼流程該如何處理。SessionStatus 在這裡用於處理
34.    * 完請求後，清空 session 裡的資料。
35.    */
36. @RequestMapping("/updateUser")  
37. public String updateUser(@ModelAttribute("the-attribute") User user,   
38.             BindingResult result, SessionStatus status) {  
39. if (result.hasErrors) {  
40. return"error";  
41.     }  
42.     userService.updateUser(user);  
43. // 我們通過呼叫 status.setComplete() 方法，該 Controller 所有放在 session 級別的模型屬性資料
44. // 將從 session 中清空
45.     status.setComplete();  
46. return"redirect:getUser?userId=" + user.getId();  
47.   }  
48. }  

• 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 中的指定的資料。

• org.springframework.web.servlet.ModelAndView。這個不用多說，檢視資訊和模型資訊都能通過它返回。
• java.lang.String。該型別返回值代表邏輯檢視名，模型資料需要以其它形式提供，比如為處理方法宣告一個 ModelMap 型別的引數。注意，如果返回 null，並不代表向客戶端輸出空頁面(定向思維惹的禍)，這種情況下，框架會從請求路徑中提取檢視資訊。如果返回 null 就是要表示方法內部已處理完請求，也不需要通知頁面，就是想僅僅返回空白頁面，唉，我還沒有想出來咋整。。。反正 writer.write("") 這樣寫可以，還得宣告一個 Writer 型別的方法引數。
• org.springframework.ui.ModelMap。ModelMap 型別返回值只包含了模型資料資訊而沒有檢視資訊，框架將根據請求的路徑來提取檢視資訊。
• void。沒有任何返回值，檢視資訊將從請求路徑中提取，模型資料需要通過其它形式提供。

1. /**
2.  * 初始化方法不能有返回值，而且至少應該有一個型別為 org.springframework.web.bind.WebDataBinder 的
3.  * 方法引數。同時，一個典型的基於註解的 Controller 的處理方法可以使用的方法引數中，除了 Command 物件
4.  * 以及相關的 Errors/BindingResult 物件作為方法的引數外，都可以作為初始化方法的引數。
5.  *
6.  * 這裡，我們沒有必要為日期再定製自定義繫結規則，Spring 已經為我們提供了 CustomDateEditor，這裡只是演
7.  * 示如何提供自定義資料繫結規則。
8.  *
9.  * 這裡的 WebDataBinder，是不是很像 PropertyEditorRegistry？
10.  */
11. @InitBinder
12. publicvoid initBinder(WebDataBinder binder) {  
13.   binder.registerCustomEditor(Date.class, new PropertyEditorSupport() {  
14. final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");  
15. @Override
16. publicvoid setAsText(String text) throws IllegalArgumentException {  
17. try {  
18.         Date date = sf.parse(text);  
19.         setValue(date);  
20.       } catch (ParseException e) {  
21.         Date data = sf.parse(text);  
22. thrownew IllegalArgumentException(e);  
23.       }  
24.     }  
25.   })  
26. }  

1. publicclass MyBindingInitializer implements WebBindingInitializer {  
2. publicvoid initBinder(WebBinder binder, WebRequest request) {  
3.     binder.registerCustomEditor(SomeDataType.class, somePropertyEditor)  
4. // 如果需要，這裡可以繼續註冊更多的 propertyEditor
5. // ......
6.   }  
7. }  

1. <beanclass=""org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter>
2. <propertyname="webBindingInitializer">
3. <beanclass="...MyBindingInitializer"/>
4. </property>
5. </bean>

1. 向 spring 容器中註冊 DefaultAnnotationHandlerMapping。
2. 向 spring 容器中註冊 AnnotationMethodHandlerAdapter。
3. 配置一些 messageconverter。
4. 解決了 @Controller 註解的使用前提配置，即 HandlerMapping 能夠知道誰來處理請求。

1. 向 spring 容器中註冊 AutowiredAnnotationBeanPostProcessor。
2. 向 spring 容器中註冊 CommonAnnotationBeanPostProcessor。
3. 向 spring 容器中註冊 PersistenceAnnotationBeanPostProcessor。
4. 向 spring 容器中註冊 RequiredAnnotationBeanPostProcessor。
5. 使用 <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 /> 移除了。

轉載自：https://my.oschina.net/abian/blog/128028