Spring（三）--AOP【面向切面编程】、通知类型及使用、切入点表达式

1.概念：Aspect Oriented Programming 面向切面编程

在方法的前后添加方法

 

2.作用：本质上来说是一种简化代码的方式
     继承机制
     封装方法
     动态代理
     ……
    
3.情景举例
　　①数学计算器接口[MathCalculator]
          int add(int i,int j);
          int sub(int i,int j);
          int mul(int i, int j);

          int div(int i,int j);

 

因为后面的通知方法需要返回值，所以在这里类型声明为 int 类型

public interface MathCaculator {
      public int add(int i,int j);
      public int sub(int i,int j);
      public int mul(int i,int j);
      public int div(int i,int j);
}

 

　　 ②提供简单实现[EasyImpl]

 　　   一定要在类上写注解，否则在 IOC容器中找不到

 

@Component
public class CacultorEasyImpl implements MathCaculator{
      @Override
      public void add(int i, int j) {
            System.out.println("[日志]，【参数：】"+i+","+j);
            int result = i + j;
            System.out.println("[日志]，【参数：】"+i+","+j+"--"+result);
      }

      @Override
      public void sub(int i, int j) {
            System.out.println("[日志]，【参数：】"+i+","+j);
            int result = i - j;
            System.out.println("[日志]，【参数：】"+i+","+j+"--"+result);
      }

      @Override
      public void mul(int i, int j) {
            System.out.println("[日志]，【参数：】"+i+","+j);
            int result = i * j;
            System.out.println("[日志]，【参数：】"+i+","+j+"--"+result);
      }

      @Override
      public void div(int i, int j) {
            System.out.println("[日志]，【参数：】"+i+","+j);
            int result = i / j;
            System.out.println("[日志]，【参数：】"+i+","+j+"--"+result);
      }
}

<context:component-scan base-package="com.neuedu.aop"></context:component-scan>

　　③在简单实现的基础上让每一个计算方法都能够打印日志[LoginImpl]

private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
      CacultorEasyImpl bean = ioc.getBean(CacultorEasyImpl.class);
      bean.add(10, 2);
      bean.sub(10, 2);
      bean.mul(10, 2);
      bean.div(10, 2);
}

　　④缺陷
          [1]手动添加日志繁琐，重复
          [2]统一修改不便
          [3]对目标方法本来要实现的核心功能有干扰，使程序代码很臃肿，不易于开发维护
         
      ⑤使用动态代理实现
          [1]创建一个类，让这个类能够提供一个目标对象的代理对象
          [2]在代理对象中打印日志

 

4.AOP术语！[参见图例和doc文档]
      AOP概述
          ●AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论

            是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。

          ●参见图例和doc文档解释AOP的各个术语！
          ●Spring的AOP既可以使用xml配置的方式实现，也可以使用注解的方式来实现！

 

 

5.在Spring中使用AOP实现日志功能
　　①Spring中可以使用注解或XML文件配置的方式实现AOP。
　　②导入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
            commons-logging-1.1.3. jar
            spring-aop-4.0.0.RELEASE.jar
            spring-aspects-4.0.0.RELEASE.jar
            spring-beans-4.0.0.RELEASE.jar
            spring-context-4.0.0.RELEASE.jar
            spring-core-4.0.0.RELEASE.jar
            spring-expression-4.0.0.RELEASE. jar
           
　　③开启基于注解的AOP功能 < aop:aspectj-autoproxy />

<context:component-scan base-package="com.neuedu.aop"></context:component-scan>
<aop:aspectj-autoproxy/>

　　④声明一个切面类，并把这个切面类加入到 IOC容器中

　　　在类上加以下两个注解
          @Aspect  ：表示这是一个切面类
          @Component  ：加入IOC容器
         
　　⑤在切面类中声明通知方法
          [1] 前置通知：@Before
          [2] 返回通知：@AfterReturning
          [3] 异常通知：@AfterThrowing
          [4] 后置通知：@After
          [5] 环绕通知：@Around :环绕通知是前面四个通知的集合体！

 

@Component
@Aspect
public class CaculatorAspect {

