Controller层自定义注解拦截request请求校验

这篇具有很好参考价值的文章主要介绍了Controller层自定义注解拦截request请求校验。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、背景

笔者工作中遇到一个需求,需要开发一个注解,放在controller层的类或者方法上,用以校验请求参数中(不管是url还是body体内,都要检查,有token参数,且符合校验规则就放行)是否传了一个token的参数,并且token符合一定的生成规则,符合就不予拦截,放行请求,否则拦截请求。

用法如下图所示

Controller层自定义注解拦截request请求校验,spring,java

可以看到 @TokenCheck 注解既可以放在类上,也可以放在方法上 ,放在类上则对该类中的所有的方法进行拦截校验。

注意:是加了注解才会校验是否拦截,不加没有影响。

整个代码都是使用的最新springboot版本开发的,所以servlet相关的类都是使用jakarta

Controller层自定义注解拦截request请求校验,spring,java

Controller层自定义注解拦截request请求校验,spring,java

Controller层自定义注解拦截request请求校验,spring,java

如果你的springboot版本比较老 ,请使用javax

先引入以下依赖(javax不飘红不用引入)

<dependency>

      <groupId>javax.servlet</groupId>

      <artifactId>javax.servlet-api</artifactId>

      <version>4.0.1</version>

      <scope>provided</scope>

</dependency>

Controller层自定义注解拦截request请求校验,spring,java

 Controller层自定义注解拦截request请求校验,spring,java

Controller层自定义注解拦截request请求校验,spring,java

我用到的第三方依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.24</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.11</version>
</dependency>

二、TokenCheck注解

package com.example.demo.interceptorToken;
 
import java.lang.annotation.*;
 
/**
 * 是否有token
 */
@Documented
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TokenCheck {
}

三、请求包装器RequestWrapper

主要是对request请求包装下,因为拦截器会拦截request,会读取其中的参数流,而流只能读一次,后续再用到流的读取会报错,所以用一个包装器类处理下,把流以字节形式读出来,重写了getInputStream(),后续可以重复使用。

package com.example.demo.interceptorToken;

import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.lang3.StringUtils;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * @Description 由于 request中getReader()和getInputStream()只能调用一次 导致在Controller @ResponseBody的时候获取不到 null 或 Stream closed
 * 在项目中,可能会出现需要针对接口参数进行校验等问题
 * 构建可重复读取inputStream的request
 */
