JSR303和拦截器

目录

一、JSR303

1.简介

2.JSR303服务端校验步骤 

二、拦截器的初步认识 

 1.什么是拦截器

 2.拦截器于过滤器

2.1 什么是过滤器（Filter） 

2.2 拦截器于过滤器的区别 

3.应用场景 

4.拦截器快速入门 

 4.1 入门案例

4.2 拦截器方法说明 

 4.3拦截器使用步骤

三、拦截器链 

1.多拦截器 

四、登录权限控制 

五、总结 

1.JSR303 

2.拦截器

---

一、JSR303

1.简介

服务端验证

2.JSR303服务端校验步骤 

2.1 pom依赖导入
2.2 在待校验的数据库列段对应的实体类打上校验标签
    非空效验
2.3 在controller层
    方法上添加@valid注解配合前面的校验标签
    添加bindingResult，此对象包含了所有  效验未通过的错误信息

2.4 可以将所有的错误信息以map集合的方式保存，并且传递到前台页面展示

 2.1  pom 依赖

 <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.7.Final</version>
    </dependency>

2.2 Clazz.java实体类

package com.zking.ssm.model;
 
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
 
/**
 * @NotNull ：作用于基本数据类型
 * @NotEmpty：   作用于集合
 * @NotBlank：   作用于字符串
 */
public class Clazz {
    @NotNull
    protected Integer cid;
 
    @NotBlank
    protected String cname;
 
    @NotEmpty
    protected String cteacher;
 
    protected String pic;
 
    public Clazz(Integer cid, String cname, String cteacher, String pic) {
        this.cid = cid;
        this.cname = cname;
        this.cteacher = cteacher;
        this.pic = pic;
    }
 
    public Clazz() {
        super();
    }
 
    public Integer getCid() {
        return cid;
    }
 
    public void setCid(Integer cid) {
        this.cid = cid;
    }
 
    public String getCname() {
        return cname;
    }
 
    public void setCname(String cname) {
        this.cname = cname;
    }
 
    public String getCteacher() {
        return cteacher;
    }
 
    public void setCteacher(String cteacher) {
        this.cteacher = cteacher;
    }
 
    public String getPic() {
        return pic;
    }
 
    public void setPic(String pic) {
        this.pic = pic;
    }
}

运行结果如图所示：

我们直接提交，然后它也还是会直接运行到后台，也就是说我们还没有做然后的校验，它最后运行结果会报错如图所示：

 我们希望最终效果是我们没有填它会在后面提示我们，cid不能为空以及cname不能为空等等，这样的效果演示，上面的实体类是因为我们导入了注解依赖，才会有这些注解，怎么才能让注解生效？看下面

Clazz.java 实体类

package com.zking.ssm.model;
 
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
 
/**
 * @NotNull ：作用于基本数据类型
 * @NotEmpty：   作用于集合
 * @NotBlank：   作用于字符串
 */
public class Clazz {
    @NotNull(message = "cid不能为空")
    protected Integer cid;
 
    @NotBlank(message = "班级名称不能为空")
    protected String cname;
 
    @NotEmpty(message = "教员老师不能为空")
    protected String cteacher;
 
    protected String pic;
 
    public Clazz(Integer cid, String cname, String cteacher, String pic) {
        this.cid = cid;
        this.cname = cname;
        this.cteacher = cteacher;
        this.pic = pic;
    }
 
    public Clazz() {
        super();
    }
 
    public Integer getCid() {
        return cid;
    }
 
    public void setCid(Integer cid) {
        this.cid = cid;
    }
 
    public String getCname() {
        return cname;
    }
 
    public void setCname(String cname) {
        this.cname = cname;
    }
 
    public String getCteacher() {
        return cteacher;
    }
 
    public void setCteacher(String cteacher) {
        this.cteacher = cteacher;
    }
 
    public String getPic() {
        return pic;
    }
 
    public void setPic(String pic) {
        this.pic = pic;
    }
}

2.3 控制层 ClazzController.java

package com.zking.ssm.controller;
 
import com.zking.ssm.biz.ClazzBiz;
import com.zking.ssm.model.Clazz;
import com.zking.ssm.model.dto.ClazzDto;
import com.zking.ssm.util.PageBean;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;
 
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-18 21:50
 */
