filter是Servlet规范的内容,不属于Spring。通过filter,可以获取请求和响应信息,不能获取执行的类以及方法信息。
1.1 Filter类package com.ruoyi.framework.filter;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;
public class TimerFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
System.out.println("Time Filter init");
}
@Override
public void destroy() {
Filter.super.destroy();
System.out.println("time filter destroy");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
long start = System.currentTimeMillis();
filterChain.doFilter(servletRequest,servletResponse);
System.out.println("time filter:"+(System.currentTimeMillis()-start));
System.out.println("time filter finish");
}
}
通过示例代码,可以看到,可以获取请求servletRequest和响应ServletResponse,但是并不知道经过了那个controller的那个方法处理过。
1.2 配置filterpackage com.ruoyi.framework.config;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.filter.TimerFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.DispatcherType;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class TimeFilterConfig {
private String urlPatterns = "/system
@Component
public class TimeInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if(handler instanceof HandlerMethod)
{
HandlerMethod handlerMethod = (HandlerMethod)handler;
System.out.println("method name:" + handlerMethod.getMethod().getName());
System.out.println("class name:" + handlerMethod.getBean().getClass().getName());
}
System.out.println("handler:" + handler);
request.setAttribute("startTime",System.currentTimeMillis());
boolean res = HandlerInterceptor.super.preHandle(request, response, handler);
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
Long start = (Long)request.getAttribute("startTime");
System.out.println("time interceptor 耗时:"+(System.currentTimeMillis()-start));
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion");
Long start = (Long)request.getAttribute("startTime");
System.out.println("time interceptor 耗时:"+(System.currentTimeMillis()-start));
}
}
从实例代码中,可以看到,可以获取请求HttpServletRequest和响应HttpServletResponse信息,还有一个参数handler,通过该参数,可以获取执行的方法信息。
2.2 interceptor注册package com.ruoyi.framework.config;
import com.ruoyi.framework.interceptor.TimeInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class TimeInterceptorWebConfig implements WebMvcConfigurer {
@Autowired
private TimeInterceptor timeInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(timeInterceptor)
.addPathPatterns("/system
@RestControllerAdvice
public class GlobalExceptionHandler
{
private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@ExceptionHandler(AuthorizationException.class)
public Object handleAuthorizationException(AuthorizationException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',权限校验失败'{}'", requestURI, e.getMessage());
if (ServletUtils.isAjaxRequest(request))
{
return AjaxResult.error(PermissionUtils.getMsg(e.getMessage()));
}
else
{
return new ModelAndView("error/unauth");
}
}
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e,
HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
return AjaxResult.error(e.getMessage());
}
@ExceptionHandler(RuntimeException.class)
public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生未知异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
@ExceptionHandler(Exception.class)
public AjaxResult handleException(Exception e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
@ExceptionHandler(ServiceException.class)
public Object handleServiceException(ServiceException e, HttpServletRequest request)
{
log.error(e.getMessage(), e);
if (ServletUtils.isAjaxRequest(request))
{
return AjaxResult.error(e.getMessage());
}
else
{
return new ModelAndView("error/service", "errorMessage", e.getMessage());
}
}
@ExceptionHandler(BindException.class)
public AjaxResult handleBindException(BindException e)
{
log.error(e.getMessage(), e);
String message = e.getAllErrors().get(0).getDefaultMessage();
return AjaxResult.error(message);
}
@ExceptionHandler(DemoModeException.class)
public AjaxResult handleDemoModeException(DemoModeException e)
{
return AjaxResult.error("演示模式,不允许操作");
}
}
可以看到,在类上添加了@RestControllerAdvice,在方法上添加了@ExceptionHandler,并且通过参数的形式,指定了该方法处理的异常类型。
其中@RestControllerAdvice表示在方法出现异常后,返回信息采用@ResponseBody的方式将信息编码后输出到response对象的body属性,通常是json格式的数据。
3.2 自定义异常代码package com.ruoyi.common.exception;
public final class ServiceException extends RuntimeException
{
private static final long serialVersionUID = 1L;
private String message;
private String detailMessage;
public ServiceException()
{
}
public ServiceException(String message)
{
this.message = message;
}
public String getDetailMessage()
{
return detailMessage;
}
public ServiceException setDetailMessage(String detailMessage)
{
this.detailMessage = detailMessage;
return this;
}
public String getMessage()
{
return message;
}
public ServiceException setMessage(String message)
{
this.message = message;
return this;
}
}
可以根据业务的需要,定义各种各样的异常类。
4. Aspect(切面)切面拦截的时候,可以指定拦截哪些方法,也可以获得方法的参数和返回值。
4.1 切面示例代码package com.ruoyi.framework.aspectj;
import com.alibaba.fastjson.JSON;
import com.ruoyi.common.annotation.EventTrack;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.ShiroUtils;
import com.ruoyi.system.domain.EventTrackLog;
import com.ruoyi.system.service.IEventTrackLogService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
@Aspect
@Component
public class EventTrackAspect {
//日志工厂获取日志对象
static Logger logger = LoggerFactory.getLogger(EventTrackAspect.class);
public static final String[] EXCLUDE_PROPERTIES = { "password", "oldPassword", "newPassword", "confirmPassword" };
@Autowired
private IEventTrackLogService eventTrackLogService;
//startTime存放开始时间
private ThreadLocal
这里以一个记录日志的切面为例进行说明。切面包括前置通知,后置通知和环绕通知。这里以指定的注解来判断是否需要拦截。
这里虽然同时使用了前置通知,后置通知以及环绕通知,在实际的使用场景中,可以根据需要进行有选择的使用。
4.2 自定义注解代码package com.ruoyi.common.annotation;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.OperatorType;
import org.springframework.web.bind.annotation.ResponseBody;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// 事件埋点
@Target({ElementType.PARAMETER, ElementType.METHOD})//作用在参数和方法上
@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Documented//表明这个注解应该被 javadoc工具记录
// @ResponseBody//响应时转JSON格式
public @interface EventTrack {
public String title() default "";
public BusinessType businessType() default BusinessType.OTHER;
public OperatorType operatorType() default OperatorType.MANAGE;
public boolean isSaveRequestData() default true;
public boolean isSaveResponseData() default true;
String description() default "";
boolean isLog() default true;
}
以上是对Aspect、ControllerAdvice、Interceptor、Fliter的举例说明,通过这些示例,可以更具体的理解他们的差异。
1.过滤器:Filter :可以获得Http原始的请求和响应信息,但是拿不到处理该请求的方法信息(比如类名称,方法名称等);
2.拦截器:Interceptor:可以获得Http原始的请求和响应信息,也可以拿得到相应方法的信息,根据httpServeltRquest也能拿到请求参数;
3.ControllerAdvice(Controller增强):主要是用于全局的异常拦截和处理,这里的异常可以使自定义异常,也可以是JDK里面的异常;
4.切片:Aspect:主要是进行公共方法的拦截,可以拿得到方法参数的值,也可以获得方法处理后的返回值。
从技术层次来看,可以参考下图:
外层技术主要是原始的请求和响应,内层可以具体到某个具体的Controller的方法,获取的信息可以更具体和准确。



