package com.example.demo.aspect;
import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;
/** * @Author Paul * @Date 2022/7/3 15:52 */@Servicepublic class CustomService {
  @Transactional(rollbackFor = Exception.class)  public void echo(){    boolean s = true;    if (s){      throw new RuntimeException("test");    }    System.out.println("Hello------");  }
}

package com.example.demo.aspect;
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.stereotype.Component;
/** * @Author Paul * @Date 2022/7/3 15:49 */@Component@Aspectpublic class CustomAspect {
    @Pointcut("execution(* com.example.demo.aspect..*(..))")    public void pointcut(){    }
    @Around("pointcut()")    public void around(ProceedingJoinPoint joinPoint){        try {            joinPoint.proceed();        } catch (Throwable throwable) {            throwable.printStackTrace();        }    }
}

package com.example.demo.controller;
import com.example.demo.aspect.CustomService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
@RestController@RequestMapping("/home")public class HomeController {
    private CustomService customService;
    @Autowired    public void setCustomService(CustomService customService) {        this.customService = customService;    }
    @GetMapping("/echo")    public String echo(){        customService.echo();        return new Date().toString();    }}

/** * General purpose AOP callback. Used when the target is dynamic or when the * proxy is not frozen. */private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
  private final AdvisedSupport advised;
  public DynamicAdvisedInterceptor(AdvisedSupport advised) {    this.advised = advised;  }
  @Override  @Nullable  public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {    Object oldProxy = null;    boolean setProxyContext = false;    Object target = null;    TargetSource targetSource = this.advised.getTargetSource();    try {      if (this.advised.exposeProxy) {        // Make invocation available if necessary.        oldProxy = AopContext.setCurrentProxy(proxy);        setProxyContext = true;      }      // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...      target = targetSource.getTarget();      Class<?> targetClass = (target != null ? target.getClass() : null);      List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);      Object retVal;      // Check whether we only have one InvokerInterceptor: that is,      // no real advice, but just reflective invocation of the target.      if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {        // We can skip creating a MethodInvocation: just invoke the target directly.        // Note that the final invoker must be an InvokerInterceptor, so we know        // it does nothing but a reflective operation on the target, and no hot        // swapping or fancy proxying.        Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);        retVal = methodProxy.invoke(target, argsToUse);      }      else {        // We need to create a method invocation...        retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();      }      retVal = processReturnType(proxy, target, method, retVal);      return retVal;    }    finally {      if (target != null && !targetSource.isStatic()) {        targetSource.releaseTarget(target);      }      if (setProxyContext) {        // Restore old proxy.        AopContext.setCurrentProxy(oldProxy);      }    }  }
  @Override  public boolean equals(@Nullable Object other) {    return (this == other ||      (other instanceof DynamicAdvisedInterceptor &&        this.advised.equals(((DynamicAdvisedInterceptor) other).advised)));  }
  /**   * CGLIB uses this to drive proxy creation.   */  @Override  public int hashCode() {    return this.advised.hashCode();  }}

public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {
  @Override  public List<Object> getInterceptorsAndDynamicInterceptionAdvice(      Advised config, Method method, @Nullable Class<?> targetClass) {
    // This is somewhat tricky... We have to process introductions first,    // but we need to preserve order in the ultimate list.    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();    Advisor[] advisors = config.getAdvisors();    List<Object> interceptorList = new ArrayList<>(advisors.length);    Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());    Boolean hasIntroductions = null;
    for (Advisor advisor : advisors) {      if (advisor instanceof PointcutAdvisor) {        // Add it conditionally.        PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;        if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {          MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();          boolean match;          if (mm instanceof IntroductionAwareMethodMatcher) {            if (hasIntroductions == null) {              hasIntroductions = hasMatchingIntroductions(advisors, actualClass);            }            match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);          }          else {            match = mm.matches(method, actualClass);          }          if (match) {            MethodInterceptor[] interceptors = registry.getInterceptors(advisor);            if (mm.isRuntime()) {              // Creating a new object instance in the getInterceptors() method              // isn't a problem as we normally cache created chains.              for (MethodInterceptor interceptor : interceptors) {                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));              }            }            else {              interceptorList.addAll(Arrays.asList(interceptors));            }          }        }      }      else {        Interceptor[] interceptors = registry.getInterceptors(advisor);        interceptorList.addAll(Arrays.asList(interceptors));      }    }
    return interceptorList;  }
}