Filter - 自定义过滤器做数据拦截校验

最新推荐文章于 2023-12-25 15:23:04 发布
最新推荐文章于 2023-12-25 15:23:04 发布
阅读量738 收藏 3
点赞数
分类专栏： 工作日常 filter 文章标签： java filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36782325/article/details/120325261
版权

一、 过滤器与拦截器的区别

过滤器：可以修改request，需要在servlet容器中实现，只能在方法请求前后使用。用于筛选。
拦截器：不能修改request，可以调用IOC容器中的各种依赖，可以详细到每个方法。用于终止流程。

1.配置需要过滤的接口

在resource文件夹下，创建一个存放方法名/路径的yml文件。eg：method.yml

// 路径名示例
method:
  map: {
     "[/base/data/getList]": '2,3',
     "[/base/data/getPage]": '2,3'
  }

// 方法名示例
method:
  map: {
     getList: '2,3',
     getPage: '2,3'
  }

获得配置文件中的map值

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Map;

@Component
@Data
@ConfigurationProperties(prefix = "method")
public class MethodConfig {

    Map<String, String> map;
}

在启动类配置读取配置文件

//yaml属性源PropertySourcesPlaceholderConfigurer对象
@Bean
public static PropertySourcesPlaceholderConfigurer properties() {
    PropertySourcesPlaceholderConfigurer configurer = new
            PropertySourcesPlaceholderConfigurer();
    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    yaml.setResources(new ClassPathResource("method.yml"));
    configurer.setProperties(yaml.getObject());
    return configurer;
}

2.自定义Filter

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

@Slf4j
@Component
@AllArgsConstructor
public class VerifyFilter extends OncePerRequestFilter {
	
	// 自定义异常抛出路径
    private static final String  errorFilterPath = "/filter/errorFilter";

    private static final String  errorCode = "errorCode";

	// 请求类型
    private static final String METHOD_GET = "GET";

    private static final String METHOD_POST = "POST";

	// 从yml文件中读取map	
    @Resource
    private final MethodConfig methodConfig;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

		// 获得接口路径 /base/data/getList
        String requestURI = request.getRequestURI();

        //先判断该路径是否需要数据校验
        // 从配置文件中读取接口的数据权限，没有配置说明不需要数据权限
        Map<String, String> map = methodConfig.getmap();
        String str = map.get(requestURI);

        // 查询该接口所关联的角色，判断用户是否属于其中，如果该接口未绑定角色，说明不需要进行数据校验，直接跳回
        if (StringUtils.isBlank(str)) {
            filterChain.doFilter(request, response);
            return;
        }
        List<String> orgTypeList = Arrays.asList(orgTypeStr.split(","));

        log.info("进入数据校验拦截器, 接口路径 = " + request.getRequestURI());

		// 从token中获得用户信息
       User user = getUserByToken();
       
        String orgType = user.getOrgType();
        if (!orgTypeList.contains(orgType)) {
            // 抛异常，无权限
            request.setAttribute(errorCode, "数据校验未通过");
            
            // 重定向至抛出异常的接口
            request.getRequestDispatcher(errorFilterPath).forward(request, response);
            return;
        }

        // 如果用户是 valid类型，则需要校验code参数
        if ("valid".equals(orgType)) {
            Integer code = lusEntity.getCode();
            HttpServletRequest req = (HttpServletRequest)request;

            String codeParam= null;
            String method = req.getMethod();
            if (METHOD_POST.equals(method)) {
                // post 请求，获得Json格式的参数
				// 自定义wrapper，过滤、读取request请求参数
                XssHttpServletRequestWrapper requestWrapper = new XssHttpServletRequestWrapper((HttpServletRequest) request);
                Map<String, Object> bodyMap = requestWrapper.getBodyMap(requestWrapper.getInputStream());
                if (bodyMap != null && bodyMap.get("code") != null) {
                    codeParam = bodyMap.get("code").toString();
                }
            } else {
                // get 请求，直接取出参数
                codeParam = request.getParameter("code");
            }

            if (!code.toString().equals(codeParam)) {
                // 抛异常
                request.setAttribute(errorCode, "数据校验未通过");
                
                  // 重定向至抛出异常的接口
                request.getRequestDispatcher(errorFilterPath).forward(request, response);
                return;
            }
        }

        filterChain.doFilter(request, response);
    }
}

3.自定义wrapper

