spring-boot注解详解(五)

拼搏现实的明天。 2021-11-23 09:08 307阅读 0赞

## @AutoWired ##

*  首先要知道另一个东西，default-autowire，它是在xml文件中进行配置的，可以设置为byName、byType、constructor和autodetect；比如byName，不用显式的在bean中写出依赖的对象，它会自动的匹配其它bean中id名与本bean的set\*\*相同的，并自动装载。
 *  @Autowired是用在JavaBean中的注解，通过byType形式，用来给指定的字段或方法注入所需的外部资源。
 *  两者的功能是一样的，就是能减少或者消除属性或构造器参数的设置，只是配置地方不一样而已。
 *  autowire四种模式的区别：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70]
 *  先看一下bean实例化和@Autowired装配过程：

\*\*

1.  一切都是从bean工厂的getBean方法开始的，一旦该方法调用总会返回一个bean实例，无论当前是否存在，不存在就实例化一个并装配，否则直接返回。（Spring  
    MVC是在什么时候开始执行bean的实例化过程的呢？其实就在组件扫描完成之后)
2.  实例化和装配过程中会多次递归调用getBean方法来解决类之间的依赖。
3.  Spring几乎考虑了所有可能性，所以方法特别复杂但完整有条理。
4.  @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;
       @Autowired
       public 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/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
     
       <context:annotation-config/>
     
       
       <bean id="textEditor" class="com.tutorialspoint.TextEditor">
       </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 { 
       @Autowired
       private 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/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
     
       <context:annotation-config/>
     
       
       <bean id="textEditor" class="com.tutorialspoint.TextEditor">
       </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;
       @Autowired
       public TextEditor(SpellChecker spellChecker){ 
          System.out.println("Inside TextEditor constructor." );
          this.spellChecker = spellChecker;
       }
       public void spellCheck(){ 
          spellChecker.checkSpelling();
       }
    }

下面是配置文件 Beans.xml：

一旦你在源文件和 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;
       }
       @Autowired
       public void setName(String name) { 
          this.name = name;
       }   
       public String getName() { 
          return name;
       }

## @Qualifier ##

*  在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？  
    下面上铺垫图  
    ![在这里插入图片描述][20190726113332847.png]  
    请忽略我的红线  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70 1]  
    在Controller中使用 @Autowired注入时  
    ![在这里插入图片描述][20190726113410331.png]  
    Qualifier的意思是合格者，通过这个标示，表明了哪个实现类才是我们所需要的，添加@Qualifier注解，需要注意的是@Qualifier的参数名称为我们之前定义@Service注解的名称之一。  
    使用@Resource注入时  
    ![在这里插入图片描述][20190726113437777.png]  
    使用@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是一个接口

1.  spring先找类型为ExamUserMapper的bean
2.  如果存在且唯一，则OK；
3.  如果不唯一，在结果集里，寻找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 进行的配置的时候, 你需要指定请求与处理方法之间的映射关系。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70 2]  
要配置 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 服务。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70]: /images/20211122/eb76e2e1c6444675ada7030100c4c2b8.png
[20190726113332847.png]: /images/20211122/bc849e70f7a94384974931938b90a93e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70 1]: /images/20211122/3346d81507974436864fa3e12cc30dfa.png
[20190726113410331.png]: /images/20211122/e7ae432709b44a7ab2dafc805c8fa1a5.png
[20190726113437777.png]: /images/20211122/5ef1c2d797fd4f589208fe8d002912f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpa3VucGVuZzY2NTYyMDE_size_16_color_FFFFFF_t_70 2]: /images/20211122/79f43e00814548d3a9b15187a445e46b.png