SpringAOP使用之多切面运行顺序

public class LogUtil {
    public void perfORMance(){}
    public void logStart(JoinPoint joinPoint)
    {
        //获取方法上的参数列表
        Object[] args = joinPoint.getArgs();
        //获取方法签名
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();//获取方法名
        System.out.println("前置通知："+name+" 方法开始执行了....参数是："+ Arrays.asList(args) +"");
    }
    public void logReturn(JoinPoint point,Object result)
    {
        String name = point.getSignature().getName();
        Object[] args = point.getArgs();
        System.out.println("返回通知： "+name+"方法正常执行，返回结果是："+result+"");
    }
    public void logException(JoinPoint point,Exception e)
    {
        String name = point.getSignature().getName();
        System.out.println("异常通知："+name+" 方法出现了异常，异常是 "+e+"...");
    }
    public void logEnd(JoinPoint joinPoint)
    {
        String name = joinPoint.getSignature().getName();
        System.out.println("后置通知："+name+"方法结束了");
    }
    //环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
        Object proceed = null;
            //获取方法名
        String name = proceedingJoinPoint.getSignature().getName();
            //获取执行方法的参数列表
        Object[] args = proceedingJoinPoint.getArgs();
        try {
            System.out.println("环绕前置通知："+name+"方法开始执行了，参数是"+Arrays.asList(args)+"");
            //等于 method.invoke();通过反射执行指定方法
            proceed = proceedingJoinPoint.proceed();
            System.out.println("环绕返回通知："+name+"方法返回结果是"+proceed+";");
        } catch (Throwable throwable) {
            System.out.println("环绕异常通知：异常是"+throwable+"");
            throwable.printStackTrace();
        }finally {
            System.out.println("环绕后置通知："+name+"方法结束了");
        }
        return proceed;
    }

package main.java.cn.zixue.domain;public class MyCalculator
{   
  public int add(int a,int b)   
 {
         return a+b;   
 }    
 public int sub(int a,int b) 
 {        
 	return a-b;    
 }
     public int mul(int a,int b)
 {        
 	return a*b;   
  }    
  public int dev(int a,int b)
  {        
  		return a/b;    
  }    
  public double add(double a,float b,int c) 
  {
          return a+b+c;    
   }
 }

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="main.java.cn"></context:component-scan>
    <bean id="myCalculator" class="main.java.cn.zixue.domain.MyCalculator"></bean>
    <bean id="logUtil" class="main.java.cn.zixue.utils.LogUtil"></bean>
    <!--AOP名称空间-->
    <aop:config>
      <!--  制定切面的方法-->
        <aop:pointcut id="performance" expression="execution(public * main.java.cn.zixue.domain.MyCalculator.*(..))"></aop:pointcut>
        <!--指定切面-->
        <aop:aspect ref="logUtil">
            <aop:after method="logEnd" pointcut-ref="performance"></aop:after>
            <aop:before method="logStart" pointcut-ref="performance"></aop:before>
            <aop:after-returning method="logReturn" pointcut-ref="performance" returning="result"></aop:after-returning>
            <aop:after-throwing method="logException" pointcut-ref="performance" throwing="e"></aop:after-throwing>
            <aop:around method="myAround" pointcut-ref="performance"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

@Test
public void Test02()
{
    MyCalculator myCalculator = (MyCalculator) context.getBean("myCalculator");
    myCalculator.add(1,10);
    System.out.println("========================");
}

public Object aop(Method method,Object object) {
    try {
        try {
            
            doBefore();
            method.invoke(object);
            
        } finally {
            doAfter();
        }
        doAfterReturning();
    } catch (Exception e) {
        doAfterThrowing();
    }
}

@Component 
public class StrategyService extends BaseStrategyService  { 
    public PricingResponse getFactor(Map<String, String> pricingParams) { 
        // 做一些参数校验，以及异常捕获相关的事情 
        return this.loadFactor(tieredPricingParams); 
    }
 
    @Override 
    @StrategyCache(keyName = "key0001", expireTime = 60 * 60 * 2) 
    private PricingResponse loadFactor(Map<String, String> pricingParams) { 
        //代码执行 
    } 
}
 

 public static void main(String[] args) { 
        ProxyFactory factory = new ProxyFactory(new SimplePojo()); 
        factory.addInterface(Pojo.class); 
        factory.addAdvice(new RetryAdvice()); 
        Pojo pojo = (Pojo) factory.getProxy(); 
        // this is a method call on the proxy! 
        pojo.foo(); 
    }

@Component 
public class StrategyService{ 
    public PricingResponse getFactor(Map<String, String> pricingParams) { 
        // 做一些参数校验，以及异常捕获相关的事情 
        // 这里不使用this.loadFactor而是使用AopContext.currentProxy()调用，目的是解决AOP代理不支持方法自调用的问题 
        if (AopContext.currentProxy() instanceof StrategyService) { 
            return ((StrategyService)AopContext.currentProxy()).loadFactor(tieredPricingParams); 
        } else {
 
            // 部分实现没有被代理过，则直接进行自调用即可 
            return loadFactor(tieredPricingParams); 
        } 
    }
 
    @Override 
    @StrategyCache(keyName = "key0001", expireTime = 60 * 60 * 2) 
    private PricingResponse loadFactor(Map<String, String> oricingParams) { 
        //代码执行 
    } 
}
 
//还有个地方需要注意，以上方式还需要将Aspect的expose-proxy设置成true。如果是配置文件修改：
 <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
//如果是SpringBoot，则修改应用启动入口类的注解：
@EnableAspectJAutoProxy(exposeProxy = true) 
public class Application { 
}