需求

因为想写一个通用的 log 日志拦截组件，所以写了一个统一 aspect 切面。

aspect 代码

package com.github.houbb.auto.log.spring.aop;

import com.github.houbb.aop.spring.util.SpringAopUtil;
import com.github.houbb.auto.log.annotation.AutoLog;
import com.github.houbb.auto.log.api.IAutoLogContext;
import com.github.houbb.auto.log.core.bs.AutoLogBs;
import com.github.houbb.auto.log.spring.context.SpringAopAutoLogContext;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 这是一种写法
 * 自动日志输出 aop
 * @author binbin.hou
 * @since 0.0.3
 */
@Aspect
@Component
@EnableAspectJAutoProxy
public class AutoLogAop {

    /**
     *
     * 切面方法：
     */
    @Pointcut("@within(com.github.houbb.auto.log.annotation.AutoLog)" +
            "|| @annotation(com.github.houbb.auto.log.annotation.AutoLog)")
    public void autoLogPointcut() {
    }

    /**
     * 执行核心方法
     *
     * 相当于 MethodInterceptor
     *
     * @param point 切点
     * @return 结果
     * @throws Throwable 异常信息
     * @since 0.0.3
     */
    @Around("autoLogPointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Method method = SpringAopUtil.getCurrentMethod(point);
        AutoLog autoLog = AnnotationUtils.getAnnotation(method, AutoLog.class);

        //获取当前类注解信息
        if(autoLog == null) {
            autoLog = SpringAopUtil.getClassAnnotation(point, AutoLog.class);
        }

        // 如果不存在
        if(autoLog == null) {
            return point.proceed();
        }
        // 如果存在，则执行切面的逻辑
        IAutoLogContext logContext = SpringAopAutoLogContext.newInstance()
                .method(method)
                .autoLog(autoLog)
                .point(point);

        return AutoLogBs.newInstance()
                .context(logContext)
                .execute();
    }

}

pointcut 的不足

一开始把扫描的范围配置的很大，但是这样存在一定的性能问题。

于是改成了基于注解的方式，指定了注解的类和方法才会拦截。

但是这依然是一个问题，这样用户使用的时候会依然觉得不够遍历。

那么，如何可以让用户动态指定呢？

注解的属性必须为常量

第一个想法就是让 pointcut 的切面信息直接动态读取配置。

但是发现注解的信息必须是一个常量，这个要如何动态修改呢？

pointcut 基础知识

格式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?) 

修饰符匹配（modifier-pattern?）
返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等
类路径匹配（declaring-type-pattern?）
方法名匹配（name-pattern）可以指定方法名 或者 *代表所有, set* 代表以set开头的所有方法
参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(*,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(..)表示零个或多个任意参数
异常类型匹配（throws-pattern?）
其中后面跟着“?”的是可选项

1）execution(* *(..))  
//表示匹配所有方法  
2）execution(public * com. savage.service.UserService.*(..))  
//表示匹配com.savage.server.UserService中所有的公有方法  
3）execution(* com.savage.server..*.*(..))  
//表示匹配com.savage.server包及其子包下的所有方法 

实现方式 1

如何将aop中的pointcut值从配置文件中读取

首先，我们可以先创建一个类来实现 MethodInterceptor 类：

class LogAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before method");//这里做你的before操作
        Object result = invocation.proceed();
        System.out.println("After method");//这里做你的after操作
        return result;
    }
}

然后创建一个Configuration类，创建Bean：

@Configuration
public class ConfigurableAdvisorConfig {

    @Value("${pointcut.property}")
    private String pointcut;

    @Bean
    public AspectJExpressionPointcutAdvisor configurabledvisor() {
        AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor();
        advisor.setExpression(pointcut);
        advisor.setAdvice(new LogAdvice ());
        return advisor;
    }
}

这里面的 pointcut.property值来自于你的application.properties 等配置文件。

这样，各项目只须要引用该jar，然后在配置文件中指定要拦截的pointcut就可以了。

spring 中的 pointcut-实现方式2

