SSM【定制化】～Spring MVC

R.quite

已于 2022-07-19 20:00:17 修改

阅读量317

点赞数

分类专栏： SSM【定制化】 Spring【定制化】文章标签： mybatis java spring

于 2022-07-16 17:57:27 首次发布

本文链接：https://blog.csdn.net/qq_41135440/article/details/125823029

版权

SSM【定制化】同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

Spring【定制化】

2 篇文章 0 订阅

订阅专栏

1、概述

1.1、什么是SpringMVC？

JavaEE体系结构包括四层，从上到下分别：
1. 应用层
2. Web层
3. 业务层
4. 持久层
Struts和SpringMVC是Web层的框架.
Spring是业务层的框架.
Hibernate和MyBatis是持久层的框架.

1.2、MVC 设计模式

SpringMVC是一种基于Java，实现了Web MVC设计模式，请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web层进行职责解耦。
基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，SpringMVC也是要简化我们日常Web开发。
MVC设计模式的任务是将包含业务数据的模块与显示模块的视图解耦。

1.3、SpringMVC架构

DispatcherServlet：核心的前端控制器。
DispatcherServlet是前置控制器，配置在web.xml中的。拦截匹配的请求，Servlet拦截匹配规则要自己定义，把拦截下来的请求，依据相应的规则分发到目标Controller来处理，是配置spring MVC的第一步。

在这里插入图片描述

1.3.1、DispatcherServlet 具体执行流程

1、浏览器发送请求 ——> DispatcherServlet

前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制;

2、DispatcherServlet ——> HandlerMapping

处理器映射器将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器对象、多个HandlerInterceptor拦截器）对象；

3、DispatcherServlet ——> HandlerAdapter

处理器适配器将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4、HandlerAdapter ——> 调用处理器相应功能处理方法

调用处理器相应功能处理方法，并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；

5、ModelAndView对象（Model部分是业务对象返回的模型数据，View部分为逻辑视图名）——> ViewResolver

视图解析器将把逻辑视图名解析为具体的View；

6、View ——> 渲染

View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；

7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

2、入门案例

注意：最好按照这个方法创建web项目，不然可能会遇到奇奇怪怪的问题。

2.1、创建 maven 项目

在这里插入图片描述

2.2、引入 SpringMVC 依赖

<!-- webmvc 依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>

2.3、创建 Controller 控制器

在 java.com.ruanjia.controller 包下创建 IndexController 类.

//@Controller注解：表示这是一个控制器
@Controller
public class IndexController
{

    // 访问路径：localhost:8080/main --> /WEB-INF/views/main.jsp
    @GetMapping("main")
    public Object main()
    {
        return new ModelAndView("main");
    }
}

2.4、创建 Spring-MVC.xml 配置文件

Spring MVC 核心配置文件。

<beans 	xmlns="http://www.springframework.org/schema/beans"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:mvc="http://www.springframework.org/schema/mvc"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="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
							http://www.springframework.org/schema/mvc
							http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 扫描所有 Controller 组件（bean）： base-package="扫面包路径"-->
    <context:component-scan base-package="com.ruanjia.controller">
        <!-- 只扫描 Controller 注解的组件 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 开启MVC注解驱动（注解模式） -->
    <mvc:annotation-driven />

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/views/"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

2.5、创建 webapp 目录

先创建 webapp 目录
在 webapp 目录下创建 WEB-INF 目录（该目录是不能直接访问，是一个安全目录）
在 WEB-INF 目录下创建 web.xml 配置文件（重点文件）
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、DispatcherServlet：SpringMVC的核心控制器　-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--
        初始化：Servlet的初始化参数，读取SpringMvc核心配置文件内容，创建SpringMVC规则。
    -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:Spring-MVC.xml</param-value>
    </init-param>
    <!--启动时加载-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

2.6、创建 main.jsp

在 WEB-INF 目录下创建 views 目录
在 views 目录下面创建 main.jsp
main.jsp 内容如下：

<html>
<body>
<div>
    Hello SpringMvc.
</div>
</body>
</html>

2.7、运行测试

使用 Tomcat 运行该项目
访问地址：localhost:8080/main

在这里插入图片描述

至此，成功入门！

2.8、完整项目结构

在这里插入图片描述

三、接收请求参数多种方式

前端发起请求携带参数，后端 Controller 层接收请求参数。

3.1、基本类型参数

3.1.1、普通接收

1、get 请求参数接收方式

@RestController
public class ParamsController
{

    //接收 Integer 参数：localhost:8080/test01?intPam=111
    @RequestMapping(value = "/test01", method = RequestMethod.GET)
    public Object intPam(Integer intPam)
    {
        return intPam;
    }

    //接收 String 参数：localhost:8080/test02?strPam=111
    @RequestMapping(value = "/test02", method = RequestMethod.GET)
    public Object stringPam(String strPam)
    {
        return strPam;
    }

    //接收 Long 类型参数：localhost:8080/test03?logPam=111
    @RequestMapping(value = "/test03", method = RequestMethod.GET)
    public Object logPam(Long logPam)
    {
        return logPam;
    }

    /* ------------------------------------------数组形式接收参数------------------------------------------ */

    //接收 Integer[] 类型参数：localhost:8080/test04?integers=111,222,333
    @RequestMapping(value = "test04", method = RequestMethod.GET)
    public Object intPams(Integer[] integers)
    {
        return integers;
    }
    
