SpringMVC 与 JSON数据开发
1. 学习目标
2. Spring思想 & SpringMVC框架概念与特点
2.1. 什么叫MVC?
模型-视图-控制器(mvc)是一个众所周知的以设计为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常,模型负责封装应用程序数据在视图层显示。视图仅仅只是展示这些数据,不包含任何业务逻辑。处理后后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。mvc模式的核心思想是将业务逻辑从界面中分离出来,允许它们单独改变而不会互相影响。
2.2. 常见MVC框架运行性能比较
Jsp+servlet > struts1 > spring mvc > struts2+freemarker > struts2,ognl,值栈。
开发效率上,基本正好相反。值得强调的是,spring mvc开发效率和struts2不相上下,但从目前来看,
spring mvc 的流行度已远远超过struts2。
2.3. Spring MVC是什么?
Spring MVC是Spring家族中的一个web成员,它是一种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架,即使用了MVC架构模式的思想,将web层进行职责解耦,基于请求驱动指的就是使用请求-响应模式,框架的目的就是帮助我们简化开发,Spring MVC也是要简化我们日常web开发的。
Spring MVC是服务到工作者思想的实现。前端控制器是DispatcherServlet;应用控制器拆为处理器映射
器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理;支持本地化/国际化
(Locale)解析及文件上传等;提供了非常灵活的数据验证、格式化和数据绑定机制;提供了强大的约
定大于配置(惯例优先原则)的契约式编程支持。
2.4. Spring MVC能帮我们做什么?
- 让我们能非常简单的设计出干净的Web层;
- 进行更简洁的Web层开发
- 天生与Spring框架集成(如IOC容器、AOP等)
- 提供强大的约定大于配置的契约式编程支持
- 能简单的进行Web层的单元测试
- 支持灵活的URL到页面控制器的映射
- 非常容易与其他视图技术集成,如jsp、Velocity、
FreeMarker等等,因为模型数据不放在特定的API
里,而是放在一个Model里 - 非常灵活的数据验证、格式化和数据绑定机制,能使用任何对象进行数据绑定,不必实现特定框架的API
- 支持灵活的本地化等解析
- 更加简单的异常处理
- 对静态资源的支持
- 支持Restful风格
3. SpringMVC请求流程 & 环境搭建
3.1. Spring MVC请求处理流程分析
Spring MVC框架也是一个基于请求驱动的Web框架,并且使用了前端控制器模式(是用来提供一个集中
的请求处理机制,所有的请求都将由一个单一的处理程序处理来进行设计,再根据请求映射规则分发给
相应的页面控制器(动作/处理器)进行处理。首先让我们整体看一下Spring MVC处理请求的流程:
- 首先用户发送请求,请求被SpringMvc前端控制器(DispatherServlet)捕获;
- 前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调用HandlerMapping;
- 前端控制器(DispatherServlet)获得返回的HandlerExecutionChain(包括Handler对象以及Handler对
象对应的拦截器); - DispatcherServlet 根据获得的HandlerExecutionChain,选择一个合适的HandlerAdapter。(附注:
如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler(…)方法); - HandlerAdapter根据请求的Handler适配并执行对应的Handler;HandlerAdapter(提取Request中的模
型数据,填充Handler入参,开始执行Handler(Controller)。 在填充Handler的入参过程中,根据配
置,Spring将做一些额外的工作:
HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定
的响应信息。
数据转换:对请求消息进行数据转换。如String转换成Integer、Double等数据格式化:
数据格式化。 如将字符串转换成格式化数字或格式化日期等
数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中) - Handler执行完毕,返回一个ModelAndView(即模型和视图)给HandlerAdaptor
- HandlerAdaptor适配器将执行结果ModelAndView返回给前端控制器。
- 前端控制器接收到ModelAndView后,请求对应的视图解析器。
- 视图解析器解析ModelAndView后返回对应View;
- 渲染视图并返回渲染后的视图给前端控制器。
11、最终前端控制器将渲染后的页面响应给用户或客户端
3.2. Spring MVC优势
- 清晰的角色划分:前端控制器(DispatcherServlet)、请求到处理器映射(HandlerMapping)、处
理器适配器(HandlerAdapter)、视图解析器(ViewResolver)、处理器或页面控制器
(Controller)、验证器( Validator)、命令对象(Command 请求参数绑定到的对象就叫命令对
象)、表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。 - 分工明确,而且扩展点相当灵活,可以容易扩展,虽然几乎不需要
- 和Spring其他框架无缝集成,是其他Web框架所不具备的
- 可适配,通过HandlerAdapter可以支持任意的类作为处理器
- 可定制型,HandlerMapping ViewResolver等能够非常简单的定制
- 功能强大的数据验证、格式化、绑定机制
- 利用Spring提供的Mock对象能够非常简单的进行Web层单元测试
- 本地化、主题的解析的支持,使我们更容易进行国际化和主题的切换
- 强大的JSP标签,使JSP编写更容易
3.3. Spring MVC环境搭建
3.3.1. 开发环境
Idea + Maven + Jdk1.8 + Jeetty
3.3.2. 新建 Maven WebApp
Idea 下创建 springmvc工程
3.3.3. pom.xml坐标添加
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.liuxidong</groupId>
<artifactId>Spring_mvc01</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>Spring_mvc01 Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- spring web -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>
<!-- spring mvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>
<!-- web servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
</dependency>
<!-- 添加json 依赖jar包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.14.2</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.14.2</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.14.2</version>
</dependency>
</dependencies>
<build>
<finalName>Spring_mvc01</finalName>
<plugins>
<!-- 编译环境插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<!-- jetty插件 -->
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.4.27.v20200227</version>
<configuration>
<scanIntervalSeconds>10</scanIntervalSeconds>
<!-- 设置端口 -->
<httpConnector>
<port>8083</port>
</httpConnector>
<!-- 设置项目路径 -->
<webAppConfig>
<contextPath>/</contextPath>
</webAppConfig>
</configuration>
</plugin>
</plugins>
</build>
</project>
3.3.4. 配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<!-- 编码过滤 utf-8 -->
<filter>
<description>char encoding filter</description>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- servlet请求分发器 -->
<servlet>
<servlet-name>springMvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:servlet-context.xml</param-value>
</init-param>
<!-- 表示启动容器时初始化该Servlet -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMvc</servlet-name>
<!-- 这是拦截请求, "/"代表拦截所有请求,"*.do"拦截所有.do请求 -->
<url-pattern>/</url-pattern>
<!--<url-pattern>*.do</url-pattern>-->
</servlet-mapping>
</web-app>
3.3.5. servlet-context.xml配置
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启扫描器 -->
<context:component-scan base-package="com.liuxidong.springmvc.controller"/>
<!-- 使用默认的 Servlet 来响应静态文件 -->
<mvc:default-servlet-handler/>
<!-- 开启注解驱动-->
<mvc:annotation-driven/>
<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
id="internalResourceViewResolver">
<!-- 前缀:在WEB-INF目录下的jsp目录下 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀:以.jsp结尾的资源 -->
<property name="suffix" value=".jsp"/>
</bean>
<!-- mvc 请求映射 处理器与适配器配置 -->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter" />
<bean
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
</mvc:message-converters>
</mvc:annotation-driven>
</beans>
3.3.6. 页面控制器的编写
/**
* @author lxd
* 页面控制器
* #Description HelloController
* #Date: 2023/4/14 10:36
*/
@Controller
public class HelloController {
/** @Author lxd
* 请求映射地址
* @Param
* @return
**/
@RequestMapping("/hello")
public ModelAndView hello(){
ModelAndView modelAndView = new ModelAndView();
// 设置数据
modelAndView.addObject("hello","Hello Spring MVC");
// 设置视图名称
modelAndView.setViewName("hello");
return modelAndView;
}
}
3.3.7. 添加视图页面
<%--
Created by IntelliJ IDEA.
User: 86131
Date: 2023/4/14
Time: 10:41
To change this template use File | Settings | File Templates.
--%>
<%@page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath =
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML>
<html>
<head>
<base href="<%=basePath %>">
<title>My JSP 'hello.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
</head>
<body>
<!-- el表达式接收参数值 -->
${hello}
</body>
</html>
3.3.8. 启动jetty服务器
4. URL地址映射配置 & 参数绑定
4.1. URL地址映射配置之@RequestMapping
通过注解@RequestMaooing将请求与方法进行绑定,可以在类级别和方法级别声明。类基本的注解负责将一个特定的请求路径映射到一个控制器上,将url和类绑定;通过方法级别的注解可以细化映射,能够将一个特定的请求路径映射到某个具体的方法上,将url和类的方法绑定。
4.1.1. 映射单个URL
@RequestMapping(“”)&@RequestMapping(value = “”)
/**
* 路径开头是否加 斜杠"/" 均可
* @RequestMapping("/请求路径") 与 @RequestMapping("请求路径")均可
* 建议加上,如:@RequestMapping("/test02")
* 访问地址:(如果有类路径需要写在方法路径前面)
* http://ip:port/springmvc01/test02
* @return
*/
@RequestMapping("test01")
public ModelAndView test01(){
ModelAndView modelAndView = new ModelAndView();
// 设置数据
modelAndView.addObject("hello","test01");
// 设置视图名称
modelAndView.setViewName("hello");
return modelAndView;
}
4.1.2. 映射多个URL
@RequestMapping({“”,“”}) 或 @RequestMapping(value={“”,“”})
/**
* @RequestMapping 声明在方法上面,映射多个 URL
* 支持一个方法绑定多个 url 的操作
* 访问地址:(如果有类路径需要写在方法路径前面)
* http://ip:port/springmvc01/test03_01
* http://ip:port/springmvc01/test03_02
* @return
*/
/*
@RequestMapping({"test02_01", "test02_02"})
*/
@RequestMapping(value = {"test02_01", "test02_02"})
public ModelAndView test02(){
ModelAndView modelAndView = new ModelAndView();
// 设置数据
modelAndView.addObject("hello","test02");
// 设置视图名称
modelAndView.setViewName("hello");
return modelAndView;
}
4.1.3. 映射URL在控制器上
用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径
@Controller
@RequestMapping("/url")
public class UrlController {
/**
* @RequestMapping 声明在类上面,类中的的方法都是以该地址作为父路径
* 声明级别:
* 类级别 + 方法级别 (/类路径/方法路径)
* 访问地址:
* http://ip:port/springmvc01/url/test04
* @return
*/
@RequestMapping("/test04")
public ModelAndView test04(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("hello","test04");
modelAndView.setViewName("hello");
return modelAndView;
}
}
4.1.4. 设置URL映射的请求方式
默认没有设置请求方式,在HTTP请求中最常用的请求方法是GET,POST,还有其他的一些方法,如:DELET,PUT,HEAD等。
可以通过method属性设置支持的请求方式,如method-RequestMethod.POST;如果设置多种请求方式,以大括号包围,逗号隔开即可。
/**
* 设置请求方式
* 通过 method 属性设置方法支持的请求方式,默认 GET请求和 POST等请求都支持。
* 设置了请求方式,则只能按照指定的请求方式请求。
* 访问地址:(只能使用POST请求访问)
* http://ip:port/springmvc01/url/test05
* @return
*/
@RequestMapping(value = "test04",method = RequestMethod.POST)
public ModelAndView test04(){
ModelAndView modelAndView = new ModelAndView();
// 设置数据
modelAndView.addObject("hello","test04");
// 设置视图名称
modelAndView.setViewName("hello");
return modelAndView;
}```
#### 4.1.5. 通过参数名称映射URL
```java
/**
* 通过参数名称访问
* 通过参数的形式访问
* 访问地址:
* http://ip:port/springmvc01/url?test06
* @return
*/
@RequestMapping(params = "test03")
public ModelAndView test03(){
ModelAndView modelAndView = new ModelAndView();
// 设置数据
modelAndView.addObject("hello","test03");
// 设置视图名称
modelAndView.setViewName("hello");
return modelAndView;
}```
### 4.2. 参数绑定
客户端请求的参数到控制器功能处理方法上的参数的绑定,对于参数绑定非常灵活
#### 4.2.1. 基本数据类型
```java
**
* 基本类型数据绑定
* 参数值必须存在。如果没有指定参数值,也没有设置参数默认值,则会报500异常。
* @param age
* @param money
*/
@RequestMapping("date01")
public void test01(int age , int money){
System.out.println("age: " + age + " money: " + money);
}
/**
* 基本类型数据绑定
* 通过注解 @RequestParam 标记一个形参为请求参数。(注解声明在形参的前面)
* 可以通过注解的属性设置相关内容
* 设置参数的默认值 defaultValue
* @param age
* @param money
*/
@RequestMapping("date02")
public void test02(@RequestParam(defaultValue = "10") int age ,
@RequestParam(defaultValue = "20") int money){
System.out.println("age: " + age + " money: " + money);
}
/**
* 基本类型数据绑定
* 通过注解 @RequestParam 标记一个形参为请求参数。(注解声明在形参的前面)
* 可以通过注解的属性设置相关内容
* 设置参数的参数名(别名) name
* @param age
* @param money
*/
@RequestMapping("date03")
public void test03(@RequestParam(defaultValue = "10" , name = "userAge") int age ,
@RequestParam(defaultValue = "20" , name = "userMoney")int money){
System.out.println("age: " + age + " money: " + money);
}
4.2.2. 包装类型
/**
* 包装类型数据绑定 (如果数据是基本类型,建议使用包装类型)
* 客户端请求参数名与方法形参名保持一致,默认参数值为null
* 可以通过 @RequestParam 的name属性设置参数的别名,defaultValue属性设置参数默认值
* @param age
* @param money
*/
@RequestMapping("date04")
public void test04(Integer age , Integer money){
System.out.println("age: " + age + " money: " + money);
}
4.2.3. 字符串类型
/**
* 字符串数据绑定
* 客户端请求参数名与方法形参名保持一致,默认参数值为null
* 可以通过 @RequestParam 的name属性设置参数的别名,defaultValue属性设置参数默认值
* @param userName
* @param userPwd
*/
@RequestMapping("date05")
public void test05(String userName , String userPwd){
System.out.println("userName: " + userName + " userPwd: " + userPwd);
}
4.2.4. 数组类型
/**
* 数组类型数据绑定
* 客户端传参形式:str=rap&str=dance
* @param str
*/
@RequestMapping("date06")
public void test06(String[] str){
for (String s:str) {
System.out.println("s: " + s + "---");
}
}
4.2.5. JavaBean类型
package com.liuxidong.springmvc.po;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author lxd
* #Description User
* #Date: 2023/4/14 15:14
*/
public class User {
private Integer id;
private String userName;
private String userPwd;
private List<Integer> list;
private Map<Integer, String> map = new HashMap<Integer, String>();
public Map<Integer, String> getMap() {
return map;
}
public void setMap(Map<Integer, String> map) {
this.map = map;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPwd() {
return userPwd;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
public List<Integer> getList() {
return list;
}
public void setList(List<Integer> list) {
this.list = list;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", userName='" + userName + '\'' +
", userPwd='" + userPwd + '\'' +
", list=" + list +
", map=" + map +
'}';
}
}
/**
* JavaBean 数据绑定
* 客户端请求的参数名与JavaBean对象的属性字段名保持一致
* @param user
*/
@RequestMapping("date07")
public void test07(User user){
System.out.println(user);
}
4.2.6. List类型
/** @Author lxd
* List集合类型 数据绑定
* 注:集合类型的数据 使用JavaBean对象进行包装
* @Param
* @return
**/
@RequestMapping("/data08")
public void data08(User user){
System.out.println(user);
}
5. 请求转发与重定向的问题
SpringMVC 默认采用服务器内部转发的形式展示页面信息。同样也支持重定向页面。
5.1. 重定向
重定向是发一个302的状态码给浏览器,浏览器自己去请求跳转的网页。地址栏会发生改变。
重定向以 redirect: 开头
/**
* @author lxd
* 重定向到JSP页面
* #Description ViewController
* #Date: 2023/4/14 16:27
*/
@Controller
public class ViewController {
@RequestMapping("/view01")
public String test01(){
return "redirect:view.jsp";
}
/**
* 重定向到JSP页面
* 传递参数
* @return
*/
@RequestMapping("/view02")
public String test02(){
return "redirect:view.jsp?userName=admin&userPwd=12345";
}
/**
* 重定向到JSP页面
* 传递参数 (通过 RedirectAttributes 对象设置重定向参数,避免中文乱码问题)
* @param redirectAttributes
* @return
*/
@RequestMapping ("/view03")
public String test03(RedirectAttributes redirectAttributes){
redirectAttributes.addAttribute("userName","赵丽颖");
redirectAttributes.addAttribute("userPwd","123456");
return "redirect:view.jsp";
}
/**
* 重定向到JSP页面
* 返回 ModelAndView 对象
* @param modelAndView
* @return
*/
@RequestMapping("/view04")
public ModelAndView test04(ModelAndView modelAndView){
modelAndView.addObject("userName","赵丽颖");
modelAndView.addObject("userPwd","123456");
modelAndView.setViewName("redirect:view.jsp");
return modelAndView;
}
/**
* 重定向到Controller
* 返回 ModelAndView 对象
* @param modelAndView
* @return
*/
@RequestMapping("/view05")
public ModelAndView test05(ModelAndView modelAndView){
modelAndView.addObject("userName","赵丽颖");
modelAndView.addObject("userPwd","123456");
modelAndView.setViewName("redirect:test");
return modelAndView;
}
5.2. 请求转发
请求转发,直接调用跳转的页面,让它返回。对于浏览器来说,它无法感觉服务器有没有forward。地
址栏不发生改变。可以获取请求域中的数据。
请求转发以 forward: 开头
/**
* 请求转发到JSP页面
*/
@RequestMapping("/view06")
public String test06(){
return "forward:view.jsp";
}
/**
* 请求转发到JSP页面
* 设置参数
*/
@RequestMapping("view07")
public String test07(){
return "forward:view.jsp?userName=赵丽颖&userPwd=26";
}
/**
* 请求转发到JSP页面
* 设置请求域
*/
@RequestMapping("view08")
public String test08(Model model){
model.addAttribute("userName","赵丽颖");
model.addAttribute("userPwd","26");
return "forward:view.jsp";
}
/**
* 请求转发到JSP页面 (默认)
* 默认会去指定目录下找JSP页面 (配置文件中设置的)
*/
@RequestMapping("/view09")
public String test09(){
return "/../../view";
}
}
6. Spring开发与JSON数据开发
6.1. 基本概念
Json 在企业开发中已经作为通用的接口参数类型,在页面(客户端)解析很方便。SpringMVC 对于json
提供了良好的支持,这里需要修改相关配置,添加 json 数据支持功能
6.1.1. @ResponseBody
该注解用于将 Controller 的方法返回的对象,通过适当的 HttpMessageConverter 转换为指定格式后,写
入到 Response 对象的 body 数据区。
返回的数据不是 html 标签的页面,而是其他某种格式的数据时(如 json、xml 等)使用(通常用于
ajax 请求)。
6.1.2. @RequestBody
该注解用于读取 Request 请求的 body 部分数据,使用系统默认配置的 HttpMessageConverter 进行解
析,然后把相应的数据绑定到要返回的对象上 ,再把 HttpMessageConverter 返回的对象数据绑定到
controller 中方法的参数上
6.2. 使用配置
6.2.1. pom.xml添加json坐标
<!-- 添加json 依赖jar包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.10.0</version>
</dependency>
6.2.2. 修改servle-context.xml
<!-- mvc 请求映射 处理器与适配器配置 -->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter" />
<bean
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
</mvc:message-converters>
</mvc:annotation-driven
6.2.3. 注解使用
6.2.3.1. @ResponseBody
/**
* @ResponseBody 返回的是JOSN格式的数据,返回JavaBean对象
* 注解设置在方法体上
* @return
*/
@RequestMapping("/query01")
@ResponseBody
public User queryUser01(){
User user = new User();
user.setId(1);
user.setUserName("赵丽颖");
user.setUserPwd("知否知否应是绿肥红瘦");
return user;
}
/**
* @ResponseBody 返回的是JOSN格式的数据,返回JavaBean对象
* 注解设置在方法返回对象前,修饰符之后
* @return
*/
@RequestMapping("/query02")
public @ResponseBody User query02(){
User user = new User();
user.setId(2);
user.setUserName("赵丽颖");
user.setUserPwd("风吹半夏");
return user;
}
/**
* @ResponseBody 返回的是JOSN格式的数据,返回集合
* @return
*/
@RequestMapping("/query03")
@ResponseBody
public List<User> query03(){
ArrayList<User> list = new ArrayList<>();
User user = new User();
user.setId(1);
user.setUserName("赵丽颖");
user.setUserPwd("知否知否应是绿肥红瘦");
User user1 = new User();
user1.setId(2);
user1.setUserName("赵丽颖");
user1.setUserPwd("风吹半夏");
list.add(user);
list.add(user1);
return list;
}
6.2.3.2. @RequestBody
@RequestBody 注解常用来处理 content-type 不是默认的 application/x-www-form-urlcoded 类型的内
容,比如说:application/json 或者是application/xml 等。一般情况下来说常用其来处理 application/json
类型。@RequestBody接受的是一个 json 格式的字符串,一定是一个字符串。
通过 @RequestBody 可以将请求体中的 JSON 字符串绑定到相应的 bean 上,当然,也可以将其分别绑
定到对应的字符串上。
/**
* @RequestBody 规定请求的参数是JOSN格式的字符串
* 注解设置在形参前面
* @param user
* @return
*/
@RequestMapping("/getUser")
@ResponseBody
public User getUser(@RequestBody User user){
System.out.println(user);
return user;
}