java 拦截、过滤器2

已于 2024-05-21 10:40:18 修改
阅读量71 收藏
点赞数
分类专栏： Java 文章标签： java
于 2023-07-23 15:52:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17842663/article/details/131880334
版权

一、概述

在SpringMVC中，除了Filter和Interceptor拦截器外，还有对请求Controller的处理，即对请求和响应内容的处理和对请求参数的处理。
image.png

二、ControllerAdvice

@ControllerAdvice本质上同Component一样，因此也会被当成组件扫描。
其中@ExceptionHandler常用到。即抛出的异常会被统一拦截处理。在项目中对MethodArgumentNotValidException异常拦截处理

@ControllerAdvice
public class GlobalHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result exceptionHandler(MethodArgumentNotValidException e) {
        Result result = new Result(BizExceptionEnum.INVALID_REQ_PARAM.getErrorCode(),
                BizExceptionEnum.INVALID_REQ_PARAM.getErrorMsg());
        logger.error("req params error", e);
        return result;
    }
}
// 上述对MethodArgumentNotValidException异常统一拦截后并统一返回异常

实现原理：

public class DispatcherServlet extends FrameworkServlet {
    // ......
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        // 处理所有异常
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
    // ......
}

DispatcherServlet的initHandlerExceptionResolvers(context)方法，方法会取得所有实现了HandlerExceptionResolver接口的bean并保存起来，其中就有一个类型为ExceptionHandlerExceptionResolver的bean，这个bean在应用启动过程中会获取所有被@ControllerAdvice注解标注的bean对象做进一步处理，关键代码在这里

public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
        implements ApplicationContextAware, InitializingBean {
    // ......
    private void initExceptionHandlerAdviceCache() {
        // ......
        List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        AnnotationAwareOrderComparator.sort(adviceBeans);

        for (ControllerAdviceBean adviceBean : adviceBeans) {
            ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(adviceBean.getBeanType());
            if (resolver.hasExceptionMappings()) {
                // 找到所有ExceptionHandler标注的方法并保存成一个ExceptionHandlerMethodResolver类型的对象缓存起来
                this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
                if (logger.isInfoEnabled()) {
                    logger.info("Detected @ExceptionHandler methods in " + adviceBean);
                }
            }
            // ......
        }
    }
}

public ExceptionHandlerMethodResolver(Class<?> handlerType) {
    // 查询当前类中@ExceptionHandler的方法
    for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
        // 获取方法的异常类型
        for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
            // 添加到缓存中
            addExceptionMapping(exceptionType, method);
        }
    }
}

最后ExceptionHandler被执行过程

// 处理返回结果时，如果异常不为空，则进行异常处理
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                   @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                   @Nullable Exception exception) throws Exception {
    boolean errorView = false;
    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            // ...
        }
        else {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            // 调用异常Handler处理
            mv = processHandlerException(request, response, handler, exception);
            errorView = (mv != null);
        }
    }
    // ...
}

三、RequestBodyAdvice和ResponseBodyAdvice

该类是对入参或者是返回值的处理
RequestBodyAdvice和ResponseBodyAdvice
在ControllerAdvice中，还包含了RequestBodyAdvice，ResponseBodyAdvice

  1. RequestBodyAdvice对请求Body的处理
  2. ResponseBodyAdvice对响应Body的处理
3.1 Spring如何管理

RequestBodyAdvice和ResponseBodyAdvice的实现方式是RequestResponseBodyAdviceChain，其中存储了xxBodyAdvice的方法，在spring处理请求参数和返回数据是被调用。

class RequestResponseBodyAdviceChain implements RequestBodyAdvice, ResponseBodyAdvice<Object> {
  //它持有所有的，记住是所有的advice们
  private final List<Object> requestBodyAdvice = new ArrayList<>(4);
  private final List<Object> responseBodyAdvice = new ArrayList<>(4);

  // 可以看到这是个通用的方法。内来进行区分存储的   getAdviceByType这个区分方法可以看一下
  // 兼容到了ControllerAdviceBean以及beanType本身
  public RequestResponseBodyAdviceChain(@Nullable List<Object> requestResponseBodyAdvice) {
    this.requestBodyAdvice.addAll(getAdviceByType(requestResponseBodyAdvice, RequestBodyAdvice.class));
    this.responseBodyAdvice.addAll(getAdviceByType(requestResponseBodyAdvice, ResponseBodyAdvice.class));
  }

