spring-boot注解詳解(五)

@AutoWired

首先要知道另一個東西，default-autowire，它是在xml文件中進行配置的，可以設置為byName、byType、constructor和autodetect；比如byName，不用顯式的在bean中寫出依賴的對象，它會自動的匹配其它bean中id名與本bean的set**相同的，并自動裝載。
@Autowired是用在JavaBean中的注解，通過byType形式，用來給指定的字段或方法注入所需的外部資源。
兩者的功能是一樣的，就是能減少或者消除屬性或構造器參數的設置，只是配置地方不一樣而已。
autowire四種模式的區別：
先看一下bean實例化和@Autowired裝配過程：

一切都是從bean工廠的getBean方法開始的，一旦該方法調用總會返回一個bean實例，無論當前是否存在，不存在就實例化一個并裝配，否則直接返回。（Spring
MVC是在什么時候開始執行bean的實例化過程的呢？其實就在組件掃描完成之后)
實例化和裝配過程中會多次遞歸調用getBean方法來解決類之間的依賴。
Spring幾乎考慮了所有可能性，所以方法特別復雜但完整有條理。
@Autowired最終是根據類型來查找和裝配元素的，但是我們設置了后會影響最終的類型匹配查找。因為在前面有根據BeanDefinition的autowire類型設置PropertyValue值得一步，其中會有新實例的創建和注冊。就是那個autowireByName方法。

下面通過@Autowired來說明一下用法
Setter 方法中的 @Autowired 你可以在 JavaBean中的 setter 方法中使用 @Autowired 注解。當
Spring遇到一個在 setter 方法中使用的 @Autowired 注解，它會在方法中執行 byType 自動裝配。這里是
TextEditor.java 文件的內容：

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {private SpellChecker spellChecker;@Autowiredpublic void setSpellChecker( SpellChecker spellChecker ){this.spellChecker = spellChecker;}public SpellChecker getSpellChecker( ) {return spellChecker;}public void spellCheck() {spellChecker.checkSpelling();}
}

下面是另一個依賴的類文件 SpellChecker.java 的內容：

package com.tutorialspoint;
public class SpellChecker {public SpellChecker(){System.out.println("Inside SpellChecker constructor." );}public void checkSpelling(){System.out.println("Inside checkSpelling." );}  
}

下面是 MainApp.java 文件的內容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");TextEditor te = (TextEditor) context.getBean("textEditor");te.spellCheck();}
}

下面是配置文件 Beans.xml：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd"><context:annotation-config/><!-- Definition for textEditor bean without constructor-arg  --><bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean><!-- Definition for spellChecker bean --><bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean></beans>

一旦你已經完成的創建了源文件和 bean 配置文件，讓我們運行一下應用程序。如果你的應用程序一切都正常的話，這將會輸出以下消息：

Inside SpellChecker constructor. Inside checkSpelling. 屬性中的
@Autowired 你可以在屬性中使用 @Autowired 注解來除去 setter 方法。當時使用
為自動連接屬性傳遞的時候，Spring 會將這些傳遞過來的值或者引用自動分配給那些屬性。所以利用在屬性中 @Autowired
的用法，你的 TextEditor.java 文件將變成如下所示：

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {@Autowiredprivate SpellChecker spellChecker;public TextEditor() {System.out.println("Inside TextEditor constructor." );}  public SpellChecker getSpellChecker( ){return spellChecker;}  public void spellCheck(){spellChecker.checkSpelling();}
}

下面是配置文件 Beans.xml：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd"><context:annotation-config/><!-- Definition for textEditor bean --><bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean><!-- Definition for spellChecker bean --><bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean></beans>

一旦你在源文件和 bean 配置文件中完成了上面兩處改變，讓我們運行一下應用程序。如果你的應用程序一切都正常的話，這將會輸出以下消息：

