java+spring+aop切成处理

日志切面处理：

import java.util.Arrays;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;

@Aspect
@Component
@Slf4j
public class WebLogAspect {

    /**
     *     切入点
     */
    @Pointcut("execution(public * controller..*.*(..))")
    public void webLog() {
    }
    
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        HttpServletRequest request = attributes.getRequest();
        
        String argStr=null;
        try {
            Object[] args=joinPoint.getArgs();
            argStr=JSONUtil.toJsonStr(args);
        } catch (Exception e) {
            argStr=Arrays.toString(joinPoint.getArgs());
        }
        // 记录下请求内容
        log.info("[HTTP_URL:{}][HTTP_METHOD:{}][IP:{}][CLASS_METHOD:{}][ARGS:{}]", request.getRequestURL().toString(),
                request.getMethod(), request.getRemoteAddr(),
                joinPoint.getSignature().getDeclaringTypeName().concat(".").concat(joinPoint.getSignature().getName()),
                argStr);
    }
    
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) {
        try {
            ret=JSONUtil.toJsonStr(ret);
        } catch (Exception e) {
        }
        // 处理完请求，返回内容
        log.info("RESPONSE:[{}]", ret);
    }
}

复杂表达式切面处理：
args(): 用于匹配当前执行的方法传入的参数为指定类型的执行方法;
this(): 用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配;
target(): 用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配;
within(): 用于匹配指定类型内的方法执行;

public interface TSysUserMapper{

    /**
     * 新增
     */
    int insert(TSysUser entity);
    /**
     * 更新
     */
    int updateByPrimaryKey(TSysUser entity);
}

@Aspect
@Component
public class SysUserAspect{
    // 本地异常日志记录对象
    private static final Logger logger = LoggerFactory.getLogger(SysUserAspect.class);
    
    @Pointcut("this(TSysUserMapper) && execution(* *.insert*(..)) && args(user)")
    public void classInsertPointcut(TSysUser user) {
    }
    
    @Pointcut("this(TSysUserMapper) && execution(* *.update*(..)) && args(user)")
    public void classUpdatePointcut(TSysUser user) {
    }
    
    @Around("classInsertPointcut(user)")
    public Object doInsertAround(ProceedingJoinPoint jp,TSysUser user) {
        Result rs=new Result();
        try {
            Object proceed = jp.proceed();
            System.out.println(user);
            return proceed;
        } catch (Throwable e) {
            e.printStackTrace();
            logger.error("消息队列处理失败:",e);
            rs.setSuccess(false);
            rs.setMessage("操作失败!");
            return rs;
        }
    }
    
    @Around("classUpdatePointcut(user)")
    public Object doUpdateAround(ProceedingJoinPoint jp,TSysUser user) {
        Result rs=new Result();
        try {
            Object proceed = jp.proceed();
            System.out.println(user);
            return proceed;
        } catch (Throwable e) {
            e.printStackTrace();
            logger.error("处理失败:",e);
            rs.setSuccess(false);
            rs.setMessage("操作失败!");
            return rs;
        }
    }
}