  @Override
  public boolean supports(MethodParameter param, Type type, Class<? extends HttpMessageConverter<?>> converterType) {
    throw new UnsupportedOperationException("Not implemented");
  }
  @Override
  public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
    throw new UnsupportedOperationException("Not implemented");
  }

  // 可以看到最终都是委托给具体的Advice去执行的（supports方法）
  // 特点：符合条件的所有的`Advice`都会顺序的、依次的执行
  @Override
  public HttpInputMessage beforeBodyRead(HttpInputMessage request, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
    for (RequestBodyAdvice advice : getMatchingAdvice(parameter, RequestBodyAdvice.class)) {
      if (advice.supports(parameter, targetType, converterType)) {
        request = advice.beforeBodyRead(request, parameter, targetType, converterType);
      }
    }
    return request;
  }
  ... // 其余方法略。处理逻辑同上顺序执行。
  // 最重要的是如下这个getMatchingAdvice()匹配方法


  private <A> List<A> getMatchingAdvice(MethodParameter parameter, Class<? extends A> adviceType) {
    // 简单的说你想要的是Request的还是Response的List呢？
    List<Object> availableAdvice = getAdvice(adviceType);
    if (CollectionUtils.isEmpty(availableAdvice)) {
      return Collections.emptyList();
    }
    List<A> result = new ArrayList<>(availableAdvice.size());
    for (Object advice : availableAdvice) {
      if (advice instanceof ControllerAdviceBean) {
        ControllerAdviceBean adviceBean = (ControllerAdviceBean) advice;


        // 这里面会调用beanTypePredicate.test(beanType)方法
        // 也就是根据basePackages等等判断此advice是否是否要作用在本类上
        if (!adviceBean.isApplicableToBeanType(parameter.getContainingClass())) {
          continue;
        }
        advice = adviceBean.resolveBean();
      }
      // 当前的advice若是满足类型要求的，那就添加进去  最终执行切面操作
      if (adviceType.isAssignableFrom(advice.getClass())) {
        result.add((A) advice);
      }
    }
    return result;
  }
}

我们知道所有的xxxBodyAdvice最终都是通过暴露的RequestResponseBodyAdviceChain来使用的，它内部持有容器内所有的Advice的引用。由于RequestResponseBodyAdviceChain的访问权限是default，所以这套机制完全由Spring内部控制。
**他唯一设值处是：**AbstractMessageConverterMethodArgumentResolver。

AbstractMessageConverterMethodArgumentResolver（一般实际为RequestResponseBodyMethodProcessor）：
  // 唯一构造函数，指定所有的advices
  public AbstractMessageConverterMethodArgumentResolver(List<HttpMessageConverter<?>> converters, @Nullable List<Object> requestResponseBodyAdvice) {
    Assert.notEmpty(converters, "'messageConverters' must not be empty");
    this.messageConverters = converters;
    this.allSupportedMediaTypes = getAllSupportedMediaTypes(converters);
    this.advice = new RequestResponseBodyAdviceChain(requestResponseBodyAdvice);
  }

此构造函数在new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)时候调用，传进来的requestResponseBodyAdvice就刚好是在初始化RequestMappingHandlerAdapter的时候全局扫描进来的所有的增强器们

3.2 如何使用

请求日志的打印，用于POST请求的，这里实现了RequestBodyAdvice用来打印请求参数，也使用了ResponseBodyAdvice打印返回的信息

