Spring入门05-SpringMVC01

YGFive

已于 2023-05-04 09:22:46 修改

阅读量238

点赞数

分类专栏： spring入门笔记文章标签： spring mvc

于 2023-04-14 21:31:16 首次发布

本文链接：https://blog.csdn.net/YiGeFive/article/details/130160832

版权

spring入门笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、导图

二、MVC 思想 & SpringMVC 框架概念与特点

Spring MVC是什么?

Spring MVC能帮我们做什么?

三、SpringMVC 请求流程 & 环境搭建

URL 地址映射配置之 @RequestMapping

映射单个 URL：@RequestMapping("") 或 @RequestMapping(value="")

映射多个 URL：@RequestMapping({"",""}) 或 @RequestMapping(value={"",""})

九、SpringMVC 之 JSON 数据开发

@ResponseBody

@RequestBody

json.jsp

一、导图

二、MVC 思想 & SpringMVC 框架概念与特点

什么叫MVC？

模型-视图-控制器（MVC）是一个众所周知的以设计界面应用程序为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常，模型负责封装应用程序数据在视图层展示。视图仅仅只是展示这些数据，不包含任何业务逻辑。控制器负责接收来自用户的请求，并调用后台服务（service或者dao）来处理业务逻辑。处理后，后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核心思想是将业务逻辑从界面中分离出来，允许它们单独改变而不会相互影响。

Spring MVC是什么?

Spring MVC是Spring家族中的一个web成员，它是一种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring MVC也是要简化我们日常Web开发的。

Spring MVC是服务到工作者思想的实现。前端控制器是DispatcherServlet；应用控制器拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；支持本地化/国际化(Locale)解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

其他解释参考：

Spring MVC是什么

Spring MVC能帮我们做什么?

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

三、SpringMVC 请求流程 & 环境搭建

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、最终前端控制器将渲染后的页面响应给用户或客户端

其他解释参考：

Spring MVC工作流程

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编写更容易。

四、 Spring MVC 环境搭建

开发环境 ：Idea + Maven + Jdk1.8 + Jetty

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.msb</groupId>
  <artifactId>springmvc01</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>springmvc01 Maven Webapp</name>
  <url>http://maven.apache.org</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>
    <!-- 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.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>
  </dependencies>

  <build>
  <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>8086</port>
        </httpConnector>
        <!-- 设置项目路径 -->
        <webAppConfig>
          <contextPath>/springmvc01</contextPath>
        </webAppConfig>
      </configuration>
    </plugin>
  </plugins>
  </build>

</project>

配置 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>

要想启动我们的 SpringMVC 环境，目前对于 mvc 框架的配置还未进行。以上在 web.xml 中引用了 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.msb.springmvc.controller"/>
    <!-- 使用默认的 Servlet 来响应静态文件 -->
    <mvc:default-servlet-handler/>
    <!-- 开启注解驱动-->
    <mvc:annotation-driven/>

    <!-- 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>

    <!-- 配置视图解析器 -->
    <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>
</beans>

页面控制器的编写

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * 页面控制器
 */
@Controller
public class HelloController {
    /**
     * 请求地址映射
     *      /hello.do
     * @return
     */
    @RequestMapping("/hello")
    public ModelAndView hello(){
        ModelAndView modelAndView = new ModelAndView();
        //设置数据
        modelAndView.addObject("hello", "Hello SpringMVC");
        //设置视图名称
        modelAndView.setViewName("hello");
        //return
        return modelAndView;
    }
}

添加视图页面

在 WEB-INF 下新建 jsp 文件夹，并在文件夹下新建 hello.jsp

<%@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>

启动 jetty 服务器

访问地址 http://localhost:8086/springmvc01/hello.do

五、URL 地址映射配置

URL 地址映射配置之 @RequestMapping

通过注解 @RequestMapping 将请求地址与方法进行绑定，可以在类级别和方法级别声明。类级别的注解负责将一个特定的请求路径映射到一个控制器上，将 url 和类绑定；通过方法级别的注解可以细化映射，能够将一个特定的请求路径映射到某个具体的方法上，将 url 和类的方法绑定。

