Spring-MVC使用JSR303及拦截器，增强网络隐私安全-阿里云开发者社区

一、JSR303

( 1 ) 是什么

JSR 303是Java规范请求（Java Specification Request）的一部分，它定义了一套标准的Java Bean验证规范，也被称为Bean验证。它提供了一种简单而强大的方式来验证Java对象的属性的值。

在开发应用程序时，数据的验证是非常重要的，以确保数据的完整性和一致性。传统的验证方式通常需要大量的手动编码，而且容易出错。JSR 303的目标是提供一种通用的验证框架，以便开发人员可以在应用程序中轻松地执行输入验证。

JSR 303定义了一套验证规范，通过在Java类的属性级别上定义验证规则，并通过注解的方式将这些规则与属性关联起来。开发人员可以使用内置的验证注解，也可以自定义验证注解，以满足特定的验证需求。

内置的验证注解包括@NotNull、@Size、@Min、@Max、@Pattern、@Email等。这些注解可以用于验证属性的值是否满足特定的条件，如非空、长度范围、最小值、最大值、正则表达式匹配等。

开发人员还可以通过编写自定义的验证注解和验证器来定义和执行自定义的验证规则。自定义验证注解可以根据具体的业务需求定义，而验证器则负责实现具体的验证逻辑。

JSR 303的验证框架可以在Java EE和Java SE环境中使用，并且已经被许多Java框架广泛采用。例如，Hibernate Validator是一个基于JSR 303规范的验证框架，它与Hibernate ORM框架集成，提供了强大的数据验证功能。Spring Framework也支持JSR 303规范，可以在Spring应用程序中使用注解进行数据验证。

通过使用JSR 303的验证框架，开发人员可以简化数据验证的过程，减少手动编码的工作量，并提高代码的可读性和可维护性。它是Java开发中重要的一部分，帮助开发人员构建更健壮和可靠的应用程序。

( 2 ) 作用

JSR 303的具体作用是提供一种通用的验证框架，用于验证Java对象的属性的值。它在应用程序开发中的作用有以下几个方面：

1. 数据验证：JSR 303允许开发人员在Java类的属性级别上定义验证规则，并通过注解的方式将这些规则与属性关联起来。通过使用内置的验证注解或自定义的验证注解，开发人员可以验证属性的值是否符合特定的条件，如非空、长度范围、最小值、最大值、正则表达式等。这样可以确保输入数据的完整性和一致性，防止无效或不合法的数据进入应用程序。

2. 错误处理：JSR 303提供了一种标准的错误处理机制，当验证失败时，可以生成详细的错误信息。开发人员可以通过捕获验证异常或检查验证结果来处理验证错误。这样可以帮助开发人员快速定位和解决数据验证问题，并向用户提供友好的错误提示。

3. 可读性和可维护性：通过使用JSR 303的验证框架，开发人员可以将验证规则与属性直接关联起来，使代码更加清晰和易于理解。验证规则以注解的形式存在于代码中，使得验证逻辑更加直观和可读。此外，通过使用注解，验证规则与属性的关联性得到了明确的表达，使得代码更易于维护和修改。

4. 框架集成：JSR 303的验证框架已经被许多Java框架广泛采用。例如，Hibernate Validator是一个基于JSR 303规范的验证框架，与Hibernate ORM框架集成，提供了强大的数据验证功能。Spring Framework也支持JSR 303规范，可以在Spring应用程序中使用注解进行数据验证。通过与这些框架的集成，开发人员可以更方便地使用JSR 303的验证功能，提高开发效率。

总之，JSR 303的具体作用是提供一种简单而强大的验证框架，用于验证Java对象的属性的值。它可以帮助开发人员确保输入数据的完整性和一致性，并提供标准的错误处理机制。通过提高代码的可读性和可维护性，以及与其他框架的集成，JSR 303可以提高应用程序的质量和开发效率。

( 3 ) 常用注解