Inside TextEditor constructor. Inside SpellChecker constructor.
Inside checkSpelling. 構造函數中的 @Autowired 你也可以在構造函數中使用
@Autowired。一個構造函數 @Autowired 說明當創建 bean 時，即使在 XML 文件中沒有使用元素配置 bean
，構造函數也會被自動連接。讓我們檢查一下下面的示例。

這里是 TextEditor.java 文件的內容：


package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {private SpellChecker spellChecker;@Autowiredpublic TextEditor(SpellChecker spellChecker){System.out.println("Inside TextEditor constructor." );this.spellChecker = spellChecker;}public void spellCheck(){spellChecker.checkSpelling();}
}

下面是配置文件 Beans.xml：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd"><context:annotation-config/><!-- Definition for textEditor bean without constructor-arg  --><bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean><!-- Definition for spellChecker bean --><bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean></beans>

一旦你在源文件和 bean 配置文件中完成了上面兩處改變，讓我們運行一下應用程序。如果你的應用程序一切都正常的話，這將會輸出以下消息：

Inside TextEditor constructor.
Inside SpellChecker constructor.
Inside checkSpelling.

@Autowired 的（required=false）選項默認情況下，@Autowired 注解意味著依賴是必須的，它類似于
@Required 注解，然而，你可以使用 @Autowired 的（required=false）選項關閉默認行為。
即使你不為 age 屬性傳遞任何參數，下面的示例也會成功運行，但是對于 name 屬性則需要一個參數。你可以自己嘗試一下這個示例，因為除了只有 Student.java 文件被修改以外，它和 @Required 注解示例是相似的。

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class Student {private Integer age;private String name;@Autowired(required=false)public void setAge(Integer age) {this.age = age;}  public Integer getAge() {return age;}@Autowiredpublic void setName(String name) {this.name = name;}   public String getName() {return name;}

@Qualifier

在Controller中需要注入service那么我的這個server有兩個實現類如何區分開這兩個impl呢？
下面上鋪墊圖

請忽略我的紅線

在Controller中使用 @Autowired注入時

Qualifier的意思是合格者，通過這個標示，表明了哪個實現類才是我們所需要的，添加@Qualifier注解，需要注意的是@Qualifier的參數名稱為我們之前定義@Service注解的名稱之一。
使用@Resource注入時

使用@resource注入時比較簡單了注解自帶了“name”的val就是@Service注解的名稱之一。

@Resource

spring不但支持自己定義的@Autowired注解，還支持幾個由JSR-250規范定義的注解，它們分別是@Resource、@PostConstruct以及@PreDestroy。
　　@Resource的作用相當于@Autowired，只不過@Autowired按byType自動注入，而@Resource默認按 byName自動注入罷了。@Resource有兩個屬性是比較重要的，分是name和type，Spring將@Resource注解的name屬性解析為bean的名字，而type屬性則解析為bean的類型。所以如果使用name屬性，則使用byName的自動注入策略，而使用type屬性時則使用byType自動注入策略。如果既不指定name也不指定type屬性，這時將通過反射機制使用byName自動注入策略。
　　@Resource裝配順序
　　1. 如果同時指定了name和type，則從Spring上下文中找到唯一匹配的bean進行裝配，找不到則拋出異常
　　2. 如果指定了name，則從上下文中查找名稱（id）匹配的bean進行裝配，找不到則拋出異常
　　3. 如果指定了type，則從上下文中找到類型匹配的唯一bean進行裝配，找不到或者找到多個，都會拋出異常
　　4. 如果既沒有指定name，又沒有指定type，則自動按照byName方式進行裝配；如果沒有匹配，則回退為一個原始類型進行匹配，如果匹配則自動裝配；
@Autowired 與@Resource的區別：
1、 @Autowired與@Resource都可以用來裝配bean. 都可以寫在字段上,或寫在setter方法上。

2、 @Autowired默認按類型裝配（這個注解是屬業spring的），默認情況下必須要求依賴對象必須存在，如果要允許null值，可以設置它的required屬性為false，如：@Autowired(required=false) ，如果我們想使用名稱裝配可以結合@Qualifier注解進行使用，如下：

@Autowired()@Qualifier("baseDao")
privateBaseDao baseDao;

3、@Resource（這個注解屬于J2EE的），默認按照名稱進行裝配，名稱可以通過name屬性進行指定，如果沒有指定name屬性，當注解寫在字段上時，默認取字段名進行安裝名稱查找，如果注解寫在setter方法上默認取屬性名進行裝配。當找不到與名稱匹配的bean時才按照類型進行裝配。但是需要注意的是，如果name屬性一旦指定，就只會按照名稱進行裝配。

@Resource(name="baseDao")
privateBaseDao baseDao;

推薦使用：@Resource注解在字段上，這樣就不用寫setter方法了，并且這個注解是屬于J2EE的，減少了與spring的耦合。這樣代碼看起就比較優雅。
@Autowired是根據類型進行自動裝配的。如果當Spring上下文中存在不止一個UserDao類型的bean時，就會拋出BeanCreationException異常;如果Spring上下文中不存在UserDao類型的bean，也會拋出BeanCreationException異常。我們可以使用@Qualifier配合@Autowired來解決這些問題。如下：

①可能存在多個UserDao實例

@Autowired   
@Qualifier("userServiceImpl")   
public IUserService userService;

@Autowired   
public void setUserDao(@Qualifier("userDao") UserDao userDao) {   this.userDao = userDao;   
}

這樣Spring會找到id為userServiceImpl和userDao的bean進行裝配。

②可能不存在UserDao實例

@Autowired(required = false)   
public IUserService userService

個人總結：

@Autowired//默認按type注入
@Qualifier(“cusInfoService”)//一般作為@Autowired()的修飾用
@Resource(name=“cusInfoService”)//默認按name注入，可以通過name和type屬性進行選擇性注入

一般@Autowired和@Qualifier一起用，@Resource單獨用。

當然沒有沖突的話@Autowired也可以單獨用
-----------常用注解--------

–定義Bean的注解

@Controller

@Controller(“Bean的名稱”)

定義控制層Bean,如Action

@Service

@Service(“Bean的名稱”)

定義業務層Bean

@Repository

@Repository(“Bean的名稱”)

定義DAO層Bean

@Component

定義Bean, 不好歸類時使用.

–自動裝配Bean （選用一種注解就可以）

@Autowired (Srping提供的)

默認按類型匹配,自動裝配(Srping提供的)，可以寫在成員屬性上,或寫在setter方法上

@Autowired(required=true)

一定要找到匹配的Bean，否則拋異常。默認值就是true

@Autowired

@Qualifier(“bean的名字”)

按名稱裝配Bean,與@Autowired組合使用，解決按類型匹配找到多個Bean問題。

@Resource JSR-250提供的

默認按名稱裝配,當找不到名稱匹配的bean再按類型裝配.

可以寫在成員屬性上,或寫在setter方法上

可以通過@Resource(name=“beanName”) 指定被注入的bean的名稱, 要是未指定name屬性, 默認使用成員屬性的變量名,一般不用寫name屬性.

@Resource(name=“beanName”)指定了name屬性,按名稱注入但沒找到bean, 就不會再按類型裝配了.

@Inject 是JSR-330提供的

按類型裝配，功能比@Autowired少，沒有使用的必要。

–定義Bean的作用域和生命過程

@Scope(“prototype”)

值有:singleton,prototype,session,request,session,globalSession

@PostConstruct

相當于init-method,使用在方法上，當Bean初始化時執行。

@PreDestroy

相當于destory-method，使用在方法上，當Bean銷毀時執行。

–聲明式事務

@Transactional

@Autowired @Resource @Qualifier的區別

實用理解：@Autowired @Resource 二選其一，看中哪個就用哪個。

簡單理解：

@Autowired 根據類型注入，

@Resource 默認根據名字注入，其次按照類型搜索

@Autowired @Qualifie(“userService”) 兩個結合起來可以根據名字和類型注入
復雜理解：

比如你有這么一個Bean

@Service(“UserService”)public Class UserServiceImpl implements UserService｛｝;現在你想在UserController 里面使用這個UserServiceImpl public Class UserController ｛

@AutoWire //當使用這個注入的時候上面的 UserServiceImpl 只需要這樣寫 @Service，這樣就會自動找到UserService這個類型以及他的子類型。UserServiceImpl 實現了UserService，所以能夠找到它。不過這樣有一個缺點，就是當UserService實現類有兩個以上的時候，這個時候會找哪一個呢，這就造成了沖突，所以要用@AutoWire注入的時候要確保UserService只有一個實現類。

@Resource 默認情況下是按照名稱進行匹配，如果沒有找到相同名稱的Bean，則會按照類型進行匹配，有人可能會想了，這下好了，用這個是萬能的了，不用管名字了，也不用管類型了，但這里還是有缺點。首先，根據這個注解的匹配效果可以看出，它進行了兩次匹配，也就是說，如果你在UserService這個類上面這樣寫注解，@Service,它會怎么找呢，首先是找相同名字的，如果沒有找到，再找相同類型的，而這里的@Service沒有寫名字，這個時候就進行了兩次搜索，顯然，速度就下降了許多。也許你還會問，這里的@Service本來就沒有名字，肯定是直接進行類型搜索啊。其實不是這樣的，UserServiceImpl 上面如果有@Service默認的名字是這個userServiceImpl，注意看，就是把類名前面的大寫變成小寫，就是默認的Bean的名字了。 @Resource根據名字搜索是這樣寫@Resource(“userService”)，如果你寫了這個名字叫userService，那么UserServiceImpl上面必須也是這個名字，不然還是會報錯。

@Autowired @Qualifie(“userService”) 是直接按照名字進行搜索，也就是說，對于UserServiceImpl 上面@Service注解必須寫名字，不寫就會報錯，而且名字必須是@Autowired @Qualifie(“userService”) 保持一致。如果@Service上面寫了名字，而@Autowired @Qualifie() ，一樣會報錯。

private UserService userService;｝

說了這么多，可能你有些說暈了，那么怎么用這三個呢，要實際的工作是根據實際情況來使用的，通常使用AutoWire和@Resource多一些，bean的名字不用寫，而UserServiceImpl上面能會這樣寫 @Service(“userService”)。這里的實際工作情況，到底是什么情況呢？說白了就是整個項目設計時候考慮的情況，如果你的架構設計師考慮的比較精細，要求比較嚴格，要求項目上線后的訪問速度比較好，通常是考慮速度了。這個時候@AutoWire沒有@Resource好用，因為@Resource可以根據名字來搜索，是這樣寫的@Resource(“userService”)。這個@Autowired @Qualifie(“userService”) 也可以用名字啊，為什么不用呢，原因很簡單，這個有點長，不喜歡，增加工作量。因為根據名字搜索是最快的，就好像查數據庫一樣，根據Id查找最快。因為這里的名字與數據庫里面的ID是一樣的作用。這個時候，就要求你多寫幾個名字，工作量自然就增加了。而如果你不用注解，用xml文件的時候，對于注入Bean的時候要求寫一個Id，xml文件時候的id就相當于這里的名字。

說了那么多沒用，你能做的就是簡單直接，什么最方便就用什么，

你就直接用@Resource得了，如果你喜歡用@AutoWire也行，不用寫名字。

通常情況一個Bean的注解寫錯了，會報下面這些錯誤，最為常見，

No bean named ‘user’ is defined，這個表示沒有找到被命名為user的Bean，通俗的說，就是名字為user的類型，以及它的子類型，出現這個錯誤的原因就是注入時候的類型名字為user，而搜索的時候找不到，也就是說可能那個搜索的類型，并沒有命令為user，解決辦法就是找到這個類型，去命令為user，

下面這個錯誤也常見，
No qualifying bean of type [com.service.UserService] found for dependency:

這個錯誤的原因就是類型上面沒有加@Service這個注入，不僅僅是@Service，如果是其他層也會出現這個錯誤，這里我是以Service為例子說明，如果是DAO層就是沒有加@Repository，Controller層，則是沒有加@Controller。

還有，如果你還是想再簡單點，無論是DAO,Controller，Service三個層，都可以用這個注解，@Component，這個注解通用所有的Bean，這個時候你可能會說了，有通常的為什么用的人少呢，那是因為MVC這個分層的設計原則，用@Repository,@Service，@Controller，這個可以區別MVC原則中的DAO,Service，Controller。便于識別。
在使用Spring框架中@Autowired標簽時默認情況下使用
注釋進行自動注入時，Spring 容器中匹配的候選 Bean 數目必須有且僅有一個。當找不到一個匹配的 Bean 時，Spring 容器將拋出 BeanCreationException 異常，并指出必須至少擁有一個匹配的 Bean。
@Autowired 默認是按照byType進行注入的，如果發現找到多個bean，則，又按照byName方式比對，如果還有多個，則報出異常。

例子：

@Autowired
private ExamUserMapper examUserMapper; - ExamUserMapper是一個接口

spring先找類型為ExamUserMapper的bean
如果存在且唯一，則OK；
如果不唯一，在結果集里，尋找name為examUserMapper的bean。因為bean的name有唯一性，所以，到這里應該能確定是否存在滿足要求的bean了

@Autowired也可以手動指定按照byName方式注入，使用@Qualifier標簽，例如：
@Autowired () @Qualifier ( “baseDao” )

Spring 允許我們通過
@Qualifier
注釋指定注入 Bean 的名稱，這樣歧義就消除了，可以通過下面的方法解決異常。
@Qualifier(“XXX”)
中的 XX是 Bean 的名稱，所以 @Autowired 和 @Qualifier 結合使用時，自動注入的策略就從 byType 轉變成 byName 了。

@Autowired 可以對成員變量、方法以及構造函數進行注釋，而 @Qualifier 的標注對象是成員變量、方法入參、構造函數入參。

Spring不但支持自己定義的@Autowired注解，還支持幾個由JSR-250規范定義的注解，它們分別是@Resource、@PostConstruct以及@PreDestroy。 
@Resource

的作用相當于@Autowired，只不過@Autowired按byType自動注入，而@Resource默認按 byName自動注入罷了。@Resource有兩個屬性是比較重要的，分是name和type，Spring將@Resource注解的name屬性解析為bean的名字，而type屬性則解析為bean的類型。所以如果使用name屬性，則使用byName的自動注入策略，而使用type屬性時則使用byType自動注入策略。如果既不指定name也不指定type屬性，這時將通過反射機制使用byName自動注入策略。

@Resource裝配順序
　　1. 如果同時指定了name和type，則從Spring上下文中找到唯一匹配的bean進行裝配，找不到則拋出異常
　　2. 如果指定了name，則從上下文中查找名稱（id）匹配的bean進行裝配，找不到則拋出異常
　　3. 如果指定了type，則從上下文中找到類型匹配的唯一bean進行裝配，找不到或者找到多個，都會拋出異常
　　4. 如果既沒有指定name，又沒有指定type，則自動按照byName方式進行裝配；如果沒有匹配，則回退為一個原始類型進行匹配，如果匹配則自動裝配

@RequestMapping

@RequestMapping 是 Spring Web 應用程序中最常被用到的注解之一。這個注解會將 HTTP 請求映射到 MVC 和 REST 控制器的處理方法上。

在這篇文章中，你將會看到 @RequestMapping 注解在被用來進行 Spring MVC 控制器方法的映射可以如何發揮其多才多藝的功能的。

Request Mapping 基礎用法
在 Spring MVC 應用程序中，RequestDispatcher (在 Front Controller 之下) 這個 servlet 負責將進入的 HTTP 請求路由到控制器的處理方法。

在對 Spring MVC 進行的配置的時候, 你需要指定請求與處理方法之間的映射關系。
在這里插入圖片描述
要配置 Web 請求的映射，就需要你用上 @RequestMapping 注解。

@RequestMapping 注解可以在控制器類的級別和/或其中的方法的級別上使用。

在類的級別上的注解會將一個特定請求或者請求模式映射到一個控制器之上。之后你還可以另外添加方法級別的注解來進一步指定到處理方法的映射關系。

下面是一個同時在類和方法上應用了 @RequestMapping 注解的示例：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping("/")  String get() {  //mapped to hostname:port/home/  return "Hello from get";  }  @RequestMapping("/index")  String index() {  //mapped to hostname:port/home/index/  return "Hello from index";  }  
}

如上述代碼所示，到 /home 的請求會由 get() 方法來處理，而到 /home/index 的請求會由 index() 來處理。
@RequestMapping 來處理多個 URI
你可以將多個請求映射到一個方法上去，只需要添加一個帶有請求路徑值列表的 @RequestMapping 注解就行了。

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = {  "",  "/page",  "page*",  "view/*,**/msg"  })  String indexMultipleMapping() {  return "Hello from index multiple mapping.";  }  
}

