AspectJ和AOP细节

AspectJ
1、 简介
　　AspectJ：Java社区里最完整最流行的AOP框架。（在Spring中AOP是一种思想，而AspectJ是一种AOP的更明确具体实现）
　　在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
2、在Spring中启用AspectJ注解支持
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-aop-4.0.0.RELEASE.jar
 spring-aspects-4.0.0.RELEASE.jar
2) 引入aop名称空间

3) 配置

<!-- 配置扫描包 -->
 <context:component-scan base-package="com.atguigu.spring.aop"></context:component-scan>
<!-- 开启aspectJ的自动代理功能 -->
    <aop:aspectj-autoproxy />

当Spring IOC容器侦测到bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动为 与AspectJ切面匹配的bean创建代理

 用AspectJ注解声明切面
1) 要在Spring中声明AspectJ切面，只需要在IOC容器中将切面声明为bean实例。
2) 当在Spring IOC容器中初始化AspectJ切面之后，Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。
3) 在AspectJ注解中，切面只是一个带有@Aspect注解的Java类，它往往要包含很多通知。
4) 通知是标注有某种注解的简单的Java方法。
5) AspectJ支持5种类型的通知注解：
　　① @Before：前置通知，在方法执行之前执行
　　② @After：后置通知，在方法执行之后执行
　　③ @AfterRunning：返回通知，在方法返回结果之后执行
　　④ @AfterThrowing：异常通知，在方法抛出异常之后执行
　　⑤ @Around：环绕通知，围绕着方法执行

AOP细节

切入点表达式
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）在AspectJ中，切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来。
表达式    execution (* *.add(int,..)) || execution(* *.sub(int,..))
含义      任意类中第一个参数为int类型的add方法或sub方法
表达式    !execution (* *.add(int,..)) 
含义      匹配不是任意类中第一个参数为int类型的add方法

3、切入点表达式应用到实际的切面类中

当前连接点细节

1、概述
　　切入点表达式通常都会是从宏观上定位一组方法，和具体某个通知的注解结合起来就能够确定对应的连接点。那么就一个具体的连接点而言，我们可能会关心这个连接点的一些具体信息，例如：当前连接点所在方法的方法名、当前传入的参数值等等。这些信息都封装在JoinPoint接口的实例对象中。
2、JoinPoint
通知

1、 概述
　　1) 在具体的连接点上要执行的操作。
　　2) 一个切面可以包括一个或者多个通知。
　　3) 通知所使用的注解的值往往是切入点表达式。
2、 前置通知
　　1) 前置通知：在方法执行之前执行的通知
　　2) 使用@Before注解
3、后置通知
　　1) 后置通知：后置通知是在连接点完成之后执行的，即连接点返回结果或者抛出异常的时候
　　2) 使用@After注解
4、返回通知
　　1) 返回通知：无论连接点是正常返回还是抛出异常，后置通知都会执行。如果只想在连接点返回的时候记录日志，应使用返回通知代替后置通知。
　　2) 使用@AfterReturning注解,在返回通知中访问连接点的返回值
 　　　　①在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。该属性的值即为用来传入返回值的参数名称
 　　　　②必须在通知方法的签名中添加一个同名参数。在运行时Spring AOP会通过这个参数传递返回值
 　　　　③原始的切点表达式需要出现在pointcut属性中
5、异常通知
　　1) 异常通知：只在连接点抛出异常时才执行异常通知
　　2) 将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。
　　3) 如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行
6、环绕通知
　　1) 环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
　　2) 对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。
　　3) 在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。
　　4) 注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。

package com.atguigu.spring.aop;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
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.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect//标注当前类为切面
public class MyloggerAspect {
    