@Controller
//加上我们的窄化入境，在做项目一定要加
@RequestMapping("/clz")
public class ClazzController {
    @Autowired
    private ClazzBiz clazzBiz;
 
//    list————>bookList
//    toList————>重定向list————>"redirect:clz/list"
//    toEdit————>跳转到编辑界面————>clzEdit
//    Clazz：以前是通过模型驱动接口封装，现在是直接在方法中接收参数即可
 
    @RequestMapping("/list")
    public String list(Clazz clazz, HttpServletRequest request){
        PageBean pageBean = new PageBean();
        pageBean.setRequest(request);
        List<Clazz> lst = this.clazzBiz.listPager(clazz, pageBean);
        request.setAttribute("lst",lst);
        request.setAttribute("pageBean",pageBean);
        return "clzList";
    }
 
    @RequestMapping("/toEdit")
    public String toEdit(Clazz clazz, HttpServletRequest request){
        Integer cid = clazz.getCid();
//        传递的id代表了修改，没传代表了新增
        if(cid != null){
            List<Clazz> lst = this.clazzBiz.listPager(clazz, null);
            request.setAttribute("b",lst.get(0));
        }
        return "clzEdit";
    }
 
    /**
     * @Valid：是与实体类中  的服务端校验 注解配合使用的
     * BindingResult：存放了所以违背 效验的错误信息
     * @param clazz
     * @param bindingResult
     * @return
     */
//     给数据添加服务端校验
    @RequestMapping("/valiAdd")
    public String valiAdd(@Valid Clazz clazz, BindingResult bindingResult,HttpServletRequest request){
//         如果服务端验证不通过，有错误
        if(bindingResult.hasErrors()){//违背了规则
            Map msg = new HashMap<>();
//            服务端验证了实体类的多个属性，多个属性都没有验证通过
            List<FieldError> fieldErrors = bindingResult.getFieldErrors();
            for (FieldError fieldError : fieldErrors) {
//                将多个属性的验证失败信息输送到控制台    比如：cid   提示cid不能为空
                System.out.println(fieldError.getField() + ":" + fieldError.getDefaultMessage());
//                msg.put(cid,cid不能为空)
                msg.put(fieldError.getField(),fieldError.getDefaultMessage());
            }
            request.setAttribute("msg",msg);
//            如果出现了错误，应该讲提示语显示在 表单提交元素后方
            return "clzList";
        }
        else {//没有违背规则
            this.clazzBiz.insertSelective(clazz);
        }
        return "redirect:/clz/list";
    }
 
    @RequestMapping("/add")
    public String add(Clazz clazz){
       this.clazzBiz.insertSelective(clazz);
        return "redirect:/clz/list";
    }
 
    @RequestMapping("/edit")
    public String edit(Clazz clazz){
        this.clazzBiz.updateByPrimaryKeySelective(clazz);
        return "redirect:/clz/list";
    }
 
    @RequestMapping("/del")
    public String del(Clazz clazz){
        this.clazzBiz.deleteByPrimaryKey(clazz.getCid());
        return "redirect:/clz/list";
    }
 
//    文件上传
    @RequestMapping("/upload")
    public String upload(ClazzDto clazzDto){
    try {
        //        前台上传文件
        MultipartFile picFile = clazzDto.getPicFile();
//        实际应该配置到 resource.properties 中
        String diskPath = "E:/temp/images/";// 图片的存放地址
//        最终访问：http:localhost:8080/upload/mvc/22.jsp
        String requestPath = "/upload/mvc/";// 数据库保存的地址，也是访问地址
//        拿到上传文件的名字
        String fileName = picFile.getOriginalFilename();// 22.jsp
//        完成文件上传
        FileUtils.copyInputStreamToFile(picFile.getInputStream(),new File(diskPath+fileName));
//        将图片上传之后，并且保存到数据库中
        Clazz clazz = new Clazz();
        clazz.setCid(clazzDto.getCid());
        clazz.setPic(requestPath+fileName);
        this.clazzBiz.updateByPrimaryKeySelective(clazz);
    }catch (Exception e){
        e.printStackTrace();
    }
        return "redirect:/clz/list";
    }
 