//Pointcut表示式(可以使用&& || ! 这三个运算)
@Pointcut("execution(* com.github.houbb.*(..))")
//Point签名
private void log(){} 

实现动态 pointcut 的思路

关于SpringAop

AspectJ方式织入的核心，是一个 BeanPostProcess（会扫描所有的Pointcut与遍历所有Bean,并对需要的Bean进行织入-自动代理，当对象实例化的时候，为其生成代理对象并返回）

思路

在Aop的BeanPostProcess执行之前( springApplication.run之前),使用javassist修改目标Aop类字节码，动态设置@Pointcut,设置 value为我们自己动态查询到的值。

其他

由于Spring boot的类加载机制，运行时javassist会扫描不到包，要通过insertClassPath添加扫描路径

修改 @Pointcut 的切点值后，通过toClass覆盖原有类，需要通过类加载器重新加载。

实现

springboot

@SpringBootApplication
public class UidServerApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        AspectPoincutScan();
        SpringApplication springApplication = new SpringApplication(UidServerApplication.class);
        springApplication.addInitializers(new UidApplicationContextInitializer());
        springApplication.run(args);
    }

    @Override
    protected SpringApplicationBuilder configure(
            SpringApplicationBuilder builder) {
        AspectPoincutScan();
        return builder.sources(UidServerApplication.class)
                .initializers(new UidApplicationContextInitializer())
                .listeners(new UidApplicationRefreshedListener())
                .listeners(new UidApplicationCloseListener());
    }


    private static void AspectPoincutScan() {
        try {
            ClassPool pool = ClassPool.getDefault();
            // 添加包的扫描路径
            ClassClassPath classPath = new ClassClassPath(UidServerApplication.class);
            pool.insertClassPath(classPath);
            //获取要修改的Class
            CtClass ct = pool.get("com.github.houbb.auto.log.spring.aop.AutoLogAop");
            CtMethod[] cms = ct.getDeclaredMethods();
            for (CtMethod cm : cms) {
                //找到@pointcut 注解的方法
                if (cm.getName().equals("pointcut")) {

                    MethodInfo methodInfo = cm.getMethodInfo();
                    ConstPool cPool = methodInfo.getConstPool();

                    AnnotationsAttribute attribute = new AnnotationsAttribute(cPool, AnnotationsAttribute.visibleTag);
                    //获取@pointcut 注解，修改其value值
                    Annotation annotation = new Annotation("org.aspectj.lang.annotation.Pointcut", cPool);
                    annotation.addMemberValue("value", new StringMemberValue("execution(xxxx", cPool));
                    attribute.setAnnotation(annotation);
                    methodInfo.addAttribute(attribute);

                    //覆盖原有类
                    ct.toClass();
                    //使用类加载器重新加载Aop类
                    pool.getClassLoader().loadClass("com.github.houbb.auto.log.spring.aop.AutoLogAop");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

aop

编程式AOP实现动态PointCut

PonitCut

public static Pointcut getAdapterServicePointcut(){
        AspectJExpressionPointcut adapterPointcut = new AspectJExpressionPointcut();
        //从配置文件中获取PointCut表达式
        adapterPointcut.setExpression(MonitorPropertyConfig.getPoinitcutAdapter());
        return adapterPointcut;}
        
//扩展Spring中AbstractBeanFactoryPointcutAdvisor

public class AdapterServiceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

    @Override
    public Pointcut getPointcut() {
        return getAdapterServicePointcut();
    }

}

Advice

public class AdapterServiceMonitorInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
       //做一些操作...
    }
}

配置Advisor Bean

@Configuration
public class MonitorProxyConfiguration {

    @Bean(name = "adapterServiceAdvisor")
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public AdapterServiceAdvisor adapterServiceAdvisor() {
        AdapterServiceAdvisor advisor = new AdapterServiceAdvisor();
        advisor.setAdviceBeanName("adapterServiceAdvice");
        advisor.setAdvice(new AdapterServiceMonitorInterceptor());
        advisor.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return advisor;
    }
}