springmvc第十个练习（@responseBody处理器方法返回值为Student对象）

做一道光

已于 2022-06-30 15:30:23 修改

阅读量292

点赞数 2

分类专栏： springMVC 文章标签： java 前端服务器

于 2022-06-20 19:00:28 首次发布

本文链接：https://blog.csdn.net/weixin_59334478/article/details/125378396

版权

springMVC 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

返回对象 Object

处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer ， String ，自定义对象， Map ， List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出

现的。

返回对象，需要使用 @ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。

项目结构

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 对象。

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请求。

做一道光

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
springmvc第十个练习（@responseBody处理器方法返回值为Student对象）

1.导入jackson的pom.xml依赖2.在springmvc.xml配置文件中声明注解驱动 3.定义Student类4.定义MyController 类5.定义index.jsp页面6.web.xml项目结果点击处理器方法的返回值为Student对象下的按钮，发起ajax请求。......
复制链接

扫一扫