    //    文件下载
    @RequestMapping("/download")
    public ResponseEntity download(ClazzDto clazzDto){
        try {
//        1.点击下载传递文件的ID，通过文件的ID查询文件的路径
            Clazz clazz = this.clazzBiz.selectByPrimaryKey(clazzDto.getCid());
            String pic = clazz.getPic();// 数据库中的图片路径 比如：/upload/mvc/33.jpg
            //        实际应该配置到 resource.properties 中
            String diskPath = "E:/temp/images/";// 图片的存放地址
//        最终访问：http:localhost:8080/upload/mvc/22.jsp
            String requestPath = "/upload/mvc/";// 数据库保存的地址，也是访问地址
 
//        2.通过文件的请求地址，转换成文件存放的硬盘地址
           String realPath = pic.replace(requestPath,diskPath);// E:/temp/images/2.png
//           有可能图片是中文的所以要转乱码
            String fileName = realPath.substring(realPath.lastIndexOf("/")+1);
 
//        3.将硬盘中文件下载下来---->固定代码
            //下载关键代码
            File file=new File(realPath);
            HttpHeaders headers = new HttpHeaders();//http头信息
            String downloadFileName = new String(fileName.getBytes("UTF-8"),"iso-8859-1");//设置编码
            headers.setContentDispositionFormData("attachment", downloadFileName);
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            //MediaType:互联网媒介类型  contentType：具体请求中的媒体类型信息
            return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers, HttpStatus.OK);
        }catch (Exception e){
            e.printStackTrace();
        }
//        下载好了就不需要重新查询一遍了
        return null;
    }
 
}

 2.4 前端        clzEdit.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>博客的编辑界面</title>
</head>
<body>
<%--<form action="${pageContext.request.contextPath }/clz/${empty b ? 'add' : 'edit'}" method="post">--%>
<form action="${pageContext.request.contextPath }/clz/${empty b ? 'valiAdd' : 'edit'}" method="post">
    cid:<input type="text" name="cid" value="${b.cid }"><span style="color: red">${msg.cid}</span><br>
    cname:<input type="text" name="cname" value="${b.cname }"><span style="color: red">${msg.cname}</span><br>
    cteacher:<input type="text" name="cteacher" value="${b.cteacher }"><span style="color: red">${msg.cteacher}</span><br>
    <input type="submit">
</form>
</body>
</html>

运行一下看看有没有生效我们的原来的add就换成了valiAdd如图所示：

 我们加了一个班级然后它就提示两个为空，我们加两个也一样的增加不成功，要全部加上

   

我们增加个15 如图所示： 

二、拦截器的初步认识 

 1.什么是拦截器

 SpringMVC的处理器拦截器,类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。------>拦截器就类似于我们的过滤器

  依赖于web框架，在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个 
  controller生命周期之内可以多次调用。

 2.拦截器于过滤器

2.1 什么是过滤器（Filter） 

  依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作，比如：在过滤器中修改字符编码； 在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。

2.2 拦截器于过滤器的区别 

过滤器（Filter）: 

    1) filter属于Servlet技术，只要是web工程都可以使用
    2) filter主要对所有请求过滤
    3) filter的执行时机早于Interceptor

拦截器（interceptor） 

    1) interceptor属于SpringMVC技术，必须要有SpringMVC环境才可以使用。

                                                                                        ————》也就是Springmvc的jar包
    2) interceptor通常对处理器Controller进行拦截
    3) interceptor只能拦截dispatcherServlet处理的请求

3.应用场景 

 1）日志记录：记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等。

 2）权限检查：如登录检测，进入处理器检测是否登录，如果没有直接返回到登录页面；

 3）性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）；

 4）通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个Controller中的处理方法都需要的，我们就可以使用拦截器实现。

                ——————》也就是只要属于面向切面编程（AOP）拦截器就可以做

4.拦截器快速入门 

 4.1 入门案例

    创建HelloController
    创建自定义拦截器并实现HandlerInterceptor接口。

   
       
   

4.2 拦截器方法说明 

preHandle方法

作用：用于对拦截到的请求进行预处理，方法接收布尔（true，false）类型的返回值，返回true：放行，false：不放行。

执行时机：在处理器方法执行前执行

方法参数：

        ① request 请求对象

        ② response 响应对象

        ③ handler 拦截到的方法处理

postHandle 方法

作用：用于对拦截到的请求进行后处理，可以在方法中对模型数据和视图进行修改

执行时机：在处理器的方法执行后，视图渲染之前

方法参数：

        ① request 请求对象

        ② response 响应对象

        ③ handler 拦截到的处理器方法

        ④ ModelAndView 处理器方法返回的模型和视图对象，可以在方法中修改模型和视图

afterCompletion方法