	//接收 String[] 类型参数：localhost:8080/test05?strings=hello,123,你好
    @RequestMapping(value = "test05", method = RequestMethod.GET)
    public Object strPams(String[] strings)
    {
        return strings;
    }

    //接收 Long[] 类型参数：localhost:8080/test06?longs=111,222,333
    @RequestMapping(value = "test06", method = RequestMethod.GET)
    public Object logPams(Long[] longs)
    {
        return longs;
    }

}

2、post 请求参数接收方式

这里使用 Postman 测试（Postman是一个接口请求测试工具，可以接受多种请求方式）.

1、Controller 层代码

@RestController
@RequestMapping("/post")
public class PostParamsController
{

    //接收 Integer 参数
    @RequestMapping(value = "/test01", method = RequestMethod.POST)
    public Object intPam(Integer intPam)
    {
        return result("Integer", intPam);
    }

    //接收 String 参数
    @RequestMapping(value = "/test02", method = RequestMethod.POST)
    public Object stringPam(String strPam)
    {
        return result("String", strPam);
    }

    //接收 Long 类型参数
    @RequestMapping(value = "/test03", method = RequestMethod.POST)
    public Object logPam(Long logPam)
    {

        return result("Long : ", logPam);
    }

    private Object result(String msg, Object param)
    {
        return "post response "+msg+" : "+param;
    }

    /* ------------------------------------------数组形式接收参数------------------------------------------ */

    @RequestMapping(value = "test04", method = RequestMethod.POST)
    public Object intPams(Integer[] integers)
    {
        return integers;
    }

    @RequestMapping(value = "test05", method = RequestMethod.POST)
    public Object strPams(String[] strings)
    {
        return strings;
    }

    @RequestMapping(value = "test06", method = RequestMethod.POST)
    public Object logPams(Long[] longs)
    {
        return longs;
    }
    
}

2、jsp代码

使用 form 表单提交 post 请求。
form 标签的 action 属性指定 Controller 层接口地址，method 属性指定请求方式（get/post）。
input 标签的 name 属性值要和 Controller 层，对应接口的参数属性名称一致（不一致无法接收）。

<html>
<body>
    <div>
        <span>Integer：</span>
        <form action="/post/test01" method="post">
            <input type="text" name="intPam" />
            <button type="submit">提交</button>
        </form>
        <br>
        <span>String：</span>
        <form action="/post/test02" method="post">
            <input type="text" name="strPam" />
            <button type="submit">提交</button>
        </form>
        <br>
        <span>Long：</span>
        <form action="/post/test03" method="post">
            <input type="text" name="logPam" />
            <button type="submit">提交</button>
        </form>
        <br>

        <p>---------------------------------------------------数组参数请求--------------------------------------------------</p>
        <br>

        <span>Integer[]：</span>
        <form action="/post/test04" method="post">
            <input type="text" name="integers" />
            <button type="submit">提交</button>
        </form>
        <br>
        <span>String[]：</span>
        <form action="/post/test05" method="post">
            <input type="text" name="strings" />
            <button type="submit">提交</button>
        </form>
        <br>
        <span>Long[]：</span>
        <form action="/post/test06" method="post">
            <input type="text" name="longs" />
            <button type="submit">提交</button>
        </form>
    </div>
</body>
</html>

3.1.2、注解接收

使用注解绑定前端传递的参数。

1、@RequestParam

作用：用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter("name")，它有三个常用参数：
1. defaultValue = "0"：指定默认值
2. required = false/true：required 通过boolean设置是否是必须要传入的参数（默认 true）
3. value = "xxx"：参数名（与前端参数名一致）

//url格式：localhost:8080/test01?name=HelloName
@RequestMapping("/test01")
public Object test01(@RequestParam(value="fast_name", required=true) String name)
{
    return name;
}

2、@RequestBody

作用：用于在SpringMVC后台控制层获取参数（Entity类型参数），它有一个参数：
1. required = true/false：required 通过boolean设置是否是必须要传入的参数（默认 true）
要以 JSON 形式传递参数

1、User 实体对象

public class User
{
    private Long userId;
    private String username;
    private List<Long> roles;
    private String[] hobby;
    
    //前端参数格式：2022-07-17 14:14:00
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date dateTime;

    //getter/setter等方法
}

2、Controller 层接口

用于 Controller 层接收参数

@RequestMapping(value = "test01", method = RequestMethod.POST)
public Object test01(@RequestBody User user)
{
    return user;
}

3、使用 Postman 测试：

注意：JSON 格式提交.

{
    "userId": 1,
    "username": "ruanjia",
    "roles": [1,2,3],
    "hobby": ["打篮球", "嘻嘻哈哈", "你已经抖音中毒"],
    "dateTime": "2022-07-17 14:02:00"
}

3.2、实体类型参数

前端传递 Query Params

3.2.1、普通接收

1、User 实体对象

public class User
{
    private Long userId;
    private String username;
    private List<Long> roles;
    private String[] hobby;
    
    //前端参数格式：2022-07-17 14:14:00
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date dateTime;

    //getter/setter等方法
}

2、Controller 层接口

@RequestMapping(value = "test02", method = RequestMethod.POST)
public Object test02(User user)
{
    return user;
}

3、Postman 测试

在这里插入图片描述
测试结果：

3.2.1、注解接收

@RequestBody：接收 JSON 格式数据

1、User 实体对象

