SpringMVC与JSON数据开发

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能帮我们做什么?

  1. 让我们能非常简单的设计出干净的Web层;
  2. 进行更简洁的Web层开发
  3. 天生与Spring框架集成(如IOC容器、AOP等)
  4. 提供强大的约定大于配置的契约式编程支持
  5. 能简单的进行Web层的单元测试
  6. 支持灵活的URL到页面控制器的映射
  7. 非常容易与其他视图技术集成,如jsp、Velocity、
    FreeMarker等等,因为模型数据不放在特定的API
    里,而是放在一个Model里
  8. 非常灵活的数据验证、格式化和数据绑定机制,能使用任何对象进行数据绑定,不必实现特定框架的API
  9. 支持灵活的本地化等解析
  10. 更加简单的异常处理
  11. 对静态资源的支持
  12. 支持Restful风格

3. SpringMVC请求流程 & 环境搭建

3.1. Spring MVC请求处理流程分析

在这里插入图片描述
Spring MVC框架也是一个基于请求驱动的Web框架,并且使用了前端控制器模式(是用来提供一个集中
的请求处理机制,所有的请求都将由一个单一的处理程序处理来进行设计,再根据请求映射规则分发给
相应的页面控制器(动作/处理器)进行处理。首先让我们整体看一下Spring MVC处理请求的流程:

  1. 首先用户发送请求,请求被SpringMvc前端控制器(DispatherServlet)捕获;
  2. 前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调用HandlerMapping;
  3. 前端控制器(DispatherServlet)获得返回的HandlerExecutionChain(包括Handler对象以及Handler对
    象对应的拦截器);
  4. DispatcherServlet 根据获得的HandlerExecutionChain,选择一个合适的HandlerAdapter。(附注:
    如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler(…)方法);
  5. HandlerAdapter根据请求的Handler适配并执行对应的Handler;HandlerAdapter(提取Request中的模
    型数据,填充Handler入参,开始执行Handler(Controller)。 在填充Handler的入参过程中,根据配
    置,Spring将做一些额外的工作:
    HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定
    的响应信息。
    数据转换:对请求消息进行数据转换。如String转换成Integer、Double等数据格式化:
    数据格式化。 如将字符串转换成格式化数字或格式化日期等
    数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中)
  6. Handler执行完毕,返回一个ModelAndView(即模型和视图)给HandlerAdaptor
  7. HandlerAdaptor适配器将执行结果ModelAndView返回给前端控制器。
  8. 前端控制器接收到ModelAndView后,请求对应的视图解析器。
  9. 视图解析器解析ModelAndView后返回对应View;
  10. 渲染视图并返回渲染后的视图给前端控制器。
    11、最终前端控制器将渲染后的页面响应给用户或客户端

3.2. Spring MVC优势

  1. 清晰的角色划分:前端控制器(DispatcherServlet)、请求到处理器映射(HandlerMapping)、处
    理器适配器(HandlerAdapter)、视图解析器(ViewResolver)、处理器或页面控制器
    (Controller)、验证器( Validator)、命令对象(Command 请求参数绑定到的对象就叫命令对
    象)、表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。
  2. 分工明确,而且扩展点相当灵活,可以容易扩展,虽然几乎不需要
  3. 和Spring其他框架无缝集成,是其他Web框架所不具备的
  4. 可适配,通过HandlerAdapter可以支持任意的类作为处理器
  5. 可定制型,HandlerMapping ViewResolver等能够非常简单的定制
  6. 功能强大的数据验证、格式化、绑定机制
  7. 利用Spring提供的Mock对象能够非常简单的进行Web层单元测试
  8. 本地化、主题的解析的支持,使我们更容易进行国际化和主题的切换
  9. 强大的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;
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值