面向切面编程（Aspect Oriented Programming, AOP)是面向对象编程（Object Oriented Programming，OOP）的强大补充，通过横切面注入的方式引入其他额外功能，比如日志记录，事务处理等，用户无需修改源代码就可以"优雅"的实现额外功能的补充，对于Programmer来说，AOP是个非常强大的工具。

AOP中的切面处理逻辑会被应用到我们所定义的切点（Point Cut）上，切面逻辑定义可以使用 around, before,after等Aspect注解实现，切点可以使用Aspect注解中的参数指定或者通过xml配置文件声明。在编写代码的过程中，切点控制往往不够灵活，需要我们在xml或者Aspect注解参数中指定方法的path，当切点较多，需要颗粒度更加细致的切点控制时，通常我们需要添加大量的切点定义代码，这样比较麻烦。通常呢我们我们可以通过结合自定义注解来解决这个问题，实现更加灵活的切点控制。

自定义注解实现AOP切点定义的背后原理说起来其实很简单，通过扫描项目所有的类，然后过滤出标注点的位置，将切面自定义逻辑应用到标注点上，就实现了我们的业务需求。但是，技术上如何去实现呢？本文就这一问题，结合Java Spring AOP框架给出解答。

目标

我们的自定义注解需要具备以下功能：

类中方法添加注解，则这个方法成为切点
类添加注解，则这个类中所有的方法成为切点
抽象类方法添加注解，则抽闲类中的这个方法成为切点
抽象类添加注解，则抽象类中的所有方法成为切点
接口添加注解，则接口中定义的所有方法成为切点
接口中方法添加注解，则接口中的这个方法成为切点

JDK提供的关键类和方法

Class

Java最基本的元素称为"类"，类中可以包涵方法和属性的定义。Class对象提供了很多有用的方法，可以帮助我们切点位置定位，比如：

public native Class<? super T> getSuperclass();获取当前类的父类
public Class<?>[] getInterfaces()；获取当前类实现的接口
public Method[] getDeclaredMethods() throws SecurityException 获取当前类中声明的方法
public < A extends Annotation > A getAnnotation(Class < A > annotationClass)获取当前类指定标签的对象，若为空，表明当前类没有标签annotationClass。

Method

我们还使用到Method类的一些方法：

public String getName(); 获取方法的名字
public < T extends Annotation > T getAnnotation(Class annotationClass)；取当前类指定标签的对象，若为空，表明当前类没有标签annotationClass

ProceedingJoinPoint

ProceedingJoinPoint接口提供了很多实用的函数，便于用户获取应用切面点函数具体的信息。下面四个接口是我们用的比较多的：

Object proceed() throws Throwable; 调用要拦截的方法
Object proceed(Object[] var1) throws Throwable;调用要拦截的方法，可以自定义传入参数
Object[] getArgs();获取拦截方法的传入参数
Signature getSignature();获取拦截方法的方法名

实现

XML配置

配置xml文件，使能AOP和Spring Bean自动装配

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

			http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

			http://www.springframework.org/schema/aop

			http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 使能AOP-->

    <aop:aspectj-autoproxy/>

    <!-- 自动装载bean使能-->

    <context:component-scan base-package="com.mj.spring.aop"/>

    <context:annotation-config/>

</beans>

定义自定义标签

我们的自定义标签可以作用于类，方法上，运行时工作。这儿需要说一下两个标签@Target和Retention，@Target用来设置标签的作用范围：

@Target(ElementType. FIELD)表示标签只能用来修饰字段、枚举的常量
@Target(ElementType.METHOD)表示标签只能用来修饰方法
@Target(ElementType.TYPE) 标签可用来修饰接口、类、枚举、注解
...

@Retention用来修饰注解的生存范围

@Retention(RetentionPolicy.SOURCE) 注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS) 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME) 注解会在class字节码文件中存在，在运行时可以通过反射获取到
```
 @Retention(RetentionPolicy.RUNTIME)

 public @interface AOPLog4jAnnotation {

 }
```

注意到我们没有添加Target标签，不指定标签的作用范围，那么标签适用于所有范围。

定义切面类

完整的切面类代码如下所示，类中实现了切面逻辑的定义和切点判断的逻辑代码。

@Component

@Aspect

public class APIProxy{

    private final static Log LOGGER = LogFactory.getLog(APIProxy.class);

    //切面应用范围是在com.mj.spring.aop包下面所有函数

    @Around("execution(* com.mj.spring.aop..*.*(..))")

    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {

        String signatureName = joinPoint.getSignature().getName();

        Class<? extends Object> invokeClass = joinPoint.getTarget().getClass();

        if (isTagged(invokeClass, signatureName)) {

            LOGGER.info(signatureName + " is tagged");

            joinPoint.proceed();

            return;

        }

        joinPoint.proceed();

    }

    //扫描父类是否被打上标签,或者父类中的这个方法是否被打伤标签