public class User
{
    private Long userId;
    private String username;
    private List<Long> roles;
    private String[] hobby;
    
    //前端参数格式：2022-07-17 14:14:00
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date dateTime;

    //getter/setter等方法
}

2、Controller 层接口

@RequestMapping(value = "test01", method = RequestMethod.POST)
public Object test01(@RequestBody User user)
{
    return user;
}

3、Postman 测试

3.1、传递参数

{
    "userId": 1,
    "username": "ruanjia",
    "roles": [1,2,3],
    "hobby": ["打篮球", "嘻嘻哈哈", "你已经抖音中毒"],
    "dateTime": "2022-07-17 14:02:00"
}

在这里插入图片描述

测试结果：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L2byjwXH-1658231598912)(C:\Users\Administrator\Desktop\Typora-img\image-20220717152104987.png)]$

3.3、数组类型参数

3.3.1、普通接收

// http://localhost:8080/array/test01?hobbys=打篮球,抖音中毒
@RequestMapping(value = "test01", method = RequestMethod.GET)
public Object test01(String[] hobbys)
{
    return hobbys;
}

3.3.2、注解接收

// http://localhost:8080/array/test02?names=打篮球,抖音中毒
@RequestMapping(value = "test02", method = RequestMethod.GET)
public Object test02(@RequestParam("names") String[] hobbys)
{
    return hobbys;
}

3.4、集合类型参数

建议配合注解接收参数。

3.4.1、注解接收

// http://localhost:8080/array/test04?roleIds=11,22,33,44,55
@RequestMapping(value = "test04", method = RequestMethod.GET)
public Object test04(@RequestParam("roleIds") List<Long> ids)
{
    return ids;
}

3.5、路径类型参数

使用 @PathVariable("") 绑定参数。
简写形式：@PathVariable，使用参数名作为绑定参数。

// localhost:8080/array/test05/10001
@RequestMapping(value = "test05/{userId}", method = RequestMethod.GET)
public Object test05(@PathVariable("userId") Long userId)
{
    return userId;
}

// 简写形式
@RequestMapping(value = "test07/{userId}", method = RequestMethod.GET)
public Object test07(@PathVariable Long userId)
{
    return userId;
}

// localhost:8080/array/test06/Hello
@RequestMapping(value = "test06/{name}", method = RequestMethod.GET)
public Object test06(@PathVariable("name") String name)
{
    return name;
}

四、中文乱码

4.1、post 请求中文参数乱码问题

在 web.xml 配置编码过滤器

<!-- 配置过滤器，解决中文乱码的问题 -->
<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>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

4.2、String 类型响应乱码问题

1、创建一个配置类

public class DefaultCharset implements BeanPostProcessor
{
    //Bean 后处理器：实例化之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
    {
        //如果返回的是String类型数据，设置UTF8
        if(bean instanceof StringHttpMessageConverter)
        {
            MediaType mediaType = new MediaType("text", "html", Charset.forName("UTF-8"));
            List<MediaType> types = new ArrayList<MediaType>();
            types.add(mediaType);
            ((StringHttpMessageConverter) bean).setSupportedMediaTypes(types);
        }
        return bean;
    }
}

2、把这个配置类注册 Spring Bean 容器即可

<!-- 解决响应中文乱码 -->
<bean class="com.ruanjia.config.DefaultCharset" />

4.3、Tomcat 控制台乱码

1、修改 Tomcat 配置文件（logging.properties）

# 编码修改为 UTF-8
java.util.logging.ConsoleHandler.encoding = UTF-8

在这里插入图片描述

2、修改 idea 配置

在文件最后添加配置：-Dfile.encoding=UTF-8

在这里插入图片描述

4.4、JSP页面乱码

头部添加

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

4.5、Tomcat 控制台打印中文乱码

-Dfile.encoding=UTF-8

在这里插入图片描述

五、MVC 跳转

Spring MVC 请求方式分为转发、重定向 2 种：
1. 转发：forward
2. 重定向：redirect

5.1、转发

转发是将用户对当前处理的请求转发给另一个视图或处理请求（转发是服务器行为）;
以前的 request 中存放的信息不会失效;
客户浏览器发送 http 请求，Web 服务器接收此请求，调用内部的一个方法在容器内部完成请求处理和转发动作，将目标资源发送给客户;

@Controller
@RequestMapping("/forw")
public class ForwardController
{
    @RequestMapping("/test1")
    public String test01()
    {
        // 转发跳转：/views/test01.jsp
        return "forward:/views/users.jsp";
    }
    
    @RequestMapping("/test2")
    public String test02()
    {
        //转发到：/forw/test1
        return "forward:/forw/test1"; //绝对路径
    }
   
    @RequestMapping("/test3")
    public String test03()
    {
        //转发到本类中的 test2
        return "forward:test02"; //相对路径
    }
}

5.2、重定向

重定向是将用户从当前处理请求定向到另一个视图(例如 JSP)或处理请求;
以前的请求(request)中存放的信息全部失效，并进入一个新的 request 作用域;
客户浏览器发送 http 请求，Web 服务器接受后发送 302 状态码响应及对应新的 location 给客户浏览器，客户浏览器发现是 302 响应，则自动再发送一个新的 http 请求，请求 URL 是新的 location 地址，服务器根据此请求寻找资源并发送给客户。