如你在這段代碼中所看到的，@RequestMapping 支持統配符以及ANT風格的路徑。前面這段代碼中，如下的這些 URL 都會由 indexMultipleMapping() 來處理：

localhost:8080/home
localhost:8080/home/
localhost:8080/home/page
localhost:8080/home/pageabc
localhost:8080/home/view/
localhost:8080/home/view/view
- 帶有 @RequestParam 的 @RequestMapping
@RequestParam 注解配合 @RequestMapping 一起使用，可以將請求的參數同處理方法的參數綁定在一起。

@RequestParam 注解使用的時候可以有一個值，也可以沒有值。這個值指定了需要被映射到處理方法參數的請求參數, 代碼如下所示：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/id")  String getIdByValue(@RequestParam("id") String personId) {  System.out.println("ID is " + personId);  return "Get ID from query string of URL with value element";  }  @RequestMapping(value = "/personId")  String getId(@RequestParam String personId) {  System.out.println("ID is " + personId);  return "Get ID from query string of URL without value element";  }  
}

在代碼的第6行，id 這個請求參數被映射到了 thegetIdByValue() 這個處理方法的參數 personId 上。

如果請求參數和處理方法參數的名稱一樣的話，@RequestParam 注解的 value 這個參數就可省掉了, 如代碼的第11行所示。