映射单个 URL：@RequestMapping("") 或 @RequestMapping(value="")

// @RequestMapping("请求路径") 或  @RequestMapping("/请求路径") 均可
// 建议加上，如：@RequestMapping("/test01")
@RequestMapping(value = "/test01")
    public ModelAndView test01(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello", "test01");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

映射多个 URL：@RequestMapping({"",""}) 或 @RequestMapping(value={"",""})

@RequestMapping(value = {"/test03_01","/test03_02"})
    public ModelAndView test03(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello", "test03");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

映射 URL 在控制器上

用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

通过注解 @RequestMapping 将请求路径与方法进行绑定，可以声明在方法级别和类级别。

声明级别：

方法级别
类级别 + 方法级别（/类路径/方法路径）

访问路径：http://localhost:8086/springmvc01/url/test04

设置 URL 映射的请求方式

通过method属性设置请求方式，默认 GET和POST等请求方式都支持。
如果设置了请求方式，则必须通过指定请求方式访问。

@RequestMapping(value = "test06",method = RequestMethod.POST)
    public ModelAndView test06(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test06");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

通过参数名称映射 URL

    /**
     * 通过参数名称访问
     *      通过参数的形式访问
     *      访问地址：
     *         http://localhost:8086/springmvc01/url?test05
     * @return
     */
    @RequestMapping(params = "test05")
    public ModelAndView test05(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello", "test05");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

六、参数绑定

通过形参获取请求参数。我们可以在 Controller 的控制器方法中设置与请求参数同名的形参，以获取请求中携带的参数。当浏览器发送的请求匹配到这个控制器方法时，Spring MVC 会自动将请求参数赋值给相应的方法形参。

/**
 * 参数绑定
 *      1. 基本类型 （包装类型）
 *      2. 字符串类型
 *      3. 数组类型
 *      4. JavaBean
 *      5. 集合 List/Set/Map （了解）
 */
@Controller
public class ParamsController {
    /**
     * 基本类型数据绑定
     *      参数值必须存在。如果参数值不存在，也没有设置默认值，则会报500异常
     * @param age
     * @param money
     */
    @RequestMapping("/data01")
    public void data01(int age, double money){
        System.out.println("age="+age+", money="+money);
    }
    /**
     * 基本类型数据绑定
     *      通过注解 @RequestParam 标记一个形参作为请求参数。（注解声明在形参前面）
     *      可以通过注解的属性设置相关内容
     *          设置参数的默认值  defaultValue属性 （避免基本类型的数据为空时的500异常！）
     * @param age
     * @param money
     */
    @RequestMapping("/data02")
    public void data02(@RequestParam(defaultValue = "22") int age,
                       @RequestParam(defaultValue = "100.6") double money){
        System.out.println("age="+age+", money="+money);
    }
    /**
     * 基本类型数据绑定
     *      通过注解 @RequestParam 标记一个形参作为请求参数。（注解声明在形参前面）
     *      可以通过注解的属性设置相关内容
     *          设置参数的默认值  defaultValue属性 （避免基本类型的数据为空时的500异常！）
     *          设置参数的参数名（参数的别名）   name属性 （如果设置了别名，客户端传递的参数名 要与别名保持一致）
     * @param age
     * @param money
     */
    @RequestMapping("/data03")
    public void data03(@RequestParam(defaultValue = "22", name="userAge") int age,
                       @RequestParam(defaultValue = "100.6", name = "userMoney") double money){
        System.out.println("age="+age+", money="+money);
    }
    /**
     * 包装类型数据绑定
     *      请求的参数名要与方法的形参名保持一致（在未设置别名的情况下），默认值为null
     *      可以通过注解 @RequestParam 的属性设置 默认值 和 别名
     * @param age
     * @param money
     */
    @RequestMapping("/data04")
    public void data04(Integer age, Double money){
        System.out.println("age:" + age + "，money:" + money);
    }
    /**
     * 字符串类型数据绑定
     *      请求的参数名要与方法的形参名保持一致（在未设置别名的情况下），默认值为 null
     *      可以通过注解 @RequestParam 的属性设置 默认值 和 别名
     * @param userName
     * @param userPwd
     */
    @RequestMapping("/data05")
    public void data05(String userName, String userPwd){
        System.out.println("userName:" + userName + "，userPwd:" + userPwd);
    }

    /**
     * 数组类型数据绑定
     *      客户端传递参数形式：hobbys=sing&hobbys=dance&hobbys=rap
     * @param hobbys
     */
    @RequestMapping("/data06")
    public void data06(String[] hobbys){
        for (String hobby: hobbys){
            System.out.println(hobby);
        }
    }
    /**
     * JavaBean类型 数据绑定
     *      客户端请求的参数名与javabean对象中属性字段名保持一致
     * @param user
     */
    @RequestMapping("/data07")
    public void data07(User user){
        System.out.println(user);
    }

    /**
     * List集合类型 数据绑定
     *      注：集合类型的数据，使用JavaBean对象进行包装
     * @param user
     */
    @RequestMapping("/data08")
    public void data08(User user){
        System.out.println(user);
    }
}

通过控制器方法的形参获取请求参数时注意：

必须保证参数名一致
无视数据类型
不适用于请求参数过多的请求
同名请求参数的处理方式

相关参考：

Spring MVC获取请求参数

七、请求域对象

在 Spring MVC 中，控制器在接收到 DispatcherServlet 分发过来的请求后，会继续调用 Model 层对请求进行处理。Model 层处理完请求后的结果被称为模型数据，会将模型数据返回给 Controller。Controller 在接收到 Model 层返回的模型数据后，下一步就是将模型数据通过域对象共享的方式传递给 View 视图进行渲染，最终返回给客户端展示。

域对象是服务器在内存上创建的一块存储空间，主要用不同动态资源之间的数据传递和数据共享。在 Spring MVC 中，常用的域对象有 request 域对象、session 域对象、application 域对象等。

参考资料：

Spring MVC域对象共享数据

代码：

/**
 * 请求域对象设置 API
 *      ModelAndView
 *      Model
 *      ModelMap
 *      Map
 *      HttpServletRequest
 */
@Controller
public class ModelController {
    /**
     * ModelAndView
     * @return
     */
    @RequestMapping("/model01")
    public ModelAndView model01(){
        /**
         * 数据模型：Model
         * 视图：View
         */
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据模型（请求域对象的数据）
        modelAndView.addObject("hello", "Hello Model01");
        // 设置视图
        modelAndView.setViewName("hello");
        // 返回modelAndView
        return modelAndView;
    }
    /**
     * ModelMap
     * @param modelMap
     * @return
     */
    @RequestMapping("/model02")
    public String model02(ModelMap modelMap){
        // 设置请求域对象
        modelMap.addAttribute("hello","Hello Model02");
        //返回视图
        return "hello";
    }
    /**
     * Model
     * @param model
     * @return
     */
    @RequestMapping("/model03")
    public String model03(Model model){
        // 设置请求域对象
        model.addAttribute("hello", "Hello Model03");
        // 返回视图
        return "hello";
    }
    /**
     * Map
     * @param map
     * @return
     */
    @RequestMapping("/model04")
    public String model04(Map map){
        // 设置请求域对象
        map.put("hello", "Hello Model03");
        //返回视图
        return "hello";
    }
    /**
     * HttpServletRequest对象
     * @param request
     * @return
     */
    public String model05(HttpServletRequest request, HttpSession session) {
        // 设置请求域对象
        request.setAttribute("hello", "Hello Model05");
        // 返回视图
        return "hello";
    }

}

八、请求转发与重定向

SpringMVC 默认采用服务器内部转发的形式展示页面信息。同样也支持重定向页面。

重定向以 redirect: 开头

重定向是发一个302的状态码给浏览器，浏览器自己去请求跳转的网页。地址栏会发生改变。

页面中获取参数值：${param.参数名}

请求转发以 forward: 开头

请求转发，直接调用跳转的页面，让它返回。对于浏览器来说，它无法感觉服务器有没有forward。地址栏不发生改变。可以获取请求域中的数据。

页面中获取数据：

获取传递的参数：${param.参数名}

获取请求域的数据：${请求域中设置的名称}

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

/**
 * 请求转发与重定向
 */
@Controller
public class ViewController {
    /**
     * 重定向到JSP页面
     * @return
     */
    @RequestMapping("/view01")
    public String view01(Model model){
        // 设置请求域对象
        model.addAttribute("name", "admin");
        return "redirect:view.jsp";
    }
    /**
     * 重定向到JSP页面
     *      传递参数
     * @return
     */
    @RequestMapping("/view02")
    public String view02(){
        return "redirect:view.jsp?uname=zhangsan&upwd=123456";
    }
    /**
     * 重定向到JSP页面
     *      传递中文参数 （传递中文参数会出现乱码）
     * @return
     */
    @RequestMapping("/view03")
    public String view03(){
        return "redirect:view.jsp?uname=张三&upwd=123456";
    }
    /**
     * 重定向到JSP页面
     *      传递参数 （通过 RedirectAttributes 对象设置重定向的参数，避免中文乱码问题）
     * @param attributes
     * @return
     */
    @RequestMapping("/view04")
    public String view04(RedirectAttributes attributes){
        //设置参数
        attributes.addAttribute("uname", "张三");
        attributes.addAttribute("upwd", "123456");
        return "redirect:view.jsp";
    }
    /**
     * 重定向到JSP页面
     *      返回的是 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view05")
    public ModelAndView view05(ModelAndView modelAndView){
        //设置模型数据
        modelAndView.addObject("uname", "李四");
        modelAndView.addObject("upwd", "admin");
        // 设置视图
        modelAndView.setViewName("redirect:view.jsp");
        return modelAndView;
    }
    /**
     * 重定向到Controller
     *      返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view06")
    public ModelAndView view06(ModelAndView modelAndView){
        //设置模型数据
        modelAndView.addObject("uname", "王五");
        modelAndView.addObject("upwd", "admin");
        // 设置视图
        modelAndView.setViewName("redirect:test");
        return modelAndView;
    }

    /**
     * 请求转发到jsp页面
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view07")
    public String view07(ModelAndView modelAndView){
        return "forward:view.jsp";
    }
    /**
     * 请求转发到JSP页面
     *      传递参数 （中文不乱码）
     * @return
     */
    @RequestMapping("/view08")
    public String view08(){
        return "forward:view.jsp?uname=张三&upwd=123";
    }
    /**
     * 请求转发到JSP页面
     *      设置请求域
     * @param model
     * @return
     */
    @RequestMapping("/view09")
    public String view09(Model model){
        //设置请求域
        model.addAttribute("name", "管理员");
        return "forward:view.jsp?uname=张三&upwd=123";
    }

    /**
     * 请求转发到JSP页面（默认）
     *      默认会去指定的目录下查找JSP页面 （配置文件中设置的）
     * @param model
     * @return
     */
    @RequestMapping("/view10")
    public String view10(Model model){
        //设置请求域
        model.addAttribute("name", "管理员");
        return "/../../view";
    }
    /**
     * 请求转发到Controller
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view11")
    public ModelAndView view11(ModelAndView modelAndView){
        modelAndView.setViewName("forward:test");
        return modelAndView;
    }
    /**
     * 请求转发到Controller
     *      传递参数
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view12")
    public ModelAndView view12(ModelAndView modelAndView){
        modelAndView.setViewName("forward:test?uname=admin&upwd=123");
        return modelAndView;
    }
}

九、SpringMVC 之 JSON 数据开发

Json 在企业开发中已经作为通用的接口参数类型，在页面（客户端）解析很方便。SpringMVC 对于json提供了良好的支持，这里需要修改相关配置，添加 json 数据支持功能。

@ResponseBody

该注解用于将 Controller 的方法返回的对象，通过 HttpMessageConverter 转换为指定格式后，写入到 Response 对象的 body 数据区。

@RequestBody

该注解用于读取 Request 请求的 body 部分数据，使用系统默认配置的HttpMessageConverter 进行解析，然后把相应的数据绑定到要返回的对象上，再把 HttpMessageConverter 返回的对象数据绑定到controller 中方法的参数上。

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * @ResponseBody 返回的数据是JSON格式（返回JavaBean对象）
     *      注解设置在方法体上
     * @return
     */
    @RequestMapping("/query01")
    @ResponseBody
    public User queryUser01(){
        User user = new User();
        user.setId(1);
        user.setUserName("阿炯");
        user.setUserPwd("223344");
        return user;
    }
    /**
     * @ResponseBody 返回的数据是JSON格式（返回JavaBean对象）
     *      注解设置在方法返回对象前，修饰符后
     * @return
     */
    @RequestMapping("/query02")
    public @ResponseBody User queryUser02(){
        User user = new User();
        user.setId(2);
        user.setUserName("快乐阿炯");
        user.setUserPwd("55667788");
        return user;
    }

    @RequestMapping("/query03")
    @ResponseBody
    public List<User> queryUser03(){
        List<User> list = new ArrayList<>();
        User user = new User();
        user.setId(3);
        user.setUserName("叙利亚炯");
        user.setUserPwd("55667788");
        User user2 = new User();
        user2.setId(4);
        user2.setUserName("加勒比炯");
        user2.setUserPwd("55667788");
        list.add(user);
        list.add(user2);

        return list;
    }

    /**
     * 当ajax请求时， @ResponseBody会将数据转化成json格式，响应给ajax的回调函数
     * @return
     */
    @RequestMapping("/query04")
    @ResponseBody
    public User queryUser04(){
        User user = new User();
        user.setId(5);
        user.setUserName("小巨人炯");
        user.setUserPwd("223344");
        return user;
    }
    /**
     * @RequestBody 规定请求的参数必须是JSON格式的字符串
     *      注解设置在形参前面
     *      1. @RequestBody 处理不是默认的类型（application/x-www-form-urlcoded）的内容。
     *          比如说：application/json 或者是application/xml 等。
     *      2. 请求的参数一定是JSON格式的字符串，一定是字符串
     * @param user
     * @return
     */
    @RequestMapping("/query05")
    @ResponseBody
    public User queryUser05(@RequestBody User user) {   /*设置了@RequestBody 要求必须传递json格式字符串*/
        System.out.println(user);
        return user;
    }

}

json.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Json处理</title>
    <%--引入Jquery的核心js文件--%>
    <script type="text/javascript" src="js/jquery-3.4.1.js"></script>
</head>
<body>
    <input type="button" value="响应json数据" onclick="test01()">
    <input type="button" value="设置请求JSON" onclick="test02()">
    <script type="text/javascript">
        /**
         * 通过ajax访问后台的方法，获取返回的数据
         */
        function test01(){
            //发送ajax请求
            $.ajax({
                //请求方式 GET|POST
                type:"post",
                //请求路径 URL
                url:"user/query04",
                //设置参数
                data:{
                    "userName":"root",
                    "userPwd":"123"
                },
                //回调函数，接收服务端返回的结果（函数中的形参用来接收放回的数据）
                success:function (data){
                    console.log(data);
                }
            });
        }
        /**
         * 传递JSON格式的参数
         */
        function test02(){
            // 发送ajax请求
            $.ajax({
                // 请求方式 GET|POST
                type:"post",
                // 请求路径
                url:"user/query05",
                // 设置服务器请求参数的类型为 application/json
                contentType:"application/json",
                data: '{"userName":"zhangsan", "userPwd":"123456"}',
                // 回调函数，接收服务端返回的结果 (函数中的形参用来接收返回的数据)
                success: function (data) {
                    console.log(data);
                }
            });
        }
    </script>
</body>
</html>

YGFive

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring入门05-SpringMVC01

Spring MVC是Spring家族中的一个web成员，它是一种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring MVC也是要简化我们日常Web开发的。类级别的注解负责将一个特定的请求路径映射到一个控制器上，将 url 和类绑定；通过方法级别的注解可以细化映射，能够将一个特定的请求路径映射到某个具体的方法上，将 url 和类的方法绑定。
复制链接

扫一扫