自定义注解+AOP，实现日志拦截存储

最新推荐文章于 2025-02-21 10:19:35 发布

原创最新推荐文章于 2025-02-21 10:19:35 发布 · 1.2k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#自定义注解+aop实现日志保存

AOP 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种使用自定义注解和AOP技术实现日志存储的方法。通过定义注解OperateLog并结合AOP切面，可以自动记录请求模块、业务方法、操作人员类型等信息，并在方法执行前后进行日志记录。

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

这里我们介绍下使用自定义注解，加aop来实现日志的存储

首先自定义注解

import com.etc.mainboot.enums.BusinessType;
import com.etc.mainboot.enums.OperatorType;

import java.lang.annotation.*;

/**
 * 操作日志记录处理
 */
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLog {

    /**
     * 请求模块-title
     */
    String title() default "";

    /**
     * 请求具体业务方法
     */
    BusinessType bizType() default BusinessType.OTHER;

    /**
     * 操作人员类型
     */
    OperatorType operateType() default OperatorType.OTHER;

    /**
     * 是否保存请求参数，默认false
     */
    boolean isSaveData() default false;
}

编写AOP切面

package com.etc.mainboot.aop;

import com.etc.mainboot.annotation.OperateLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
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 java.lang.reflect.Method;
import java.util.Map;

/**
 * aop切面处理
 * 对模块、方法、参数的日志处理
 * @Aspect注解切面,@PointCut定义切点,标记方法
 * @author ChenDang
 * @date 2019/5/28 0028
 */
@Aspect
@Component
public class LogAspect {

    /**
     * 此处定义切点是注解方法,这里使用注解的方式。
     * 也可以使用aop最原始的支撑包名的方式
     */
    @Pointcut("@annotation(com.etc.mainboot.annotation.OperateLog)")
    public void operateLog(){}

    /**
     * 环绕增强，在这里进行日志操作
     */
    @Around("operateLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable{

        Object res = null;
        long time = System.currentTimeMillis();
        try {
            //方法继续执行
            res =  joinPoint.proceed();
            time = System.currentTimeMillis() - time;
            return res;
        } finally {
            try {
                //方法执行完成后增加日志
                addOperationLog(joinPoint,res,time);
            }catch (Exception e){
                System.out.println("LogAspect 操作失败：" + e.getMessage());
                e.printStackTrace();
            }
        }
    }


    private void addOperationLog(JoinPoint joinPoint, Object res, long time){
        //joinPoint.getSignature()获取封装了署名的对象，在该对象中可以获取目标方法名，
        //所属类的class等信息
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        String method = signature.getDeclaringTypeName() + "." + signature.getName();
        System.out.println("拦截方法名："+method);
        //获取注解对象，取到注解里定义的字段
        OperateLog annotation = signature.getMethod().getAnnotation(OperateLog.class);
        if(annotation != null) {

            String title = annotation.title();
            String bizType = annotation.bizType().name();
            String operateType = annotation.operateType().name();
            boolean isSaveData = annotation.isSaveData();
            System.out.println("title:"+title+",bizType:"+bizType+",operateType:"+operateType+",isSaveData:"+isSaveData);
            //获取参数
            HttpServletRequest request = ((ServletRequestAttributes)(RequestContextHolder.getRequestAttributes())).getRequest();
            Map<String, String[]> map =request.getParameterMap();
            if (map == null || map.isEmpty()) {
                return;
            }
            //输出参数
            for(String key : map.keySet()){
                System.out.println("key:"+key+",value="+map.get(key));
            }
        }
        //TODO 这里保存日志
        System.out.println("记录日志:");
    }

    @Before("operateLog()")
    public void doBeforeAdvice(JoinPoint joinPoint){
        System.out.println("进入方法前执行.....");

    }

    /**
     * 处理完请求，返回内容
     * @param ret
     */
    @AfterReturning(returning = "ret", pointcut = "operateLog()")
    public void doAfterReturning(Object ret) {
        System.out.println("方法的返回值 : " + ret);
    }

    /**
     * 后置异常通知
     */
    @AfterThrowing("operateLog()")
    public void throwss(JoinPoint jp){
        System.out.println("方法异常时执行.....");
    }


    /**
     * 后置最终通知,final增强，不管是抛出异常或者正常退出都会执行
     */
    @After("operateLog()")
    public void after(JoinPoint jp){
        System.out.println("方法最后执行.....");
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private OperateLog getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(OperateLog.class);
        }
        return null;
    }

}

编写Controller，测试

package com.etc.mainboot;

import com.etc.mainboot.annotation.OperateLog;
import com.etc.mainboot.enums.BusinessType;
import com.etc.mainboot.enums.OperatorType;
import com.etc.mainboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/index")
public class IndexController {

    @Autowired
    UserService userService;

    @OperateLog(title = "hello",bizType = BusinessType.QUERY,operateType = OperatorType.CUSTOMER)
    @RequestMapping("/hello")
    public String hello(){
        userService.hello();
        return "hello world";
    }
}

编写Service和实现类

public interface UserService {

    public void hello();
}

@Service
public class UserServiceImpl implements UserService {

    @Async("asyncServiceExecutor")
    @Override
    public void hello(){
        System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());
    }
}

这里我们使用了线程池管理

@Configuration
@EnableAsync
public class ThreadExecutorConfig {

    @Bean
    public Executor asyncServiceExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(10);
        //配置最大线程数
        executor.setMaxPoolSize(10);
        //配置队列大小
        executor.setQueueCapacity(99999);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("async-service-thread-");

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
        return executor;
    }
}

访问controller

看下控制台输出结果

==========================================

进入方法前执行.....
拦截方法名：com.etc.mainboot.IndexController.hello
当前运行的线程名称：async-service-thread-3
title:hello,bizType:QUERY,operateType:CUSTOMER,isSaveData:false
key:username,value=[Ljava.lang.String;@63cf387f
记录日志:
方法最后执行.....
方法的返回值 : hello world

===================================

总结

使用自定义注解+aop，实现日志的存储。在环绕通知doAround里，我们可以获取访问方法和注解相关信息，以及request请求里的信息，包含参数、参数值、请求方法、客户端信息等等，然后在doAround里，保存信息到数据库，这里我就没有写数据库操作了，大家自己写下。