@RequestParam 注解的 required 這個參數定義了參數值是否是必須要傳的。

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/name")  String getName(@RequestParam(value = "person", required = false) String personName) {  return "Required element of request param";  }  
}

在這段代碼中，因為 required 被指定為 false，所以 getName() 處理方法對于如下兩個 URL 都會進行處理：

/home/name?person=xyz
/home/name
@RequestParam 的 defaultValue 取值就是用來給取值為空的請求參數提供一個默認值的。

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/name")  String getName(@RequestParam(value = "person", defaultValue = "John") String personName) {  return "Required element of request param";  }  
}

在這段代碼中，如果 person 這個請求參數為空，那么 getName() 處理方法就會接收 John 這個默認值作為其參數。
用 @RequestMapping 處理 HTTP 的各種方法
Spring MVC 的 @RequestMapping 注解能夠處理 HTTP 請求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的請求默認都會是 HTTP GET 類型的。

為了能降一個請求映射到一個特定的 HTTP 方法，你需要在 @RequestMapping 中使用 method 來聲明 HTTP 請求所使用的方法類型，如下所示：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(method = RequestMethod.GET)  String get() {  return "Hello from get";  }  @RequestMapping(method = RequestMethod.DELETE)  String delete() {  return "Hello from delete";  }  @RequestMapping(method = RequestMethod.POST)  String post() {  return "Hello from post";  }  @RequestMapping(method = RequestMethod.PUT)  String put() {  return "Hello from put";  }  @RequestMapping(method = RequestMethod.PATCH)  String patch() {  return "Hello from patch";  }  
}

