Spring AOP 5种通知与java动态代理

@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }

}

public class ArithmeticCalculatorLoggingImpl implements ArithmeticCalculator {

    
    @Override
    public int add(int i, int j) {
        System.out.println("The method add begins with [" + i + "," + j + "]");
        int result = i + j;
        System.out.println("The method add ends with " + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("The method sub begins with [" + i + "," + j + "]");
        int result = i - j;
        System.out.println("The method sub ends with " + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("The method mul begins with [" + i + "," + j + "]");
        int result = i * j;
        System.out.println("The method mul ends with " + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("The method div begins with [" + i + "," + j + "]");
        int result = i / j;
        System.out.println("The method div ends with " + result);
        return result;
    }

}

public class ArithmeticCalculatorLoggingProxy {
    
    
    private ArithmeticCalculator target;
    
    public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
        super();
        this.target = target;
    }


    public ArithmeticCalculator getLoggingProxy(){
        ArithmeticCalculator proxy = null;
        
        ClassLoader loader = target.getClass().getClassLoader();
        Class [] interfaces = new Class[]{ArithmeticCalculator.class};
        InvocationHandler h = new InvocationHandler() {
            /*method 方法
             *args 参数 
             * */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                String methodName = method.getName();
                
                //前置通知
                System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));
                
                Object result = null;
                try {
                    
                    result = method.invoke(target, args);//返回通知
                    
                } catch (NullPointerException e) {
                    e.printStackTrace();
                    //异常通知
                }
                //后置通知
                System.out.println("[after] The method ends with " + result);
                
                return result;
            }
        };
        
        proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
        
        return proxy;
    }
}

/**
 * AOP 
 * 1. 导入jar包
 * com.springsource.net.sf.cglib-2.2.0.jar
 * com.springsource.org.aopalliance-1.0.0.jar
 * com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
 * spring-aspects-4.0.0.RELEASE.jar
 * 
 * 2. 在配置文件中加入AOP的命名空间
 * xmlns:aop="http://www.springframework.org/schema/aop"
 * 
 * 3. 基于注解的方式
 * <context:component-scan base-package="com.atguigu.spring.aop"></context:component-scan>
 * <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 *  
 * 4.把横切关注点的代码抽象到切面的类中
 *   @Aspect
 *     @Component
 *     public class LoggingAspect {}
 *
 * 5.AspectJ支持5种类型的通知注解
 *   @Before()前置通知，在方法开始前执行
 *   @After()后置通知，在方法执行后执行，无论抛异常都会执行；不能访问方法执行的结果
 *   @AfterRunning()返回通知，在方法返回结果后执行（即方法正常结束后才执行）；可以得到方法执行的结果
 *   @AfterThrowing()异常通知，在方法抛出异常时执行
 *   @Around()环绕通知，围绕着方法执行
 * 6.AspectJ表达式
 *  execution(public int com.aop.beans.ArithmeticCalculator.*(int, int)) 
 *  execution(* com.aop.beans.*.*(int, int))
 *  
 * 7.JoinPoint
 * 通过他可以得到方法的信息
 */

//把这个类放入到IOC容器中@Component；再声明为一个切面@Aspect
@Aspect
@Component
public class LoggingAspect {
    //该方法是一个前置通知，即在目标方法开始前执行@Before（）
    @Before("execution(public int com.aop.beans.ArithmeticCalculator.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();//得到方法名
        Object [] args = joinPoint.getArgs();//得到参数
        
        System.out.println("前置通知：The method " + methodName + " begins with " + Arrays.asList(args));
    }
    
    @After("execution(* com.aop.beans.*.*(..))")//位置为这个包下的所有类、所有方法、不论参数是什么类型
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置通知：The method " + methodName + " ends");
    }
    
    
    @AfterReturning(value="execution(public int com.aop.beans.ArithmeticCalculator.*(int, int))",
            returning="result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("返回通知：The method " + methodName + " ends with " + result);
    }
    

    @AfterThrowing(value="execution(public int com.aop.beans.ArithmeticCalculator.*(int, int))",
            throwing="e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常通知：The method " + methodName + " occurs excetion:" + e);
    }
    
    /*
     * 环绕通知功能相当于动态代理的全过程，需要有ProceedingJoinPoint 类型的参数；
     * pjd 参数可以决定是否执行目标方法
     * 环绕通知必须有返回值，返回值即为目标方法的返回值
     * 
     * 
    @Around("execution(public int com.aop.beans.ArithmeticCalculator.*(int, int))")
    public Object aroundMethod(ProceedingJoinPoint pjd){
        
        Object result = null;//返回值
        String methodName = pjd.getSignature().getName();//得到方法名
        
        try {
            //前置通知
            System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
            result = pjd.proceed();//执行方法 //返回通知
            System.out.println("The method " + methodName + " ends with " + result);
        } catch (Throwable e) {
            //异常通知
            System.out.println("The method " + methodName + " occurs exception:" + e);
            throw new RuntimeException(e);
        }
        //后置通知
        System.out.println("The method " + methodName + " ends");
        
        return result;
    }
    */
    
}

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 自动扫描的包；  扫描@注解，添加到IOC容器中，让Spring管理-->
    <context:component-scan base-package="com.aop.beans"></context:component-scan>

    <!-- 使 AspectJ 的注解起作用 ； autoproxy自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

public class Main {
    
    public static void main(String[] args) {
        /*代理模式实现添加日志功能
        ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();        
        arithmeticCalculator = new ArithmeticCalculatorLoggingProxy(arithmeticCalculator).getLoggingProxy();        
        int result = arithmeticCalculator.add(11, 12);
        System.out.println("result:" + result);
        result = arithmeticCalculator.div(21, 3);
        System.out.println("result:" + result);
        */

        //AOP实现添加日志功能
        ApplicationContext ctx = new ClassPathXmlApplicationContext("com/aop/beans/beans-aop.xml");
        ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        
        System.out.println(arithmeticCalculator.getClass().getName());
        
        int result = arithmeticCalculator.add(11, 12);
        System.out.println("result:" + result);
        result = arithmeticCalculator.div(21, 2);
        System.out.println("result:" + result);
        
    }
    
}