@Controller
@RequestMapping("/redir")
public class RedirectController
{
    @RequestMapping("/test1")
    public String test01()
    {
        //重定向到：/redir/test2
        return "redirect:/redir/test2";//绝对路径
    }
    
    @RequestMapping("/test2")
    public String test02()
    {
        //重定向到：/views/test.jsp
        return "redirect:/view/test.jsp";
    }
    
    @RequestMapping("/test3")
    public String test03()
    {
        //转发到本类中的 test1
        return "redirect:test1"; 
    }
}

5.3、细节问题

在增删改之后，为了防止请求重复提交，重定向跳转.
在查询之后，建议使用转发跳转.

六、值传递

把数据保存到作用域中，然后传递到前端渲染。

6.1、JSP 九大内置对象四大作用域（重点）

原文链接：https://blog.csdn.net/weixin_42614447/article/details/86535581
学习值传递前先了解以下九大作用域.
JSP中一共预先定义了9个内置对象：内置对象，又叫做隐含对象，不需要预先声明就可以在脚本代码和表达式中随意使用request、response、session、application、out、pagecontext、config、page、exception.

内置对象	类型	作用域
request（请求对象）	javax.servlet.ServletRequest	Request
response（响应对象）	javax.servlet.SrvletResponse	Page
pageContext（页面上下文对象）	javax.servlet.jsp.PageContext	Page
session（会话对象）	javax.servlet.http.HttpSession	Session
application（应用程序对象）	javax.servlet.ServletContext	Application
out（输出对象）	javax.servlet.jsp.JspWriter	Page
config（配置对象）	javax.servlet.ServletConfig	Page
page（页面对象）	javax.lang.Object	Page
exception（例外对象）	javax.lang.Throwable	Page

6.1.1、四大作用域

1、什么是作用域（Scope）？

作用域是在运行时代码中的某些特定部分中的变量，函数和对象的可访问性（说白就是你能不能访问某个作用域变量的问题）。

2、四大作用域范围

2.1、Request

request 里的变量可以在前后页面之间存活，但是只要刷新页面，就会重新加载数据.
前后页面之间有效.

2.2、Page

page 里的变量没办法从 index01.jsp 传递到 index02.jsp.
只要页面跳转了，它们就失效了.
只在当前页面有效.

2.3、Session、application

session和application里的变量一直在累加，开始还看不出区别，只要关闭浏览器，再次重启浏览器访问这页，session里的变量就重新计算了，application里的变量一直在累加，除非你重启tomcat，否则它会一直变大.
浏览器关闭前有效.

2.4、注意点

把变量放到 pageContext 里，就说明它的作用域是 page，它的有效范围只在当前jsp页面里。
把变量放到 request 里，就说明它的作用域是 request，它的有效范围是当前请求周期（浏览器关闭前有效）。
把变量放到session里，就说明它的作用域是session，它的有效范围是当前会话（会话，就是指从用户打开浏览器开始，到用户关闭浏览器这中间的过程）。
把变量放到application里，就说明它的作用域是application，它的有效范围是整个应用。
application作用域里的变量，它们的存活时间是最长的，如果不进行手工删除，它们就一直可以使用。

6.2、九大内置对象

6.2.1、request（请求对象）

