【SSM】基于AOP自定义注解的操作日志

【SSM】基于AOP自定义注解实现操作日志

1. 导入aop依赖

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>

2. 自定义注解

	import java.lang.annotation.*;
	//需要手动填入的日志变量信息
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.METHOD)
	@Documented
	public @interface OperationAnnotation {
	    String action() default "";
	}

3. 基于AOP切面切点

	import org.aspectj.lang.JoinPoint;
	import org.aspectj.lang.annotation.After;
	import org.aspectj.lang.annotation.Aspect;
	import org.aspectj.lang.annotation.Before;
	import org.aspectj.lang.annotation.Pointcut;
	import org.aspectj.lang.reflect.CodeSignature;
	import org.aspectj.lang.reflect.MethodSignature;
	import org.springframework.scheduling.annotation.EnableAsync;
	import org.springframework.stereotype.Component;
	import org.springframework.web.bind.annotation.RequestMapping;
	import javax.annotation.Resource;
	import java.lang.reflect.Method;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.UUID;
	
	//@Aspect:作用是把当前类标识为一个切面供容器读取
	@Aspect
	@Component
	@EnableAsync
	public class LogAspect {
		// 可以自动获取的日志变量信息
	    private String id;
	    private String path;//路径
	    private String time;//时间
	    private String parameter;//参数
	    private String title;//方法名
	    private String action;//方法描述
	
	    @Resource
	    private LogAopService logAopService;
	
	    @Pointcut("@annotation(aop_log.OperationAnnotation)")
	    public void logPointCut(){
	    }
	    @Before("logPointCut()")
	    public void setUUId(){
	        this.id=UUID.randomUUID().toString();
	    }
	
	// 切点后：获取自定义注解中传入的参数内容
	    @After("logPointCut()")
	    public void setAction(JoinPoint joinPoint){
	        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
	        Method method = signature.getMethod();
	        OperationAnnotation annotation = method.getAnnotation(OperationAnnotation.class);
	        this.action= annotation.action();
	    }
	
	    public Map<String,Object> getNameAndValue(JoinPoint joinPoint){
	        Map<String,Object> param= new HashMap<>();
	        Object[] paramValues=joinPoint.getArgs();
	        String[] paramNames=((CodeSignature)joinPoint.getSignature()).getParameterNames();
	        for (int i=0;i<paramNames.length;i++){
	            if(paramValues[i] instanceof Integer || paramValues[i] instanceof String){
	                param.put(paramNames[i], paramValues[i]);
	            }
	        }
	        return param;
	    }
	
	//  切点前：获得日志
	    @Before("logPointCut()")
	    public  void setPath(JoinPoint joinPoint) {
	        Class<?> targetClass = joinPoint.getTarget().getClass();
	        //获取对象后再获得类,因为要获得的是交给IOC的那个对象类
	        RequestMapping requestMapping=targetClass.getAnnotation(RequestMapping.class);
	        if (requestMapping != null){
	            this.path=requestMapping.value()[0];
	        }
	    }
	
	
	//  切点后：将日志内容存入数据库
	    @After("logPointCut()")
	    public void save(){
	        LogAop logAop=new LogAop(id, path, time, parameter, title, action);
	        logAopService.insert(logAop);
	        System.out.println(logAop);
	    }
	}

4. 创建实体类，存入操作日志的对应字段变量

	@Data
	@ToString
	@AllArgsConstructor
	public class LogAop {
	    private String id;
	    private String path;
	    private String time;
	    private String parameter;
	    private String title;
	    private String action;
	}

5. 在方法上使用自定义注解

	@RestController
	public class LogAopController {
	    
	    @OperationAnnotation(action = "注解参数内容")
	    public RespResult findList(){
	        return RespResult.success();
	    }
	}