返回对象
Object
处理器方法也可以返回
Object
对象。这个
Object
可以是
Integer
,
String
,自定义对象,
Map
,
List
等。但返回的对象不是作为逻辑视图出现的,而是作为直接在页面显示的数据出
现的。
返回对象,需要使用
@ResponseBody
注解,将转换后的
JSON
数据放入到响应体中。
项目结构
![](https://i-blog.csdnimg.cn/blog_migrate/e169313b1f258c9a628ca18e1960f6fc.png)
1.导入jackson的pom.xml依赖
由于返回
Object
数据,一般都是将数据转化为了
JSON
对象后传递给浏览器页面的。而
这个由
Object
转换为
JSON
,是由
Jackson
工具完成的。所以需要导入
Jackson
的相关
Jar
包。
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.it</groupId>
<artifactId>springMVC4Return</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>springMVCHello Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!--springMVC依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!-- jackson依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编码和编译和JDK版本 -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
2.在springmvc.xml配置文件中声明注解驱动
将
Object
数据转化为
JSON
数据,需要由消息转换器
HttpMessageConverter
完成。而转
换器的开启,需要由
<mvc:annotation-driven/>
来完成。
SpringMVC
使用消息转换器实现请求数据和对象,处理器方法返回对象和响应输出之间
的自动转换
当
Spring
容器进行初始化过程中,在
<mvc:annotation-driven/>
处创建注解驱动时,默认
创建了七个
HttpMessageConverter
对象。也就是说,我们注册
<mvc:annotation-driven/>
,就
是为了让容器为我们创建
HttpMessageConverter
对象。
![](https://i-blog.csdnimg.cn/blog_migrate/7a758570b2ca1fd4dbba84530456c929.png)
HttpMessageConverter
接口
:
HttpMessageConverter<T>
是
Spring3.0
新添加的一个接口,
负责将请求信息转换为一个对象(类型为
T
),将对象(类型为
T
)输出为响应信息
HttpMessageConverter<T>
接口定义的方法:
boolean canRead(Class<?> clazz,MediaType mediaType):
指定转换器可以读取的对象类型,即
转 换 器 是 否 可 将 请 求 信 息 转 换 为
clazz
类 型 的 对 象 , 同 时 指 定 支 持
MIME
类型
(text/html,applaiction/json
等
)
boolean canWrite(Class<?> clazz,MediaType mediaType):
指定转换器是否可将
clazz
类型的对
象写到响应流中,响应流支持的媒体类型在
MediaType
中定义。
LIst<MediaType>getSupportMediaTypes()
:该转换器支持的媒体类
型。
T read(Class<? extends T> clazz,HttpInputMessage inputMessage)
:将请求信息流转换为
T
类型
的对象。
void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):
将
T
类型的对象写
到响应流中,同时指定相应的媒体类型为
contentType
加入注解驱动
<mvc:annotation-driven/>
后适配器类的
messageConverters
属性值
<?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"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器-->
<context:component-scan base-package="com.it.controller"/>
<!--声明springmvc框架中的视图解析器,帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀:视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/"/>
<!-- 后缀:视图文件的扩展名-->
<property name="suffix" value=".jsp"/>
</bean>
<!-- 注解驱动 -->
<mvc:annotation-driven/>
</beans>
3.定义Student类
package com.it.entity;
//用来保存请求值的一个普通类
public class Student {
//使用对象接收参数,属性名和请求中的参数名一样
private String name;
private Integer age;
public Student() {
System.out.println("Student无参构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("setName"+name);
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
System.out.println("setAge"+age);
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
4.定义MyController 类
package com.it.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.it.entity.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@Controller
public class MyController {
// 处理器方法返回String--表示逻辑视图名称,需要配置视图解析器
@RequestMapping(value = "/returnString-view.do")
public String doReturnView(HttpServletRequest request, String name, Integer age){
//手动添加数据到request作用域
request.setAttribute("myname",name);
request.setAttribute("myage",age);
//show:逻辑视图名称,项目中配置了视图解析器。框架对视图执行forward转发操作
return "show";
}
//处理器方法返回String,表示完整视图路径,此时不能配置视图解析器
@RequestMapping(value = "/returnString-view2.do")
public String doReturnView2(HttpServletRequest request, String name, Integer age){
//手动添加数据到request作用域
request.setAttribute("myname",name);
request.setAttribute("myage",age);
//完整视图路径,项目中不能配置视图解析器
return "/WEB-INF/view/show.jsp";
}
//处理器方法返回void,响应ajax请求
@RequestMapping(value = "/returnVoid-ajax.do")
public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
//处理ajax,使用json做数据的格式
//暂时认为service调用完成了,使用Student表示处理的结果
Student student=new Student();
student.setName(name);
student.setAge(age);
String json="";
//把结果对象转为json格式的数据
if (student!=null){
ObjectMapper om=new ObjectMapper();
json=om.writeValueAsString(student);
}
//输出数据,响应ajax请求
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
PrintWriter out=response.getWriter();
out.println(json);
out.flush();
out.close();
}
//处理器方法返回一个Student,通过框架转为json,响应ajax请求
/**
* @ResponseBody:把处理器方法返回对象转为json后,通过HttpServletResponse输出给浏览器
* 位置:方法的定义上面。和其它注解不区分先后顺序
*
* 返回对象框架的处理流程:
*1.框架会返回Student类型,调用框架中的ArrayList<HttpMessageConverter>中每个类的canWrite()方法
* 检查那个HttpMessageConverter接口的实现类能处理Student类型的数据。--MappingJackson2HttpMessageConverter
*
* 2.框架会调用现类的write(),MappingJackson2HttpMessageConverter的write()方法
* 把李四同学的student对象转为json,调用Jackson的ObjectMapping实现转为json
* contentType:application/json;charset=utf-8
*
* 3.框架会调用 @ResponseBody把2步骤的结果数据输出到浏览器,ajax请求处理完成
*/
@RequestMapping(value = "/returnStudentJson.do")
@ResponseBody
public Student doStudnetJsonObject(String name,Integer age){
//调用service,获取请求结果的数据,Student对象表示结果数据
Student student=new Student();
student.setName("小明");
student.setAge(20);
return student;//会被框架转为json
}
}
5.定义index.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script type="text/javascript" src="js/jquery-3.3.1.min.js"></script>
<script type="text/javascript">
$(function () {
$("#btn1").click(function () {
// alert("按钮单击了")
$.ajax({
//url:"returnVoid-ajax.do",
url:"returnStudentJson.do",
data:{
name:"张山",
age:"22"
},
type:"post",
//dataType:"json",
success:function (resp) {
//resp从服务器端返回的是json格式的字符串{"name":"张山","age":22}
//jquery会把字符串转为json对象,赋值给resp形参
alert(resp.name+" "+resp.age);
}
})
})
})
</script>
</head>
<body>
<h2>处理器方法的返回值</h2>
<p>处理器方法返回String,表示视图名称</p>
<form action="returnString-view.do" method="post">
姓名:<input type="text" name="name"/><br>
年龄:<input type="text" name="age"/><br>
<input type="submit" value="提交参数"/>
</form>
<p>处理器方法返回String,表示视图完整路径</p>
<form action="returnString-view2.do" method="post">
姓名:<input type="text" name="name"/><br>
年龄:<input type="text" name="age"/><br>
<input type="submit" value="提交参数"/>
</form>
<br>
<p>处理器方法的返回值为void</p>
<button id="btn">发起ajax请求</button>
<br>
<p>处理器方法的返回值为Student对象</p>
<button id="btn1">发起ajax请求</button>
</body>
</html>
6.web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--
1.声明,注册springmvc核心对象DispatcherServlet
需要在tomcat服务器启动后,创建 DispatcherServlet对象的实例,
因为DispatcherServlet在他的创建过程中,会同时创建springmvc容器对象,
读取springmvc的配置文件时,可以把配置文件都创建好当用户发起请求时就可以直接访问对象
2.servlet初始化会执行init()方法,DispatcherServlet在init()中{
//创建容器,读取配置文件
WebApplicationContext wac=new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,wac);
}
-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--自定义springmvc读取的配置文件的位置-->
<init-param>
<!-- springmvc的配置文件的位置属性-->
<param-name>contextConfigLocation</param-name>
<!-- 指定自定义文件的位置-->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在tomcat启动后,创建Servlet对象
load-on-startup:表示tomcat启动后创建对象的顺序,它的值是整数,数值越小,tomcat创建对象的时间越早(大于等于0的整数)
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--
使用框架的时候,url-pattern可以使用两种值
1.使用扩展名的方式,语法 *.xxxx,xxxx是自定义的扩展名,常用的方法 *.do,*.action,*.mvc等等。
2.使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!-- 注册声明过滤器-->
<filter>
<filter-name>characterEncodingFilter</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>
<!-- 强制请求对象(HttpServletRequest)使用 encoding编码的值 -->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!--强制应答对象(HttpServletResponse)使用encoding编码的值 -->
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
项目结果
点击处理器方法的返回值为Student对象下的按钮,发起ajax请求。