注解	说明
@Null	用于验证对象为null
@NotNull	用于对象不能为null，无法查检长度为0的字符串
@NotBlank	只用于String类型上，不能为null且trim()之后的size>0
@NotEmpty	用于集合类、String类不能为null,且size>0。但是带有空格的字符串校验不出来
@Size	用于对象（Array,Collection,Map,String）长度是否在给定的范围之内
@Range	用于验证数字或字符串的值是否在指定范围内。
@Length	用于String对象的大小必须在指定的范围内
@Pattern	用于String对象是否符合正则表达式的规则
@Email	用于String对象是否符合邮箱格式
@Min	用于Number和String对象是否大等于指定的值
@Max	用于Number和String对象是否小等于指定的值
@AssertTrue	用于Boolean对象是否为true
@AssertFalse	用于Boolean对象是否为false
@DecimalMin	用于验证数字的最小值，可以指定包含最小值的边界。
@DecimalMax	用于验证数字的最大值，可以指定包含最大值的边界。

这些注解可以与属性的getter方法或字段上使用，用于定义验证规则。开发人员可以根据具体的业务需求选择合适的注解来进行数据验证。此外，JSR 303还支持自定义注解和验证器，开发人员可以根据需要定义自己的验证规则。

@Validated与@Valid区别

@Validated：

Spring提供的
支持分组校验
可以用在类型、方法和方法参数上。但是不能用在成员属性（字段）上
由于无法加在成员属性（字段）上，所以无法单独完成级联校验，需要配合@Valid

@Valid：

JDK提供的（标准JSR-303规范）
不支持分组校验
可以用在方法、构造函数、方法参数和成员属性（字段）上
可以加在成员属性（字段）上，能够独自完成级联校验

( 4 ) 入门使用

以下的实例代码是基于本人博客中的代码进行扩展 : Spring-MVC的文件上传下载

导入依赖

<!-- JSR303 -->
<hibernate.validator.version>6.0.7.Final</hibernate.validator.version>
<!-- JSR303 -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>${hibernate.validator.version}</version>
</dependency>

以上代码在我博客中已经导入完成配置 : Spring-MVC的文件上传下载

配置校验规则

在实体类相对应的属性中增加注解用来指定校验

例如 :

@NotNull(message = "房间编号不能为空")
    //@Size(max = 100,min = 23,message = "编号大小必须在23至100之间")
    private Long hid;
    @NotBlank(message = "房间名不能为空")
    private String hname;
    @NotBlank(message = "房间的类型名称不能为空")
    private String htype;

在需要校验的对象类的控制器 ( HotelController ) 中，增加要请求处理方法中，使用@Validated或@Valid注解要验证的对象，并根据BindingResult判断校验是否通过；

（增加以下方法代码）例如 :

//需要校验，使用@Validated或@Valid注解要验证的对象
    @RequestMapping("/valiadd")
    public String valiadd(@Validated Hotel hotel, BindingResult result, HttpServletRequest request){
        //        如果服务端验证不通过，有错误
        if(result.hasErrors()){
//            服务端验证了实体类的多个属性，多个属性都没有验证通过
            List<FieldError> fieldErrors = result.getFieldErrors();
            Map<String,Object> map = new HashMap<>();
            for (FieldError fieldError : fieldErrors) {
//                将多个属性的验证失败信息输送到控制台
                System.out.println(fieldError.getField() + ":" + fieldError.getDefaultMessage());
                map.put(fieldError.getField(),fieldError.getDefaultMessage());
            }
            request.setAttribute("bugMap",map);
        }else {
            hotelbiz.insertSelective(hotel);
            return "redirect:list";
        }
        return "hot/edit";
    }

在将我们的编辑页面的使用代码修改为以下代码 :

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
    <title>酒店管理编辑界面</title>
</head>
<body>
<form action="${pageContext.request.contextPath }/hot/${empty h ? 'valiadd' : 'edit'}" method="post">
    房间编号:<input type="text" name="hid" value="${h.hid }"><span style="color: cornflowerblue;margin-left: 20px;">${bugMap.hid}</span><br>
    房间名称:<input type="text" name="hname" value="${h.hname }"><span style="color: cornflowerblue;margin-left: 20px;">${bugMap.hname}</span><br>
    房间类型:<input type="text" name="htype" value="${h.htype }"><span style="color: cornflowerblue;margin-left: 20px;">${bugMap.htype}</span><br>
    <input type="submit">
