AOP 面向切面的编程

　　一、面向切面的编程需求的产生

1. 1. 代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。
   2. 代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。

　　二、实现面向切面的编程

1. 1. 将需要实现AOP的类注入到Spring容器中，例如：

      package com.neuedu.aop;
      
      import org.springframework.stereotype.Component;
      
      @Component
      public class RawCaculator implements MathCaculator{
      
          @Override
          public int add(int i, int j) {
              int rs=i+j;
              System.out.println(i+"+"+j+"="+rs);
              return rs;
          }
      
          @Override
          public int sub(int i, int j) {
              int rs=i-j;
              System.out.println(i+"-"+j+"="+rs);
              return rs;
          }
      
          @Override
          public int mul(int i, int j) {
              int rs=i*j;
              System.out.println(i+"*"+j+"="+rs);
              return rs;
          }
      
          @Override
          public int div(int i, int j) {
              int rs=i/j;
              System.out.println(i+"/"+j+"="+rs);
              return rs;
          }
      
      }

   2. 实现切面类
      1. 使用前置通知、后置通知、返回通知、异常通知实现切面类，注入到Spring容器中

         package com.neuedu.aop;
         
         import static org.hamcrest.CoreMatchers.nullValue;
         
         import java.util.Arrays;
         import java.util.List;
         
         import org.aspectj.lang.JoinPoint;
         import org.aspectj.lang.ProceedingJoinPoint;
         import org.aspectj.lang.Signature;
         import org.aspectj.lang.annotation.After;
         import org.aspectj.lang.annotation.AfterReturning;
         import org.aspectj.lang.annotation.AfterThrowing;
         import org.aspectj.lang.annotation.Around;
         import org.aspectj.lang.annotation.Aspect;
         import org.aspectj.lang.annotation.Before;
         import org.springframework.core.annotation.Order;
         import org.springframework.stereotype.Component;
         
         @Component
         //@Aspect表明当前类是一个切面类
         @Aspect
         //@Order表示切面执行顺序，value值越小优先级越高
         @Order(value=50)
         public class CaculatorAspect {
                 @Before(value = "execution(public int com.neuedu.aop.RawCaculator.*(int, int))")
                 public void showBeginLog(JoinPoint point){
                     //System.out.println("【日志】【前置通知】");
                     //获得参数列表：
                     Object[] args = point.getArgs();
                     List<Object> asList = Arrays.asList(args);
                     //获得方法名：
                     Signature signature = point.getSignature();
                     String name = signature.getName();
                     System.out.println("【日志】【前置通知】 目标方法名为："+name+"参数为："+asList);
                 }
                 @AfterThrowing(value = "execution(public int com.neuedu.aop.RawCaculator.*(..))" ,throwing="ex")
                 public void showThrowing(JoinPoint point,Exception ex){
                     //System.out.println("【日志】【异常通知】");
                     System.out.println("【日志】【异常通知】 异常信息："+ex);
                 }
                 @After(value = "execution(public int com.neuedu.aop.RawCaculator.*(..))")
                 public void showAfter(){
                     System.out.println("【日志】【后置通知】");
                 }
                 @AfterReturning(value = "execution(* * .*(..))",returning="result")
                 public void showAfterReturning(JoinPoint point,Object result){
                     //System.out.println("【日志】【返回通知】");
                     System.out.println("【日志】【返回通知】 目标方法的返回值为"+result);
                 }
             }

　　　　　　　　　　 使用黄色背景标注的代码是声明的通知，其中包括通知类型和切入点表达式，以下就是对通知类型的介绍，切入点表达式在最后

　　　　　　　　　　　　@Before  前置通知：在方法执行之前执行的通知

　　　　　　　　　　　　@After　后置通知：后置通知是在连接点完成之后执行的，即连接点返回结果或者抛出异常的时候

　　　　　　　　　　　　@AfterReturning   返回通知：

• • • • • 无论连接点是正常返回还是抛出异常，后置通知都会执行。如果只想在连接点返回的时候记录日志，应使用返回通知代替后置通知。
        • 在返回通知中访问连接点的返回值：
          • 在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。该属性的值即为用来传入返回值的参数名称
          • 必须在通知方法的签名中添加一个同名参数。在运行时Spring AOP会通过这个参数传递返回值
          • 原始的切点表达式需要出现在pointcut属性中　

　　　　　　　　　　　　@AfterThrowing　异常通知：只在连接点抛出异常时才执行异常通知.：

• • • • 将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。
        • • 如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行

　　　　　　　　　　　

　　　　　　　　　　2.使用环绕通知实现切面类，注入到Spring容器中

 1　　 package com.neuedu.aop;

　　import java.util.Arrays;
　　import java.util.List;

　　import org.aspectj.lang.ProceedingJoinPoint;
　　import org.aspectj.lang.Signature;
　　import org.aspectj.lang.annotation.Around;
　　import org.aspectj.lang.annotation.Aspect;
　　import org.springframework.core.annotation.Order;
　　import org.springframework.stereotype.Component;