所有的處理處理方法會處理從這同一個 URL( /home)進來的請求, 但要看指定的 HTTP 方法是什么來決定用哪個方法來處理。

例如，一個 POST 類型的請求 /home 會交給 post() 方法來處理，而一個 DELETE 類型的請求 /home 則會由 delete() 方法來處理。

你會看到 Spring MVC 將使用這樣相同的邏輯來映射其它的方法。
用 @RequestMapping 來處理生產和消費對象
可以使用 @RequestMapping 注解的 produces 和 consumes 這兩個元素來縮小請求映射類型的范圍。

為了能用請求的媒體類型來產生對象, 你要用到 @RequestMapping 的 produces 元素再結合著 @ResponseBody 注解。

你也可以利用 @RequestMapping 的 comsumes 元素再結合著 @RequestBody 注解用請求的媒體類型來消費對象。

下面這段代碼就用到的 @RequestMapping 的生產和消費對象元素：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/prod", produces = {  "application/JSON"  })  @ResponseBody  String getProduces() {  return "Produces attribute";  }  @RequestMapping(value = "/cons", consumes = {  "application/JSON",  "application/XML"  })  String getConsumes() {  return "Consumes attribute";  }  
}

在這段代碼中， getProduces() 處理方法會產生一個 JSON 響應， getConsumes() 處理方法可以同時處理請求中的 JSON 和 XML 內容。