</form>
</body>
</html>

最后开启服务器，到浏览器中请求访问该地址进行测试 : 酒店后台管理系统 http://localhost:8081/ssm/hot/list 酒店后台管理系统

工作台输出结果 :

演示效果 :

二、拦截器

2.1 是什么

拦截器（Interceptor）是一种在请求处理过程中，对请求进行拦截和处理的机制。它可以在请求到达目标处理器之前、之后或者完全替代目标处理器来执行一些特定的操作。拦截器通常用于实现一些横切关注点（Cross-cutting Concerns），如日志记录、权限验证、性能监控等。

在Web开发中，拦截器常用于对请求进行预处理和后处理。当一个请求到达服务器时，拦截器可以在请求到达目标处理器之前对请求进行一些预处理操作，如记录日志、验证权限等；在请求处理完成后，拦截器可以对响应进行后处理操作，如修改响应数据、设置响应头等。

拦截器可以在整个请求处理过程中对请求进行多次拦截，每个拦截器都可以根据自己的需求对请求进行处理，并决定是否继续传递给下一个拦截器或目标处理器。拦截器可以形成一个拦截器链，按照一定的顺序依次对请求进行处理，每个拦截器都可以对请求进行修改或者中断请求处理流程。

在Java的Web开发中，拦截器通常是通过实现javax.servlet.Filter接口来实现的。Filter是Servlet规范中定义的一种用于在请求和响应之间进行拦截和处理的组件。通过在web.xml配置拦截器的URL模式和顺序，可以将拦截器应用到特定的URL或URL模式上。

拦截器的优点是可以将一些通用的操作抽离出来，避免在每个处理器中重复编写相同的代码。它提供了一种可扩展和可配置的方式来处理请求，使得系统的功能更加模块化和可维护。拦截器还可以实现一些与业务逻辑无关的功能，如性能监控、日志记录等，提高系统的可用性和可靠性。

拦截器工作原理

2.2 拦截器与过滤器的区别

什么是过滤器（Filter）

过滤器（Filter）是Java Web开发中的一种组件，它主要用于对Servlet请求进行预处理和后处理。过滤器可以在请求到达目标Servlet之前或者之后执行一些特定的操作，如对请求参数进行解析、字符编码转换、请求日志记录等。通过过滤器，开发人员可以对请求进行统一的处理，提高代码的复用性和可维护性。

过滤器是基于Java的Servlet规范实现的，它是通过实现Filter接口来定义过滤器，并通过在web.xml配置过滤器的URL模式和顺序来应用到特定的请求。在过滤器链中，每个过滤器都可以对请求进行修改或者中断请求处理流程。过滤器的执行顺序由web.xml中的配置决定，按照配置的顺序依次对请求进行处理。

过滤器的主要作用包括：

请求预处理：对请求进行预处理，如解析请求参数、字符编码转换、请求日志记录等。
请求后处理：对请求的响应进行后处理，如设置响应头、字符编码转换、响应日志记录等。
权限验证：对请求进行权限验证，如用户登录验证、访问权限验证等。
缓存控制：对请求进行缓存控制，如设置缓存过期时间、缓存验证等。
异常处理：对请求中可能出现的异常进行处理，如捕获异常、记录异常日志等。

拦截器的主要作用包括：

日志记录：拦截器可以记录请求的相关信息，如请求的URL、请求参数、请求的处理时间等，用于系统的日志记录和分析。

权限验证：拦截器可以对请求进行权限验证，判断用户是否具有访问特定资源的权限，如用户登录验证、角色权限验证等。

参数校验：拦截器可以对请求的参数进行校验，确保参数的合法性和有效性，如参数的格式、范围、长度等。

请求预处理：拦截器可以对请求进行预处理，如字符编码转换、请求参数解析、请求数据的封装等。