作用：用于在整个流程完成之后进行最后的处理，如果请求流程中有异常，可以在方法中获取对象

执行时机：视图渲染完成后（整个流程结束之后）

方法参数：

        ① request 请求参数

        ② response 响应对象

        ③ handler 拦截到的处理器方法

        ④ ex 异常对象

 4.3拦截器使用步骤

    4.1 实现HandlerInterceptor接口   对应实现三个方法    预处理——>处理后——>完成后
    4.2 完成springmvc-mybatis.xml中的配置 

代码演示：

创建包，创建类实现HandlerInterceptor接口

  

OneHandlerInterceptor.java

package com.zking.ssm.interceptor;
 
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-20 11:02
 */
public class OneHandlerInterceptor implements HandlerInterceptor {
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//      预处理
        System.out.println("[OneHandlerInterceptor] . preHandle");
        return true;
    }
 
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
//        后处理
        System.out.println("[OneHandlerInterceptor] . postHandle...");
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//       完成后执行
        System.out.println("[OneHandlerInterceptor] . afterCompletion");
    }
}

 配置拦截器        springmvc-servlet.xml

"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       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-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    
    
    <aop:aspectj-autoproxy/>
    
    <context:component-scan base-package="com.zking.ssm"/>
 
    
    
    
    
    <mvc:annotation-driven>mvc:annotation-driven>
 
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView">property>
        
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    bean>
 
    
    
   
    
    <mvc:resources location="/static/" mapping="/static/**"/>
 
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        
        <property name="defaultEncoding" value="UTF-8">property>
        
        <property name="maxUploadSize" value="52428800">property>
        
        <property name="resolveLazily" value="true"/>
    bean>
 
    
    <mvc:interceptors>
        
        <bean class="com.zking.ssm.interceptor.OneHandlerInterceptor">bean>
    mvc:interceptors>
beans>

HelloController.java

package com.zking.ssm.interceptor;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-20 11:14
 */
@Controller
public class HelloController {
    @RequestMapping("hello")
    public String hello(){
        System.out.println("进入业务方法...");
        return "index";
    }
}

我们看看它们的执行顺序————运行结果如图所示： 

 

在来运行结果如图所示：它就不会执行我们的业务方法

而且我们的     Hello World!    也没有了

 

三、拦截器链 

1.多拦截器 

拦截器链的概率：如果多个拦截器能够对相同的请求进行拦截，则多个拦截器会形成一个拦截器链，主要理解拦截器中各个拦截器的执行顺序。拦截器链中多个拦截器的执行顺序，根拦截器的配置顺序有关，先配置的先执行。

<mvc:interceptors>
      <mvc:interceptor>
          <mvc:mapping path="/**"/>
          <bean class="com.zking.springmvc07.interceptor.CustomInterceptor"/>
      </mvc:interceptor>
      <mvc:interceptor>
          <mvc:mapping path="/user/**"/>
          <bean class="com.zking.springmvc07.interceptor.Custom2Interceptor"/>
      </mvc:interceptor>
  </mvc:interceptors>

我们在去写一个类

TwoHandlerInterceptor.java

package com.zking.ssm.interceptor;
 
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-20 11:02
 */
public class TwoHandlerInterceptor implements HandlerInterceptor {
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//      预处理
        System.out.println("[TwoHandlerInterceptor] . preHandle");
        return true;
    }
 
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
//        后处理
        System.out.println("[TwoHandlerInterceptor] . postHandle...");
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//       完成后执行
        System.out.println("[TwoHandlerInterceptor] . afterCompletion");
    }
}