      @Before(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showBeginLog(){
            System.out.println("日志开始");
      }

      @After(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showReturnLog(){
            System.out.println("日志正常返回");
      }

      @AfterThrowing(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showExceptionLog(){
            System.out.println("日志有错");
      }

      @AfterReturning(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showAfterLog(){
            System.out.println("日志最终结束");
      }
}

　　⑥被代理的对象也需要加入IOC容器

@Component
public class RawCaculatorImpl implements MathCaculator{

      @Override
      public void add(int i, int j) {
            int result = i + j;
            System.out.println(i+"+"+j+"="+result);
      }

      @Override
      public void sub(int i, int j) {
            int result = i - j;
            System.out.println(i+"-"+j+"="+result);
      }

      @Override
      public void mul(int i, int j) {
            int result = i * j;
            System.out.println(i+"*"+j+"="+result);
      }

      @Override
      public void div(int i, int j) {
            int result = i / j;
            System.out.println(i+"/"+j+"="+result);
      }
}

　　Test 中 用 id 查找，通过强转，调用加减乘除四个方法

private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
      MathCaculator bean = (MathCaculator) ioc.getBean("rawCaculatorImpl");
      bean.add(10, 2);
      bean.sub(10, 2);
      bean.mul(10, 2);
      bean.div(10, 2);
}

6.切入点表达式：

（1）上述案例通过junit测试，会发现，我们调用目标类的四个方法只有add方法被加入了4个通知

        如果想所有的方法都加上这些通知，可以在切入点表达式处：

        将execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int)) 换成： execution(public int com.neuedu.aop.target.MathCalculatorImpl.*(int, int))

        这样只要是有两个参数，且参数类型为int的方法在执行的时候都会执行其相应的通知方法！

　　

@Component
@Aspect
public class CaculatorAspect {

      @Before(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showBeginLog(){
            System.out.println("日志开始");
      }

      @After(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showReturnLog(){
            System.out.println("日志正常返回");
      }

      @AfterThrowing(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showExceptionLog(){
            System.out.println("日志有错");
      }

      @AfterReturning(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showAfterLog(){
            System.out.println("日志最终结束");
      }

}

　　如果方法中的参数类型不一致，可以用 (..) 代替 (int,int)

@Component
@Aspect
public class CaculatorAspect {

     @Pointcut(value="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))")
     public void showLog(){}

      @Before(value="showLog()")
      public void showBeginLog(JoinPoint point){
            Object[] args = point.getArgs();//获取参数
            List<Object> asList = Arrays.asList(args);//转为list类型
            Signature signature = point.getSignature();//获取签名
            String name = signature.getName();//获取方法名字
            System.out.println("【前置通知】目标方法名："+name+"，参数为："+asList);
      }

      @After(value="showLog()")
      public void showReturnLog(){
            System.out.println("【后置通知】日志最终返回");
      }

      @AfterThrowing(value="showLog()",throwing="ex")
      public void showExceptionLog(JoinPoint point,Exception ex){
            System.out.println("【异常通知】异常信息为："+ex.getMessage());
      }

      @AfterReturning(value="showLog()",returning="result")
      public void showAfterLog(JoinPoint point,Object result){
            System.out.println("【返回通知】方法的返回值："+result);
            System.out.println();
      }
}

（2）①切入点表达式的语法格式[参见第5章AOP细节]

          execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))
    
       参见第5章AOP细节:演示验证
       1.任意参数，任意类型
       2.任意返回值
       3.用@PointCut注解统一声明,然后在其它通知中引用该统一声明即可！
          需要注意的是：权限是不支持写通配符的，当然你可以写一个*表示所有权限所有返回值！


     最详细的切入点表达式：
          execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))
     最模糊的切入点表达式：

          execution (* *.*(..))

          第一个 * 代表   权限和返回类型

     但是不可以 无权限却有返回类型   例如： execution(* int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))

 

7.统一声明切入点表达式
     @Pointcut(value= "execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))")
     public void myPointCut(){}
    
    
8.通知方法的细节
  　①在通知中获取目标方法的方法名和参数列表

          [1]在通知方法中声明一个JoinPoint类型的形参

               JointPoint 是切入点，

          [2]调用JoinPoint对象的getSignature()方法获取目标方法的签名
          [3]调用JoinPoint对象的getArgs()方法获取目标方法的实际参数列表

 

 

@Before(value="showLog()")
public void showBeginLog(JoinPoint point){
      Object[] args = point.getArgs();//获取参数
      List<Object> asList = Arrays.asList(args);//转为list类型
      Signature signature = point.getSignature();//获取签名
      String name = signature.getName();//获取方法名字
      System.out.println("目标方法名："+name+"，参数为："+asList);
      System.out.println("日志开始");
}

　　

　   ②在返回通知中获取方法的返回值

          [1]在 @AfterReturning   注解中添加returning属性

          [2]在返回通知的通知方法中声明一个形参，形参名和returning属性的值一致     

              不知道返回什么类型，所以用 Object 类型

              