请求后处理：拦截器可以对请求的响应进行后处理，如设置响应头、字符编码转换、响应数据的封装等。

异常处理：拦截器可以捕获请求处理过程中可能出现的异常，并进行相应的处理，如异常的日志记录、错误页面的跳转等。

性能监控：拦截器可以对请求的处理时间进行监控，用于系统的性能分析和优化。

2.3 应用场景

日志记录：拦截器可以用于记录请求的相关信息，如请求的URL、请求参数、请求的处理时间等。通过拦截器记录日志，可以方便后续的系统日志记录和分析，以及对请求的追踪和排查问题。
权限验证：拦截器可以用于对用户进行权限验证，判断用户是否具有访问特定资源的权限。例如，在用户访问某个需要登录的页面之前，拦截器可以检查用户是否已登录，并根据用户的角色判断是否有权限访问该页面。
请求预处理：拦截器可以用于对请求进行预处理，如字符编码转换、请求参数解析、请求数据的封装等。通过拦截器进行预处理，可以减轻目标处理器的负担，提高请求的处理效率和系统的稳定性。
性能监控：拦截器可以用于监控请求的处理时间，用于系统的性能分析和优化。例如，拦截器可以记录请求的处理时间，并根据时间阈值进行性能告警或者对慢请求进行分析和优化。

总之，拦截器可以应用于多个场景，包括权限验证、日志记录、参数校验、请求预处理、请求后处理、异常处理和性能监控等。通过拦截器，开发人员可以对请求进行统一的处理，提高代码的复用性和可维护性，同时实现系统的安全性、稳定性和性能优化。

2.4 基础使用

创建一个名为 Interceptor 的包，存放创建自定义拦截器

创建一个创建自定义拦截器，名为 : OneInterceptor，代码如下

package com.CloudJun.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 OneInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("【OneInterceptor】：preHandle...");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("【OneInterceptor】：postHandle...");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("【OneInterceptor】：afterCompletion...");
    }
}

在名为 spring-mvc.xml 的配置文件中，配置自定义拦截器

<mvc:interceptors>
        <bean class="com.CloudJun.interceptor.OneInterceptor"></bean>
</mvc:interceptors>

启动项目服务器，打开浏览器访问请求地址，测试拦截器的拦截效果。

如以下请求地址 : 酒店后台管理系统 http://localhost:8081/ssm/hot/list 酒店后台管理系统 (根据自己配置的请求地址进行访问)

演示测试结果为:

拦截器链（同时配置多个拦截器，可以进行区别拦截）

在 Interceptor 的包里，创建一个拦截器 TwoInterceptor。

package com.CloudJun.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 TwoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("【TwoInterceptor】：preHandle...");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("【TwoInterceptor】：postHandle...");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("【TwoInterceptor】：afterCompletion...");
    }
}

在名为 spring-mvc.xml 的配置文件中，配置自定义拦截器链

<!--2) 配置自定义多拦截器（拦截器链）-->
    <mvc:interceptors>
    <!--    拦截所以有用请求地址   -->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.CloudJun.Interceptor.OneInterceptor"/>
        </mvc:interceptor>
        <!--    只拦截中间有用名为clz的请求地址   -->
        <mvc:interceptor>
            <mvc:mapping path="/hot/**"/>
            <bean class="com.CloudJun.Interceptor.TwoInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

注意: 这里需要将我们上次配置的拦截器配置，进行注释，注释以下配置



<mvc:interceptors>

<bean class="com.CloudJun.Interceptor.OneInterceptor"></bean>

</mvc:interceptors>

启动项目服务器，打开浏览器访问请求地址，测试拦截器链的拦截效果。

如以下请求地址 : http://localhost:8081/ssm/hot/list (根据自己配置的请求地址进行访问)

2.5 用户登录权限控制

创建一个名为 : LoginInterceptor 的拦截器

package com.CloudJun.Interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("【implements】：preHandle...");
        StringBuffer url = request.getRequestURL();
        if (url.indexOf("/login") > 0 || url.indexOf("/logout") > 0){
            //        如果是 登录、退出 中的一种
            return true;
        }
