SpringMvc框架详解：入门、配置、注解开发与实战技巧-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47724824/article/details/121191128

SpringMvc框架:

介绍: springmvc框架属于spring框架中的一个核心组件，与spring框架无缝衔接; springMvc是属于视图层框架的

属于MVC结构的框架(Model- View - Controller)，是开发Web应用的核心框架;

springmvc实际上出现的目的就是为了替换掉servlet, 也就是说springMvc是对servlet的一个深入封装

作用就是用来接收请求，处理响应的框架;

它与Struts2不同，基于实体Bean映射的，SpringMvc是基于方法映射的, 更轻便，快捷, 所以Struts2淘汰了;

Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块，

最早是SSH( Struts2 + Spring + Hibernate )整合开发，

现在是SSM(SpringMvc + Spring + Mybatis)开发 ,SpringMvc替换了Struts2，Mybatis替换了Hibernate;

1.入门程序：

1.1 创建工程导入jar包:

创建Java Enteripse项目，勾选Web Application; 将项目部署到Tomcat服务器上

在WEB-INF文件夹下创建lib文件夹，导入jar包:

spring-web.jar , spring-webmvc.jar 并添加到库

spring-beans.jar, spring-contxt.jar ,spring-core.jar , spring-expression.jar ,common-logging.jar ,

spring-aop.jar

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

    <!-- 配置前台控制器DispatcherServlet 相当于一个调度中心 -->
    <servlet>
        <servlet-name>SpringMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- 加载 springMvc自己的配置文件 Ioc ，DI
             init-param的作用就是用来加载配置文件的
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>

        <!--
            当tomcat服务器启动时 要加载这个类,如果没有这个配置
            那么只有发送请求时 ，容器才会实例化这个DispatcherServlet
         -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>SpringMvc</servlet-name>
        <!-- 所有的请求路径都要以.do 结尾
            这样前台控制器才会拦截
            /* : 拦截所有请求 ，只能在过滤器中使用 ，要不然就是404
            /  : 拦截静态资源css ， js ，jpg ，png结尾的文件，自动放行.jsp结尾文件
            *.do : 放行所有请求，一个都不拦截
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

1.3 spring-mvc.xml配置文件

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  1.处理器映射器 : 作用就是根据名字映射url地址   -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>

    <!--  2.处理器是适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

    <!--  3.视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
  
     <!-- 实例化自己的HelloController -->
    <bean name="/hello.do" class="com.oracle.controller.HelloController"></bean>
</beans>

1.4 控制器

package com.oracle.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        /**
         * ModelAndView : model模型数据   View视图  就是jsp
         */
        ModelAndView modelAndView = new ModelAndView();

        String username = request.getParameter("username");
        String password = request.getParameter("password");

        System.out.println(username);
        System.out.println(password);

        //添加数据
        modelAndView.addObject("user",username);

        //设置了视图的名字
        modelAndView.setViewName("main");

        return modelAndView;
    }
}

1.5 页面

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
     <a href="/hello.do?username=admin&password=123">跳转第一个Controller</a>
  </body>
</html>

main.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   欢迎 ${user} 登录
</body>
</html>

