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;
     }
     */
 
 }

方法三：利用Spring AOP AspectJ实现为方法添加日志

 <?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>

beans-aop.xml

 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);
 
     }
 
 }

测试类