public class RequestWrapper extends HttpServletRequestWrapper {
    // 将流保存下来
    private final byte[] requestBody;

    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        requestBody = readBytes(request.getReader());
    }

    @Override
    public ServletInputStream getInputStream() {

        final ByteArrayInputStream basic = new ByteArrayInputStream((requestBody != null && requestBody.length >0) ? requestBody : new byte[]{});

        return new ServletInputStream() {

            @Override
            public int read() {
                return basic.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * 通过BufferedReader和字符编码集转换成byte数组
     */
    private byte[] readBytes(BufferedReader br) throws IOException {
        String str;
        StringBuilder retStr = new StringBuilder();
        while ((str = br.readLine()) != null) {
            retStr.append(str);
        }
        if (StringUtils.isNotBlank(retStr.toString())) {
            return retStr.toString().getBytes(StandardCharsets.UTF_8);
        }
        return null;
    }
}

四、过滤器RequestFilter

自定义请求过滤器,把请求用自定义的包装器RequestWrapper包装下,往调用下文传递,也是为了让request请求的流能多次读取

package com.example.demo.interceptorToken;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.NonNull;
import org.springframework.core.annotation.Order;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import java.io.IOException;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 自定义请求过滤器
 */
//排序优先级,最先执行的过滤器
@Order(0)
public class RequestFilter extends OncePerRequestFilter {

    //spring6.0版本后删除了CommonsMultipartResolver,使用StandardServletMultipartResolver
    //如果是spring6.0版本,此行代码不报错请使用如下
    // private CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
    private final StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
    /**
     *
     */
    @Override
    protected void doFilterInternal(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull FilterChain filterChain) throws ServletException, IOException {
        //请求参数有form_data的话,防止request.getHeaders()报已使用,单独处理
        if (request.getContentType() != null && request.getContentType().contains("multipart/form-data")) {
            MultipartHttpServletRequest multiReq = multipartResolver.resolveMultipart(request);
            filterChain.doFilter(multiReq, response);
        }else{
            ServletRequest requestWrapper;
            requestWrapper = new RequestWrapper(request);
            filterChain.doFilter(requestWrapper, response);
        }
    }

}

五、请求过滤器配置类TokenFilterConfig

这个很好理解,把自定义配置类注入spring容器

package com.example.demo.interceptorToken;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletContext;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Enumeration;


/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 将过滤器注入spring容器中
 */
@Configuration
public class TokenFilterConfig implements FilterConfig {
    @Bean
    Filter bodyFilter() {
        return new RequestFilter();
    }

    @Bean
    public FilterRegistrationBean<RequestFilter> filters() {
        FilterRegistrationBean<RequestFilter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter((RequestFilter) bodyFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.setName("requestFilter");
        //多个filter的时候order的数值越小 则优先级越高
        //filterRegistrationBean.setOrder(0);
        return filterRegistrationBean;
    }

    @Override
    public String getFilterName() {
        return null;
    }

    @Override
    public ServletContext getServletContext() {
        return null;
    }

    @Override
    public String getInitParameter(String s) {
        return null;
    }

    @Override
    public Enumeration<String> getInitParameterNames() {
        return null;
    }
}

 六、核心类RequestInterceptor拦截器

注意如果你的springboot版本也是低于3.0,请继承HandlerInterceptorAdapter类,实现其中方法,基本不用改动类中的内容,只需要 把implements HandlerInterceptor 改为extends HandlerInterceptorAdapter即可。

package com.example.demo.interceptorToken;

import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.NonNull;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.StreamUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 自定义请求拦截器(spring boot 3.0以下的版本,需要继承HandlerInterceptorAdapter类,实现对应得方法)
 */

public class RequestInterceptor implements HandlerInterceptor {

    /**
     * 需要从请求里验证的关键字参数名
     */
    private static final String TOKEN_STR = "token";

    /**
     * 进入拦截的方法前触发
     * 这里主要从打了注解请求中查找有没有token关键字,并且token的值是否符合一定的生成规则,是就放行,不是就拦截
     */
    @Override
    public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler) throws Exception {
        if (handler instanceof HandlerMethod handlerMethod) {
            //获取token注解
            TokenCheck tokenCheck = getTokenCheckAnnotation(handlerMethod);
            //请求参数有form_data的话,防止request.getHeaders()或request.getInputStream()报已使用错误,单独处理
            if (request.getContentType() != null && request.getContentType().contains("multipart/form-data")) {
                //判断当前注解是否存在
                if (tokenCheck != null) {
                    final StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
                    MultipartHttpServletRequest multipartHttpServletRequest = multipartResolver.resolveMultipart(request);
                    String urlOrBodyToken = "", tokenFromHeaders, tokenFromCookies;
                    //获取全部参数,不管是params里的还是body(form_data)里的
                    urlOrBodyToken = getTokenFromUrlOrBody(multipartHttpServletRequest);
                    //从headers获取token
                    tokenFromHeaders = getTokenFromHeaders(multipartHttpServletRequest);
                    //从cookies获取token
                    tokenFromCookies = getTokenFromCookies(multipartHttpServletRequest);
                    if (tokenRuleValidation(urlOrBodyToken) || tokenRuleValidation(tokenFromHeaders) || tokenRuleValidation(tokenFromCookies)) {
                        return true;
                    } else {
                        returnJson(response, "token校验失败");
                        return false;
                    }
                }
            } else {
                //判断当前注解是否存在
                if (tokenCheck != null) {
                    // 获取请求方式,如果需要根据请求方式做不同处理,则获取后自行判断即可
                    //String requestMethod = request.getMethod();
                    request = new RequestWrapper(request);
                    //token关键字,分别是来自url、headers、cookies、body中的token
                    String tokenFromUrl, tokenFromHeaders, tokenFromCookies, tokenFromBody;
                    //url获取token请求参数
                    tokenFromUrl = getTokenFromUrl(request);
                    //从headers获取token
                    tokenFromHeaders = getTokenFromHeaders(request);
                    //从cookies获取token
                    tokenFromCookies = getTokenFromCookies(request);
                    //从body体获取token参数
                    tokenFromBody = getTokenFromBody(request);
                    //token校验判断
                    if (tokenRuleValidation(tokenFromUrl) || tokenRuleValidation(tokenFromHeaders) || tokenRuleValidation(tokenFromCookies) || tokenRuleValidation(tokenFromBody)) {
                        return true;
                    } else {
                        returnJson(response, "token校验失败");
                        return false;
                    }
                }
            }
            return true;
        }
        return true;
    }

    /**
     * 获取TokenCheck注解(先从类上优先获取)
     */
    private TokenCheck getTokenCheckAnnotation(HandlerMethod handler) {
        Method method = handler.getMethod();
        //获取方法所属的类,并获取类上的@TokenCheck注解
        Class<?> clazz = method.getDeclaringClass();
        TokenCheck tokenCheck = null;
        if (clazz.isAnnotationPresent(TokenCheck.class)) {
            tokenCheck = clazz.getAnnotation(TokenCheck.class);
        }
        //类上没有注解,则从方法上再获取@TokenCheck
        tokenCheck = tokenCheck == null ? method.getAnnotation(TokenCheck.class) : tokenCheck;
        return tokenCheck;
    }

//===============================================================================================================================

    /**
     * form_data参数形式,从url和body中获取符合生成规则条的token
     */
    private String getTokenFromUrlOrBody(HttpServletRequest multipartHttpServletRequest) {
        String urlOrBodyToken = "";
        Map<String, String[]> urlAndBodyParam = multipartHttpServletRequest.getParameterMap();
        String[] tokenFromUrlOrBody = urlAndBodyParam.get(TOKEN_STR);
        for (String tokenStr : tokenFromUrlOrBody) {
            if (tokenRuleValidation(tokenStr)) {
                urlOrBodyToken = tokenStr;
                break;
            }
        }
        return urlOrBodyToken;
    }
//===============================================================================================================================

    /**
     * 从headers获取token
     */
    private String getTokenFromHeaders(HttpServletRequest request) {
        Map<String, String> headerMap = new HashMap<>();
        Enumeration<String> enumeration = request.getHeaderNames();
        while (enumeration.hasMoreElements()) {
            String name = enumeration.nextElement();
            String value = request.getHeader(name);
            headerMap.put(name, value);
        }
        return headerMap.get(TOKEN_STR) == null ? "" : String.valueOf(headerMap.get(TOKEN_STR));
    }
//===============================================================================================================================

    /**
     * 从cookies获取token
     */
    private String getTokenFromCookies(HttpServletRequest request) {
        Map<String, String> cookieMap = new ConcurrentHashMap<>();
        Cookie[] cookies = request.getCookies();
        if (null != cookies) {
            Arrays.stream(cookies).forEach(element ->
                    cookieMap.put(element.getName(), element.getValue())
            );
        }
        return cookieMap.get(TOKEN_STR) == null ? "" : String.valueOf(cookieMap.get(TOKEN_STR));
    }

//===============================================================================================================================

    /**
     * 从请求体获取token参数
     */
    private String getTokenFromBody(HttpServletRequest request) throws Exception {
        String bodyParamsStr = this.getPostParam(request);
        String tokenFromBody = "";
        //判断是否是json数组
        boolean isJsonArray = JSONUtil.isTypeJSONArray(bodyParamsStr);
        if (!isJsonArray) {
            tokenFromBody = JSONUtil.parseObj(bodyParamsStr).getStr(TOKEN_STR);
        } else {
            JSONArray jsonArray = JSONUtil.parseArray(bodyParamsStr);
            Set<String> tokenSet = new HashSet<>();
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                if (StringUtils.isNotEmpty(jsonObject.getStr(TOKEN_STR))) {
                    tokenSet.add(jsonObject.getStr(TOKEN_STR));
                }
            }
            if (!tokenSet.isEmpty()) {
                tokenFromBody = tokenSet.stream().filter(this::tokenRuleValidation).findFirst().orElse("");
            }
        }
        return tokenFromBody;
    }

    private String getPostParam(HttpServletRequest request) throws Exception {
        RequestWrapper readerWrapper = new RequestWrapper(request);
        return StringUtils.isEmpty(getBodyParams(readerWrapper.getInputStream(), request.getCharacterEncoding())) ?
                "{}" : getBodyParams(readerWrapper.getInputStream(), request.getCharacterEncoding());
    }

    private String getBodyParams(ServletInputStream inputStream, String charset) throws Exception {
        String body = StreamUtils.copyToString(inputStream, Charset.forName(charset));
        if (StringUtils.isEmpty(body)) {
            return "";
        }
        return body;
    }

//===============================================================================================================================

    /**
     * 如果是get请求,则把url中的请求参数获取到,转换为map
     */
    public String getTokenFromUrl(HttpServletRequest request) throws UnsupportedEncodingException {
        //获取当前请求的编码方式,用于参数value解码
        String encoding = request.getCharacterEncoding();
        String urlQueryString = request.getQueryString();
        Map<String, String> queryMap = new HashMap<>();
        String[] arrSplit;
        if (urlQueryString == null) {
            return "";
        } else {
            //每个键值为一组
            arrSplit = urlQueryString.split("&");
            for (String strSplit : arrSplit) {
                String[] arrSplitEqual = strSplit.split("=");
                //解析出键值
                if (arrSplitEqual.length > 1) {
                    queryMap.put(arrSplitEqual[0], URLDecoder.decode(arrSplitEqual[1], encoding));
                } else {
                    if (!"".equals(arrSplitEqual[0])) {
                        queryMap.put(arrSplitEqual[0], "");
                    }
                }
            }
        }
        return queryMap.get(TOKEN_STR) == null ? "" : String.valueOf(queryMap.get(TOKEN_STR));
    }

    /**
     * token 规则校验
     *
     * @param token token关键字
     */
    private boolean tokenRuleValidation(String token) {
        return "AAABBB".equals(token);

    }

    /**
     * 离开拦截的方法后触发
     */
    @Override
    public void postHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler, ModelAndView modelAndView) {

    }

    /**
     * 返回response的json信息
     */
    private void returnJson(HttpServletResponse response, String json) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html; charset=utf-8");
        try (PrintWriter writer = response.getWriter()) {
            writer.print(json);
        }
    }
}

