public class LogUtil {
    public void performance(){}
    public void logStart(JoinPoint joinPoint)
    {
        //獲取方法上的參數(shù)列表
        Object[] args = joinPoint.getArgs();
        //獲取方法簽名
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();//獲取方法名
        System.out.println("前置通知："+name+" 方法開始執(zhí)行了....參數(shù)是："+ Arrays.asList(args) +"");
    }
    public void logReturn(JoinPoint point,Object result)
    {
        String name = point.getSignature().getName();
        Object[] args = point.getArgs();
        System.out.println("返回通知： "+name+"方法正常執(zhí)行，返回結果是："+result+"");
    }
    public void logException(JoinPoint point,Exception e)
    {
        String name = point.getSignature().getName();
        System.out.println("異常通知："+name+" 方法出現(xiàn)了異常，異常是 "+e+"...");
    }
    public void logEnd(JoinPoint joinPoint)
    {
        String name = joinPoint.getSignature().getName();
        System.out.println("后置通知："+name+"方法結束了");
    }
    //環(huán)繞通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
        Object proceed = null;
            //獲取方法名
        String name = proceedingJoinPoint.getSignature().getName();
            //獲取執(zhí)行方法的參數(shù)列表
        Object[] args = proceedingJoinPoint.getArgs();
        try {
            System.out.println("環(huán)繞前置通知："+name+"方法開始執(zhí)行了，參數(shù)是"+Arrays.asList(args)+"");
            //等于 method.invoke();通過反射執(zhí)行指定方法
            proceed = proceedingJoinPoint.proceed();
            System.out.println("環(huán)繞返回通知："+name+"方法返回結果是"+proceed+";");
        } catch (Throwable throwable) {
            System.out.println("環(huán)繞異常通知：異常是"+throwable+"");
            throwable.printStackTrace();
        }finally {
            System.out.println("環(huán)繞后置通知："+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 {
            /*doAround start*/
            doBefore();
            method.invoke(object);
            /*doAround end*/
        } finally {
            doAfter();
        }
        doAfterReturning();
    } catch (Exception e) {
        doAfterThrowing();
    }
}

@Component 
public class StrategyService extends BaseStrategyService  { 
    public PricingResponse getFactor(Map<String, String> pricingParams) { 
        // 做一些參數(shù)校驗，以及異常捕獲相關的事情 
        return this.loadFactor(tieredPricingParams); 
    }
 
    @Override 
    @StrategyCache(keyName = "key0001", expireTime = 60 * 60 * 2) 
    private PricingResponse loadFactor(Map<String, String> pricingParams) { 
        //代碼執(zhí)行 
    } 
}
 

 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) { 
        // 做一些參數(shù)校驗，以及異常捕獲相關的事情 
        // 這里不使用this.loadFactor而是使用AopContext.currentProxy()調(diào)用，目的是解決AOP代理不支持方法自調(diào)用的問題 
        if (AopContext.currentProxy() instanceof StrategyService) { 
            return ((StrategyService)AopContext.currentProxy()).loadFactor(tieredPricingParams); 
        } else {
 
            // 部分實現(xiàn)沒有被代理過，則直接進行自調(diào)用即可 
            return loadFactor(tieredPricingParams); 
        } 
    }
 
    @Override 
    @StrategyCache(keyName = "key0001", expireTime = 60 * 60 * 2) 
    private PricingResponse loadFactor(Map<String, String> oricingParams) { 
        //代碼執(zhí)行 
    } 
}
 
//還有個地方需要注意，以上方式還需要將Aspect的expose-proxy設置成true。如果是配置文件修改：
 <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
//如果是SpringBoot，則修改應用啟動入口類的注解：
@EnableAspectJAutoProxy(exposeProxy = true) 
public class Application { 
}