springMVCJSR303和拦截器

最新推荐文章于 2024-01-18 09:20:30 发布

小陈爱吃糖- T L

最新推荐文章于 2024-01-18 09:20:30 发布

阅读量162

点赞数

分类专栏： idea 文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_62735525/article/details/126420884

版权

idea 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、JSR303实现

1.1 JSR303的作用:服务端的验证

1.2 pom依赖

1.3 后台代码在待校验的数据列段对应的实体类属性打上校验标签

一、JSR303实现

1.1 JSR303的作用:服务端的验证

1.2 pom依赖

<dependency>

      <groupId>org.hibernate</groupId>

      <artifactId>hibernate-validator</artifactId>

      <version>6.0.7.Final</version>

    </dependency>

1.3 后台代码在待校验的数据列段对应的实体类属性打上校验标签

非空校验

@NotNull ：作用于基本数据类型

@NotEmpty 作用于集合

@NotBlank 作用于字符串

ClazzController

package com.cdl.ssm.controller;

import com.cdl.ssm.biz.ClazzBiz;
import com.cdl.ssm.model.Clazz;
import com.cdl.ssm.model.dto.ClazzDto;
import com.cdl.ssm.util.PageBean;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-17 20:47
 */
@Controller
@RequestMapping("/clz")
public class ClazzController {

    @Autowired
    private ClazzBiz clazzBiz;

    @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";
    }

    @RequestMapping("/add")
    public String add(Clazz clazz){
        this.clazzBiz.insertSelective(clazz);
        return "redirect:/clz/list";
    }

    /**
     *@Valid 是与实体类中 的服务端校验 注解配合使用的
     *
     * bindingResult：存放了所有违背校验的错误信息
     * @param clazz
     * @param bindingResult
     * @param req
     * @return
     */
    @RequestMapping("/valiAdd")
    public String valiAdd(@Validated Clazz clazz, BindingResult bindingResult, HttpServletRequest req){
//        如果服务端验证不通过，有错误
        if(bindingResult.hasErrors()){//违背了规则
//            服务端验证了实体类的多个属性，多个属性都没有验证通过
            List<FieldError> fieldErrors = bindingResult.getFieldErrors();
            Map<String,Object> map = new HashMap<>();
            for (FieldError fieldError : fieldErrors) {
//                将多个属性的验证失败信息输送到控制台
                System.out.println(fieldError.getField() + ":" + fieldError.getDefaultMessage());
                //msg.put(cid,cid不能为空)
                map.put(fieldError.getField(),fieldError.getDefaultMessage());
            }
            req.setAttribute("errorMap",map);
        }else {//没有违背
            this.clazzBiz.insertSelective(clazz);
            return "redirect:/clz/list";
        }
        return "clzEdit";
    }

    @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:/cdl/";//图片的存放地址
            String requestPath = "/upload/mvc/";//访问的地址 数据库保存的地址
            //拿到上传文件的名字
            String fileName = picFile.getOriginalFilename();
            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";
    }

}

1.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: coral">${errorMap.cid}</span><br>
    cname:<input type="text" name="cname" value="${b.cname }"><span style="color: coral">${errorMap.cname}</span><br>
    cteacher:<input type="text" name="cteacher" value="${b.cteacher}"><span style="color: coral">${errorMap.cteacher}</span><br>
    <input type="submit">
</form>
</body>
</html>

结果：

二、拦截器的初步认识和简单应用

2.1 什么是拦截器

和aop的环绕通知类似

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

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

2.2 拦截器与过滤器的区别

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

过滤器(filter)：

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

   拦截器(interceptor)

   1) interceptor属于SpringMVC技术，必须要有SpringMVC环境才可以使用
   2) interceptor通常对处理器Controller进行拦截
   3) interceptor只能拦截dispatcherServlet处理的请求

2.3 应用场景

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

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

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

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

2.4使用案例（快速入门拦截器）

2.4.1 写一个类创建HelloController
创建自定义拦截器并实现HandlerInterceptor接口。

package com.cdl.ssm.intercept;

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

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 20:23
 */
public class OneHandlerInterceptor 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...");
    }

}

