Spring Boot 实现用户行为记录的四种方式

最新推荐文章于 2025-02-28 10:38:26 发布

无痕之剑

最新推荐文章于 2025-02-28 10:38:26 发布

阅读量4.2k

点赞数 5

分类专栏：项目实战文章标签： aop 后端 spring boot

本文链接：https://blog.csdn.net/m0_37824308/article/details/121523285

版权

项目实战专栏收录该内容

2 篇文章

订阅专栏

本文档详细介绍了如何在Spring Boot应用中使用AOP切面编程、Interceptor拦截器和Filter过滤器来实现用户行为日志记录。通过创建日志实体、定义注解和切面，以及实现拦截器和过滤器，实现了对用户操作的全面跟踪，并提供了代码示例。同时，提到了ArgumentResolver作为另一种可能的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、需求背景

根据产品经理要求，需要对用户的行为进行记录。重点记录用户的姓名、IP、操作行为、请求参数和返回参数。先采用暴力解决问题，每个行为增加记录行为，当然这个是最不恰当的方案，工作量大不说，还不具有扩展性。因此参考他人博客，使用4种方案来实现该需求。

二、需要的pom依赖

    <!--以下为功能相关的核心注解，其他注解自行添加-->    
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
	    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.9</version>
    </dependency>
	   <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
	    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus</artifactId>
      <version>2.3</version>
    </dependency>

三、AOP切面编程实现

在每一个需要记录日志的方法前增加切点，然后对切点进行处理即可。废话不多说，直接上代码。

先创建日志行为记录需要的日志表TOperateLog
实现接口OperateLog，作为后续使用的注解
使用 @Aspect 声明一下切面类使用 @Aspect 声明一下切面类 OperateLogAspect；
在切面类内添加一个切点 operateLogAspect()，
在切面类中使用 spring 的 AOP 注解 @Around 声明一个通知方法，在里面进行相关日志记录操作

拓展：如果使用AOP做auth认证，使用的是@Before声明

实体类：TOperateLog.java

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TOperateLog implements Serializable {

  private static final long serialVersionUID = 1L;

  @TableId(value = "id", type = IdType.AUTO)
  private Long id;

  /**
   * 操作人
   */
  private String operator;


  /**
   * 操作ip
   */
  private String operateIp;
  /**
   * 用户名
   */
  private String username;
  /**
   * 密码
   */
  private String password;

  /**
   * 操作方法
   */
  private String method;

  /**
   * 接口url
   */
  private String url;

  /**
   * 请求参数
   */
  private String request;

  /**
   * 返回参数
   */
  private String response;

  /**
   * 状态：0成功1失败
   */
  private Boolean status;

  /**
   * 创建时间
   */
  private LocalDateTime createTime;
}

注解接口类：OperateLog.java

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperateLog {
  /**
   * 操作方法
   */
  String method() default "";
}

切面实现类：OperateLogAspect.java

@Slf4j
@Order(1)
@Component
@Aspect
public class OperateLogAspect {

  @Pointcut("@annotation(com.snowriver.it.springdemo.aspect.OperateLog)")
  public void operateLogAspect() {
  }

//  @Around("operateLogAspect()")
  @Around(value = "operateLogAspect() && @annotation(OperateLog)")
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    log.info("-----  进入AOP  aspect doAround 方法内 -----");
    HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    String requestUri = request.getRequestURI();
    String[] ignoreUri = {"/test","/aspect"};
    Map<String, String[]> parameterMap = request.getParameterMap();
    String username = parameterMap.get("username")[0];
    String password = parameterMap.get("password")[0];
    MethodSignature signature = (MethodSignature) pjp.getSignature();
    //获取方法
    Method method = signature.getMethod();
    OperateLog operateLog = method.getAnnotation(OperateLog.class);
    TOperateLog bean = new TOperateLog();
    bean.setUsername(username);
    bean.setPassword(password);
    bean.setMethod(operateLog.method());
    bean.setOperateIp(getIP(request));
    bean.setUrl(requestUri);
    bean.setCreateTime(LocalDateTime.now());
    Gson gson = new Gson();
    if ("GET".equals(request.getMethod())) {
      Map<String, String[]> parameterMap2 = request.getParameterMap();
      bean.setRequest(JSONObject.toJSONString(parameterMap2));
    } else {
      //获取参数列表
      Object[] args = pjp.getArgs();
      bean.setRequest(gson.toJson(args));
    }
    //获取接口执行后的结果
    Object result = pjp.proceed();
    bean.setResponse(gson.toJson(result));
    //此处可以将bean入库，自行实现
    //operatemapper.save(bean);
    log.info("-----  走出AOP  aspect doAround 方法  -----");
    return gson.toJson(bean);
  }

  /**
   * 获取客户端IP
   */
  private static String getIP(HttpServletRequest request) {
    String ip = request.getRemoteAddr();
    String headerIp = request.getHeader("x-real-ip");
    if (headerIp == null || "".equals(headerIp) || "null".equals(headerIp)) {
      headerIp = request.getHeader("x-forwarded-for");
    }
    if (headerIp != null && !"".equals(headerIp) && !"null".equals(headerIp)) {
      ip = headerIp;
    }
    return ip;
  }
}

测试方法：

  @ResponseBody
  @OperateLog(method = "test-get方法进行日志记录")
  @RequestMapping(value = "/test-get", method = RequestMethod.GET, produces = 
  MediaType.APPLICATION_JSON_VALUE)
  public String testPost(@RequestParam("username") String username, 
  @RequestParam("password") String password) {
    HashMap<String, Object> map = new HashMap<>();
    map.put("username", username);
    map.put("password", password);
    return map.toString();
  }