2 SpringMvc的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dUfyh4Qh-1636266379812)(file:///C:\Users\GaoYuanze\Desktop\1.SpringMvc执行流程.png)]

SpringMvc的执行流程如下:

1.用户点击某个请求路径，发起一个Http协议的请求，该请求会被提交到DispatcherServlet(前台控制器)中;

2.前台控制器接收到请求后，去找一个或多个HandlerMapping(处理器映射器)，并返回一个执行链(HandlerExecutionChain).

3.DispathcerServlet将执行链中的Handler(Controller)的信息发送给HandlerAdapter处理器适配器;

4.HandlerAdapter处理器适配器根据Handler的信息找到真正的Controller;

5.Controller执行方法返回ModelAndView对象给HandlerAdpater，这个对象是SpringMvc底层对象，包括Mode数据和 View视图名(逻辑视图);

6.HandlerAdpater接收到ModelAndView对象，在返回给DispatcherServlet;

7.DispatcherServlet接收到ModelAndView对象，在发送给视图解析器(InternalResourceViewResolver);

8.InternalResourceViewResolver视图解析器，解析逻辑视图View，在返回前台控制器DispatcherServlet

9.DispatcherServlet拿着View，进行渲染，讲逻辑视图View，变成真正的物理视图 main.jsp ，这个main.jsp

就是字符串拼接出来的，前缀prefix和suffix;

10.视图将View变成了真正的页面并返回给客户端

3. 基于注解开发SpringMvc

3.1 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.配置前台控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- 扫描 springmvc.xml 配置文件 位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

3.2 springMvc.xml配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

     <!-- 1.注解开发 -->
    <context:component-scan base-package="com.oracle.controller"/>

    <!-- 2. 开启mvc 注解驱动
             这个注解驱动替代了 处理器映射器， 处理器适配器
    -->
    <mvc:annotation-driven/>

    <!--3.配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/"></property>
            <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

3.3 Controller的编写

package com.oracle.controller;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

@Controller // 相当于<bean name="/user.do" class="com.oracle.controller.UserContoller">
public class UserController {

    /**
     * 方法一定要有返回值，默认应该是String类型
     * 为什么是String类型 ，因为必须返回逻辑视图名
     * @return  视图名
     */
    @RequestMapping("/hello.do")
    public String login(HttpSession session){

        session.setAttribute("username","李四");

        System.out.println("我是注解开发的springMvc");

        return "main";
    }
}

3.4 jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <a href="/hello.do">登录</a>
  </body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    欢迎${username}登录
</body>
</html>

4.SpringMvc的注解

4.1 @Controller注解（用于类上）

这个注解本身不是SpringMvc 的注解是Spring框架的注解，

是@Component的衍生注解用于Ioc操作

4.2 .@RequestMapping注解（用于方法上或类上）

接收请求的，但是要记住的是一个Controller中，会有一个或多个请求的方法

那么就会有多个@RequestMapping注解，例如UserController中可以有添加用户，修改用户，删除用户

查询用户，每一个方法都是负责不同的操作；

注解中的属性如下：

value: 是这个注解的默认属性，代表了当前请求的路径, 如果是一个属性的化就可以省略掉

例如: @RequestMapping(value = “/hello.do”)

name: 属性就是相当于注释的意思，解释说明 @RequestMapping(value = “/hello.do”,name = “这是登录的方法”)

method: 这个属性代表了当前这个方法能接收什么样的请求:

默认普通的请求方式就只有: GET ,POST (不区分什么操作的)

   RESTful风格的请求方式：  GET(查询) , POST(添加) , PUT(修改), DELETE(删除)

4.3 @RequestParam注解（用于修饰方法入参）

在页面标签中的name属性的名子和方法入参的名字不一致时，使用这个注解接收页面传递的参数值

@RequestMapping(value = "/hello.do")
public String login(@RequestParam("username") String a,
                    @RequestParam("password") String b){
  System.out.println("我是SpringMvc的自动映射");
  System.out.println(a);
  System.out.println(b);
  return "main";
}

4.4 @PathVariable注解（用于修饰方法入参）

前提：如果你的*.do的路径是*.do 那么这个注解就是不好使；所以只能是/

作用是用来接收URL地址栏中的请求参数;

<a href="/delete/admin/23/哈尔滨">删除用户</a>

@RequestMapping("/delete/{name}/{id}/{address}")
public String deleteUserById(@PathVariable String name,
                             @PathVariable Integer id,
                             @PathVariable String address){

      System.out.println("要删除的id为： " + id);
      System.out.println("要删除的name为： " + name);
      System.out.println("要删除的address为： " + address);
      return "main";
}

4.5 @ModelAttribute 注解用于方法入参

作用是用来接收请求参数的，那么有什么好处呢，就是会自动将接收的参数封装到实体对象中，

并直接存储到Model域对象中，不需要程序员手动的addAttribute方法添加，

如果没有这个注解，就自动映射实体后，调用model.addAttribute(“user”,user); 方法手动添加

相比而言更加自动化, 方便;

/**
  * 注册操作
  * @return 返回主页
  */
@RequestMapping("/register")
public String register(@ModelAttribute("user") User user){
   System.out.println(user);
   //这里接收到用户信息后 老师没 添加到 域对象中 ，但是页面会自动取出
   return "main";
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    ${user} 
</body>
</html>

拓展：一定要知道springMvc控制器中方法的入参类型有多少种:

1.可以添加实体Bean的映射; 前提是页面的name属性名一定要和 java实体Bean的属性名一致

2.可以使用方法的形参形式接收请求参数

3.可以使用原始的HttpServletRequest对象的 getParameter(“username”);方法获取参数

4.可以是@RequestParam 接收参数

5.可以使用@PathVariable接收URL中的请求参数，属于RESTful风格的请求方式

6.可以使用@ModelAttribute(“user”) 注解接收参数，并自动存储域对象

5. SpringMvc的转发和重定向

forward 和 redirect :

springMvc请求中，请求方式有两种：分别是forward和redirect ，用在Controller方法的返回值处;

转发属于服务器行为（发生在服务器内部) ，转发地址栏不会改变

重定向数据客户端行为 (发生在服务器外部) ，重定向地址栏会改变

转发: 可以携带参数

return "forward:/getAll?pageNo=1&like=李";

重定向: 可以携带参数

return "redirect:/getAll?pageNo=1&like=张";

6. @ModelAttribute注解

1.第一个功能是作为方法的入参，会自动绑定数据到实体中，并将数据放到域对象中;

@RequestMapping("/register")
public String register(@ModelAttribute("user") User user){
  System.out.println(user);
  //这里接收到用户信息后 老师添加到 域对象中
  return "forward:/getAll?pageNo=1&like=李";
}

2.可以放在一个无返回值的方法中,会优先执行与目标方法, 如果想在执行目标方法前执行一些事儿的时候

可以用@ModelAttribute注解，优先执行;

@ModelAttribute
public void myModel(@RequestParam String name,Model model){
    //手动的存储到域对象中
    model.addAttribute("name",name);
    System.out.println("我是myModel方法");
}
/**
     * 方法一定要有返回值，默认应该是String类型
     * 为什么是String类型 ，因为必须返回逻辑视图名
     * @return  视图名
     */
@RequestMapping(value = "/hello")
public String login(Model model){
    System.out.println("我是hello请求");
    Object name = model.getAttribute("name");
    System.out.println("我是从model中获取的名字:"+name);
    return "main";
}

3.修饰有返回值的方法,会自动的将返回值存储到域对象中，其他方法可以通过getAttribute(“name”)获取

@Controller
public class PersonController {
    /**
     * 优先执行     ，会自动将数据存储到域对象中，返回就是域对象的值
     * @param name   域对象的 key
     * @return   域对象的值
     */
    @ModelAttribute("name")
    public String myModel(@RequestParam String name){
        System.out.println("myModel方法");
        return name;
    }
    @RequestMapping("/person")
    public String model(){
        System.out.println("model方法");
        return "main";
    }
}

7. SpringMvc 与 JSON数据交互

先处理POST字符集乱码问题:

1.配置字符集过滤器:

springMvc提供的一个固定的字符集过滤器: 在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>

2.字符集处理方式：produces = “text/html;charset=UTF-8”

/**
     * 这个注解中有 value， name ， method
     * response.setContentType("text/html;charset=UTF-8");
     * @return
     */
    @RequestMapping(value = "/person",produces = "text/html;charset=UTF-8" )
    public String model(){
        System.out.println("model方法");
        return "main";
    }

SpringMvc配置静态资源放行:

<script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
    //页面加载函数
    $(function(){

        $("button").click(function(){
            alert("-====");
        })
    })
</script>

静态资源放行有3种方式：这是其中两种

<!-- 静态资源放行js, css, img ，记得清缓存-->
<mvc:default-servlet-handler/>

<!-- location属性代表本地文件夹下的资源
     mapping 是映射，/** 代表可见    -->
<mvc:resources mapping="/**" location="/js/"></mvc:resources>
<mvc:resources mapping="/**" location="/css/"></mvc:resources>
<mvc:resources mapping="/**" location="/img/"></mvc:resources>

@ResponseBody 响应Json格式的数据：这个注解响应的数据，会自动变成json格式

@RequestBody 接收Json格式的数据 : 必须接收的是json格式的字符串

1.导入jackson的jar包：jackson是springMvc处理json格式数据的第三方插件

它还支持Gson ，阿里巴巴的 fastJson ，但是需要配置麻烦，但是jsonson内部继承，不需要配置

一个 <mvc:annotation-driven/> 就已经解决了

2.编写Controller: 使用@RequestBody接收json格式的字符串，@ResponseBody响应一个对象,它就会变成json格式

@ResponseBody  //这个注解响应的数据，会自动变成json格式
@RequestMapping(value = "/login",produces = "application/json;charset=UTF-8")
public User getJsonAndResponseJson(@RequestBody User user){

  System.out.println(user);

  System.out.println("我是用来接收json格式，和 响应json格式的方法");

  return user;
}

@RequestMapping(value = "/login",produces = "application/json;charset=UTF-8")
public @ResponseBody User getJsonAndResponseJson(@RequestBody User user){

  System.out.println(user);

  System.out.println("我是用来接收json格式，和 响应json格式的方法");

  return user;
}

3.编写Ajax代码:

<script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
    //页面加载函数
    $(function(){
        $("button").click(function(){
            var a = $("input[name='username']").val();
            var b = $("input[name='password']").val();
            //手动拼接成json格式
            var person = { username: a, password : b};
            alert(person);
            //万能的 异步请求的方式
            $.ajax({
                url: "/login",// 请求路径
                type: "post", //请求方式
                data: JSON.stringify(person), //发送的是json格式的字符串
                contentType: "application/json;charset=UTF-8", //发送json格式
                dataType: "json", //返回值的格式 json
                success: function(data){
                    alert(data.username);
                    alert(data.password);
                }
            })
        })
    })
</script>

注意: 在springMvc使用jackson处理json格式的时候一定是高版本的，要不然jar包版本不兼容;

例如: jackson-core.2.1.0.jar , jackson-databind.2.1.0.jar ,jackson-annotation.2.1.0.jar 就不可以

8. SpringMvc 使用 RESTful 风格请求方式

RESTful : (英文：Representational State Transfer，简称REST，意思：使用URL路径形式传递参数)。它的结构清晰，易于理解，但是这个概念比较复杂，我们以应用为主; SpringMvc支持，为给SpringBoot打基础;

传统的url：http://localhost:8080/login?username=admin&password=123

RESTful的url: http://localhost:8080/login/admin/123, @PathVariable注解接收数据

SpringMvc REST 的风格可以理解为：使用URL 表示资源时，每个操作都要用独一无二的URL来表示；

传统的请求方式就两种: GET , POST -----> form表单支持的

如果用RESTful风格的那么就是四种:

GET(查询)
POST(添加)
PUT(修改)
DELETE(删除)

传统的:  /login?id=1	 	  	REST风格的: /login/12   	 一定要结合使用,才能达到最好的效果

本身HTTP协议默认在springMvc中是不支持POST 和 DELETE，

1.只能将DELETE 和 PUT 请求转换为POST 请求，例如:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试RESTful风格的请求方式</title>
</head>
<body>
    <h4>发送GET请求</h4>
    <a href="user/1">GET</a>

    <h4>发送POST请求</h4>
    <form action="user" method="post">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="POST请求">
    </form>

    <h4>发送PUT请求</h4>
    <form action="user" method="post">
                <input type="hidden" name="_method" value="PUT">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="PUT请求">
    </form>

    <h4>发送DELETE请求</h4>
    <form action="user" method="post">
        <input type="hidden" name="_method" value="DELETE">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="DELETE">
    </form>
</body>
</html>

2.在web.xml中配置一个过滤器:

<!-- 设置 RESTful风格的请求方式-->
<filter>
  <filter-name>hiddenHttpMethodFilter</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>

<filter-mapping>
  <filter-name>hiddenHttpMethodFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

3.Controller: 处理器

package com.oracle.controller;

import com.oracle.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RESTController {
  
    //现在用的是RESTful风格的请求方式，那么就必须指定请求方式
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String get(@PathVariable Integer id){
        System.out.println("get请求的id: " + id+" 我是查询操作");
        return "main";
    }

    @RequestMapping(value = "/user",method = RequestMethod.POST)
    public String post(){
        System.out.println("我是post请求，是添加操作");
        return "main";
    }

    @RequestMapping(value = "/user",method = RequestMethod.PUT)
    public String put(User user){
        System.out.println(user);
        System.out.println("我是put请求，是修改操作");
        return "main";
    }

    @RequestMapping(value="/user",method = RequestMethod.DELETE)
    public String delete(User user){
        System.out.println(user);
        System.out.println("我是delete请求，是删除操作");
        return "main";
    }
}

控制台结果：

我是delete请求，是删除操作
我是put请求，是修改操作
我是post请求，是添加操作
我是get请求，id:1 是查询操作

总结:

1.form表单的method属性的值必须是POST请求

2.web.xml 必须添加过滤器HiddenHttpMethodFilter

3.Controller中的方法必须指定请求类型@RequestMapping(value="/login",method = RequestMethod.POST)

4.如果Controller返回的页面出现了405那么就在这个页面的头部添加isErrorPage=“true”;

9. SpringMvc 拦截器

SpringMvc中提供了一个Interceptor拦截器的技术点，与Servlet阶段的中的Filter过滤器相似，但是不是同一个东西,所处位置也不同;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xkeVjerc-1636266379814)(C:\Users\GaoYuanze\Desktop\拦截器.png)]

作用: 一般用于登录时检测用户权限，活着请求信息的时候记录到日志中，等等登录拦截

最简单的就是不登陆，不可以直接访问主页；体现的就是请求的预处理和后处理;`

拦截器的定义:

package com.oracle.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TestInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("在执行控制器的方法之前执行，返回true就是放行,返回false是拦截");

        return true;    //返回false是拦截， 返回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("在视图解析器执行完毕后 执行，一般用于资源关闭，记录日志");
    }
}

拦截器的配置：

 <!-- 拦截器 -->
<mvc:interceptors>

  <!-- 全局的拦截器，拦截所有请求-->
  <bean class="com.oracle.interceptor.TestInterceptor"></bean>

</mvc:interceptors>

9.1 拦截案例(登录验证)：

不登录，不可以直接访问主页，必须登录后，才可以随便访问主页

Controller:

package com.oracle.controller;

import com.oracle.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class UserController {

    @RequestMapping("/toLogin")
    public String toLogin(){
        return "forward:/index.jsp";
    }
    @RequestMapping("/login")
    public String login(User user, HttpSession session, Model model){
        String username = user.getUsername();
        String password = user.getPassword();
        if("admin".equals(username) && "123".equals(password)){
            //存储session
            session.setAttribute("user",user);
            return "forward:/main";
        }
        //登录失败,存储提示信息
        model.addAttribute("msg","用户名或密码错误，请重新登录");

        return "forward:/toLogin";
    }
    @RequestMapping("/main")
    public String toMain(){
        return "main";
    }
    @RequestMapping("/logOut")
    public String logOut(HttpSession session){

        //主动退出，session就不存储在了 ,清除session
        session.invalidate();

        return "forward:/index.jsp";
    }
}

拦截器：LoginInterceptor

package com.oracle.interceptor;

import com.oracle.pojo.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //先做指定路径放行
        String path = request.getRequestURI();
        if(path.endsWith("/toLogin") || path.endsWith("/login")){
            //放行
            return true;
        }
        //如果直接访问main的化 就的验证了
        HttpSession session = request.getSession();
        User user = (User)session.getAttribute("user");
        if(user != null){
            //放行  刚刚登录完，没退出
            return true;
        }
        //没登录呢，必须登录，才能访问主页
        request.setAttribute("msg","还没登录，请先登录");
        request.getRequestDispatcher("index.jsp").forward(request,response);
        return false;
    }
}

配置 Spring-mvc.xml配置文件：添加拦截器

 <!-- 拦截器 -->
<mvc:interceptors>

  <!-- 全局的拦截器，拦截所有请求-->
  <bean class="com.oracle.interceptor.TestInterceptor"></bean>

  <!-- 登录验证拦截器 -->
  <mvc:interceptor>
    <!-- 需要拦截的请求  /** 拦截所有  -->
    <mvc:mapping path="/**"/>
    <!-- 除去 哪些路径 -->               
	<mvc:exclude-mapping path="/login"/>
    <!-- 指定拦截器 -->
    <bean class="com.oracle.interceptor.LoginInterceptor"></bean>
  </mvc:interceptor>
  <mvc:interceptor>
  		....
  </mvc:interceptor>
</mvc:interceptors>

登录页面：index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
   <%-- <a href="/login">测试拦截器</a>--%>

    <form action="/login" method="post">
        用户:<input type="text" name="username">
        密码:<input type="password" name="password">
        <input type="submit" value="登录">
    </form>
    <div style="color: red">${msg}</div>
  </body>
</html>

主页面: main.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	欢迎${user.username}登录本小店 <a href="/logOut">退出</a>
</body>
</html>

10. SpringMvc 图片上传

SpringMvc框架的文件上传是基于commons-fileupload组件完成的(第三方工具)，只不过是简化了过程；

为了实现这一功能,SpringMvc提供了一个接口 MultipartResolver

1.导入图片上传的依赖jar包:

commons-fileupload.jar, commons-io.jar

2.配置Spring-mvc.xml配置文件:

 <!-- 图片上传   使用二进制的形式进行图片上传  其中这个id属性必须加，不加就是NullPointException -->
<bean id="multipartResolver"        			   class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <!-- 设置图片上传的大小 单位是字节-->
  <property name="maxUploadSize" value="5000000"></property>
  <!--设置字符集-->
  <property name="defaultEncoding" value="UTF-8"></property>
</bean>

JSP 页面提交:

<!-- 要支持 多媒体上传  不加 就不能完成图片上传 -->
<form action="/uploadFile" method="post" enctype="multipart/form-data">
  文件: <input type="file" name="myFile">
  <input type="submit" value="上传">
</form>

UploadController:

package com.oracle.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@Controller
public class UploadController {
    /**
     * 后台必须有一个指定类型接收它
     * 入参myFile  必须和 input标签的name属性名一致
     */
    @RequestMapping("/uploadFile")
    public String uploadFile(MultipartFile myFile) throws IOException {
        //System.out.println(originalFilename);

        /*byte[] bytes = myFile.getBytes();
        System.out.println("内容: "+bytes);

        long size = myFile.getSize();
        System.out.println("文件大小： " + size);*/

        String originalFilename = myFile.getOriginalFilename();

        String path = "C:\\Users\\GaoYuanze\\IdeaProjects\\SpringMvc_Interceptor\\web\\img\\";

        //路径，文件名
        File file = new File(path,originalFilename);

        //如果不存在 ，记住有叹号
        if(!file.exists()){
            file.mkdirs();
        }
        //上传
        myFile.transferTo(file);
        return "success";
    }
}