配置springmvc-servlet.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: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">
    <!-- 通过context:component-scan元素扫描指定包下的控制器-->
    <!--1) 扫描com.cdl.zf及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <aop:aspectj-autoproxy/>
    <context:component-scan base-package="com.cdl"/>

    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <!--两个bean，这两个bean是spring MVC为@Controllers分发请求所必须的。并提供了数据绑定支持，-->
    <!--@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）-->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!--3) ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!--<mvc:resources location="/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/images/" mapping="/images/**"/>-->
    <!--<mvc:resources location="/js/" mapping="/js/**"/>-->
    <mvc:resources location="/static/" mapping="/static/**"/>

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 必须和用户JSP 的pageEncoding属性一致，以便正确解析表单的内容 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 文件最大大小(字节) 1024*1024*50=50M-->
        <property name="maxUploadSize" value="52428800"></property>
        <!--resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常-->
        <property name="resolveLazily" value="true"/>
    </bean>

    <!--配置拦截器-->
        <mvc:interceptors>
            <!--针对所有的请求进行拦截-->
            <bean class="com.cdl.ssm.intercept.OneHandlerInterceptor"></bean>
        </mvc:interceptors>
</beans>

OneHandlerInterceptor

package com.cdl.ssm.intercept;

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

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 20:23
 */
public class OneHandlerInterceptor 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...");
    }

}

HelloController

package com.cdl.ssm.controller;

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 20:33
 */
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        System.out.println("进入业务方法。。。。");
        return "index";
    }
}

2.4.2 拦截器链

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

配置拦截器链 springmvc-servlet.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: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">
    <!-- 通过context:component-scan元素扫描指定包下的控制器-->
    <!--1) 扫描com.cdl.zf及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <aop:aspectj-autoproxy/>
    <context:component-scan base-package="com.cdl"/>

    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <!--两个bean，这两个bean是spring MVC为@Controllers分发请求所必须的。并提供了数据绑定支持，-->
    <!--@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）-->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!--3) ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!--<mvc:resources location="/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/images/" mapping="/images/**"/>-->
    <!--<mvc:resources location="/js/" mapping="/js/**"/>-->
    <mvc:resources location="/static/" mapping="/static/**"/>

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 必须和用户JSP 的pageEncoding属性一致，以便正确解析表单的内容 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 文件最大大小(字节) 1024*1024*50=50M-->
        <property name="maxUploadSize" value="52428800"></property>
        <!--resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常-->
        <property name="resolveLazily" value="true"/>
    </bean>

    <!--配置拦截器-->
        <!--<mvc:interceptors>
            &lt;!&ndash;针对所有的请求进行拦截&ndash;&gt;
            <bean class="com.cdl.ssm.intercept.OneHandlerInterceptor"></bean>
        </mvc:interceptors>-->

    <!--配置拦截器链-->
    <mvc:interceptors>
       <mvc:interceptor>
           <mvc:mapping path="/**"/>
           <bean class="com.cdl.ssm.intercept.OneHandlerInterceptor"></bean>
       </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/clz/**"/>
            <bean class="com.cdl.ssm.intercept.TwoHandlerInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

TwoHandlerInterceptor

package com.cdl.ssm.intercept;

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

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 20:23
 */
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...");
    }

}

2.5 使用拦截器完成登录权限控制

LoginController

package com.cdl.ssm.controller;

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

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 23:59
 */
@Controller
public class LoginController {

    @RequestMapping("/login")
    public String login(HttpServletRequest req){
        String uname = req.getParameter("uname");
        HttpSession session = req.getSession();
        if ("zhangssan".equals(uname)){
            session.setAttribute("uname",uname);
        }
        return "index";
    }

    @RequestMapping("/logout")
    public String logout(HttpServletRequest req){
        req.getSession().invalidate();//销毁session
        return "index";
    }


}

需要登录才能访问clzList.jsp

OneHandlerInterceptor

package com.cdl.ssm.intercept;

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

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

/**
 * @author cdl
 * @site www.cdl.com
 * @create 2022-08-19 20:23
 */
public class OneHandlerInterceptor implements HandlerInterceptor {


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       //预处理
        System.out.println("【OneInterceptor】：preHandle...");
       //如果 login/loginout 这个请求 就直接执行
        StringBuffer url = request.getRequestURL();
        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 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...");
    }

}