四、Interceptor拦截器实现

1、定义拦截器类 OperateLogInterceptor 类并实现 HandlerInterceptor 接口。

2、实现其 preHandle() 方法；

3、在 preHandle 方法内通过注解和参数判断是否需要拦截请求，拦截请求时接口返回 true；

4、在自定义的 WebMvcConfigurationSupport 类内注册此拦截器；

注意：WebMvcConfigurerAdapter已被弃用，不建议使用。

拦截器：OperateLogInterceptor.java

@Slf4j
@Component
public class OperateLogInterceptor implements HandlerInterceptor {

  private static final ThreadLocal<Long> startTimeThreadLocal = new NamedThreadLocal<Long>("ThreadLocal StartTime");


  /**
   * 预处理
   */
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    log.info("-----  进入  Interceptor preHandle 方法  -----");
    //开始时间
    Long beginTime = System.currentTimeMillis();
    //线程绑定变量（该数据只有当前请求的线程可见）
    startTimeThreadLocal.set(beginTime);
    log.info("-----  走出  Interceptor preHandle 方法  -----");
    return true;
  }

  /**
   * 返回处理
   */
  @Override
  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    log.info("-----  进入  Interceptor postHandle 方法  -----");
    if (modelAndView != null){
      log.info("ViewName: " + modelAndView.getViewName());
    }
    log.info("-----  走出  Interceptor postHandle 方法  -----");
  }

  /**
   * 后处理
   */
  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    log.info("-----  进入  Interceptor afterCompletion 方法  -----");

    // 输出日志信息
    log.info("-----  访问地址：" + request.getRequestURI() + "，执行方式：" + request.getMethod()+"  -----");
    //得到线程绑定的局部变量（开始时间）
    Long beginTime = startTimeThreadLocal.get();
    //结束时间
    Long costTime = System.currentTimeMillis() - beginTime;
    log.info("-----  走出  Interceptor afterCompletion 方法  -----");
  }
  /**
   * 获取客户端IP
   */
  private static String getIP(HttpServletRequest request) {
    String ip = request.getRemoteAddr();
    String headerIp = request.getHeader("x-real-ip");
    if (headerIp == null || "".equals(headerIp) || "null".equals(headerIp)) {
      headerIp = request.getHeader("x-forwarded-for");
    }
    if (headerIp != null && !"".equals(headerIp) && !"null".equals(headerIp)) {
      ip = headerIp;
    }
    return ip;
  }

}

注册拦截器：MvcConfiguration.java

@Slf4j
@Configuration
public class MvcConfiguration extends WebMvcConfigurationSupport {
  @Autowired
  private OperateLogInterceptor operateLogInterceptor;

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    log.info("=====  Adapter addInterceptors被加载 =====");
    registry.addInterceptor(operateLogInterceptor)
        .addPathPatterns("/**")
        .excludePathPatterns("/test","/aspect");
    super.addInterceptors(registry);
  }

  //Resolver方案有待研究
  @Override
  public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
    log.info("=====  Adapter addArgumentResolvers被加载 =====");
    argumentResolvers.add(new OperateLogParamResolver());
  }

}

五、Filter过滤器实现

直接上代码：

定义过滤器：OperateLogFilter.java

@Slf4j
public class OperateLogFilter implements Filter {

  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
    log.info("-----  进入  Filter init 方法  -----");
    Filter.super.init(filterConfig);
  }

  @Override
  public void doFilter(ServletRequest request, ServletResponse response,
      FilterChain filterChain) throws IOException, ServletException {
    log.info("-----  进入  Filter doFilter 方法  -----");
    filterChain.doFilter(request, response); // 请求通过要显示调用
  }

  @Override
  public void destroy() {
    log.info("-----  进入  Filter destroy 方法  -----");
    Filter.super.destroy();
  }
}

配置过滤器：FilterConfiguration.java

@Slf4j
@Configuration
public class FilterConfiguration {

  @Bean
  public FilterRegistrationBean someFilterRegistration() {
    log.info("=====  Filter Configuration被加载 =====");
    FilterRegistrationBean registration = new FilterRegistrationBean();
    registration.setFilter(new OperateLogFilter());
    registration.addUrlPatterns("/*");
    registration.setName("operateLog");
    // 设置过滤器被调用的顺序
    registration.setOrder(1);
    return registration;
  }
}

六、ArgumentResolver

该方法是其他博客建议的方法之一，但是本人没有跑通，等有时间了再研究下。

参数解析器是 Spring 提供的用于解析自定义参数的工具，使用它，我们可以将参数在进入Controller Action之前就组合成我们想要的样子。

七、拓展部分

这三种方式的调用顺序为：Filter过滤器---->拦截器---->AOP.，一起使用打印日志如下：

=====  Filter Configuration被加载 =====
-----  进入  Filter init 方法  -----
=====  Adapter addInterceptors被加载 =====
=====  Adapter addArgumentResolvers被加载 =====


-----  进入  Filter doFilter 方法  -----
-----  进入  Interceptor preHandle 方法  -----
-----  走出  Interceptor preHandle 方法  -----
-----  进入AOP  aspect doAround 方法内 -----
-----  走出AOP  aspect doAround 方法  -----
-----  进入  Interceptor postHandle 方法  -----
-----  走出  Interceptor postHandle 方法  -----
-----  进入  Interceptor afterCompletion 方法  -----
-----  访问地址：/aspcet/test-get，执行方式：GET  -----
-----  走出  Interceptor afterCompletion 方法  -----