AOP细节

Posted TYD

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了AOP细节相关的知识,希望对你有一定的参考价值。

(aop所需的jar包http://www.cnblogs.com/TYDBLOG/p/7450059.html

 

切入点表达式

1.1 作用

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

1.2 语法细节

1.2.1切入点表达式的语法格式

execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))

1.2.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))

含义

参数类型为doubledouble类型的方法

 

1.2.3在AspectJ中,切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来。

表达式

execution (* *.add(int,..)) || execution(* *.sub(int,..))

含义

任意类中第一个参数为int类型的add方法或sub方法

2 通知

2.1 概述

  •  在具体的连接点上要执行的操作。
  •  一个切面可以包括一个或者多个通知。
  •  通知所使用的注解的值往往是切入点表达式。

2.2 前置通知

  •  前置通知:在方法执行之前执行的通知
  •  使用@Before注解

2.3 后置通知

  •  后置通知:后置通知是在连接点完成之后执行的,即连接点返回结果或者抛出异常的时候
  •  使用@After注解

2.4 返回通知

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

 

2.5 异常通知

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

 

2.6 环绕通知

  •  环绕通知是所有通知类型中功能最为强大的,能够全面地控制连接点,甚至可以控制是否执行连接点。
  •  对于环绕通知来说,连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口,允许控制何时执行,是否执行连接点。
  •  在环绕通知中需要明确调用ProceedingJoinPointproceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了,但目标方法没有被执行。
  •  注意:环绕通知的方法需要返回目标方法执行之后的结果,即调用 joinPoint.proceed();的返回值,否则会出现空指针异常。

2.7 代码示例

      写一个类实现加减乘除,并生成 前置通知、后置通知、返回通知、异常通知 或环绕通知

  2.7.1 配置文件:

      创建文件时勾选aop bean context三个选项

      

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
    <!-- 配置扫描的包 -->
    <context:component-scan base-package="com.tyd.spring.aop"></context:component-scan>
    <!-- 使用aop要创建此标签 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

 

  2.7.2 创建math接口以及方法实现类:

     

package com.tyd.spring.aop;

public interface Math {
    public void add(int a,int b);
    public void sub(int a,int b);
    public void mul(int a,int b);
    public void div(int a,int b);
    public void add(int a, int b,int c);
}

 

package com.tyd.spring.aop;

import org.springframework.stereotype.Component;

@Component
public class MyEpressionMath implements Math{
    @Override
    public void add(int a, int b) {
        int num=a+b;
        System.out.println(a+"+"+b+"="+num);
        
    }

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

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

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

    @Override
    public void add(int a, int b, int c) {
        System.out.println(a+"+"+b+c+"="+(a+b+c));
        
    }

}

  2.7.3使用前置通知、后置通知、返回通知、异常通知实现日志

package com.tyd.spring.aop;

 
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before; 
import org.springframework.stereotype.Component;


@Component
@Aspect  //表明是切面类
public class CaculatorAspect  {
    //value值为方法的全类名以及方法名:public void(访问权限及返回值类型)com.tyd.spring.aop.MyEpressionMath(全类名).*代表此类中所有方法(..)代表所有参数类型
    @Before(value="execution(public void com.tyd.spring.aop.MyEpressionMath.*(..))")
    public void showBegin(){
        System.out.println("【日志】【方法开始】");
    }
    @AfterReturning(value="execution(public void  com.tyd.spring.aop.MyEpressionMath.*(..))",returning="result")
    public void showAfter(){
        System.out.println("【日志】【方法正常结束】");
    }
    @AfterThrowing(value="execution(public void  com.tyd.spring.aop.MyEpressionMath.*(..))")
    public void showexception(){
        System.out.println("【日志】【方法出异常】");
    }
    @After(value="execution(public void com.tyd.spring.aop.MyEpressionMath.*(..))")
    public void showAfterRe(){
        System.out.println("【日志】【方法执行结束】");
    }
}

2.7.4环绕通知实现:

package com.tyd.spring.aop;

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

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.stereotype.Component;


@Component
@Aspect  //表明是切面类
public class CaculatorAspect  {
    
    
    @Around(value="execution(public void com.tyd.spring.aop.MyEpressionMath.*(..))")
    public Object around(ProceedingJoinPoint joinPoint){
        //获取目标方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("args:"+args);
        //获取签名
        Signature signature = joinPoint.getSignature();
        System.out.println("signature:"+signature);
        //获取方法名
        String methodName = signature.getName();
        System.out.println("methodName:"+methodName);
        List<Object> list = Arrays.asList(args);
        Object result = null;
        try {
            try{
                //目标方法之前要执行的操作
                System.out.println("[环绕日志]【前置通知】"+methodName+"开始了,参数为:"+list);
                //调用目标方法
                result = joinPoint.proceed(args);
                
                //目标方法正常执行之后的操作
                
            }finally{
                //方法最终结束时执行的操作!
                System.out.println("[环绕日志]【后置通知】"+methodName+"结束了!");
            }
            //目标方法正常执行之后的操作
            System.out.println("[环绕日志]【返回通知】"+methodName+"返回了,返回值为:"+result);        
        } catch (Throwable e) {
            //目标方法抛出异常信息之后的操作
            System.out.println("[环绕日志]【异常通知】"+methodName+"出异常了,异常对象为:"+e);
            throw new RuntimeException(e.getMessage());
        }finally{
            
            
        }
        return result;
    }

2.7.5测试代码

package com.tyd.spring.aop;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class text {

    @Test
    public void test() {
        
        ApplicationContext ioc=new ClassPathXmlApplicationContext("bean.xml");
        Math m=(Math) ioc.getBean("myEpressionMath");
        m.add(10, 10);
        System.out.println();
        m.div(10, 2);
        System.out.println();
        m.mul(20, 10);
        m.add(10, 10,10);
        //测试异常
        m.div(10, 0);
    }
}

 

以上是关于AOP细节的主要内容,如果未能解决你的问题,请参考以下文章

AOP细节

Android 逆向使用 Python 解析 ELF 文件 ( Capstone 反汇编 ELF 文件中的机器码数据 | 创建反汇编解析器实例对象 | 设置汇编解析器显示细节 )(代码片段

iOS架构:AOP实现局部模块化(附Demo)

spring中的AOP

Android TV - 在细节片段中失去焦点

使用Spring配置文件实现AOP