七、拦截器注册InterceptorRegister

一个配置类,把自定义的拦截器注入spring

package com.example.demo.interceptorToken;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author hulei
 * @date 2024/1/11 19:48
 * 将拦截注入spring容器
 */
@Configuration
public class InterceptorRegister implements WebMvcConfigurer {

    @Bean
    public RequestInterceptor tokenInterceptor() {
        return new RequestInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor());
    }
}

 八、总结

本例主要是自定义注解,完成请求参数的拦截校验,实际中可根据需求进行修改,如记录日志,拦截校验其他参数,修改RequestInterceptor中的拦截前方法和拦截后方法的逻辑即可

gitee地址: Token-Check-Demo: 自定义注解拦截request请求

注: 创作不易,转载请标明原作地址文章来源地址https://www.toymoban.com/news/detail-798201.html

到了这里,关于Controller层自定义注解拦截request请求校验的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 微信小程序封装request请求,包含请求拦截器,响应拦截器和请求重试功能

    在发送请求之前,先判断用户是否有token,没有就执行登陆请求,将token保存,然后再执行原来请求; 拥有token,就直接执行请求;但是用户的这个token可能是过期的,如果执行请求发现用户登陆过期,就统一返回40001,然后对40001的响应统一处理,执行登陆请求,再执行原来请

    2024年02月13日
    浏览(47)
  • 【SpringBoot】常用的的各种注解(一):Controller中的请求参数

    请求路径中的参数,可以有一个或者多个 在Postman中也是直接在请求路径中添加参数即可 获取查询参数,形式为 url?name=张三 ,可以有一个或者多个。 在Postman中可以使用 Query Params 的方式添加参数: 也可以使用Body中的 form-data 的形式添加参数 一般用于传输DTO参数,只能有一

    2024年02月06日
    浏览(48)
  • 自定义注解与拦截器实现不规范sql拦截(拦截器实现篇)

    最近考虑myBatis中sql语句使用规范的问题,如果漏下条件或者写一些不规范语句会对程序性能造成很大影响。最好的方法就是利用代码进行限制,通过拦截器进行sql格式的判断在自测环节就能找到问题。写了个简单情景下的demo,并通过idea插件来将myBatis的mapper方法都打上拦截器

    2024年01月22日
    浏览(43)
  • SpringBoot 使用【AOP 切面+注解】实现在请求调用 Controller 方法前修改请求参数和在结果返回之前修改返回结果

    在项目中需要实现 在请求调用 Controller 方法前修改请求参数和在结果返回之前修改返回结果 。 我们可以使用 AOP 切面+注解的形式实现。这样我们就可以在不修改原始代码的情况下,通过切面类在方法调用前后插入额外的逻辑。 自定义注解 @PreProcess 自定义注解 @PreProcess 用于

    2024年03月20日
    浏览(44)
  • 防重复提交:自定义注解 + 拦截器(HandlerInterceptor)

    防重复提交:自定义注解 + 拦截器(HandlerInterceptor) 一、思路: 1、首先自定义注解; 2、创建拦截器实现类(自定义类名称),拦截器(HandlerInterceptor); 3、创建类:配置拦截器路径(拦截URL规则); 二、代码示例: 1、首先自定义注解; 2、创建拦截器实现类(自定义类名

    2024年02月10日
    浏览(40)
  • SpringBoot定义拦截器+自定义注解+Redis实现接口防刷(限流)

    在拦截器Interceptor中拦截请求 通过地址+请求uri作为调用者访问接口的区分在Redis中进行计数达到限流目的 定义参数 访问周期 最大访问次数 禁用时长 代码实现 定义拦截器:实现HandlerInterceptor接口,重写preHandle()方法 注册拦截器:配置类实现WebMvcConfigurer接口,重写addIntercep

    2024年02月05日
    浏览(56)
  • Spring Boot框架中Controller层API接口如何支持使用多个@RequestBody注解接受请求体参数

    众所周知,在Spring Boot框架中,Controller层API接口编码获取请求体参数时,在参数上会使用@RequestBody注解;如果一次请求中,请求体参数携带的内容需要用多个参数接收时,能不能多次使用@RequestBody注解呢? 下面我们先测试一下,参考代码: PostMan进行请求: 服务端后端日志:

    2024年01月17日
    浏览(53)
  • java 自定义xss校验注解实现

    自定义一个注解@Xss。名字随意 validator校验类:XssValidator。这个校验类要和上面的@Xss注解上的 @Constraint(validatedBy = { XssValidator.class })对应 具体使用在某个字段上加上注解;形如: 然后在控制层中增加@Validated注解校验就可以了  以上代码实现后。会自动针对某些增加了@Xss字符

    2024年02月14日
    浏览(45)
  • Spring Boot 中自定义数据校验注解

    在 Spring Boot 中,我们可以使用 JSR-303 数据校验规范来校验表单数据的合法性。JSR-303 提供了一些常用的数据校验注解,例如 @NotNull 、 @NotBlank 、 @Size 等。但是,在实际开发中,我们可能需要自定义数据校验注解来满足特定的需求。本文将介绍如何在 Spring Boot 中自定义数据校

    2024年02月10日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包