目录
四.请求与响应
SpringMVC是web层的框架，主要的作用是接收请求、接收数据、响应结果
4.1 设置请求映射路径
只需要在Controller层的类上或者方法上添加@RequestMapping("/路径")注解即可
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/save")
@ResponseBody
public String save(){
System.out.println("user save ...");
return "{'module':'user save'}";
}
@RequestMapping("/delete")
@ResponseBody
public String save(){
System.out.println("user delete ...");
return "{'module':'user delete'}";
}
}
@Controller
@RequestMapping("/book")
public class BookController {
@RequestMapping("/save")
@ResponseBody
public String save(){
System.out.println("book save ...");
return "{'module':'book save'}";
}
}4.2 请求参数
请求路径设置好后，只要确保页面发送请求地址和后台Controller类中配置的路径一致，就可以接收到前端的请求，接收到请求后，如何接收页面传递的参数?
关于请求参数的传递与接收是和请求方式有关系的，目前比较常见的两种请求方式为：
-
GET
-
POST
针对于不同的请求前端如何发送，后端如何接收?
4.3 请求参数是中文的乱码问题
4.3.1 GET请求中文乱码
如果我们传递的参数中有中文，你会发现接收到的参数会出现中文乱码问题。
发送请求:http://localhost/commonParam?name=张三&age=18
控制台:
出现乱码的原因相信大家都清楚，Tomcat8.5以后的版本已经处理了中文乱码的问题，但是IDEA中的Tomcat插件目前只到Tomcat7，所以需要修改pom.xml来解决GET请求中文乱码问题
<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.1</version>
<configuration>
<port>80</port><!--tomcat端口号-->
<path>/</path> <!--虚拟目录-->
<uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
</configuration>
</plugin>
</plugins>
</build>4.3.2 POST请求中文乱码
发送请求与参数:
接收参数:
@Controller
public class UserController {
@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name){
System.out.println("普通参数传递 name ==> "+name);
return "{'module':'commonParam'}";
}
}控制台打印，会发现有中文乱码问题。
解决方案:配置过滤器
CharacterEncodingFilter是在spring-web包中，所以用之前需要导入对应的jar包。
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
protected Class<?>[] getRootConfigClasses() {
return new Class[0];
}
protected Class<?>[] getServletConfigClasses() {
return new Class[]{SpringMvcConfig.class};
}
protected String[] getServletMappings() {
return new String[]{"/"};
}
//乱码处理
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding("UTF-8");
return new Filter[]{filter};
}
}4.4 五种类型参数传递
前面我们已经能够使用GET或POST来发送请求和数据，所携带的数据都是比较简单的数据，接下来在这个基础上，我们来研究一些比较复杂的参数传递，常见的参数种类有:
-
普通参数
-
POJO类型参数
-
嵌套POJO类型参数
-
数组类型参数
-
集合类型参数
这些参数如何发送，后台改如何接收?我们一个个来学习。
4.4.1 普通参数
1.地址参数与形参变量名相同
url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数。
2.地址参数与形参变量名不同
如果形参与地址参数名不一致，可以使用@RequestParam注解
发送请求及其参数:
http://localhost/commonParamDifferentName?name=张三&age=18
后台接收参数：
@RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(@RequestPaam("name") String userName , int age){
System.out.println("普通参数传递 userName ==> "+userName);
System.out.println("普通参数传递 age ==> "+age);
return "{'module':'common param different name'}";
}4.4.2 POJO数据类型
简单数据类型一般处理的是参数个数比较少的请求，如果参数比较多，那么后台接收参数的时候就比较复杂，这个时候我们可以考虑使用POJO数据类型。
POJO参数：请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数
定义好POJO类：
public class User {
private String name;
private int age;
//setter...getter...略
}发送请求和参数:
后台接收参数:
//POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
System.out.println("pojo参数传递 user ==> "+user);
return "{'module':'pojo param'}";
}注意
-
POJO参数接收，前端GET和POST发送请求数据的方式不变。
-
请求参数key的名称要和POJO中属性的名称一致，否则无法封装。
4.4.3 嵌套POJO类型参数
如果POJO对象中嵌套了其他的POJO类，如
public class Address {
private String province;
private String city;
//setter...getter...略
}
public class User {
private String name;
private int age;
private Address address;
//setter...getter...略
}嵌套POJO参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数
发送请求和参数:
后台接收参数:
//POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
System.out.println("pojo参数传递 user ==> "+user);
return "{'module':'pojo param'}";
}注意: 请求参数key的名称要和POJO中属性的名称一致，否则无法封装
4.4.4 数组类型参数
举个简单的例子，如果前端需要获取用户的爱好，爱好绝大多数情况下都是多个，如何发送请求数据和接收数据呢?
数组参数：请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型即可接收参数
发送请求和参数:
后台接收参数:
//数组参数：同名请求参数可以直接映射到对应名称的形参数组对象中
@RequestMapping("/arrayParam")
@ResponseBody
public String arrayParam(String[] likes){
System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
return "{'module':'array param'}";
}4.4.5 集合类型参数
数组能接收多个值，那么集合是否也可以实现这个功能，只需要请求参数名与形参集合对象名相同且在形参集合前边加上@RequestParam注解即可
发送请求和参数:
后台接收参数:
//集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
System.out.println("集合参数传递 likes ==> "+ likes);
return "{'module':'list param'}";
}知识点1：@RequestParam
| 名称 | @RequestParam |
|---|---|
| 类型 | 形参注解 |
| 位置 | SpringMVC控制器方法形参定义前面 |
| 作用 | 绑定请求参数与处理器方法形参间的关系 |
| 相关参数 | required：是否为必传参数 defaultValue：参数默认值 |
4.5 JSON数据传输参数
现在比较流行的开发方式为异步调用。前后台以异步方式进行交换，传输的数据使用的是JSON,所以前端如果发送的是JSON数据，后端该如何接收?
对于JSON数据类型，我们常见的有三种:
-
json普通数组（["value1","value2","value3",...]）
-
json对象（{key1:value1,key2:value2,...}）
-
json对象数组（[{key1:value1,...},{key2:value2,...}]）
4.5.1 JSON普通数组
步骤1:pom.xml添加依赖
SpringMVC默认使用的是jackson来处理json的转换，所以需要在pom.xml添加jackson依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>步骤2:PostMan发送JSON数据
步骤3:开启SpringMVC注解支持
在SpringMVC的配置类中开启SpringMVC的注解支持，这里面就包含了将JSON转换成对象的功能。
@Configuration
@ComponentScan("com.itheima.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}步骤4:参数前添加@RequestBody
//使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
System.out.println("list common(json)参数传递 list ==> "+likes);
return "{'module':'list common for json param'}";
}步骤5:启动运行程序
4.5.2 JSON对象数据
我们会发现，只需要关注请求和数据如何发送?后端数据如何接收?
请求和数据的发送:
后端接收数据：
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
System.out.println("pojo(json)参数传递 user ==> "+user);
return "{'module':'pojo for json param'}";
}4.5.3 JSON对象数组
集合中保存多个POJO该如何实现?
请求和数据的发送:
后端接收数据:
@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
System.out.println("list pojo(json)参数传递 list ==> "+list);
return "{'module':'list pojo for json param'}";
}启动程序访问测试
知识点1：@EnableWebMvc
| 名称 | @EnableWebMvc |
|---|---|
| 类型 | ==配置类注解== |
| 位置 | SpringMVC配置类定义上方 |
| 作用 | 开启SpringMVC多项辅助功能 |
知识点2：@RequestBody
| 名称 | @RequestBody |
|---|---|
| 类型 | ==形参注解== |
| 位置 | SpringMVC控制器方法形参定义前面 |
| 作用 | 将请求中请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次 |
@RequestBody与@RequestParam区别
-
区别
-
@RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
-
@RequestBody用于接收json数据【application/json】
-
-
应用
-
后期开发中，发送json格式数据为主，@RequestBody应用较广
-
如果发送非json格式数据，选用@RequestParam接收请求参数
-
4.5 日期类型参数传递
接下来我们处理一种开发中比较常见的一种数据类型：日期类型
日期类型比较特殊，因为对于日期的格式有N多中输入方式，比如:
-
2088-08-18
-
2088/08/18
-
08/18/2088
-
......
针对这么多日期格式，SpringMVC该如何接收，它能很好的处理日期类型数据么?
4.5.1 SpringMVC接收日期类型步骤
步骤1:编写方法接收日期数据
在UserController类中添加方法，把参数设置为日期类型
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date)
System.out.println("参数传递 date ==> "+date);
return "{'module':'data param'}";
}步骤2:启动Tomcat服务器
查看控制台是否报错，如果有错误，先解决错误。
步骤3:使用PostMan发送请求
使用PostMan发送GET请求，并设置date参数
http://localhost/dataParam?date=2088/08/08
步骤4:查看控制台
通过打印，我们发现SpringMVC可以接收日期数据类型，并将其打印在控制台。这个时候，我们就想如果把日期参数的格式改成其他的，SpringMVC还能处理么?
步骤5:更换日期格式
为了能更好的看到程序运行的结果，我们在方法中多添加一个日期参数
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,Date date1)
System.out.println("参数传递 date ==> "+date);
return "{'module':'data param'}";
}使用PostMan发送请求，携带两个不同的日期格式，
http://localhost/dataParam?date=2088/08/08&date1=2088-08-08
发送请求和数据后，页面会报400，控制台会报出一个错误
Resolved [org.springframework.web.method.annotation.==MethodArgumentTypeMismatchException==: Failed to convert value of type 'java.lang.String' to required type 'java.util.Date'; nested exception is org.springframework.core.convert.==ConversionFailedException==: Failed to convert from type [java.lang.String] to type [java.util.Date] for value '2088-08-08'; nested exception is java.lang.IllegalArgumentException]
从错误信息可以看出，错误的原因是在将2088-08-08转换成日期类型的时候失败了，原因是SpringMVC默认支持的字符串转日期的格式为yyyy/MM/dd,而我们现在传递的不符合其默认格式，SpringMVC就无法进行格式转换，所以报错。
解决方案也比较简单，需要使用@DateTimeFormat
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
@DateTimeFormat(pattern="yyyy-MM-dd") Date date1)
System.out.println("参数传递 date ==> "+date);
System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
return "{'module':'data param'}";
}重新启动服务器，重新发送请求测试，SpringMVC就可以正确的进行日期转换了
步骤6:携带时间的日期
接下来我们再来发送一个携带时间的日期，看下SpringMVC该如何处理?
先修改UserController类，添加第三个参数
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
@DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
@DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2)
System.out.println("参数传递 date ==> "+date);
System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
return "{'module':'data param'}";
}使用PostMan发送请求，携带两个不同的日期格式，
http://localhost/dataParam?date=2088/08/08&date1=2088-08-08&date2=2088/08/08 8:08:08
重新启动服务器，重新发送请求测试，SpringMVC就可以将日期时间的数据进行转换
知识点1：@DateTimeFormat
| 名称 | @DateTimeFormat |
|---|---|
| 类型 | ==形参注解== |
| 位置 | SpringMVC控制器方法形参前面 |
| 作用 | 设定日期时间型数据格式 |
| 相关属性 | pattern：指定日期时间格式字符串 |
4.5.2 内部实现原理
讲解内部原理之前，我们需要先思考个问题:
-
前端传递字符串，后端使用日期Date接收
-
前端传递JSON数据，后端使用对象接收
-
前端传递字符串，后端使用Integer接收
-
后台需要的数据类型有很多中
-
在数据的传递过程中存在很多类型的转换
问:谁来做这个类型转换?
答:SpringMVC
问:SpringMVC是如何实现类型转换的?
答:SpringMVC中提供了很多类型转换接口和实现类
在框架中，有一些类型转换接口，其中有:
1.Converter接口
/**
* S: the source type
* T: the target type
*/
public interface Converter<S, T> {
@Nullable
//该方法就是将从页面上接收的数据(S)转换成我们想要的数据类型(T)返回
T convert(S source);
}注意:Converter所属的包为org.springframework.core.convert.converter
Converter接口的实现类
框架中有提供很多对应Converter接口的实现类，用来实现不同数据类型之间的转换,如:
请求参数年龄数据（String→Integer）
日期格式转换（String → Date）
2.HttpMessageConverter接口
该接口是实现对象与JSON之间的转换工作
==注意:SpringMVC的配置类把@EnableWebMvc当做标配配置上去，不要省略==
4.6 响应
SpringMVC接收到请求和数据后，进行了一些处理，当然这个处理可以是转发给Service，Service层再调用Dao层完成的，不管怎样，处理完以后，都需要将结果告知给用户。
比如:根据用户ID查询用户信息、查询用户列表、新增用户等。
对于响应，主要就包含两部分内容：
-
响应页面
-
响应数据
-
文本数据
-
json数据
-
因为异步调用是目前常用的主流方式，所以我们需要更关注的就是如何返回JSON数据，对于其他只需要认识了解即可。
4.6.1 响应页面[了解]
步骤1:设置返回页面
@Controller
public class UserController {
@RequestMapping("/toJumpPage")
//注意
//1.此处不能添加@ResponseBody,如果加了该注入，会直接将page.jsp当字符串返回前端
//2.方法需要返回String
public String toJumpPage(){
System.out.println("跳转页面");
return "page.jsp";
}
}步骤2:启动程序测试
此处涉及到页面跳转，所以不适合采用PostMan进行测试，直接打开浏览器，输入
http://localhost/toJumpPage
4.6.2 响应文本数据[了解]
步骤1:设置返回文本内容
@Controller
public class UserController {
@RequestMapping("/toText")
//注意此处该注解就不能省略，如果省略了,会把response text当前页面名称去查找，如果没有回报404错误
@ResponseBody
public String toText(){
System.out.println("返回纯文本数据");
return "response text";
}
}步骤2:启动程序测试
此处不涉及到页面跳转，因为我们现在发送的是GET请求，可以使用浏览器也可以使用PostMan进行测试，输入地址http://localhost/toText访问
4.6.3 响应JSON数据
1.响应POJO对象
@Controller
public class UserController {
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
System.out.println("返回json对象数据");
User user = new User();
user.setName("itcast");
user.setAge(15);
return user;
}
}返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖==@ResponseBody==注解和==@EnableWebMvc==注解
重新启动服务器，访问http://localhost/toJsonPOJO
2.响应POJO集合对象
@Controller
public class UserController {
@RequestMapping("/toJsonList")
@ResponseBody
public List<User> toJsonList(){
System.out.println("返回json集合数据");
User user1 = new User();
user1.setName("传智播客");
user1.setAge(15);
User user2 = new User();
user2.setName("黑马程序员");
user2.setAge(12);
List<User> userList = new ArrayList<User>();
userList.add(user1);
userList.add(user2);
return userList;
}
}重新启动服务器，访问http://localhost/toJsonList
知识点1：@ResponseBody
| 名称 | @ResponseBody |
|---|---|
| 类型 | ==方法\类注解== |
| 位置 | SpringMVC控制器方法定义上方和控制类上 |
| 作用 | 设置当前控制器返回值作为响应体, 写在类上，该类的所有方法都有该注解功能 |
| 相关属性 | pattern：指定日期时间格式字符串 |
说明：
-
该注解可以写在类上或者方法上
-
写在类上就是该类下的所有方法都有@ReponseBody功能
-
当方法上有@ReponseBody注解后
-
方法的返回值为字符串，会将其作为文本内容直接响应给前端
-
方法的返回值为对象，会将对象转换成JSON响应给前端
-
此处又使用到了类型转换，内部还是通过Converter接口的实现类完成的，所以Converter除了前面所说的功能外，它还可以实现:
-
对象转Json数据(POJO -> json)
-
集合转Json数据(Collection -> json)
五.Rest风格
5.1 REST简介
1.REST
-
REST，表现形式状态转换,它是一种软件架构风格，当我们想表示一个网络资源的时候，可以使用下面两种方式:
-
传统风格资源描述形式
-
http://localhost/user/getById?id=1查询id为1的用户信息 -
http://localhost/user/saveUser保存用户信息
-
-
REST风格描述形式
-
http://localhost/user/1 -
http://localhost/user
-
-
但是我们的问题也随之而来了，一个相同的url地址即可以是新增也可以是修改或者查询，那么到底我们该如何区分该请求到底是什么操作呢?
-
按照REST风格访问资源时使用==行为动作==区分对资源进行了何种操作
-
http://localhost/users查询全部用户信息 GET（查询） -
http://localhost/users/1查询指定用户信息 GET（查询） -
http://localhost/users添加用户信息 POST（新增/保存） -
http://localhost/users修改用户信息 PUT（修改/更新） -
http://localhost/users/1删除用户信息 DELETE（删除）
-
请求的方式比较多，但是比较常用的就4种，分别是GET,POST,PUT,DELETE。按照不同的请求方式代表不同的操作类型。
-
发送GET请求是用来做查询
-
发送POST请求是用来做新增
-
发送PUT请求是用来做修改
-
发送DELETE请求是用来做删
2.RESTful
清楚了什么是REST风格后，我们后期会经常提到一个概念叫RESTful，那什么又是RESTful呢?
根据REST风格对资源进行访问称为==RESTful==。
5.2 RESTful风格下Controller层的变化
5.2.1 新增方法
将请求路径更改为/users，访问该方法使用 POST: http://localhost/users
@Controller
public class UserController {
//设置当前请求方法为POST，表示REST风格中的添加操作
@RequestMapping(value = "/users",method = RequestMethod.POST)
@ResponseBody
public String save() {
System.out.println("user save...");
return "{'module':'user save'}";
}
}使用method属性限定该方法的访问方式为POST，如果发送的不是POST请求，比如发送GET请求，则会报错
5.2.2 删除方法
将请求路径更改为/users，访问该方法使用 DELETE: http://localhost/users
@Controller
public class UserController {
//设置当前请求方法为DELETE，表示REST风格中的删除操作
@RequestMapping(value = "/users",method = RequestMethod.DELETE)
@ResponseBody
public String delete(Integer id) {
System.out.println("user delete..." + id);
return "{'module':'user delete'}";
}
}访问成功，但是删除方法没有携带所要删除数据的id,所以针对RESTful的开发，如何携带数据参数?
传递路径参数
前端发送请求的时候使用:http://localhost/users/1,路径中的1就是我们想要传递的参数。
后端获取参数，需要做如下修改:
-
修改@RequestMapping的value属性，将其中修改为
/users/{id}，目的是和路径匹配 -
在方法的形参前添加@PathVariable注解
@Controller
public class UserController {
//设置当前请求方法为DELETE，表示REST风格中的删除操作
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
System.out.println("user delete..." + id);
return "{'module':'user delete'}";
}
}思考如下两个问题:
(1)如果方法形参的名称和路径{}中的值不一致，该怎么办?
(2)如果有多个参数需要传递该如何编写?
前端发送请求的时候使用:http://localhost/users/1/tom,路径中的1和tom就是我们想要传递的两个参数。
后端获取参数，需要做如下修改:
@Controller
public class UserController {
//设置当前请求方法为DELETE，表示REST风格中的删除操作
@RequestMapping(value = "/users/{id}/{name}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id,@PathVariable String name) {
System.out.println("user delete..." + id+","+name);
return "{'module':'user delete'}";
}
}5.2.3 修改方法
将请求路径更改为/users，访问该方法使用 PUT: http://localhost/users
@Controller
public class UserController {
//设置当前请求方法为PUT，表示REST风格中的修改操作
@RequestMapping(value = "/users",method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user) {
System.out.println("user update..." + user);
return "{'module':'user update'}";
}
}访问并携带参数:
5.2.4 根据ID查询
将请求路径更改为/users，访问该方法使用 GET: http://localhost/users/666
@Controller
public class UserController {
//设置当前请求方法为GET，表示REST风格中的查询操作
@RequestMapping(value = "/users/{id}" ,method = RequestMethod.GET)
@ResponseBody
public String getById(@PathVariable Integer id){
System.out.println("user getById..."+id);
return "{'module':'user getById'}";
}
}5.2.5 查询所有
将请求路径更改为/users，访问该方法使用 GET: http://localhost/users
@Controller
public class UserController {
//设置当前请求方法为GET，表示REST风格中的查询操作
@RequestMapping(value = "/users" ,method = RequestMethod.GET)
@ResponseBody
public String getAll() {
System.out.println("user getAll...");
return "{'module':'user getAll'}";
}
}知识点1：@PathVariable
| 名称 | @PathVariable |
|---|---|
| 类型 | ==形参注解== |
| 位置 | SpringMVC控制器方法形参定义前面 |
| 作用 | 绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应 |
5.2.6 接受参数的三个注解
关于接收参数，我们学过三个注解@RequestBody、@RequestParam、@PathVariable,这三个注解之间的区别和应用分别是什么?
-
区别
-
@RequestParam用于接收url地址传参或表单传参
-
@RequestBody用于接收json数据
-
@PathVariable用于接收路径参数，使用{参数名称}描述路径参数
-
-
应用
-
后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
-
如果发送非json格式数据，选用@RequestParam接收请求参数
-
采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值
-
5.3 RESTful快速开发
做完了RESTful的开发，你会发现==好麻烦==，麻烦在哪?
问题1：每个方法的@RequestMapping注解中都定义了访问路径/books，重复性太高。
问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。
问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。
对于上面所提的这三个问题，解决方案如下：
问题1：每个方法的@RequestMapping注解中都定义了访问路径/books，重复性太高。
将@RequestMapping提到类上面，用来定义所有方法共同的访问路径。
问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。
使用@GetMapping @PostMapping @PutMapping @DeleteMapping代替
问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。
1.将ResponseBody提到类上面，让所有的方法都有@ResponseBody的功能 2.使用@RestController注解替换@Controller与@ResponseBody注解，简化书写
@RestController //@Controller + ReponseBody
@RequestMapping("/books")
public class BookController {
//@RequestMapping(method = RequestMethod.POST)
@PostMapping
public String save(@RequestBody Book book){
System.out.println("book save..." + book);
return "{'module':'book save'}";
}
//@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
@DeleteMapping("/{id}")
public String delete(@PathVariable Integer id){
System.out.println("book delete..." + id);
return "{'module':'book delete'}";
}
//@RequestMapping(method = RequestMethod.PUT)
@PutMapping
public String update(@RequestBody Book book){
System.out.println("book update..." + book);
return "{'module':'book update'}";
}
//@RequestMapping(value = "/{id}",method = RequestMethod.GET)
@GetMapping("/{id}")
public String getById(@PathVariable Integer id){
System.out.println("book getById..." + id);
return "{'module':'book getById'}";
}
//@RequestMapping(method = RequestMethod.GET)
@GetMapping
public String getAll(){
System.out.println("book getAll...");
return "{'module':'book getAll'}";
}
}知识点1：@RestController
| 名称 | @RestController |
|---|---|
| 类型 | ==类注解== |
| 位置 | 基于SpringMVC的RESTful开发控制器类定义上方 |
| 作用 | 设置当前控制器类为RESTful风格， 等同于@Controller与@ResponseBody两个注解组合功能 |
知识点2：@GetMapping @PostMapping @PutMapping @DeleteMapping
| 名称 | @GetMapping @PostMapping @PutMapping @DeleteMapping |
|---|---|
| 类型 | ==方法注解== |
| 位置 | 基于SpringMVC的RESTful开发控制器方法定义上方 |
| 作用 | 设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作， 例如@GetMapping对应GET请求 |
| 相关属性 | value（默认）：请求访问路径 |
3978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