使用 @RequestMapping 來處理消息頭

@RequestMapping 注解提供了一個 header 元素來根據請求中的消息頭內容縮小請求映射的范圍。

在可以指定 header 元素的值，用 myHeader = myValue 這樣的格式：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/head", headers = {  "content-type=text/plain"  })  String post() {  return "Mapping applied along with headers";  }  
}

在上面這段代碼中， @RequestMapping 注解的 headers 屬性將映射范圍縮小到了 post() 方法。有了這個，post() 方法就只會處理到 /home/head 并且 content-typeheader 被指定為 text/plain 這個值的請求。

你也可以像下面這樣指定多個消息頭：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/head", headers = {  "content-type=text/plain",  "content-type=text/html"  }) String post() {  return "Mapping applied along with headers";  }  
}

這樣， post() 方法就能同時接受 text/plain 還有 text/html 的請求了。
使用 @RequestMapping 來處理請求參數
@RequestMapping 直接的 params 元素可以進一步幫助我們縮小請求映射的定位范圍。使用 params 元素，你可以讓多個處理方法處理到同一個URL 的請求, 而這些請求的參數是不一樣的。

你可以用 myParams = myValue 這種格式來定義參數，也可以使用通配符來指定特定的參數值在請求中是不受支持的。

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/fetch", params = {  "personId=10"  })  String getParams(@RequestParam("personId") String id) {  return "Fetched parameter using params attribute = " + id;  }  @RequestMapping(value = "/fetch", params = {  "personId=20"  })  String getParamsDifferent(@RequestParam("personId") String id) {  return "Fetched parameter using params attribute = " + id;  }  
}