    /**
     * @Before:将方法指定为前置通知
     * 必须设置value，其值为切入点表达式：找到切面作用到的连接点
     * 前置通知：作用于方法执行之前
     * @Before(value="execution(* com.atguigu.spring.aop.*.*(..))")
     * 第一个*代表任意的访问修饰符和返回值类型
     * 第二个*代表任意类
     * 第三个*代表类中任意方法
     * ..代表任意的参数列表
     */
    @Before(value = "execution(public int com.atguigu.spring.aop.MathImpl.add(int, int))")
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();//获取方法的参数
        String methodName = joinPoint.getSignature().getName();//获取方法名
        System.out.println("method:"+methodName+",arguments:"+Arrays.toString(args));
    }
    
    /**
     * @After:将方法标注为后置通知
     * 后置通知：作用于方法的finally语句块，即不管有没有异常都会执行
     */
    @After(value="execution(* com.atguigu.spring.aop.*.*(..))")
    public void afterMethod() {
        System.out.println("后置通知");
    }
    
    /**
     * @AfterReturning:将方法标注为返回通知
     * 返回通知：作用于方法执行之后
     * 可通过returning设置接收方法返回值的变量名
     * 要想在方法中使用，必须在方法的形参中设置和变量名相同的参数名的参数
     */
    @AfterReturning(value="execution(* com.atguigu.spring.aop.*.*(..))", returning="result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("method:"+methodName+",result:"+result);
    }
    
    /**
     * @AfterThrowing:将方法标注为异常通知（例外通知）
     * 异常通知（例外通知）:作用于方法抛出异常时
     * 可通过throwing设置接收方法返回的异常信息
     * 在参数列表中课通过具体的异常类型，来对指定的异常信息进行操作
     */
    @AfterThrowing(value="execution(* com.atguigu.spring.aop.*.*(..))", throwing="ex")
    public void afterThrowingMethod(ArithmeticException ex) {
        System.out.println("有异常了，messages："+ex);
    }
    
    //环绕通知
    @Around(value="execution(* com.atguigu.spring.aop.*.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) {
        
        Object result = null;
        
        try {
            //前置通知
            System.out.println("前置通知");
            result = joinPoint.proceed();//执行方法
            //返回通知
            System.out.println("返回通知");
            return result;
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            //异常通知
            System.out.println("异常通知");
        } finally {
            //后置通知
            System.out.println("后置通知");
        }
        
        return -1;
    }
}
package com.atguigu.spring.aop;

import org.springframework.stereotype.Component;

@Component   //都应该交由Spring处理
public class MathImpl implements MathI {

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

    
    
}
package com.atguigu.spring.aop;

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

public class Test {

    public static void main(String[] args) {
        
        ApplicationContext ac = new ClassPathXmlApplicationContext("aop.xml");
        MathI math = ac.getBean("mathImpl", MathI.class);
        System.out.println(math.getClass().getName());
        int i = math.div(4, 1);
        System.out.println(i);
        
    }
    
}

重用切入点定义
　　1) 在编写AspectJ切面时，可以直接在通知注解中书写切入点表达式。但同一个切点表达式可能会在多个通知中重复出现。
　　2) 在AspectJ切面中，可以通过@Pointcut注解将一个切入点声明成简单的方法。切入点的方法体通常是空的，因为将切入点定义与应用程序逻辑混在一起是不合理的。
　　3) 切入点方法的访问控制符同时也控制着这个切入点的可见性。如果切入点要在多个切面中共用，最好将它们集中在一个公共的类中。在这种情况下，它们必须被声明为public。在引入这个切入点时，必须将类名也包括在内。如果类没有与这个切面放在同一个包中，还必须包含包名。
　　4) 其他通知可以通过方法名称引入该切入点

指定切面的优先级
　　1) 在同一个连接点上应用不止一个切面时，除非明确指定，否则它们的优先级是不确定的。
　　2) 切面的优先级可以通过实现Ordered接口或利用@Order注解指定。
　　3) 实现Ordered接口，getOrder()方法的返回值越小，优先级越高。

　　4) 若使用@Order注解，序号出现在注解中

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/lemonzhang/p/12908862.html