// 生成日志信息，并放到request中
@ControllerAdvice
public class RequestBodyAdviceHandler implements RequestBodyAdvice {
    public RequestBodyAdviceHandler() {
    }

    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        Method method = methodParameter.getMethod();
        Class<?> declaringClass = method.getDeclaringClass();
        RestController RestController = (RestController)declaringClass.getAnnotation(RestController.class);
        return RestController != null;
    }

    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        return inputMessage;
    }

    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        this.writeRequestLog(body, inputMessage, parameter, targetType, converterType);
        return body;
    }

    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        this.writeRequestLog(body, inputMessage, parameter, targetType, converterType);
        return body;
    }

    private String toJSONString(Object body, MethodParameter parameter) {
        IgnoreLogBody ignore = (IgnoreLogBody)parameter.getMethodAnnotation(IgnoreLogBody.class);
        if (ignore == null) {
            return JSON.toJSONString(body);
        } else {
            String[] ignoreKey = ignore.ignoreKey();
            return ignoreKey != null && ignoreKey.length != 0 ? JSON.toJSONString(body, new IgnoreLogPropertyFilter(ignore.ignoreKey(), ignore.key()), new SerializerFeature[0]) : JSON.toJSONString(body);
        }
    }

    private void writeRequestLog(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        HttpServletRequest request = RequestHelper.getRequest();
        request.setAttribute("_REQUEST_STARTTIME_", System.currentTimeMillis());
        String requestId = request.getHeader("_REQUEST_ID_");
        if (StringUtils.isEmptyStr(requestId)) {
            requestId = TraceContext.traceId();
        }

        if (StringUtils.isEmptyStr(requestId) || "Ignored_Trace".equals(requestId)) {
            requestId = UUID.randomUUID().toString().replaceAll("-", "");
        }

        request.setAttribute("_REQUEST_ID_", requestId);
        StringBuilder info = new StringBuilder("==>\n");
        info.append("[*=请求requestID=]>: ").append(requestId).append("\n");
        info.append("[==请求地址=======]>: ").append(request.getRequestURL().toString()).append("\n");
        info.append("[==请求方法=======]>: ").append(request.getMethod()).append("\n");
        info.append("[==操作用户=======]>: ").append(UserInfoContext.getCurrentUserCode()).append("\n");
        info.append("[==客户IP========]>: ").append(RequestHelper.getClientIP()).append("\n");
        info.append("[==映射方法=======]>: ").append(parameter.getMethod()).append(".").append("\n");
        if (body == null) {
            info.append("[==请求参数=======]>: ").append("该接口未定义参数或参数为空");
        } else if (converterType == FastJsonHttpMessageConverter.class) {
            info.append("[==请求参数=======]>: ").append(this.toJSONString(body, parameter));
        } else {
            info.append("[==请求参数=======]>: ").append(converterType);
        }

        info.append("\n");
        request.setAttribute("_REQUEST_LOG_INFO_", info);
    }
}

@ControllerAdvice
public class ResponseBodyAdviceHandler implements ResponseBodyAdvice<Object> {
    private static final IEventLogger logger = Logtube.getLogger(ResponseBodyAdviceHandler.class.getName());

    public ResponseBodyAdviceHandler() {
    }

    public boolean supports(MethodParameter methodParamter, Class<? extends HttpMessageConverter<?>> converterType) {
        return this.isRestController(methodParamter);
    }

    public Object beforeBodyWrite(Object body, MethodParameter methodParamter, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest req, ServerHttpResponse response) {
        HttpServletRequest request = RequestHelper.getRequest();
        if (request == null) {
            return body;
        } else {
            StringBuilder info = (StringBuilder)request.getAttribute("_REQUEST_LOG_INFO_");
            if (info == null) {
                info = new StringBuilder();
            }

            String requestBodyData = null;
            if (body == null) {
                requestBodyData = null;
            } else if (selectedContentType.includes(MediaType.APPLICATION_JSON)) {
                requestBodyData = JSON.toJSONString(body);
            } else {
                requestBodyData = body.toString();
            }

            Long startTime = (Long)request.getAttribute("_REQUEST_STARTTIME_");
            info.append("[==响应结果=======]>: ").append(requestBodyData == null ? "null" : requestBodyData);
            info.append("\n");
            if (startTime != null) {
                info.append("[==执行耗时=======]>: ").append(System.currentTimeMillis() - startTime).append("ms").append("\n");
            }

            String requestId = (String)request.getAttribute("_REQUEST_ID_");
            logger.info(info.toString());
            return body;
        }
    }

    private boolean isRestController(MethodParameter methodParamter) {
        RestController annotation = (RestController)methodParamter.getDeclaringClass().getAnnotation(RestController.class);
        return annotation != null;
    }
}

最后打印的日志信息
image.png

四、HandlerMethodReturnValueHandler

4.1 HandlerMethodReturnValueHandler

对返回信息做特殊处理，且只会被调用一次，谨慎处理
默认情况下，spring会调用RequestResponseBodyMethodProcessor来处理返回执行。它实现了HandlerMethodReturnValueHandler的handleReturnValue的方法，
如何选择returnHandler是在HandlerMethodReturnValueHandlerComposite类做了选择

	@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    	// 选择返回的handler处理
		HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
		if (handler == null) {
			throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
		}
        // 执行handleReturnValue将数据写入到reponse流中
		handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
	}

