一、自定义注解
package com.xxxx.common.aop; import com.xxx.common.enums.OperationLogModuleEnum; 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; /** * 自定义操作日志记录注解 * * @author minos */ @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Log { /** * 模块 */ public OperationLogModuleEnum module() default OperationLogModuleEnum.USER_MANGER; /** * 描述 */ public String describe() default ""; /** * 操作人类别 */ public String parameter() default ""; }
二、EL表达式支持
package com.xxxxx.common; public class ExpressionRootObject { private final Object object; private final Object[] args; public ExpressionRootObject(Object object, Object[] args) { this.object = object; this.args = args; } public Object getObject() { return object; } public Object[] getArgs() { return args; } }
package com.xxx.common; import org.springframework.aop.support.AopUtils; import org.springframework.context.expression.AnnotatedElementKey; import org.springframework.context.expression.CachedExpressionEvaluator; import org.springframework.context.expression.MethodBasedEvaluationContext; import org.springframework.core.DefaultParameterNameDiscoverer; import org.springframework.core.ParameterNameDiscoverer; import org.springframework.expression.EvaluationContext; import org.springframework.expression.Expression; import java.lang.reflect.Method; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; public class ExpressionEvaluator<T> extends CachedExpressionEvaluator { private final ParameterNameDiscoverer paramNameDiscoverer = new DefaultParameterNameDiscoverer(); private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>(64); private final Map<AnnotatedElementKey, Method> targetMethodCache = new ConcurrentHashMap<>(64); public EvaluationContext createEvaluationContext(Object object, Class<?> targetClass, Method method, Object[] args) { Method targetMethod = getTargetMethod(targetClass, method); ExpressionRootObject root = new ExpressionRootObject(object, args); return new MethodBasedEvaluationContext(root, targetMethod, args, this.paramNameDiscoverer); } public T condition(String conditionExpression, AnnotatedElementKey elementKey, EvaluationContext evalContext, Class<T> clazz) { return getExpression(this.conditionCache, elementKey, conditionExpression).getValue(evalContext, clazz); } private Method getTargetMethod(Class<?> targetClass, Method method) { AnnotatedElementKey methodKey = new AnnotatedElementKey(method, targetClass); Method targetMethod = this.targetMethodCache.get(methodKey); if (targetMethod == null) { targetMethod = AopUtils.getMostSpecificMethod(method, targetClass); if (targetMethod == null) { targetMethod = method; } this.targetMethodCache.put(methodKey, targetMethod); } return targetMethod; } }
三、定义aop
package com.xxxx.common.aspect; import com.xxxx.common.ExpressionEvaluator; import com.xxxx.common.aop.Log; import com.xxxx.common.utils.CurrentUserUtil; import com.xxxx.common.utils.IpUtils; import com.xxxx.common.utils.ServletUtils; import com.xxxx.model.OperationLog; import com.xxxx.service.OperationLogService; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; 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.context.expression.AnnotatedElementKey; import org.springframework.expression.EvaluationContext; import org.springframework.stereotype.Component; import java.lang.reflect.Method; /** * 操作日志记录处理 * * @author minos */ @Aspect @Component public class LogAspect { @Autowired OperationLogService operationLogService; private ExpressionEvaluator<String> evaluator = new ExpressionEvaluator<>(); private static final Logger log = LoggerFactory.getLogger(LogAspect.class); /** * 配置织入点 */ @Pointcut("@annotation(com.lets.psccs.common.aop.Log)") public void logPointCut() { } /** * 处理完请求后执行 * * @param joinPoint 切点 */ @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult") public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) { handleLog(joinPoint); } /** * 拦截异常操作 * * @param joinPoint 切点 * @param e 异常 */ @AfterThrowing(value = "logPointCut()", throwing = "e") public void doAfterThrowing(JoinPoint joinPoint, Exception e) { handleLog(joinPoint); } protected void handleLog(final JoinPoint joinPoint) { addOPerationLog(joinPoint); } /** * 写入日志 * @param joinPoint */ private void addOPerationLog(JoinPoint joinPoint) { try { // 获得注解 Log myLog = getAnnotationLog(joinPoint); if (myLog == null) { return; } // 请求的地址 String ip = IpUtils.getIpAddr(ServletUtils.getRequest()); String modelName = myLog.module().getName(); String parameter = getParameter(joinPoint); String describe = myLog.describe().replace("parameter",parameter); OperationLog operationLog=new OperationLog(CurrentUserUtil.currentUser()); operationLog.setModule(modelName); operationLog.setIp(ip); operationLog.setContent(describe); operationLogService.insertSelective(operationLog); } catch (Exception ex) { ex.printStackTrace(); } } private String getParameter(JoinPoint joinPoint) { Log handler = null; try { handler = getAnnotationLog(joinPoint); } catch (Exception e) { e.printStackTrace(); } if (joinPoint.getArgs() == null) { return null; } EvaluationContext evaluationContext = evaluator.createEvaluationContext(joinPoint.getTarget(), joinPoint.getTarget().getClass(), ((MethodSignature) joinPoint.getSignature()).getMethod(), joinPoint.getArgs()); AnnotatedElementKey methodKey = new AnnotatedElementKey(((MethodSignature) joinPoint.getSignature()).getMethod(), joinPoint.getTarget().getClass()); return evaluator.condition(handler.parameter(), methodKey, evaluationContext, String.class); } /** * 是否存在注解，如果存在就获取 */ private Log getAnnotationLog(JoinPoint joinPoint) throws Exception { Signature signature = joinPoint.getSignature(); MethodSignature methodSignature = (MethodSignature) signature; Method method = methodSignature.getMethod(); if (method != null) { return method.getAnnotation(Log.class); } return null; } }
四、使用
/** * 更新用户信息 * * @param userVo * @return */ @PostMapping("/update") @ApiOperation("更新用户信息") @Check({AuthorityConsts.XiTongSheZhi.BJYH}) @Log(module = OperationLogModuleEnum.USER_MANGER,describe ="编辑了parameter用户信息",parameter = "{#userVo.id}") public AjaxResult update(@RequestBody @Validated UserVO userVo) { User user = new User(); BeanUtils.copyProperties(userVo, user); int update = userService.update(user); return toAjax(update); }
五、效果