在這段代碼中，getParams() 和 getParamsDifferent() 兩個方法都能處理相同的一個 URL (/home/fetch) ，但是會根據 params 元素的配置不同而決定具體來執行哪一個方法。

例如，當 URL 是 /home/fetch?id=10 的時候, getParams() 會執行，因為 id 的值是10,。對于 localhost:8080/home/fetch?personId=20 這個URL, getParamsDifferent() 處理方法會得到執行，因為 id 值是 20。
使用 @RequestMapping 處理動態 URI
@RequestMapping 注解可以同 @PathVaraible 注解一起使用，用來處理動態的 URI，URI 的值可以作為控制器中處理方法的參數。你也可以使用正則表達式來只處理可以匹配到正則表達式的動態 URI。

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping(value = "/fetch/{id}", method = RequestMethod.GET)  String getDynamicUriValue(@PathVariable String id) {  System.out.println("ID is " + id);  return "Dynamic URI parameter fetched";  }  @RequestMapping(value = "/fetch/{id:[a-z]+}/{name}", method = RequestMethod.GET)  String getDynamicUriValueRegex(@PathVariable("name") String name) {  System.out.println("Name is " + name);  return "Dynamic URI parameter fetched using regex";  }  
}

在這段代碼中，方法 getDynamicUriValue() 會在發起到 localhost:8080/home/fetch/10 的請求時執行。這里 getDynamicUriValue() 方法 id 參數也會動態地被填充為 10 這個值。