　　@Component
　　//@Aspect表明当前类是一个切面类
　　@Aspect
　　@Order(value=40)
　　　　public class secondAspect {
 　　   @Around(value = "execution(* * .*(..))")
  　　  public Object Around(ProceedingJoinPoint point){
  　　      Object result=null;
   　　     Object[] args = point.getArgs();
   　　     List<Object> asList = Arrays.asList(args);
  　　      Signature signature = point.getSignature();
  　　      String name = signature.getName();
  　　      try{
  　　          System.out.println("【事物日志】【前置通知】 目标方法名为："+name+"参数为："+asList);
   　　         try {
  　　              result=point.proceed(args);
   　　      　　   } finally{
        　　   　　     System.out.println("【事物日志】【后置通知】");
   　　        　　 }    
          　　  System.out.println("【事物日志】【返回通知】 目标方法的返回值为"+result);    
      　　  }catch (Throwable e) {
         　　   System.out.println("【事物日志】【异常通知】 异常信息："+e);
     　　   }
     　　   return result;
  　　  }
38　　 }

　　　　　　　　　　　　@Around  环绕通知：

• • • • • 环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。

        • 对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。

        • 在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。

        • 注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。

　　　　　

　　　　　　　3.实现测试类

package junit.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.neuedu.aop.MathCaculator;
import com.neuedu.aop.RawCaculator;

public class TestCaculator {

    @Test
    public void test() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //MathCaculator bean = ioc.getBean(RawCaculator.class);   不可用 （代表类 类型不一样）
        //rawCaculator即使使用注解时代表类的id；又是xml配置文件里的id
        MathCaculator bean = (MathCaculator) ioc.getBean("rawCaculator");
        bean.add(10, 5);
        System.out.println();
        bean.sub(14, 5);
        System.out.println();
        bean.mul(8, 7);
        System.out.println();
        bean.div(10, 0);
    }

}

　　

　　三、关于切入点表达式

　　　　1.作用：

　　　　　　通过表达式的方式定位一个或多个具体的连接点。

　　　　2.语法细节：

　　　　　　1）切入点表达式的语法格式：execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))

　　　　　　2）举例说明：

　　　　　　　　　　

表达式	execution(* com.atguigu.spring.ArithmeticCalculator.*(..))
含义	ArithmeticCalculator接口中声明的所有方法。 第一个“*”代表任意修饰符及任意返回值。 第二个“*”代表任意方法。 “..”匹配任意数量、任意类型的参数。 若目标类、接口与该切面类在同一个包中可以省略包名。

表达式	execution(public * ArithmeticCalculator.*(..))
含义	ArithmeticCalculator接口的所有公有方法

表达式	execution(public double ArithmeticCalculator.*(..))
含义	ArithmeticCalculator接口中返回double类型数值的方法

表达式	execution(public double ArithmeticCalculator.*(double, ..))
含义	第一个参数为double类型的方法。 “..” 匹配任意数量、任意类型的参数。

表达式	execution(public double ArithmeticCalculator.*(double, double))
含义	参数类型为double，double类型的方法

　　　　3.重用切入点：

　　　　　　1）

• • • 在编写AspectJ切面时，可以直接在通知注解中书写切入点表达式。但同一个切点表达式可能会在多个通知中重复出现

    • 在Aspect切面中，可以通过@Pointcut注解将一个切入点声明成简单的方法。切入点的方法体通常是空的，因为将切入点定义与应用程序逻辑混在一起是不合理的。　
    • 切入点方法的访问控制符同时也控制着这个切入点的可见性。如果切入点要在多个切面中共用，最好将它们集中在一个公共的类中。在这种情况下，它们必须被声明为public。在引入这个切入点时，必须将类名也包括在内。如果类没有与这个切面放在同一个包中，还必须包含包名。　　

　　　　　　2）示例代码：

 1　　 @Component
 2　　 //@Aspect表明当前类是一个切面类
　　@Aspect
 4　　 //@Order表示切面执行顺序，value值越小优先级越高
 5　　 @Order(value=50)
 6　　 public class CaculatorAspect {
　　        //重用切入点
　　        @Pointcut("execution(* * .*(..))")
　　        private void LoggingOperation(){
　　            
 　　       }
 　　       @Before(value = "LoggingOperation()")
 　　       public void showBeginLog(JoinPoint point){
    　　        //获得参数列表：
       　　     Object[] args = point.getArgs();
          　　  List<Object> asList = Arrays.asList(args);
  　　          //获得方法名：
     　　       Signature signature = point.getSignature();
        　　    String name = signature.getName();
           　　 System.out.println("【日志】【前置通知】 目标方法名为："+name+"参数为："+asList);
　　        }
   　　     @AfterThrowing(value = "LoggingOperation()" ,throwing="ex")
      　　  public void showThrowing(JoinPoint point,Exception ex){
         　　   System.out.println("【日志】【异常通知】 异常信息："+ex);
　　        }
   　　     @After(value = "LoggingOperation()")
      　　  public void showAfter(){
         　　   System.out.println("【日志】【后置通知】");
29　　         }
  　　      @AfterReturning(value = "LoggingOperation()",returning="result")
     　　   public void showAfterReturning(JoinPoint point,Object result){
        　　    System.out.println("【日志】【返回通知】 目标方法的返回值为"+result);
  　　      }
 　　   }