使用SpringAOP+自定义注解快速开发一个记录审计日志的功能

[Valdanitooooo]

定义审计日志类型的枚举

public enum AuditEventType {
    ACCOUNT_CREATE, ACCOUNT_UPDATE, ACCOUNT_DELETE, ACCOUNT_ACTIVATED,
    AUTHORITY_CREATE, AUTHORITY_UPDATE, AUTHORITY_UPDATE_LANG_KEY, AUTHORITY_DELETE,
    ......
}

自定义注解

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
public @interface AuditEventLog {
    AuditEventType type();
}

在需要记录审计日志的方法上使用注解

    @AuditEventLog(type = AuditEventType.ACCOUNT_ACTIVATED)
    @GetMapping("/activate")
    public void activateAccount(final @RequestParam(value = "key") String key) {
        Optional<User> user = userService.activateRegistration(key);
        if (!user.isPresent()) {
            throw new AccountResourceException("No user was found for this activation key");
        }
    }

通过AOP切面保存日志

LoggingAspect 类

package org.xx.xx.gateway.aop.logging;

import io.github.jhipster.config.JHipsterConstants;
import org.xx.xx.gateway.annotation.AuditEventLog;
import org.xx.xx.gateway.repository.CustomAuditEventRepository;
import org.xx.xx.gateway.security.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
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.beans.factory.annotation.Value;
import org.springframework.boot.actuate.audit.AuditEvent;
import org.springframework.core.env.Environment;
import org.springframework.core.env.Profiles;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Aspect for logging execution of service and repository Spring components.
 * <p>
 * By default, it only runs with the "dev" profile.
 */
@Aspect
public class LoggingAspect {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    private final Environment env;

    @Value("${spring.application.name}")
    private String serviceName;

    @Autowired
    private CustomAuditEventRepository customAuditEventRepository;


    public LoggingAspect(Environment env) {
        this.env = env;
    }

    /**
     * Pointcut that matches all repositories, services and Web REST endpoints.
     */
    @Pointcut("within(@org.springframework.stereotype.Repository *)"
        + " || within(@org.springframework.stereotype.Service *)"
        + " || within(@org.springframework.web.bind.annotation.RestController *)")
    public void springBeanPointcut() {
        // Method is empty as this is just a Pointcut, the implementations are in the advices.
    }

    /**
     * Pointcut that matches all Spring beans in the application's main packages.
     */
    @Pointcut("within(org.xx.xx.gateway.repository..*)" + " || within(org.xx.xx.gateway.service..*)"
        + " || within(org.xx.xx.gateway.web.rest..*)")
    public void applicationPackagePointcut() {
        // Method is empty as this is just a Pointcut, the implementations are in the advices.
    }

    @Pointcut("@annotation(org.xx.xx.gateway.annotation.AuditEventLog)")
    public void auditEventLogCut() {
    }

    /**
     * Advice that logs methods throwing exceptions.
     *
     * @param joinPoint join point for advice.
     * @param e         exception.
     */
    @AfterThrowing(pointcut = "applicationPackagePointcut() && springBeanPointcut()", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
        if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT))) {
            log.error(
                "Exception in {}.{}() with cause = \'{}\' and exception = \'{}\'",
                joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName(), e.getCause() != null ? e.getCause() : "NULL", e.getMessage(),
                e
            );

        } else {
            log.error("Exception in {}.{}() with cause = {}", joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName(), e.getCause() != null ? e.getCause() : "NULL");
        }
    }

    /**
     * Advice that logs when a method is entered and exited.
     *
     * @param joinPoint join point for advice.
     * @return result.
     * @throws Throwable throws {@link IllegalArgumentException}.
     */
    @Around("auditEventLogCut() && applicationPackagePointcut() && springBeanPointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        if (log.isDebugEnabled()) {
            log.debug("Enter: {}.{}() with argument[s] = {}", joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
        }
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        Method realMethod = joinPoint.getTarget().getClass().getDeclaredMethod(
            methodSignature.getName(), method.getParameterTypes());
        AuditEventLog auditEvent = realMethod.getAnnotation(AuditEventLog.class);
        String auditEventLogType = auditEvent.type().toString();
        Map<String, Object> auditEventData = new HashMap<>();
        Object result = null;
        try {
            result = joinPoint.proceed();
            if (log.isDebugEnabled()) {
                log.debug("Exit: {}.{}() with result = {}", joinPoint.getSignature().getDeclaringTypeName(),
                    joinPoint.getSignature().getName(), result);
            }
            auditEventLogType += "_SUCCESS";
        } catch (Exception e) {
            log.error("Exception: {} in {}.{}()", Arrays.toString(joinPoint.getArgs()),
                joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
            if (e.getCause() == null) {
                auditEventData.put(e.getClass().getName(), e.getMessage());
            } else {
                auditEventData.put(e.getCause().toString(), e.getCause().getMessage());
            }
            auditEventLogType += "_FAILURE";
            throw e;
        } finally {
            AuditEvent event = new AuditEvent(
                SecurityUtils.getCurrentUserLogin().get(), auditEventLogType, auditEventData);
            customAuditEventRepository.add(event);
        }
        return result;
    }

}