// 被@ResponseBody注解的方法，会被执行该类
@Override
public boolean supportsReturnType(MethodParameter returnType) {
    return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
            returnType.hasMethodAnnotation(ResponseBody.class));
}
//将returnValue写入到流中
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
        ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
        throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

    mavContainer.setRequestHandled(true);
    ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
    ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

    // Try even with null return value. ResponseBodyAdvice could get involved.
    writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}

知道了HandlerMethodReturnValueHandler是用于返回数据的handler，那么自己实现这个类用户封装自己返回的方法。

4.2 如何使用

一般请求下，返回的数据如下：

{
    "data": {
    },
    "errorCode": "0",
    "errorMsg": "成功",
}

data是其真实数据。在Controller层，需要调用如下

@RestController
@RequestMapping("/stock/depotinventorybalance")
public class DepotInventoryBalanceController {
	@RequestMapping(value = "findById", method = RequestMethod.POST)
	public DepotInventoryBalanceDto findById(@RequestBody DepotInventoryBalanceDto depotInventoryBalance) {
		DepotInventoryBalanceDto  balance = this.depotInventoryBalanceService.findById(depotInventoryBalance);
        return ResponseResultUtil.result(balance);
	}
}

@Data
public class  ResponseResult<T> {
	private T data;
    private String errorCode;
    private String errorMsg; 

}

public static class ResponseResultUtil<T> {
    public static <T> ResponseResult<T> result(T data){
        ResponseResult<T> result = new ResponseResult<>();
        result.setErrorCode( ErrorCode.SUCCESS.getCode());
        result.setErrorMsg(ErrorCode.SUCCESS.getMessage());
        result.setData(data);
        return result;
    }
}

那么通过注解@AutoResult可以将ResponseResultUtil替换调用，就是在处理HandlerMethodReturnValueHandler时，处理自己handleReturnValue返回数据。但是这里有一个点，就是实现了自己的类，那么自己实现的ResponseBodyAdvice，将不会被调用，因为AutoResultReturnValueHandler拦截的请求，会直接返回，不会再调用后续的handler方法。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AutoResult {
    boolean value() default true;
}

public class AutoResultReturnValueHandler implements HandlerMethodReturnValueHandler {
    private static final IEventLogger logger = Logtube.getLogger(AutoResultReturnValueHandler.class.getName());

    public AutoResultReturnValueHandler() {
    }

    public boolean supportsReturnType(MethodParameter returnType) {
        return this.isRestController(returnType) && this.isAutoResult(returnType);
    }

    public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        HttpServletRequest request = (HttpServletRequest)webRequest.getNativeRequest(HttpServletRequest.class);
        mavContainer.setRequestHandled(true);
        HttpServletResponse response = (HttpServletResponse)webRequest.getNativeResponse(HttpServletResponse.class);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        StringBuilder info = (StringBuilder)request.getAttribute("_REQUEST_LOG_INFO_");
        if (info == null) {
            info = new StringBuilder();
        }

        String requestId = (String)request.getAttribute("_REQUEST_ID_");
        ResponseResult result = new ResponseResult();
        result.setData(returnValue);
        result.setErrorCode( ErrorCode.SUCCESS.getCode());
        result.setErrorMsg(ErrorCode.SUCCESS.getMessage());
        result.setRequestId(requestId);
        String jsonString = JSON.toJSONString(result, new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
        Long startTime = (Long)request.getAttribute("_REQUEST_STARTTIME_");
        info.append("[==响应结果=======]>: ").append(jsonString);
        info.append("\n");
        if (startTime != null) {
            info.append("[==执行耗时=======]>: ").append(System.currentTimeMillis() - startTime).append("ms").append("\n");
        }

        logger.info(info.toString());
        response.getWriter().append(jsonString);
    }

    private boolean isRestController(MethodParameter returnType) {
        RestController annotation = (RestController)returnType.getDeclaringClass().getAnnotation(RestController.class);
        return annotation != null;
    }

    private boolean isAutoResult(MethodParameter returnType) {
        AutoResult methodAnnotation = (AutoResult)returnType.getMethodAnnotation(AutoResult.class);
        if (methodAnnotation != null) {
            return methodAnnotation.value();
        } else {
            AutoResult annotation = (AutoResult)returnType.getDeclaringClass().getAnnotation(AutoResult.class);
            return annotation != null && annotation.value();
        }
    }
}