11. 日期处理

1.使用@DateTimeFormat(pattern = “yyyy-MM-dd”) 注解，在指定的实体中，的指定Date类型上使用】

public class User {

    private String username;
    private String password;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthDay;
  
    //省略getter， setter方法
}

2.使用@InitBinder 注解处理日期格式：数据绑定 ,它只针对当前的@Controller有用

package com.oracle.controller;

@Controller
public class UserController {
    /**
     * 优先执行与 目标方法
     *
     * 使用数据绑定技术，完成日期格式化的处理
     */
    @InitBinder
    public void initBinder(WebDataBinder binder){

        //可以处理掉 字符串两边的空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        //参数1，传入的是Date的反射对象，
        //参数2.创建一个编辑器，将SimpleDateFormat格式作用于参数中的birthDay
        //参数3，不允许为null
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        false));
    }
  
  	/**
  	  * 注册操作
  	  */
    @RequestMapping("/register")
    public String register(User user){
        System.out.println(user);
        return "main";
    }
  
}

输出结果：

User{username='admin', password='123', birthDay=Mon Nov 01 00:00:00 CST 2021}

3.全局数据绑定： @ControllerAdvice

/**
 * Global全局Controller
 */
@ControllerAdvice
public class GlobalContrller {

    /**
     * 优先执行与 目标方法
     *
     * 使用数据绑定技术，完成日期格式化的处理
     */
    @InitBinder
    public void initBinder(WebDataBinder binder){

        //可以处理掉 字符串两边的空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        //参数1，传入的是Date的反射对象，
        //参数2.创建一个编辑器，将SimpleDateFormat格式作用于参数中的birthDay
        //参数3，不允许为null
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        false));
    }

}