SpringMVC學習二：註解之註解詳細解釋
● @Controller javascript
/**
* @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(將請求參數綁定到方法參數) web
@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 裏的參數綁定到方法參數) spring
@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(將請求正文綁定到方法參數) json
/**
* 來看一個 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(將處理完請求後返回的對象綁定到響應正文) 服務器
/**
* 上面的 @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 session
/**
* @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 mvc
/**
* @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。 app
接下來來說最後一個部分，請求參數到方法參數的綁定。這個在 @RequestParam 中已經講過，不過，這裏要講的是綁定複雜的對象。在 @RequestParam 中，咱們這樣請求，date=2011-01-01 實際上是綁定不到 Date 對象的。由於不一樣的 Locale 處理日期的字符串的表達方式不同。總之，這部分涉及到字符串到對象的轉換，這很像 PropertyEditor，對吧？Spring MVC 中，能夠爲某個 Controller 定製數據綁定，即在被標註了 @InitBinder 的方法裏寫綁定邏輯，方法名能夠隨意，如： 框架
/**
* 初始化方法不能有返回值，並且至少應該有一個類型爲 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 的初始化方法。
public class MyBindingInitializer implements WebBindingInitializer {
public void initBinder(WebBinder binder, WebRequest request) {
binder.registerCustomEditor(SomeDataType.class, somePropertyEditor)
// 若是須要，這裏能夠繼續註冊更多的 propertyEditor
// ......
}
}
<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:annotation-config />以前，必須在 <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 /> 移除了。
相關文章
- 1. spring 註解詳細解釋
- 2. spring註解詳細解釋
- 3. springmvc 註解二
- 4. Spring的 @Autowired註解的詳細解釋
- 5. SpringMVC RequestMapping註解詳解
- 6. SpringMVC註解開發詳解
- 7. Java註釋詳解
- 8. JAP註釋詳解
- 9. JAVADOC註釋詳解
- 10. java自定義註解學習（二）_註解詳解
- 更多相關文章...
- • SQLite Explain（解釋） - SQLite教程
- • R 註釋 - R 語言教程
- • Flink 數據傳輸及反壓詳解
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. spring 註解詳細解釋
- 2. spring註解詳細解釋
- 3. springmvc 註解二
- 4. Spring的 @Autowired註解的詳細解釋
- 5. SpringMVC RequestMapping註解詳解
- 6. SpringMVC註解開發詳解
- 7. Java註釋詳解
- 8. JAP註釋詳解
- 9. JAVADOC註釋詳解
- 10. java自定義註解學習（二）_註解詳解