[micro service sentinel] sentinelresourceaspect details

AOP

As we mentioned above @SentinelResource annotation , We all know that annotation is just a mark , Then the real realization of current limiting logic is AOP 了 .

AOP What business problems will be solved in the actual development ？

1. Transaction related
   Used to rollback things

2. Performance monitoring
   Record the call time before and after the method call , Method execution too long or timeout alarm .

3. The caching proxy
   Cache the return value of a method , The next time you execute this method , Get it directly from the cache .

4. Software cracking
   Use AOP Modify the judgment logic of the verification class of the software .

5. Log
   Record system logs before and after method execution .

6. Workflow system
   Workflow system needs to mix business code and process engine code to execute , Then we can use AOP Separate it , And dynamically connect services .

7. Authority verification
   Verify that you have permission to execute the current method before executing the method , If not, throw an exception without permission , Captured by business code .

Next , Let's take a look at its source code
com.alibaba.csp.sentinel.annotation.aspectj.SentinelResourceAspect

Source code

@Aspect
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();
        int resourceType = annotation.resourceType();
        Entry entry = null;
        try {
    
            entry = SphU.entry(resourceName, resourceType, entryType, 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);
                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());
            }
        }
    }
}

Source code analysis

Let's analyze this code ：

1. Use aspect Of around Intercept , Interception is marked with SentinelResource Annotations
2. Call before you enter the method SphU.entry(resourceName, entryType), Call after completion entry.exit();
3. Call... In case of exception handleBlockException Method

This also verifies our previous article , Two solutions for exception handling in annotations .