配置文件 springmvc-servlet.xml

 <!--配置拦截器-->
   <!-- <mvc:interceptors>
        &lt;!&ndash;针对与所有的请求进行拦截&ndash;&gt;
        <bean class="com.zking.ssm.interceptor.OneHandlerInterceptor"></bean>
    </mvc:interceptors>-->
 
    <!--
        配置拦截器链
        /**:是拦截所有请求
        /clz/**:是拦截以clz开头的
    -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.zking.ssm.interceptor.OneHandlerInterceptor"></bean>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/clz/**"/>
            <bean class="com.zking.ssm.interceptor.TwoHandlerInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

我们预测运行结果的是怎样的：

   http://localhost:8080/hello   one prehandle/posthandle/aftercomplation
    http://localhost:8080/clz/list    one two
    one ——prehandle
    two ——prehandle
    业务方法
    two ——posthandle
    one ——posthandle
    two——aftercomplation
    one ——aftercomplation

运行结果如图所示：

 

 

第二测试结果如图所示：

在接着看下面如图所示：

就比如这样一张图：

就比如这样理解：你一开始进去的时候从one的prehandle进行——》two prehandle

        出来的时候从 two的posthandle出来——》one posthandle

        结束也是如此 two aftercomplation——》one aftercomplation

四、登录权限控制 

目前是可以直接访问数据的    http://localhost:8080/clz/list ，现在需要登录后才能访问

 springmvc-servlet.xml        我们肯定是拦截所有的

 <!--
        配置拦截器链
        /**:是拦截所有请求
        /clz/**:是拦截以clz开头的
    -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.zking.ssm.interceptor.OneHandlerInterceptor"></bean>
        </mvc:interceptor>
        <!--<mvc:interceptor>
            <mvc:mapping path="/clz/**"/>
            <bean class="com.zking.ssm.interceptor.TwoHandlerInterceptor"></bean>
        </mvc:interceptor>-->
    </mvc:interceptors>

拦截器 OneHandlerInterceptor.java

package com.zking.ssm.interceptor;
 
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-20 11:02
 */
public class OneHandlerInterceptor implements HandlerInterceptor {
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//      预处理
        System.out.println("[OneHandlerInterceptor] . preHandle");
 
//        如果是 login/logout 这个请求，就直接放行
//        拿到路径请求地址
        String url = request.getRequestURL().toString();
        if(url.indexOf("/login") > 0 || url.indexOf("/logout") > 0){
            //如果是 登录、退出 中的一种
            return true;
        }
 
//        代表不是登录，也不是退出
//        对于请求业务方法，除了登录、退出，其他操作都需要判断是否 session 登录成功过 ,才能访问
        String uname = (String) request.getSession().getAttribute("uname");
        if(uname == null || "".equals(uname)){
            response.sendRedirect("/login.jsp");
            return  false;
        }
        return false;
    }
 
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
//        后处理
        System.out.println("[OneHandlerInterceptor] . postHandle...");
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//       完成后执行
        System.out.println("[OneHandlerInterceptor] . afterCompletion");
    }
}

 业务代码 LoginController.java

package com.zking.ssm.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
import javax.servlet.http.HttpServletRequest;
 
/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-08-20 12:12
 */
@Controller
public class LoginController {
 
    @RequestMapping("/login")
    public String login(HttpServletRequest request){
//        登录成功一般需要 保存 用户信息
        String uname = request.getParameter("uname");
        if("zhangsan".equals(uname)){
            request.getSession().setAttribute("uname",uname);
        }
        return "index";
    }
 
    @RequestMapping("/logout")
    public String logout(HttpServletRequest request){
//        做销毁
        request.getSession().invalidate();
        return "index";
    }
}

页面代码        login.jsp

<%--
  Created by IntelliJ IDEA.
  User: zjjt
  Date: 2022/8/20
  Time: 12:16
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
登录界面
</body>
</html>

运行结果如图所示: 这里是不是就直接让它进入登录界面

 接着我们去登录一下如图所示：

那么我们在去访问一下  http://localhost:8080/clz/list   就不能访问了

我们输入http:localhost:8080/clz/list 它还是会让你返回登录界面的 

为什么呢?因为我们指定了登录人，我们这里就没有连接数据库了，所以我们只能登录zhangsan这样才可以进入如图所示： 

 

我们在去执行 http://localhost:8080/clz/list   就可以访问了

 

我们在去执行logout  ,退出

我们在去查询list就不能进行了如图所示： 

 

五、总结 

1.JSR303 

① 作用：做服务端的效验

② 导入pom依赖 hibernate-validate

        实体类属性添加效验的注解 @notNull        @notBlank

        controller 层方法上  添加@valid 效验实体类

        bindingResult  包含了所有的错误信息

2.拦截器 

① 简介：AOP的一种体现形式，类似于过滤器

② 与过滤器的区别？ 

        拦截器多次调用，过滤器只有一次

        拦截器依赖于SpringMVC，过滤器是依赖于web容器

        拦截器只能拦截DispatcherServlet处理的请求，而过滤器可以处理所有的请求

③ 使用

        实现HandlerInterceptor接口

        SpringMVC.xml中进行配置

        怎么配置？