实例探究Aspectj，解析SentinelResourceAspect

为了学习SentinelResourceAspect，这篇文章里我用Aspectj实现一个AOP实例，一起来看下。

Sentinel 提供了 @SentinelResource 注解用于定义资源，支持 AspectJ 的扩展用于自动定义资源、处理 BlockException 等。

SentinelResourceAspect是Sentinel中的核心切面，Sentinel对限流，拦截等的支持都依赖 SentinelResourceAspect，本文回顾AOP相关知识，实现一个AspectJ实例，然后带你从源码角度，探究SentinelResourceAspect的实现。

1、回顾 Spring AOP 知识

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

常见使用场景

• 性能监控

在方法调用前后记录调用时间，方法执行太长或超时报警。

• 缓存代理

缓存某方法的返回值，下次执行该方法时，直接从缓存里获取。

• 软件破解

使用AOP修改软件的验证类的判断逻辑。

• 记录日志

在方法执行前后记录系统日志。

• 工作流系统

工作流系统需要将业务代码和流程引擎代码混合在一起执行，那么我们可以使用AOP将其分离，并动态挂接业务。

• 权限验证

方法执行前验证是否有权限执行当前方法，没有则抛出没有权限执行异常，由业务代码捕捉。

AOP的一些概念

• Aspect Aspect : 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

• Joint point : 拦截点，如某个业务方法, 表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

• Pointcut : 表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，即Joinpoint的表达式，表示拦截哪些方法。一个Pointcut对应多个Joinpoint

• Advice Advice : 定义了在 pointcut 里面定义的程序点具体要做的操作，即要切入的逻辑，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

• Target : 被aspectj横切的对象。我们所说的joinPoint就是Target的某一行，如方法开始执行的地方、方法类调用某个其他方法的代码

在Spring 中，AOP有多种实现方式，AspectJ是其中一种，另外还有JDK 和 Cglig的动态代理等。

2、基于 AspectJ 和@annotation拦截方法实现AOP

在学习 SentinelResourceAspect 源码之前，我先动手实现一个 AspectJ 的AOP实例，完成这个实例以后，SentinelResourceAspect的原理只要看一眼源码就可以明白。

（1）编写Annotation类

@Target({ElementType.METHOD,ElementType.TYPE})
@Documented
@Inherited
public @interface WorkflowLogAnnotation {
    String field();
}

（2）编写接口和实现类

编写接口类WorkflowService，编写实现类WorkflowServiceImpl，注意此处在方法上增加WorkflowLogAnnotation

public class WorkflowServiceImpl implements WorkflowService {
    @Override
    @WorkflowLogAnnotation
    public void start(String bpmnXml) {
        System.out.println("启动流程");
    }
}

（3）加入切面动作

在流程启动前和启动后做一些操作，增加通知，注意Pointcut表达式改为拦截器方式。

@Aspect
public class WorkflowServiceAdviceAspect {

    public WorkflowServiceAdviceAspect(){

    }

    @Pointcut("annotation(Spring.WorkflowLogAnnotation)")
    public void startPoint()

    @Before("startPoint()")
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
        System.out.println("执行方法前");
    }

    @AfterReturning("startPoint()")
    public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
        System.out.println("执行方法后");
    }
}

（4）增加配置

在Xml中增加配置，如果WorkflowServiceAdviceAspect和WorkflowServiceImpl类上增加了@Component，下面的bean声明可以用Spring的自动扫描来替代。

<aop:aspectj-autoproxy />
    <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->
    <bean id="workflowServiceAdviceAspect" class="Spring.WorkflowServiceAdviceAspect"></bean>
    <!-- 定义被代理者 -->
    <bean id="workflowService" class="business.WorkflowServiceImpl"></bean>

（5）完成验证

完成上面的操作，一个 AspectJ 实例就完成了，是不是很简单，下面看下 SentinelResourceAspect的源码。

3、SentinelResourceAspect源码

可以看到，SentinelResourceAspect切面和我们上面的实例实现方式是一样的。

public class SentinelResourceAspect extends AbstractSentinelAspectSupport {

@Pointcut("@annotation(com.alibaba.csp.sentinel.annotation.SentinelResource)")
    public void sentinelResourceAnnotationPointcut() {
    }

    @Around("sentinelResourceAnnotationPointcut()")
    public Object invokeResourceWithSentinel(ProceedingJoinPoint pjp) throws Throwable {
        Method originMethod = resolveMethod(pjp);

        SentinelResource annotation = originMethod.getAnnotation(SentinelResource.class);
        if (annotation == null) {
            // Should not go through here.
            throw new IllegalStateException("Wrong state for SentinelResource annotation");
        }
        String resourceName = getResourceName(annotation.value(), originMethod);
        EntryType entryType = annotation.entryType();
        Entry entry = null;
        try {
            entry = SphU.entry(resourceName, entryType, 1, pjp.getArgs());
            Object result = pjp.proceed();
            return result;
        } catch (BlockException ex) {
            return handleBlockException(pjp, annotation, ex);
        } catch (Throwable ex) {
            Class<? extends Throwable>[] exceptionsToIgnore = annotation.exceptionsToIgnore();
            // The ignore list will be checked first.
            if (exceptionsToIgnore.length > 0 && exceptionBelongsTo(ex, exceptionsToIgnore)) {
                throw ex;
            }
            if (exceptionBelongsTo(ex, annotation.exceptionsToTrace())) {
                traceException(ex, annotation);
                return handleFallback(pjp, annotation, ex);
            }

            // No fallback function can handle the exception, so throw it out.
            throw ex;
        } finally {
            if (entry != null) {
                entry.exit(1, pjp.getArgs());
            }
        }
    }
}

（1）进入方法调用SphU.entry

SentinelResourceAspect 使用aspect的around拦截，拦截标注有SentinelResource的注解，进入方法之前调用SphU.entry(resourceName, entryType)，结束之后调用entry.exit();

            entry = SphU.entry(resourceName, entryType, 1, pjp.getArgs());
            Object result = pjp.proceed();

这个使用方式和我们单机使用 Sentinel的方式是一样的。

（2）handleBlockException处理异常

异常的时候调用handleBlockException方法，会先判断是否是降级需要处理的异常，是的话，则调用fallback方法，否则调用block handler方法。

Method blockHandlerMethod = extractBlockHandlerMethod(pjp, annotation.blockHandler(),
            annotation.blockHandlerClass());
        if (blockHandlerMethod != null) {
            Object[] originArgs = pjp.getArgs();
            // Construct args.
            Object[] args = Arrays.copyOf(originArgs, originArgs.length + 1);
            args[args.length - 1] = ex;
            if (isStatic(blockHandlerMethod)) {
                return blockHandlerMethod.invoke(null, args);
            }
            return blockHandlerMethod.invoke(pjp.getTarget(), args);
        }

        // If no block handler is present, then go to fallback.
        return handleFallback(pjp, annotation, ex);

4、总结

Sentinel 使用了Aspectj来实现切面，可以更方便的应用Sentinel。