// 该类下的所有方法都会被拦截
@AutoResult
@RestController
@RequestMapping("/stock/depotinventorybalance")
public class DepotInventoryBalanceController {
	@RequestMapping(value = "findById", method = RequestMethod.POST)
	public DepotInventoryBalanceDto findById(@RequestBody DepotInventoryBalanceDto depotInventoryBalance) {
		return this.depotInventoryBalanceService.findById(depotInventoryBalance);
	}

    // 导出的方法，最后是已文件流的方式返回，
    // 不使用AutoResult返回的结果形式，即不使用自定义Handler类
    @AutoResult(value = false)
    public void export() {
        depotInventoryBalanceService.export();
    }
}

冰魄秋雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java拦截器和过滤器的区别_拦截器和过滤器的区别
weixin_33028765的博客
02-18 2913
过滤器和拦截器的区别：①拦截器是基于java的反射机制的，而过滤器是基于函数回调。②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。⑥拦截器可以获取...
通过实例解析java过滤器和拦截器的区别
08-19
通过实例解析Java过滤器和拦截器的区别 Java过滤器和拦截器是两个常用的Web应用程序组件，它们之间的区别是什么呢？本文将通过实例解析，详细介绍Java过滤器和拦截器的区别，帮助读者更好地理解和应用它们。 1. ...
java 过滤器、拦截器
qq_17842663的博客
07-23 1278
Filter和HandlerInterceptor的认识与原理的学习
JAVA中的拦截器、过滤器
热门推荐
qq_38254635的博客
06-14 1万+
相关解释：拦截器依赖于页面有访问controller的操作，且属于SpringMVC体系的动态拦截调用机制，是java中AOP思想的运用。来看看源码作者的注释：其中倒数第二段话，描述其类似于过滤器，但其特点只允许使用自定义预处理，不能处理程序本身。此处可体现AOP思想。过滤器是在web.xml中配置，web.xml是应用程序上下文中的HandlerInterceptor。最后一段话，则体现了拦截器常用情况，如常见处理程序代码和授权检查。
Java拦截器与过滤器的区别
weixin_43914278的博客
09-15 725
过滤器：过滤器实现javax.servlet.Filter接口，它们是JavaEE规范的一部分，可以在Servlet容器级别处理请求和响应。总之，拦截器和过滤器都用于处理请求和响应，但它们的使用场景、实现方式以及生命周期有所不同。选择使用哪种取决于你的应用程序需求和技术栈。拦截器：拦截器通常实现HandlerInterceptor接口，它们与Spring框架的MVC模块一起使用，用于拦截和处理请求。过滤器：通常在Servlet容器中使用，可以用于修改请求和响应，例如修改请求参数、编码转换、请求包装等。
Java过滤器与拦截器的区别
靖节先生的博客
11-09 2610
Java过滤器与拦截器的区别1. 过滤器与拦截器概述1.1 过滤器 Filter1.2 拦截器 interceptor2. 过滤器与拦截器区别3. 过滤器与拦截器实现3.1 过滤器（Filter）3.2 拦截器 (Interceptor)3.3 拦截器WebMvc配置3.4 切片（Aspect）4. 过滤器与拦截器执行顺序验证 1. 过滤器与拦截器概述 1.1 过滤器 Filter 依赖于servlet容器，实现基于函数回调，可以对几乎所有请求进行过滤， 但是缺点是一个过滤器实例只能在容器初始化时调用一次。
java 请求参数过滤拦截
03-10
这里的“java请求参数过滤拦截”主要是指在接口接收到用户输入的数据时，通过过滤器（Filter）对参数进行检查，防止恶意攻击者利用特殊字符执行SQL注入、跨站脚本攻击(XSS)等危害。下面我们将详细探讨这一主题。 ...
Java中的拦截器、过滤器、监听器用法详解
08-30
Java中的拦截器、过滤器、监听器用法详解 Java中的拦截器、过滤器、监听器是三个重要的概念，它们在Java Web开发中扮演着非常重要的角色。本文将详细介绍Java中的拦截器、过滤器、监听器的用法，包括它们的功能、...
Java SpringBoot实现的过滤器（和拦截器）控制登录页面跳转
04-13
在Java Servlet中，过滤器（Filter）是处理HTTP请求和响应的一个中间件，它可以拦截请求，修改请求内容，或者改变响应结果。在SpringBoot中，我们可以自定义Filter实现预处理和后处理功能，例如检查用户是否已登录...
基于Java的Spring框架拦截器和过滤器设计源码
04-08
Spring框架拦截器和过滤器：基于Java开发，包含34个文件，包括28个Java类文件、3个XML配置文件、1个.gitignore文件、1个SQL文件和1个YAML配置文件。该项目是关于Spring框架的拦截器和过滤器的设计，过滤器是Java Web...
关于DeferredResult的思考
qq_17842663的博客
12-07 2046
使用SpringBoot搭建web程序，里面内置了tomcat，一般都不会关心内部实现机制，上来就可以写程序，并且可以跑起来。但是是思考了每次的请求是如何工作的。 简单的来讲就是tomcat是将每次请求都将封装成一个Servlet,该Servlet来运行完业务逻辑代码，然后再有tomcat将信息返回给调用方。每个Servlet是同步的。即在该servlet的业务逻辑做完了然后才释放掉该Servle...
java8升级到JDK21
最新发布
qq_17842663的博客
06-06 569
需要将javax.validation.Validation 替换为 jakarta.validation.Validation。如果依赖了springcloud，则需要升级到对应spring-boot3.0的版本，最新依赖都是可行的。将javax.servlet.http.HttpServletRequest。修改完后记得刷新maven依赖clean一下，在重启项目!1.Validation类变更。如Resource替换。
JDK21安装
qq_17842663的博客
06-06 416
* 需要注意，如果是下载exe文件进行安装，会自动新增了path路径，该路径一定是放到了最前面，在加载的过程中，会已第一个路径为准，导致前面的配置无效，此时做法是删除这条路径，或者是将配置路移动到该路径的前面**点击新建系统变量名为"CLASSPATH"，变量值为".;在系统变量中找到Path变量点击进行编辑，点击新建输入"%JAVA_HOME%\bin"
通过断点的方式找到问题
qq_17842663的博客
05-21 265
找问题的经验，在请求的地方打印断点，然后追踪各个请求方法，然后在关键节点出反复调试，根据经验猜对应的结果。
自己的Java规范文档
qq_17842663的博客
12-16 182
参考阿里Java规范文档 不建议使用过时方法 泛型需要加上&lt;&gt;,这种方式创建的对象是不推荐的。 Map object = new HashMap();//禁止使用 字符串比较时，不需要大小写时，使用equalsIgnore方法，不使用toUppers方法 str.equals(string.toUppers());//不推荐使用 str.equalsIgnore(...
小项目也可以学习到很多东西
qq_17842663的博客
03-01 139
今天分享关于最近做的一个小项目学习一些感悟。 一、小项目也能学习到非常多的知识 最近做的是一个数据整理的一个项目，后台系统需要一些统计的数据，如果从原有的系统中查询，会大大影响到其他端的性能，而且相对于手机端去直接用户，后台系统面对的是公司人员和运营人员，用户量少，但是查询的数据确不少，需要做大量的计算，而这大量的计算就耗掉服务器的性能。为了保证线上手机和前端的性能，数据库做了优化工作，建立的索引...
java里面如何提升编写速度
qq_17842663的博客
03-01 102
一般情况下，编写程序，是在规定的时间内，并且在一段时间内很好的按成，那么就必须要套用现成的东西。在一个新的功能中，如何调用现成的东西呢，那么就是使用第三方包或者是使用自己总结的代码库。接来下是自己看到的一些好的代码库和自己总结的代码库。 通用库 经常被使用的到apache 的集中包例如apache commons的包，goole guava包，至少需要知道其中的几个关键的类如StringUt...
JVM的理解
qq_17842663的博客
12-24 77
一、JVM如何执行程序 Java程序如何做到跨平台的，其底层就是运行的JVM虚拟机，JVM虚拟机就Java编写的代码，首先先解析成class文件，JVM然后去解析class文件成机器码，最后执行。机器码是各个操作系统中可识别的，且能够执行的。 程序执行会分两个步骤 Java代码解析成Java字节码即class文件 JVM解析成机器码 操作系统执行机器码 二、JVM结构 三、JVM类加载过程 类加...
java拦截器过滤器监听器 顺序
09-12
在Java中，拦截器、过滤器和监听器都是用于在应用程序中提供某种功能的组件。它们的执行顺序如下： 1. 过滤器(Filter)：过滤器是在请求到达Servlet之前进行处理的组件。它可以拦截请求，并在请求被Servlet处理之前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值