HttpServletRequestWrapper
当使用filter时，会出现需要获取或者改变HttpServletRequest对象的参数的情况。但是java.util.Map包装的HttpServletRequest对象的参数是不可改变的。我们不能改变对象本身，但是可以通过装饰模式来改变其状态。
HttpServletRequestWrapper类是HttpServletRequest类的装饰类。想要改变在httpServletRequest中的参数，可以通过httpServletRequest的装饰类HttpServletRequestWrapper来实现，只需要在装饰类中按照需要重写其getParameter（getParameterValues）方法即可。

@RequestBody
以流的形式读取request中的Json数据。读取流时，getReader()和getInputStream()只能调用一次。因为读取一次，标记一次当前的位置。第二次读取就从标记位置继续读取，所以会读不到数据。

获得参数
重写HttpServletRequestWrapper，可以把request保存下来。再通过过滤器，把保存下来的request填充进去，可以实现多次读取request。

XssHttpServletRequestWrapper

import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
    /**
     * 没被包装过的HttpServletRequest（特殊场景，需要自己过滤）
     */
    HttpServletRequest orgRequest;

    /**
     * 方便重复读取requestBody，由于每次都会在filter创建，因此整个生命周期中是单例的，注意线程安全问题
     */
    private byte[] requestBody;

    /**
     * html过滤
     */
    private final static HTMLFilter htmlFilter = new HTMLFilter();

    public XssHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        orgRequest = request;

        // 获取Json参数体
        InputStream is = request.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte buff[] = new byte[1024];
        int read;
        while ((read = is.read(buff)) > 0) {
            baos.write(buff, 0, read);
        }
        requestBody = baos.toByteArray();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        String json = null;
        //保存内容。方便多次获取requestBody
        if (null == this.requestBody) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            IoUtil.copy(super.getInputStream(), baos);
            this.requestBody = baos.toByteArray();
        }
        //为空，直接返回
        json = new String(this.requestBody, StandardCharsets.UTF_8);
        json = xssEncode(json);
        if (StrUtil.isBlank(json)) {
            return super.getInputStream();
        }

        final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes("utf-8"));
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return true;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {
            }

            @Override
            public int read() throws IOException {
                return bis.read();
            }
        };
    }

    @Override
    public String getParameter(String name) {
        String value = super.getParameter(xssEncode(name));
        if (StrUtil.isNotBlank(value)) {
            value = xssEncode(value);
        }
        return value;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] parameters = super.getParameterValues(name);
        if (parameters == null || parameters.length == 0) {
            return null;
        }

        for (int i = 0; i < parameters.length; i++) {
            parameters[i] = xssEncode(parameters[i]);
        }
        return parameters;
    }

    @Override
    public Map<String,String[]> getParameterMap() {
        Map<String,String[]> map = new LinkedHashMap<>();
        Map<String,String[]> parameters = super.getParameterMap();
        for (String key : parameters.keySet()) {
            String[] values = parameters.get(key);
            for (int i = 0; i < values.length; i++) {
                values[i] = xssEncode(values[i]);
            }
            map.put(key, values);
        }
        return map;
    }

    @Override
    public String getHeader(String name) {
        String value = super.getHeader(xssEncode(name));
        if (StrUtil.isNotBlank(value)) {
            value = xssEncode(value);
        }
        return value;
    }

    private String xssEncode(String input) {
        return htmlFilter.filter(input);
    }

    /**
     * 获取最原始的request
     */
    public HttpServletRequest getOrgRequest() {
        return orgRequest;
    }

    /**
     * 获取最原始的request
     */
    public static HttpServletRequest getOrgRequest(HttpServletRequest request) {
        if (request instanceof XssHttpServletRequestWrapper) {
            return ((XssHttpServletRequestWrapper) request).getOrgRequest();
        }

        return request;
    }

    //获取request请求body中参数
    public Map<String,Object> getBodyMap(InputStream in) {
        String param= null;
        BufferedReader streamReader=null;
        try {
            streamReader = new BufferedReader( new InputStreamReader(in, "UTF-8"));
            StringBuilder responseStrBuilder = new StringBuilder();
            String inputStr;
            while ((inputStr = streamReader.readLine()) != null)
                responseStrBuilder.append(inputStr);
            if(!JsonUtil.getInstance().validate(responseStrBuilder.toString())){
                return new HashMap<String, Object>();
            }
            JSONObject jsonObject = JSONObject.parseObject(responseStrBuilder.toString());
            if(jsonObject==null){
                return new HashMap<String, Object>();
            }
            param = jsonObject.toJSONString();

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(streamReader!=null){
                try {
                    streamReader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return JSONObject.parseObject(param,Map.class);
    }

}

XssFilter
把保存下来的request填充并传递下去

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * XSS过滤
 */
public class XssFilter implements Filter {

	@Override
	public void init(FilterConfig config) throws ServletException {
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
		ServletRequest requestWrapper = null;
		if (request instanceof HttpServletRequest) {
			requestWrapper = new XssHttpServletRequestWrapper((HttpServletRequest) request);
		}
		if (requestWrapper == null) {
			chain.doFilter(request, response);
		} else {
			chain.doFilter(requestWrapper, response);
		}
	}

	@Override
	public void destroy() {
	}
}

4.校验字符串是否是合法的JSON格式

方法一：工具类

import java.text.CharacterIterator;
import java.text.StringCharacterIterator;

import org.apache.commons.lang3.StringUtils;

/**
 * 用于校验字符串是否是合法的JSON格式
 */
public class JsonUtil {
    private CharacterIterator it;
    private char c;
    private int col;
    private static JsonUtil instance;

    /**
     * 获取类的实例
     *
     * @return 类的实例
     */
    public static JsonUtil getInstance() {
        if (instance == null) {
            instance = new JsonUtil();
        }
        return instance;
    }

    /**
     * 验证一个字符串是否是合法的JSON串
     *
     * @param input 要验证的字符串
     * @return true-合法 ，false-非法
     */
    public boolean validate(String input) {
        if(StringUtils.isBlank(input)){
            return false;
        }
        input = input.trim();
        boolean ret = valid(input);
        return ret;
    }

    private boolean valid(String input) {
        if ("".equals(input)) {
            return false;
        }

        boolean ret = true;
        it = new StringCharacterIterator(input);
        c = it.first();
        col = 1;
        if (!value()) {
            ret = error("value", 1);
        } else {
            skipWhiteSpace();
            if (c != CharacterIterator.DONE) {
                ret = error("end", col);
            }
        }

        return ret;
    }

    private boolean value() {
        return literal("true") || literal("false") || literal("null") || string() || number() || object() || array();
    }

    private boolean literal(String text) {
        CharacterIterator ci = new StringCharacterIterator(text);
        char t = ci.first();
        if (c != t) return false;

        int start = col;
        boolean ret = true;
        for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {
            if (t != nextCharacter()) {
                ret = false;
                break;
            }
        }
        nextCharacter();
        if (!ret) error("literal " + text, start);
        return ret;
    }

    private boolean array() {
        return aggregate('[', ']', false);
    }

    private boolean object() {
        return aggregate('{', '}', true);
    }

    private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {
        if (c != entryCharacter) return false;
        nextCharacter();
        skipWhiteSpace();
        if (c == exitCharacter) {
            nextCharacter();
            return true;
        }

        for (; ; ) {
            if (prefix) {
                int start = col;
                if (!string()) return error("string", start);
                skipWhiteSpace();
                if (c != ':') return error("colon", col);
                nextCharacter();
                skipWhiteSpace();
            }
            if (value()) {
                skipWhiteSpace();
                if (c == ',') {
                    nextCharacter();
                } else if (c == exitCharacter) {
                    break;
                } else {
                    return error("comma or " + exitCharacter, col);
                }
            } else {
                return error("value", col);
            }
            skipWhiteSpace();
        }

        nextCharacter();
        return true;
    }

    private boolean number() {
        if (!Character.isDigit(c) && c != '-') return false;
        int start = col;
        if (c == '-') nextCharacter();
        if (c == '0') {
            nextCharacter();
        } else if (Character.isDigit(c)) {
            while (Character.isDigit(c))
                nextCharacter();
        } else {
            return error("number", start);
        }
        if (c == '.') {
            nextCharacter();
            if (Character.isDigit(c)) {
                while (Character.isDigit(c))
                    nextCharacter();
            } else {
                return error("number", start);
            }
        }
        if (c == 'e' || c == 'E') {
            nextCharacter();
            if (c == '+' || c == '-') {
                nextCharacter();
            }
            if (Character.isDigit(c)) {
                while (Character.isDigit(c))
                    nextCharacter();
            } else {
                return error("number", start);
            }
        }
        return true;
    }

    private boolean string() {
        if (c != '"') return false;

        int start = col;
        boolean escaped = false;
        for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {
            if (!escaped && c == '\\') {
                escaped = true;
            } else if (escaped) {
                if (!escape()) {
                    return false;
                }
                escaped = false;
            } else if (c == '"') {
                nextCharacter();
                return true;
            }
        }
        return error("quoted string", start);
    }

    private boolean escape() {
        int start = col - 1;
        if (" \\\"/bfnrtu".indexOf(c) < 0) {
            return error("escape sequence  \\\",\\\\,\\/,\\b,\\f,\\n,\\r,\\t  or  \\uxxxx ", start);
        }
        if (c == 'u') {
            if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())
                    || !ishex(nextCharacter())) {
                return error("unicode escape sequence  \\uxxxx ", start);
            }
        }
        return true;
    }

    private boolean ishex(char d) {
        return "0123456789abcdefABCDEF".indexOf(c) >= 0;
    }

    private char nextCharacter() {
        c = it.next();
        ++col;
        return c;
    }

    private void skipWhiteSpace() {
        while (Character.isWhitespace(c)) {
            nextCharacter();
        }
    }

    private boolean error(String type, int col) {
        return false;
    }
}