方法 getDynamicUriValueRegex() 會在發起到 localhost:8080/home/fetch/category/shirt 的請求時執行。不過，如果發起的請求是 /home/fetch/10/shirt 的話，會拋出異常，因為這個URI并不能匹配正則表達式。

@PathVariable 同 @RequestParam的運行方式不同。你使用 @PathVariable 是為了從 URI 里取到查詢參數值。換言之，你使用 @RequestParam 是為了從 URI 模板中獲取參數值。
@RequestMapping 默認的處理方法
在控制器類中，你可以有一個默認的處理方法，它可以在有一個向默認 URI 發起的請求時被執行。

下面是默認處理方法的示例：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @RequestMapping()  String  default () {  return "This is a default method for the class";  }  
}

在這段代碼中，向 /home 發起的一個請求將會由 default() 來處理，因為注解并沒有指定任何值。
@RequestMapping 快捷方式
Spring 4.3 引入了方法級注解的變體，也被叫做 @RequestMapping 的組合注解。組合注解可以更好的表達被注解方法的語義。它們所扮演的角色就是針對 @RequestMapping 的封裝，而且成了定義端點的標準方法。

例如，@GetMapping 是一個組合注解，它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一個快捷方式。
方法級別的注解變體有如下幾個：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
如下代碼展示了如何使用組合注解：

@RestController  
@RequestMapping("/home")  
public class IndexController {  @GetMapping("/person")  public @ResponseBody ResponseEntity < String > getPerson() {  return new ResponseEntity < String > ("Response from GET", HttpStatus.OK);  }  @GetMapping("/person/{id}")  public @ResponseBody ResponseEntity < String > getPersonById(@PathVariable String id) {  return new ResponseEntity < String > ("Response from GET with id " + id, HttpStatus.OK);  }  @PostMapping("/person")  public @ResponseBody ResponseEntity < String > postPerson() {  return new ResponseEntity < String > ("Response from POST method", HttpStatus.OK);  }  @PutMapping("/person")  public @ResponseBody ResponseEntity < String > putPerson() {  return new ResponseEntity < String > ("Response from PUT method", HttpStatus.OK);  }  @DeleteMapping("/person")  public @ResponseBody ResponseEntity < String > deletePerson() {  return new ResponseEntity < String > ("Response from DELETE method", HttpStatus.OK);  }  @PatchMapping("/person")  public @ResponseBody ResponseEntity < String > patchPerson() {  return new ResponseEntity < String > ("Response from PATCH method", HttpStatus.OK);  }  
}

在這段代碼中，每一個處理方法都使用 @RequestMapping 的組合變體進行了注解。盡管每個變體都可以使用帶有方法屬性的 @RequestMapping 注解來互換實現, 但組合變體仍然是一種最佳的實踐 — 這主要是因為組合注解減少了在應用程序上要配置的元數據，并且代碼也更易讀。
@RequestMapping 總結
如你在本文中所看到的，@RequestMapping 注解是非常靈活的。你可以使用該注解配置 Spring MVC 來處理大量的場景用例。它可以被用來在 Spring MVC 中配置傳統的網頁請求，也可以是 REST 風格的 Web 服務。