Spring AOP入门知识点

Spring AOP基础学习

AOP 简介

• Eclipse AspectJ,一种基于Java平台的面向切面编程的语言
  Spring AOP使用AspectJWeaver实现类与方法匹配
  Spring AOP利用代理模式实现对象运行时功能扩展

• 关键概念：
  Aspect: 切面,具体的可插拔组件功能类,通常一个切面只实现一个通用功能
  Target Class/Method: 目标类、目标方法,指真正要执行与业务相关的方法
  PointCut: 切入点,使用execution表达式说明切面要作用在系统的哪些类上
  JoinPoint: 连接点,切面运行过程中是包含了目标类/方法元数据的对象
  Advice: 通知,说明具体的切面的执行时机,Spring包含了五种不同类型通知

• AOP 配置过程
  依赖AspectJ – pom.xml
  实现切面类/方法 – MethodAspect.java
  配置Aspect Bean – applicationContext.xml
  定义PointCut – applicationContext.xml
  配置Advice – applicationContext.xml

<dependency>
   <groupId>org.springframeworkgroupId>
   <artifactId>spring-contextartifactId>
   <version>5.2.6.RELEASEversion>
  dependency>

                <dependency>
                    <groupId>org.aspectjgroupId>
                    <artifactId>aspectjweaverartifactId>
                    <version>1.9.9.1version>
                dependency>
         
 
<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 https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

        <bean id="userDao" class="spring.aop.dao.UserDao"/>
        <bean id="employeeDao" class="spring.aop.dao.EmployeeDao"/>
        <bean id="userService" class="spring.aop.service.UserService">
            <property name="userDao" ref="userDao"/>
        bean>
        <bean id="employeeService" class="spring.aop.service.EmployeeService">
            <property name="employeeDao" ref="employeeDao"/>
        bean>

    
    <bean id="methodAspect" class="spring.aop.aspect.MethodAspect">bean>
        <aop:config>
            
            
            <aop:pointcut id="pointcut" expression="execution(public * spring.aop..*.*(..))"/>
            
            <aop:aspect ref="methodAspect">
                
                <aop:before method="printExecutionTime" pointcut-ref="pointcut"/>
            aop:aspect>
        aop:config>

beans>

// 切面类
public class MethodAspect {
    //切面方法，用于扩展额外功能
    //JoinPoint 连接点，通过连接点可以获取目标类/方法的信息
    public void printExecutionTime(JoinPoint joinPoint){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String now = sdf.format(new Date());
        String className = joinPoint.getTarget().getClass().getName(); // 获取目标类的名称
        String methodName = joinPoint.getSignature().getName(); // 获取目标方法名称
        System.out.println("---->" + now + ":" + className + "." + methodName);
    }
}

PointCut切点表达式

• execution(public * spring.aop..*.*(..))
  public: 为方法作用域，限制生效方法作用域的类型。
  *: 第一个星为返回值通配符，限制返回值的类型。
  spring.aop..:限制包的范围，在spring.aop包下的所有子包或者类，其中..为包通配符，意为所有的当前包下的或者子包中的类和方法。
  *:第二个星为类名通配符。
  *: 第三个星为方法名通配符。
  (..): 意为参数通配符，..是所有参数都可以，()是没有参数，(String,*)是有两个参数，并且第一个参数必须为String类型。

五种通知类型

• Before Advice: 前置通知,目标方法运行前执行
  After Returning Advice: 返回后通知,目标方法返回数据后执行
  After Throwing Advice: 异常通知,目标方法抛出异常后执行
  After Advic: 后置通知,目标方法运行后执行
  Around Advice: 最强大通知,自定义通知执行时机,可决定目标方法是否运行
  例子：

 <aop:before method="printExecutionTime" pointcut-ref="pointcut"/>

• 引介增强：引介增强(Introductionlnterceptor)是对类的增强,而非方法
  引介增强允许在运行时为目标类增加新属性或方法
  引介增强允许在运行时改变类的行为,让类随运行环境动态变更

环绕通知案例

• 查看方法的运行时长

public class MethodChecker {
    // ProceedingJoinPoint是JoinPoint的升级版，在原有功能外,还可以控制目标方法是否执行
    public Object check(ProceedingJoinPoint pjp) throws Throwable {
        try {
            long startTime = new Date().getTime();
            Object ret = pjp.proceed();// 执行目标方法, 返回值为目标方法的返回值
            long endTime = new Date().getTime();
            long duration = endTime - startTime; // 执行时长
            if(duration >= 1000){
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
                String now = sdf.format(new Date());
                String className = pjp.getTarget().getClass().getName(); // 获取目标类的名称
                String methodName = pjp.getSignature().getName(); // 获取目标方法名称
                System.out.println("---->" + now + ":" + className + "." + methodName + "("+ duration + ")");
            }
            return ret;
        } catch (Throwable throwable) {
            throw throwable;
        }
    }
}

    <bean id="methodChecker" class="spring.aop.aspect.MethodChecker">bean>
        <aop:config>
            
            
            <aop:pointcut id="pointcut" expression="execution(public * spring.aop..*.*(..))"/>
            
            <aop:aspect ref="methodChecker">
                <aop:around method="check" pointcut-ref="pointcut"/>
            aop:aspect>
        aop:config>

注解开发Spring AOP

<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 https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

@Component // 标记当前类为组件
@Aspect // 说明当前类是切面类

public class MethodChecker2 {
    // 环绕通知，参数为PointCut切点表达式
    @Around(value = "execution(* spring.aop..*Service.* (..))")

        // ProceedingJoinPoint是JoinPoint的升级版，在原有功能外,还可以控制目标方法是否执行
        public Object check(ProceedingJoinPoint pjp) throws Throwable {
            try {
                long startTime = new Date().getTime();
                Object ret = pjp.proceed();// 执行目标方法, 返回值为目标方法的返回值
                long endTime = new Date().getTime();
                long duration = endTime - startTime; // 执行时长
                if(duration >= 1000){
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
                    String now = sdf.format(new Date());
                    String className = pjp.getTarget().getClass().getName(); // 获取目标类的名称
                    String methodName = pjp.getSignature().getName(); // 获取目标方法名称
                    System.out.println("---->" + now + ":" + className + "." + methodName + "("+ duration + ")");
                }
                return ret;
            } catch (Throwable throwable) {
                throw throwable;
            }

        }
}

注：其他类要添加@Service和@Repository注解，属性要添加@Resource注解（和IoC注解使用方法相同）。

Spring AOP 实现原理–动态代理技术

• Spring基于代理类实现功能动态扩展,包含两种形式:
  目标类拥有接口,通过JDK动态代理实现功能扩展
  目标类没有接口,通过CGLib组件实现功能扩展
• CGLib是运行时字节码增强技术
  Spring AOP扩展无接口类使用CGLib
  AOP会运行时生成目标继承类字节码的方式进行行为扩展
  CGLib执行过程:
  生成代理类的二进制字节码文件
  加载二进制字节码，生成Class对象(Class.forName())
  通过反射机制获得实例构造，并创建代理类对象