    private boolean isTagged(Class invokeClass, String signatureName) {

        if (isTaggedInInterfaceOf(invokeClass, signatureName)) {

            return true;

        }

        if (!invokeClass.equals(Object.class)) {

            return isTaggedInClassOf(invokeClass, signatureName) ? true :

                    isTagged(invokeClass.getSuperclass(), signatureName);

        }

        return false;

    }

    //扫描当前类的接口

    private boolean isTaggedInInterfaceOf(Class invokeClass, String signatureName) {

        Class[] interfaces = invokeClass.getInterfaces();

        for (Class cas : interfaces) {

            return isTaggedInClassOf(cas, signatureName) ? true :

                    isTaggedInInterfaceOf(cas, signatureName);

        }

        return false;

    }

    //方法名为signatureName的方法tagged有两种情况:方法本身被taged或者方法所在的类被taged

    private boolean isTaggedInClassOf(Class cas, String signatureName) {

        return Lists.newArrayList(cas.getDeclaredMethods())

                .stream().anyMatch(method ->

                        isMethodWithName(method, signatureName) && isMethodTagged(method)

                                || isMethodWithName(method, signatureName) && isClassTagged(cas));

    }

    private boolean isClassTagged(Class invokeClass) {

        return invokeClass.getAnnotation(AOPLog4jAnnotation.class) != null;

    }

    private boolean isMethodTagged(Method method) {

        return method.getAnnotation(AOPLog4jAnnotation.class) != null;

    }

    private boolean isMethodWithName(Method method, String name) {

        return method.getName().equals(name);

    }

}

下面代码实现了一个around切面advice定义，切面逻辑的应用范围是com.mj.spring.aop包下的所有的方法，判断当前执行方法是否被打上标签，如果打上标签，那么执行我们额外添加的业务逻辑代码，这里为简单起见在方法运行前打了一个log，然后执行方法，返回。否则直接调用方法，不做任何额外处理。

//切面应用范围是在com.mj.spring.aop包下面所有函数

    @Around("execution(* com.mj.spring.aop..*.*(..))")

    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {

        String signatureName = joinPoint.getSignature().getName();

        Class<? extends Object> invokeClass = joinPoint.getTarget().getClass();

        if (isTagged(invokeClass, signatureName)) {

            LOGGER.info(signatureName + " is tagged");

            joinPoint.proceed();

            return;

        }

        joinPoint.proceed();

    }

方法被打上自定义标签有以下几种可能：

该方法方法体被打上标签
该方法所在类被打上标签
该方法所在的API接口函数对应被打上标签
该方法所在的API接口被打上标签
该方法所在的抽象类被打上标签
该方法所在的抽象类函数定义被打上标签

对于接口函数来说，接口之间可以多重嵌套，搜寻接口中指定函数的标签，需要采用递归的方式向上寻找，对于父类继承也同样如此。下面的代码实现涵盖了上面6种能性的所有判读。

    //扫描父类是否被打上标签,或者父类中的这个方法是否被打伤标签

    private boolean isTagged(Class invokeClass, String signatureName)

    {

        if (isTaggedInInterfaceOf(invokeClass, signatureName)) {

            return true;

        }

        if (!invokeClass.equals(Object.class)) {

            return isTaggedInClassOf(invokeClass, signatureName) ? true :

                    isTagged(invokeClass.getSuperclass(), signatureName);

        }

        return false;

    }

函数开始：

判断当前名为signatureName的方法是否在invokeClass类所实现的API接口中被Tag。(实现3和4的判断)
判断当前类是否为Object.class，若不是则执行第三步，否则执行第四步
判断当前名为signatureName的方法是否在类invokeClass中被tag(实现1和2的判断)
上面三项没有为真，则调用当前类的父类继续递归（实现5和6的判断）

判断当前名为signatureName的方法是否在invokeClass类所实现的API接口中被Tag的代码如下所示，首先获取当前类所有接口，分别对每个接口类进行方法检查，若检查成功，则返回true，否则继续向上递归。

    //扫描当前类的接口

    private boolean isTaggedInInterfaceOf(Class invokeClass, String signatureName) {

        Class[] interfaces = invokeClass.getInterfaces();

        for (Class cas : interfaces) {

            return isTaggedInClassOf(cas, signatureName) ? true :

                    isTaggedInInterfaceOf(cas, signatureName);

        }

        return false;

    }

判断一个名为signatureName的方法在类cas中是否被tag的代码如下所示：

    private boolean isTaggedInClassOf(Class cas, String signatureName) {

        return Lists.newArrayList(cas.getDeclaredMethods())

                .stream().anyMatch(method ->

                        isMethodWithName(method, signatureName) && isMethodTagged(method)

                                || isMethodWithName(method, signatureName)&& isClassTagged(cas));

代码逻辑实现很简单，判断方法被tag条件为：该方法是在该类中同时（该方法体是被打上标签或者类被打上标签）

Conclusion

本文和大家分享了如何通过自定义注解实现AOP切点定义，希望能够对大家有所帮助。本文完整的源码，单元测试位于:< https://github.com/jma19/spring/tree/master/spring-aop >, 欢迎大家下载，批评指正。

巴特西

如何通过自定义注解实现AOP切点定义

目标