方法二：捕获异常

import cn.hutool.json.JSONUtil;

Object param;
JSONObject jsonObject = new JSONObject();
try {
	 // 将参数转为jsonObject
    jsonObject = JSONUtil.parseObj(param);
    
} catch (Exception e) {
    // 不是json格式，额外处理。
}

5.抛出filter自定义异常

在filter过滤器中使用throw直接抛出自定义异常，会返回request内部的500错误码，而无法返回自定义的错误码和内容。
此处使用在filter中重定向至返回错误码的控制层接口，用来实现返回自定义异常。

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

import javax.servlet.http.HttpServletRequest;

@RequestMapping("/filter")
@RestController
public class FilterController {

    /**
     * 捕获filter中的异常并提示
     * @param request
     * @return
     */
    @RequestMapping("errorFilter")
    public RestResponse verifyUserFilter(HttpServletRequest request) {

        String code = request.getAttribute("errorCode").toString();
         return RestResponse.exception(code);
    }
}

参考文章：

用一个实例来说明HttpServletRequestWrapper类的使用
spring boot拦截器中获取request post请求中的参数
springMVC拦截器从Request中获取Json格式并解决request的请求流只能读取一次的问题

御坂10027
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud 使用Zuul防止xss攻击(新版本)
Alone5256的博客
04-15 2673
SpringCloud -ZUULSpringCloud 使用Zuul防止xss攻击(新版本)导入zuul和lang3的jar包编写一个过滤器SqLinjectionFilter，继承ZuulFilter SpringCloud 使用Zuul防止xss攻击(新版本) 导入zuul和lang3的jar包 <!--zuul--> <dependency> ...
Angular.Js中过滤器filter与自定义过滤器filter实例详解
10-19
Angularjs过滤器是 angularjs非常棒的特性之一。有朝一日，你可能需要使用自定义过滤器，所以下面这篇文章主要给大家介绍了Angular.Js中过滤器filter与自定义过滤器filter的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
AngularJS使用Filter自定义过滤器控制ng-repeat去除重复功能示例
10-18
主要介绍了AngularJS使用Filter自定义过滤器控制ng-repeat去除重复功能,结合实例形式分析了AngularJS自定义过滤器的定义及数组过滤相关操作技巧,需要的朋友可以参考下
Spring Security 动态url权限控制
程序员小明1024
12-19 2420
一、前言 本篇文章将讲述Spring Security 动态分配url权限，未登录权限控制，登录过后根据登录用户角色授予访问url权限 基本环境 spring-boot 2.1.8 mybatis-plus 2.2.0 mysql 数据库 maven项目 Spring Security入门学习可参考之前文章： SpringBoot集成Spring Security入门体验(一)blog....
SpringBoot_整合SpringSecurity（前后端分离版）
骑大马挎大刀
02-27 4687
Spring Security安全登录的调用过程以及获取权限的调用过程
小姑仔的博客
09-04 1452
将permissions中的两个参数"test"、"admin"分别构造SimpleGrantedAuthority类，并且放入Collectors之中，最终返回构造的Collectors权限信息，取出来的UsernamePasswordAuthenticationToken和Authentication类分别为。进入到doFilterInternal函数之中运行，首先获取token的内容，然后根据token解析出userId的内容。这里由于没有获取到token，因此调用!继续运行其他拦截器，然后返回。
关于filter抛出自定义异常问题
u013008898的博客
05-25 2028
原因:在Spring Boot由于全局异常处理@RestControllerAdvice只会去捕获所有Controller层抛出的异常，所以在filter当中抛出的异常异常类是没有感知的 解决方案:添加CustomExceptionFilter过滤器 package com.zy.basy.common.core.filter; import org.springframework.beans.factory.annotation.Autowired; import org.springfram
security框架异常，不被自己自定义的全局异常捕获处理。
Lacia_的博客
02-12 2103
spring security中，过滤器不被自定义异常捕获的问题。
【技术总结】使用Filter进行XSS过滤
张育嘉的博客
11-18 5360
一般来说，系统进行表单数据处理时都需要解决类似XSS攻击以及转义这样的问题，这样的问题具有普遍性，不可能在每个提交表单数据的处理中都加入重复的处理代码。通常通过 Filter 或 Interceptor 来拦截处理。 这里介绍下通过 Filter 进行XSS过滤的方法。 流程：使用Filter拦截请求，将普通请求转化为包装过的可以处理XSS的自定义请求，之后获取参数时都会经过XSS处理。 主要实...
springsecurity自定义异常并解决报错Error: Parse Error: Response overflow
qq_53408145的博客
09-01 1930
springsecurity全局异常处理 Error: Parse Error: Response overflow token过期处理
详解AngularJS中$filter过滤器使用(自定义过滤器)
12-09
* 过滤器即有内置过滤器也支持自定义过滤器。内置过滤器很多，可以百度。关键是如何使用： * 1.在HTML中直接使用内置过滤器 * 2.在js代码中使用内置过滤器 * 3.自定义过滤器 * * （1）常用内置过滤器 * number 数字...
Java-filter过滤器在项目开发中的应用.docx
12-13
Java-filter过滤器在项目开发中的应用.docx
SpringSecurity入门和项目中使用
weixin_43604021的博客
09-20 284
Spring Security
SpringBoot整合JWT+Spring Security+Redis实现登录拦截（一）登录认证
最新发布
郝南过的博客
12-25 1558
Spring Security 是基于 Spring 的身份认证（Authentication）和用户授权（Authorization）框架，提供了一套 Web 应用安全性的完整解决方案。其中核心技术使用了 Servlet 过滤器、IOC 和 AOP 等。实际操作时经常需要实现XXXFilter来自定义的登录以及访问控制。什么是身份认证身份认证指的是用户去访问系统资源时，系统要求验证用户的身份信息，用户身份合法才访问对应资源。常见的身份认证一般要求用户提供用户名和密码。
美团面试：接口被恶意狂刷，怎么办？
java小白翻身
05-26 1033
1.大部分情况，token校验+拦截器已然足够，敏感接口再加限流，这也是大部分企业的做法。2.简单场景用TimeStamp就行了，对于大部分机器人恶意访问，他是不可能去看你代码的。3.尽量不要封禁IP，防止误伤，因为很多小区住户往往是局域网，很多人就是共用一个IP的。4.更狠的方法是，模仿那种”请选择图片中的汽车“的做法，反向薅羊毛，嗯，大家应该明白其中的意思。
SpringSecurity提示Token过期返回错误代码而不是报系统繁忙的处理
Qyq0498的博客
02-18 4714
SpringSecurity对于每一个接口请求都会经过一个鉴权访问的Filter类，故Token过期的设置就在这里面处理啦。 第一步就是Security的入口啦，配置好SecurityConfig，注入所需要的所有Filter类 以下是我项目中的配置，仅供参考哈 package com.daqing.financial.hrauth.config; import com.daqing.financial.hrauth.filter.AdminAuthenticationProcessingFilter;
过滤器Filter和拦截器HandlerInterceptor
myfirstuser的博客
07-30 2241
1、过滤器 依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。 使用过滤器的目的是用来做一些过滤操作，获取我们想要获取的数据。 比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。 Java中的Filter并不是一个标准的Servlet ，它不能处理...
java token抛异常,启动抛异常 java.io.OptionalDataException
weixin_30789921的博客
03-20 325
前面还有个错误:org.apache.shiro.authc.AuthenticationException: Authentication failed for token submission [com.thinkgem.jeesite.modules.sys.security.UsernamePasswordToken - thinkgem, rememberMe=false (0:0:0:...
Springboot - 配置Swagger2登录密码
热门推荐
qq_36782325的博客
09-30 1万+
配置Swagger，并设置登录密码
springmvc过滤器和拦截器
05-29
Spring MVC 中的过滤器和拦截器都可以在请求处理之前或之后进行一些特定的操作，但它们的实现方式和作用范围不同。 过滤器是基于 Servlet 规范实现的，在 Servlet 容器中运行，可以拦截所有的请求（包括静态资源...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值