request 对象是 javax.servlet.httpServletRequest类型的对象。
客户端对服务器发出的请求，客户端的请求信息被封装在request对象中，通过它发送请求给服务器。它是HttpServletRequest类的实例。作用域为request(用户请求期）。

常用方法：

1. Object getAttribute(String name) 返回指定属性的属性值（常用）

2. Enumeration getAttributeNames() 返回所有可用属性名的枚举 

3. String getCharacterEncoding() 返回字符编码方式（常用）

4. int getContentLength() 返回请求体的长度（以字节数） 

5. String getContentType() 得到请求体的MIME类型 

6. ServletInputStream getInputStream() 得到请求体中一行的二进制流 

7. String getParameter(String name) 返回name指定参数的参数值（常用）

8. Enumeration getParameterNames() 返回可用参数名的枚举 

9. String[] getParameterValues(String name) 返回包含参数name的所有值的数组 

10. String getProtocol() 返回请求用的协议类型及版本号 

11. String getScheme() 返回请求用的计划名,如:http.https及ftp等 

12. String getServerName() 返回接受请求的服务器主机名 

13. int getServerPort() 返回服务器接受此请求所用的端口号 

14. BufferedReader getReader() 返回解码过了的请求体 

15. String getRemoteAddr() 返回发送此请求的客户端IP地址 

16. String getRemoteHost() 返回发送此请求的客户端主机名 

17. void setAttribute(String key,Object obj) 设置属性的属性值（常用）

18. String getRealPath(String path) 返回一虚拟路径的真实路径

6.2.2、response（响应对象）

response 代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。
服务器收到客户端请求后做出的响应。它是HttpServletResponse类的实例。作用域为page（页面执行期）。

常用方法：

1. String getCharacterEncoding() 返回响应用的是何种字符编码 （常用）

2. ServletOutputStream getOutputStream() 返回响应的一个二进制输出流 

3. PrintWriter getWriter() 返回可以向客户端输出字符的一个对象 

4. void setContentLength(int len) 设置响应头长度 

5. void setContentType(String type) 设置响应的MIME类型 

6. sendRedirect(String location) 重新定向客户端的请求 （常用）

6.2.3、session（会话对象）

session 对象是由服务器自动创建的与用户请求相关的对象。
服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。
session对象内部使用Map类来保存数据，因此保存数据的格式为 “Key/value”。
session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。
客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例，作用域session(会话期）。

常用方法：

1. long getCreationTime() 返回SESSION创建时间 

2. public String getId() 返回SESSION创建时JSP引擎为它设的惟一ID号 （常用）

3. long getLastAccessedTime() 返回此SESSION里客户端最近一次请求时间 

4. int getMaxInactiveInterval() 返回两次请求间隔多长时间此SESSION被取消(ms) 

5. String[] getValueNames() 返回一个包含此SESSION中所有可用属性的数组 （常用）

6. void invalidate() 取消SESSION，使SESSION不可用 （常用）

7. boolean isNew() 返回服务器创建的一个SESSION,客户端是否已经加入 

8. void removeValue(String name) 删除SESSION中指定的属性 

9. void setMaxInactiveInterval() 设置两次请求间隔多长时间此SESSION被取消(ms)

6.2.4、out（输出对象）

out 对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。
在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。
out对象是JspWriter类的实例,是向客户端输出内容常用的对象。作用域为page（页面执行期）.

常用方法：

1. void clear() 清除缓冲区的内容 

2. void clearBuffer() 清除缓冲区的当前内容 

3. void flush() 刷新输出流 

4. int getBufferSize() 返回缓冲区以字节数的大小，如不设缓冲区则为0 

5. int getRemaining() 返回缓冲区还剩余多少可用 

6. boolean isAutoFlush() 返回缓冲区满时，是自动清空还是抛出异常 

7. void close() 关闭输出流

6.2.5、page（页面对象）

page 对象代表JSP本身，只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量，类似于Java编程中的 this 指针。
page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例。“page” 对象代表了正在运行的由JSP文件产生的类对象，不建议一般读者使用。作用域 page.

常用方法：

1. class getClass() 返回此Object的类 （常用）

2. int hashCode() 返回此Object的hash码 

3. boolean equals(Object obj) 判断此Object是否与指定的Object对象相等 （常用）

4. void copy(Object obj) 把此Object拷贝到指定的Object对象中 

5. Object clone() 克隆此Object对象 

6. String toString() 把此Object对象转换成String类的对象 （常用）

7. void notify() 唤醒一个等待的线程 

8. void notifyAll() 唤醒所有等待的线程 

9. void wait(int timeout) 使一个线程处于等待直到timeout结束或被唤醒 

10. void wait() 使一个线程处于等待直到被唤醒 

11. void enterMonitor() 对Object加锁 

12. void exitMonitor() 对Object开锁

6.2.6、application（应用程序对象）

application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量”。

常用方法：

1. Object getAttribute(String name) 返回给定名的属性值 （常用）

2. Enumeration getAttributeNames() 返回所有可用属性名的枚举 

3. void setAttribute(String name,Object obj) 设定属性的属性值 （常用）

4. void removeAttribute(String name) 删除一属性及其属性值 （常用）

5. String getServerInfo() 返回JSP(SERVLET)引擎名及版本号 

6. String getRealPath(String path) 返回一虚拟路径的真实路径 

7. ServletContext getContext(String uripath) 返回指定WebApplication的application对象 

8. int getMajorVersion() 返回服务器支持的Servlet API的最大版本号 

9. int getMinorVersion() 返回服务器支持的Servlet API的最大版本号 

10. String getMimeType(String file) 返回指定文件的MIME类型 

11. URL getResource(String path) 返回指定资源(文件及目录)的URL路径 （常用）

12. InputStream getResourceAsStream(String path) 返回指定资源的输入流 

13. RequestDispatcher getRequestDispatcher(String uripath) 返回指定资源的RequestDispatcher对象 （常用）

14. Servlet getServlet(String name) 返回指定名的Servlet （常用）

15. Enumeration getServlets() 返回所有Servlet的枚举 

16. Enumeration getServletNames() 返回所有Servlet名的枚举 

17. void log(String msg) 把指定消息写入Servlet的日志文件 

18. void log(Exception exception,String msg) 把指定异常的栈轨迹及错误消息写入Servlet的日志文件 

19. void log(String msg,Throwable throwable) 把栈轨迹及给出的Throwable异常的说明信息 写入Servlet的日志文件

6.3.7、pageContext（页面上下文对象）

pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。
pageContext 对象的创建和初始化都是由容器来完成的，在JSP页面中可以直接使用 pageContext对象。
pageContext 相当于页面中所有功能的集大成者，它的本类名也叫pageContext。用域 Pageconfig对象

常用方法：

1. JspWriter getOut() 返回当前客户端响应被使用的JspWriter流(out) 

2. HttpSession getSession() 返回当前页中的HttpSession对象(session) 

3. Object getPage() 返回当前页的Object对象(page) 

4. ServletRequest getRequest() 返回当前页的ServletRequest对象(request) （常用）

5. ServletResponse getResponse() 返回当前页的ServletResponse对象(response) （常用）

6. Exception getException() 返回当前页的Exception对象(exception) 

7. ServletConfig getServletConfig() 返回当前页的ServletConfig对象(config) 

8. ServletContext getServletContext() 返回当前页的ServletContext对象(application) 

9. void setAttribute(String name,Object attribute) 设置属性及属性值 （常用）

10. void setAttribute(String name,Object obj,int scope) 在指定范围内设置属性及属性值 （常用）

11. public Object getAttribute(String name) 取属性的值 （常用）

12. Object getAttribute(String name,int scope) 在指定范围内取属性的值 （常用）

13. public Object findAttribute(String name) 寻找一属性,返回起属性值或NULL 

14. void removeAttribute(String name) 删除某属性 （常用）

15. void removeAttribute(String name,int scope) 在指定范围删除某属性 （常用）

16. int getAttributeScope(String name) 返回某属性的作用范围 

17. Enumeration getAttributeNamesInScope(int scope) 返回指定范围内可用的属性名枚举 

18. void release() 释放pageContext所占用的资源 

19. void forward(String relativeUrlPath) 使当前页面重导到另一页面 

20. void include(String relativeUrlPath) 在当前位置包含另一文件

6.3.8、config（配置对象）

config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时，容器把某些信息通过 config对象传递给这个 Servlet。
开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）。作用域 Page。

常用方法：

1. ServletContext getServletContext() 返回含有服务器相关信息的ServletContext对象 

2. String getInitParameter(String name) 返回初始化参数的值 

3. Enumeration getInitParameterNames() 返回Servlet初始化所需所有参数的枚举

6.3.9、exception（例外对象）

exception 对象的作用是显示异常信息，只有在包含 isErrorPage=“true” 的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样，都具有系统提供的继承结构。exception 对象几乎定义了所有异常情况。在Java程序中，可以使用try/catch关键字来处理异常情况；如果在JSP页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在page指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。
例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象.作用域 page。

常用方法：

1. String getMessage() 返回描述异常的消息 

2. String toString() 返回关于异常的简短描述消息 

3. void printStackTrace() 显示异常及其栈轨迹 

4. Throwable FillInStackTrace() 重写异常的执行栈轨迹

6.3、JSP传值

转发跳转：Request作用域
重定向跳转：Session作用域

6.3.1、Request（作用域）

@RequestMapping("/test01")
public Object test01(HttpServletRequest req)
{
    //request：保存数据到request作用域中
    req.setAttribute("age", 18);
    req.setAttribute("name", "hello request");
    req.setAttribute("birth", new Date());
   
    //转发 test01.jsp
    return "test01";
}

jsp 取值：

<!-- 日期格式化 -->
<fmt:formatDate value="${requestScope.birth}" pattern="yyyy-MM-dd"/> <br/>
${requestScope.age} <br/>
${requestScope.name} <br/>

6.3.2、Session（作用域）

@RequestMapping("/test02")
public Object test02(HttpSession session)
{
    //session：保存数据到session作用域中
   	session.setAttribute("username", "admin");
    session.setAttribute("createTime", new Date());
   
    //转发 test02.jsp
    return "test02";
}

jsp 取值：

<!-- 日期格式化 -->
<fmt:formatDate value="${sessionScope.birth}" pattern="yyyy-MM-dd"/> <br/>
${sessionScope.username} <br/>

6.3.3、Model

model中的数据，会在视图渲染之前，将数据复制一份给 request。

@RequestMapping("/test03")
public String test03(Model model)
{
    model.addAttribute("name", "张三");
    return "index";
}

jsp 取值：

${requestScope.name}

6.3.4、ModelAndView

modelandview 可以集中管理（跳转、保存数据）。

@RequestMapping("/test04")
public ModelAndView test04()
{
    // 1.新建ModelAndView对象
    ModelAndView mv = new ModelAndView();
    // 2.设置视图名（跳转视图）
    mv.setViewName("forward:test04.jsp");
    // 3.保存数据到 request
    mv.addObject("name", "hello");
    // 4.直接返回ModelAndView对象
    return mv;
}

jsp 取值：

${requestScope.name}

6.3.5、@SessionAttributes

@SessionAttributes({"name","age"}) ：将Model中的 name和age 会存入session中.
SessionStatus 移除 session。

@Controller
@SessionAttributes({"name","age"})
public class TestController 
{

    @RequestMapping("test01")
    public String hello(Model model)
    {
        model.addAttribute("gender", true); // 会存入session
        model.addObject("name", "zhangsan"); // 会存入session
        return "test01";
    }
    
    @RequestMapping("test02")
    public String hello(SessionStatus status)
    {
        // 移除通过SessionAttributes存入的session
        status.setComplete();
        return "test01";
    }
}

jsp 取值：

${sessionScope.name} <br/>
${sessionScope.age} <br/>

七、静态资源访问

7.1、什么是静态资源？

图片、css、html、js等文件...

7.2、静态资源访问问题

如果你的DispatcherServlet拦截 *.do这样的URL，就不存在访问不到静态资源的问题。
如果你的DispatcherServlet拦截“/”，拦截了所有的请求，同时对*.js,*.jpg的访问也就被拦截了。

7.2.1、方式一

<mvc:default-servlet-handler/>会把 "/**" url, 注册到 SimpleUrlHandlerMapping 的 urlMap 中, 把对静态资源的访问由 HandlerMapping 转到 org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler 处理并返回DefaultServletHttpRequestHandler 使用就是各个 Servlet 容器自己的默认 Servlet.

在Spring-MVC 核心配置文件中添加以下内容：

<!-- 解决静态资源无法直接访问问题 -->
<mvc:default-servlet-handler/>

7.2.2、方式二

如果你的DispatcherServlet拦截 *.do这样的URL，就不存在访问不到静态资源的问题。

  <!-- 1、DispatcherServlet：SpringMVC的核心控制器　-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:Spring-MVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--
        1、*.do：拦截所有 *.do 的请求，在xml配置中将请求拦截设置为指定后缀，减少资源占用（同时解决静态资源无法访问）。
    -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

7.2.3、方式三

使用映射配置解决。
Spring-MVC.xml添加配置。
mapping=""：静态资源位置，location=""：映射路径。
可以配置多个 <mvc:resources />

<!-- 直接通过 /static/xxx 访问 /static/** 下面所有静态资源 -->
<mvc:resources mapping="/static/**" location="/static/"/>

八、JSON 数据处理

通过 JSON 形式将数据返回。
一般用于返回对象的JSON形式（String 直接返回，不需要使用JSON）。

8.1、前置配置

1、pom

<!-- JSON 工具 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79</version>
</dependency>

2、Spring-mvc.xml 核心配置文件中配置 json 转换器

<!-- JSON消息转换器 -->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <!-- 避免IE执行AJAX时,返回JSON出现下载文件 -->
        <bean id="fastJsonHttpMessageConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <property name="supportedMediaTypes">
                <list>
                    <value>application/json;charset=UTF-8</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

3、配置完成，可以使用了。

8.2、@ResponseBody

作用：以 JSON 形式返回数据，可以用在方法上或方法返回类型前面。

@Controller
@RequestMapping("json")
public class JsonController
{

    @ResponseBody //以JSON格式返回数据
    @RequestMapping("test01")
    public Object test01()
    {
        SysUser user = new SysUser();
        user.setUserId(10001L);
        user.setUsername("ruanjia");
        user.setPassword("123456");
        user.setSex("0");
        user.setAge(18);
        user.setNickName("jiajia");
        user.setRoleIds(Arrays.asList(1L, 2L));

        return user;
    }

    @RequestMapping("test02")
    public @ResponseBody Object test02()
    {
        SysUser user = new SysUser();
        user.setUserId(10001L);
        user.setUsername("ruanjia");
        user.setPassword("123456");
        user.setSex("0");
        user.setAge(18);
        user.setNickName("jiajia");
        user.setRoleIds(Arrays.asList(1L, 2L));

        return user;
    }

}

返回结果：

在这里插入图片描述

8.3、@RestController

作用：相当于每个方法都使用了 @ResponseBody 注解，以 JSON 格式返回数据。

@RestController
@RequestMapping("json1")
public class JsonController01
{
    
    @RequestMapping("test01")
    public Object test01()
    {
        SysUser user = new SysUser();
        user.setUserId(10001L);
        user.setUsername("ruanjia");
        user.setPassword("123456");
        user.setSex("0");
        user.setAge(18);
        user.setNickName("jiajia");
        user.setRoleIds(Arrays.asList(1L, 2L));

        return user;
    }

}

8.4、常用注解

日期格式化：@JSONField(format="yyyy/MM/dd")
属性名修改：@JSONField(name="birth"）
忽略属性：@JSONField(serialize = false)
包含null值：@JSONField(serialzeFeatures = SerializerFeature.WriteMapNullValue) 默认会忽略所有null值,有此注解会输出null
- @JSONField(serialzeFeatures = SerializerFeature.WriteNullStringAsEmpty) null的String输出为"
自定义序列化：@JSONField(serializeUsing = MySerializer2.class)

public class SysUser implements Serializable
{
    //修改属性名
    @JSONField(name="id")
    private Long userId;
    private String username;

    //忽略返回
    @JSONField(serialize = false)
    private String password;
    private String nickName;
    private String sex;
    private Integer age;

    //日期格式化
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    private List<Long> roleIds;
}

在这里插入图片描述

九、统一异常处理

统一处理系统异常
HandlerExceptionResolver：全局异常处理器。
在SpringMVC中，提供了一个全局异常处理器，用于对系统中出现的异常进行统一处理。
一般的系统中，DAO（mapper）层、Service层及Controller层出现异常都以 “throws Exception” 的形式向上层抛出，最后都会有SpringMVC的前端控制器（DispatcherServlet）统一交由全局异常处理器进行异常处理。

public class MyHandlerExceptionResolver implements HandlerExceptionResolver
{
    /**
     * @param request 请求内容
     * @param response 响应内容
     * @param handler 请求方法
     * @param ex 异常信息
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
    {
        System.out.println("--------------- handler 异常处理器执行了 ----------------");
        ModelAndView view = new ModelAndView();

        if (ex instanceof Exception)
        {
            view.setViewName("error444");
        } else if (ex instanceof NullPointerException)
        {
            view.setViewName("error444");
        }
        return view;
    }
}

把异常类注册到Spring容器中

<bean class="com.ruanjia.exception.MyHandlerExceptionResolver"/>

十、请求拦截器

自定义请求拦截规则。
使用：创建请求拦截类，实现 HandlerInterceptor 接口（请求拦截器）

1、定义 MyHandlerInterceptor

public class MyHandlerInterceptor implements HandlerInterceptor
{
    //前置处理：目标方法执行前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
    {
        //业务逻辑
        System.out.println("目标方法执行前。");
        return true; //true 放行
    }

    //后置处理：目标方法执行后执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception 
    {
        System.out.println("目标方法执行后。");
    }

    //完成后：目标方法响应后执行（视图渲染完成后）
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception 
    {
        System.out.println("销毁，资源回收。");
    }
}

2、注册拦截器

在 Spring-mvc.xml 核心配置文件中注册拦截器

<!-- 1、版本一：拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 拦截所有请求（包括静态资源） -->
        <mvc:mapping path="/**"/>
        <!-- 注册拦截器 -->
        <bean class="com.ruanjia.intercepted.MyHandlerInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

<!-- 2、版本二：拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 拦截 test01 开头的所有请求（包括静态资源） -->
        <mvc:mapping path="/test01/**"/>
        <!-- 拦截 test02 有请求 -->
        <mvc:mapping path="/test02"/>
        <!-- 排除不拦截的资源 -->
        <mvc:exclude-mapping path="/static/**"/>
        <mvc:exclude-mapping path="**/*.jpg"/>
        <mvc:exclude-mapping path="**/*.css"/>
        <mvc:exclude-mapping path="**/*.js"/>
        <!-- 注册拦截器 -->
        <bean class="com.ruanjia.intercepted.MyHandlerInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

十一、文件上传、下载

11.1、文件上传

1、upload 依赖

<!-- 文件上传 工具库  -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
    <exclusions>
        <!-- 排除 servlet-api 避免依赖冲突 -->
        <exclusion>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2、注册文件上传解析器

Spring-mvc.xml 核心配置文件配置

<!-- 文件上传解析器：
    注意：id 必须是 multipartResolver
     -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 指定文件上传大小（超出会包异常，1024b=1kb 1M=1024*1024） -->
    <property name="maxUploadSize" value="10485760"></property>
</bean>

3、Controller 代码

@RestController
@RequestMapping("upload")
public class UploadController
{

    @RequestMapping(value = "test01", method = RequestMethod.POST)
    public Object test01(@RequestParam("fileName")String fileName,
                         @RequestParam("file") MultipartFile file, HttpSession session) throws IOException {
        //原文件名
        String orName = file.getOriginalFilename();
        System.out.println(orName);

        //定义新文件名（确保文件名唯一性，使用UUID）
        String newFileName = UUID.randomUUID().toString().replaceAll("-", "") + fileName;
        System.out.println(newFileName);

        //获取文件后缀 test.html -> html
        String fileExtension = FilenameUtils.getExtension(orName);
        System.out.println(fileExtension);

        //获取当前应用路径（打包后路径）
        String updatePath = session.getServletContext().getRealPath("/upload");
        System.out.println(updatePath);

        //目录不存在创建
        File updateFilePath = new File(updatePath);
        if (!updateFilePath.exists()) {
            updateFilePath.mkdirs();
        }

        //组装文件
        File updateData = new File(updatePath + File.separator + newFileName + "." + fileExtension);

        //上传文件
        file.transferTo(updateData);
        return "上传成功！";
    }

}

4、JSP 代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<div>
    <!-- enctype="multipart/form-data"：文件上传使用多部份上传 -->
    <form action="/upload/test01" method="post" enctype="multipart/form-data">
        文件名：<input type="text" name="fileName" /><br>
        选择文件：<input type="file" name="file" /><br>
        <button type="submit">提交</button>
    </form>
</div>
</body>
</html>

11.2、文件下载

1、Controller 代码

@RestController
@RequestMapping("/download")
public class DownloadController
{

    @RequestMapping("/test1")
    public void hello1(HttpSession session, HttpServletResponse response) throws IOException
    {
        //获得要下载文件的绝对路径
        File file = new File("C:\\Users\\Administrator\\Desktop\\img\\ru.jpg");

        //文件的完整路径
        String real_path = file.getAbsolutePath();
        System.out.println(real_path);

        //设置响应头  告知浏览器，要以附件的形式保存内容   filename=浏览器显示的下载文件名
        response.setHeader("content-disposition","attachment;filename="+file.getName());

        //读取目标文件，写出给客户端
        IOUtils.copy(new FileInputStream(real_path), response.getOutputStream());
    }

}

2、a 标签请求下载

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>首页</title>
    </head>
    <body>
        <div>
            <a href="/download/test1">文件下载测试</a>
        </div>
    </body>
</html>

十二、REST风格

推荐使用，目前流行的请求风格。
每个资源都有唯一的URL格式，不同行为使用不同请求方法（get、post、put、delete）。

请求方式	标识	意图
GET	http://localhost:8080/user	查询所有用户
POST	http://localhost:8080/user	在所有用户中增加一个
PUT	http://localhost:8080/user	在所有用户中修改一个
DELETE	http://localhost:8080/user/1	删除用户1
GET	http://localhost:8080/user/	查询用户1

12.1、实例代码

@RestController
@RequestMapping("/user")
public class RestUrlController
{
    //获取用户列表
    //localhost:8080/user
    @GetMapping
    private Object list()
    {
        return Arrays.asList(1, 2, 3, 4, 5);
    }

    //按用户ID查询用户信息
    //localhost:8080/user/1
    @GetMapping("{userId}")
    public Object findById(@PathVariable Long userId)
    {
        return userId;
    }

    //添加用户
    //localhost:8080/user
    @PostMapping
    public Object addUser(@RequestBody SysUser user)
    {
        return user;
    }

    //更新用户
    //localhost:8080/user
    @PutMapping
    public Object updateUser(@RequestBody SysUser user)
    {
        return user;
    }

    //删除用户
    //localhost:8080/user
    @DeleteMapping("{userId}")
    public Object deleteUser(@PathVariable Long userId)
    {
        return userId;
    }
}