public interface ArithmeticCalculator {
    void add(int i,int j);
    void sub(int i,int j);
}

public void add(int i, int j) {
        if(i < 0 || j < 0){
            throw new IllegalArgumentException("Positive numbers only");
        }
        System.out.println("The method add begins with " + i + "," + j);
        int result =  i + j;
        System.out.println("result: "+ result);
        System.out.println("The method add ends with " + i + "," + j);
    }

    public void sub(int i, int j) {
        if(i < 0 || j < 0){
            throw new IllegalArgumentException("Positive numbers only");
        }
        System.out.println("The method sub begins with " + i + "," + j);
        int result =  i - j;
        System.out.println("result: "+ result);
        System.out.println("The method sub ends with " + i + "," + j);
    }

public class LoggingHandler implements InvocationHandler {

    /**
     * 被代理的目标对象
     */
    private Object proxyObj;

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("The method " + method.getName() + " begins with " + Arrays.toString(args));
        Object result = method.invoke(proxyObj,args);
        System.out.println("The method " + method.getName() + " ends with " + Arrays.toString(args));
        return result;
    }

    public Object createProxy(Object proxyObj){
        this.proxyObj = proxyObj;
        //返回一个代理对象
        return Proxy.newProxyInstance(proxyObj.getClass().getClassLoader(),
                proxyObj.getClass().getInterfaces(),this);
    }
}

public class ValidationHandler implements MethodInterceptor {

    /**
     * 被代理的目标对象
     */
    private Object targetObject;


    public Object createProxy(Object targetObject){
        this.targetObject = targetObject;
        Enhancer enhancer = new Enhancer();
        //设置代理目标
        enhancer.setSuperclass(targetObject.getClass());
        //设置回调
        enhancer.setCallback(this);
        return enhancer.create();
    }

    /**
     * 在代理实例上处理方法调用并返回结果
     * @param o ： 代理类
     * @param method ：被代理的方法
     * @param objects ：该方法的参数数组
     * @param methodProxy
     */
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object result = null;

        for (Object object : objects) {
            if(Integer.parseInt(object.toString()) < 0){
                throw new IllegalArgumentException("Positive numbers only");
            }
        }
        //执行目标对象的方法
        result = methodProxy.invoke(targetObject,objects);
        return result;
    }
}

public static void main(String[] args) {

     ValidationHandler validationHandler = new ValidationHandler();
     LoggingHandler loggingHandler = new LoggingHandler();

     //cglib 要求目标对象是个单独的对象
     ArithmeticCalculatorImpl calculatorImpl = new ArithmeticCalculatorImpl();
     validationHandler.createProxy(calculatorImpl);

     //JDK 动态代理要求目标对象是接口
     ArithmeticCalculator calculator = new ArithmeticCalculatorImpl();
     ArithmeticCalculator loggingProxy = (ArithmeticCalculator) loggingHandler.createProxy(calculator);
     loggingProxy.add(1,2);

     ArithmeticCalculatorImpl validationProxy = (ArithmeticCalculatorImpl) validationHandler.createProxy(calculatorImpl);
     validationProxy.sub(-1,2);
   }

@Aspect
@Component
public class LogAspect {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 前置通知，目标方法调用前被调用
     */
    @Before("execution(* priv.starfish.aop.aspect.Calculator.add(..))")
    public void beforeAdvice(){
        log.info("The method add begins");
    }
 
}

@Pointcut("execution(* *.add(int,int)) || execution(* *.sub(int,int))")
public void loggingOperation(){};

@Before("execution(* priv.starfish.aop.aspect.Calculator.add(..))")
public void beforeAdvice(JoinPoint joinPoint) {
  log.info("The method " + joinPoint.getSignature().getName()
           + "() begins with " + Arrays.toString(joinPoint.getArgs()));
}

@Aspect
@Component
public class LogAspect {
private Logger log = LoggerFactory.getLogger(this.getClass());

  /**
   * 前置通知，目标方法调用前被调用
   */
  @Before("execution(* priv.starfish.aop.aspect.Calculator.add(..))")
  public void beforeAdvice(){
      log.info("The method add begins");
  }
  
  /**
   * 后置通知，目标方法执行完执行
   */
  @After("execution( * *.*(..))")
  public void afterAdvice(JoinPoint joinPoint){
    log.info("The method " + joinPoint.getSignature().getName() + "() ends");
  }
  
}

/**
 * 后置返回通知
 * 如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
 * 如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
 * returning 只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行
 */
@AfterReturning(value = "loggingOperation()",returning = "res")
public void afterReturningAdvice(JoinPoint joinPoint, Object res){
    System.out.println("后置返回通知 返回值："+res);
}

/**
 * 后置异常通知
 *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；
 *  throwing 只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，
 */
@AfterThrowing(value = "loggingOperation()",throwing = "exception")
public void afterThrowingAdvice(JoinPoint joinPoint,ArithmeticException exception){
    log.error(joinPoint.getSignature().getName() + "has throw an exception" + exception);
}

/**
 * 环绕通知：
 * 环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
 * 环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
 */
@Around("loggingOperation()")
public Object aroundAdvice(ProceedingJoinPoint joinPoint){
    System.out.println("- - - - - 环绕前置通知 - - - -");
    try {
        //调用执行目标方法
        Object obj = joinPoint.proceed();
        System.out.println("- - - - - 环绕后置返回通知 - - - -");
        return obj;
    } catch (Throwable throwable) {
        throwable.printStackTrace();
        System.out.println("- - - - - 环绕异常通知 - - - -");
    }finally {
        System.out.println("- - - - - 环绕后置通知 - - - -");
    }
    return null;
}

@Aspect
@Order(0)
public class ValidationAspect {
}

@Aspect
@Order(1)
public class LogAspect {

/**
 * 切入点
 */
@Pointcut("execution(public int priv.starfish.aop.aspect.CalculatorImpl.*(int,int))")
public void executePackage(){};

/**
 * 这里直接写成 value= 调用了切入点 excution 表达式
 */
@AfterReturning(value = "executePackage()",returning = "res")
public void afterReturningAdvice(JoinPoint joinPoint, Object res){
  System.out.println("- - - - - 后置返回通知- - - - -");
  System.out.println("后置返回通知 返回值："+res);
}

public class TimeHandler {

    public void printTime() {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

public static void main(String[] args) {
    ApplicationContext ctx =
            new ClassPathXmlApplicationContext("applicationContext.xml");

    Calculator calculator = (Calculator)ctx.getBean("calculator");
    calculator.add(2,3);
}