@AfterReturning(value="showLog()",returning="result")
public void showAfterLog(JoinPoint point,Object result){
      System.out.println("方法的返回值："+result);
      System.out.println("日志正常结束");
      System.out.println();
}

　 

　  ③在异常通知中获取异常对象

          [1]在 @AfterThrowing 注解中添加 throwing 属性

          [2]在异常通知的通知方法中声明一个形参，形参名和throwing属性值一致

@AfterThrowing(value="showLog()",throwing="ex")
public void showExceptionLog(JoinPoint point,Exception ex){
      System.out.println("异常信息为："+ex.getMessage());
      System.out.println("日志有错");
}

 

9.根据接口类型获取target对象时，实际上真正放在IOC容器中的对象是代理对象，而并不是目标对象本身!


10.环绕通知:@Around
    1.环绕通知需要在方法的参数中指定JoinPoint的子接口类型ProceedingJoinPoint为参数
          @Around(value="pointCut()")
          public void around(ProceedingJoinPoint joinPoint){
          }
     2.环绕通知会将其他4个通知能干的，自己都给干了！

          注意:@Around修饰的方法一定要将方法的返回值返回！本身相当于代理！

                  但是不知道返回值的类型 ，所以用 Object 

 

@Around(value="execution(public * com.neuedu.aop.RawCaculatorImpl.*(..))")
public Object showLog(ProceedingJoinPoint point){
      Object[] args = point.getArgs();
      List<Object> asList = Arrays.asList(args);
      Signature signature = point.getSignature();//获取签名
      String name = signature.getName();
      Object result=null;
      try {     
            try{
                  System.out.println("【前置通知】目标方法名："+name+"，参数为："+asList);
                  result = point.proceed(args);
             }finally{
                  System.out.println("【后置通知】日志最终返回");
             }
             System.out.println("【返回通知】方法的返回值："+result);
       } catch (Throwable e) {
             System.out.println("【异常通知】异常信息为："+e.getMessage());
       }
       System.out.println();
       return result;
}

 

11.切面的优先级
     对于同一个代理对象，可以同时有多个切面共同对它进行代理。

     可以在切面类上通过@Order (value=50)注解来进行设置，值越小优先级越高!

     没有 @Order 注解默认最大

 

@Component
@Aspect
@Order(value=20)
public class BAspect {

      @Around(value="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))")
      public Object showLog(ProceedingJoinPoint point){
            Object[] args = point.getArgs();
            List<Object> asList = Arrays.asList(args);
            Signature signature = point.getSignature();//获取签名
            String name = signature.getName();
            Object result=null;
            try {
                  try{
                        System.out.println("【前置】目标方法名："+name+"，参数为："+asList);
                        result = point.proceed(args);
                  }finally{
                        System.out.println("【后置】日志最终返回");
                  }
                  System.out.println("【返回】方法的返回值："+result);
            } catch (Throwable e) {
                  System.out.println("【异常】异常信息为："+e.getMessage());
            }
            System.out.println();
            return result;
      }
}

12.注意:上面的AOP都是通过注解实现的，AOP实际上也可以通过xml配置的方式实现！

     将注解全删掉

 

<!-- 将需要加载到IOC容器中的bean配置好 -->
<bean id="caculatorAspect" class="com.neuedu.aop.CaculatorAspect"></bean>
<bean id="bAspect" class="com.neuedu.aop.BAspect"></bean>
<bean id="rawCaculatorImpl" class="com.neuedu.aop.RawCaculatorImpl"></bean>

<!-- 配置AOP,需要导入AOP名称空间 -->
<aop:config>
      <!-- 声明切入点表达式 -->
      <aop:pointcut expression="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))" id="myPointCut"/>
      <!-- 配置日志切面类,引用前面的类 ,通过order属性控制优先级-->
      <aop:aspect ref="caculatorAspect" order="20">
      <!-- 通过method属性指定切面类的切面方法，通过pointcut-ref指定切入点表达式 -->
             <aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
             <aop:after method="showAfterLog" pointcut-ref="myPointCut"/>
             <aop:after-returning method="showReturnLog" pointcut-ref="myPointCut" returning="result"/>
             <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="ex"/>
      </aop:aspect>
      <!-- 配置事务切面类,引用前面的类 -->
      <aop:aspect ref="bAspect" order="25">
            <aop:around method="showLog" pointcut-ref="myPointCut"/>
      </aop:aspect>

</aop:config>

需要知道的是：事务的管理是和AOP是有很大关系的,即声明式事务的底层是用AOP实现的！