//            代表不是登录，也不是退出
//            除了登录、退出，其他操作都需要判断是否 session 登录成功过
        String hname = (String) request.getSession().getAttribute("hname");
        if (hname == null || "".equals(hname)){
            response.sendRedirect("/ssm/page/hot/login");
            return false;
        }
        return true;
    }
}

创建一个名为 : LoginController 的控制器

package com.CloudJun.web;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
@Controller
public class LoginController {
    @RequestMapping("/login")
    public String login(HttpServletRequest req){
        String hname = req.getParameter("hname");
        HttpSession session = req.getSession();
        if ("zs".equals(hname)){
            session.setAttribute("hname",hname);
        }
        return "redirect:/hot/list";
    }
    @RequestMapping("/logout")
    public String logout(HttpServletRequest req){
        req.getSession().invalidate();
        return "redirect:/hot/list";
    }
}

创建一个 login.jsp 的显示页面，进行测试效果

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户登入</title>
</head>
<body>
<form action="${pageContext.request.contextPath }/login" method="post" enctype="multipart/form-data">
    <label>用户名称：</label><br/>
    <input type="text" name="hname"/><br/>
    <input type="submit" value="登入"/>
</form>
</body>
</html>

在名为 spring-mvc.xml 的配置文件中，配置自定义拦截器，配置登入的用户。

<!--&lt;!&ndash;    用户权限的请求拦截&ndash;&gt;-->
    <mvc:interceptors>
        <bean class="com.CloudJun.Interceptor.LoginInterceptor"></bean>
    </mvc:interceptors>

注意:

这里需要将我们上次配置的拦截器及拦截器链配置，进行注释保证效果，(当然也可不注释)

<mvc:interceptors>

</mvc:interceptors>

<mvc:interceptors>

<mvc:interceptor>

<mvc:mapping path="/**"/>

</mvc:interceptor>

<mvc:interceptor>

<mvc:mapping path="/hot/**"/>

</mvc:interceptor>

</mvc:interceptors>

启动项目服务器，打开浏览器访问请求地址，测试效果。

如以下请求地址 : http://localhost:8081/ssm/login (根据自己配置的请求地址进行访问)

效果图 :

给我们带来的收获

学习完Spring MVC的JSR 303和拦截器可以给我们带来以下几方面的收获：

1. 参数校验的便利性：JSR 303是Java Bean验证的标准规范，它提供了一种简单而强大的方式来对请求参数进行校验。通过学习JSR 303，我们可以使用注解方式在实体类中定义参数的校验规则，从而实现对请求参数的自动校验。这样可以减少手动编写校验逻辑的工作量，提高开发效率，同时也提高了代码的可读性和可维护性。

2. 统一的请求处理流程：拦截器可以用于对请求进行统一的处理，如权限验证、日志记录、异常处理等。通过学习拦截器，我们可以实现对请求的统一拦截和处理，从而减少重复代码的编写，提高代码的复用性和可维护性。同时，拦截器还可以对请求进行预处理和后处理，从而实现一些通用的操作，如字符编码转换、请求数据的封装等。

3. 系统的安全性和稳定性：通过JSR 303和拦截器的应用，我们可以实现对请求参数的校验和权限验证，从而提高系统的安全性。同时，拦截器还可以对请求进行异常处理，捕获可能出现的异常并进行相应的处理，从而提高系统的容错性和稳定性。

4. 性能监控和优化：拦截器可以对请求的处理时间进行监控，用于系统的性能分析和优化。通过学习拦截器，我们可以实现对请求处理时间的记录和分析，从而找出系统中的性能瓶颈，并进行相应的优化，提高系统的性能和响应速度。

总之，学习完Spring MVC的JSR 303和拦截器可以帮助我们提高开发效率，减少重复代码的编写，提高代码的复用性和可维护性。同时，它们还可以提高系统的安全性、稳定性和性能优化，为我们的开发工作带来更多的便利和收益。

Spring-MVC使用JSR303及拦截器，增强网络隐私安全