Spring5 AOP(三)

一、什么是AOP

面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里添加新功能

二、AOP的的底层实现

2.1 有两种动态代理

• 有接口实现，JDK的动态代理

• 没有接口实现，CGLIB动态代理实现

2.2 JDK的动态代理

方法有三个参数：

• 第一个参数：类加载器
• 第二个参数：增强方法所在类的接口，支持多个接口
• 第三个参数：实现接口InvocationHandler 创建代理对象，写增强的部分

接下来用代码实现动态代理

首先做准备工作，写一个接口和该接口的实现类

public interface Jdk {
    void add(int a,int b);
    int sub(int a,int b);
}

public class JdkImpl implements Jdk {
    @Override
    public void add(int a, int b) {
        System.out.println(a+b);
    }

    @Override
    public int sub(int a, int b) {
        return a-b;
    }
}

一个动态代理类中要用到一个InvocationHandler接口的实现类，来提供增强，所以我们先把这个实现类和增强的功能写出来，里面提供一个构造方法，把原始类存放进去

package com.bin.spring5.aop.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JdkProxy {
    public static void main(String[] args) {
        Class[] inte = {Jdk.class};
        //创建接口实现类代理对象，此方法使用匿名内部类实现，
//        Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), inte, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        JdkImpl jdkImpl = new JdkImpl();
        Jdk jdk = (Jdk)Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), inte, new JdkDl(jdkImpl));
        jdk.add(1,2);
        jdk.sub(2,1);
    }

}

2.3 AOP的专业术语

• 连接点：类中可以被增强的方法
• 切入点：实际被增强的方法
• 通知/增强：实际增强的逻辑部分称为通知
• 切面（动作）：把通知应用到切入点的过程

通知的五种类型

• 前置通知
• 后置（返回）通知
• 环绕通知
• 异常通知
• 最终通知

2.4 AOP的操作

Spring框架一般是基于AspectJ实现AOP操作，AspectJ是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

基于AspectJ实现AOP操作 引入aop的包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>

2.4.1 切入点表达式

切入点表达式作用：知道对哪个类的哪个方法进行增强

语法结构： execution([权限修饰符][返回类型][类全路径][方法名] ([参数列表])) ；注:除返回类型，方法名，参数列表，其他可省略。

常用写法举例：execytion(* com.bin.dao.UserDao.add(..))

2.4.2 AOP基于注解的实例

创建实体类

@Component
public class Role {
    public void add(){
        System.out.println("add");
    }
}

创建AOP代理类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class RoleProxy {
    //前置通知
    @Before("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void before(){
        System.out.println("before..");
    }
    //最终通知
    @After("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void after(){
        System.out.println("after..");
    }
    //后置通知
    @AfterReturning("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void aroundReturnIng(){
        System.out.println("afterReturning..");
    }
    //异常通知
    @AfterThrowing("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void afterThrowing(){
        System.out.println("aroundThrowing..");
    }
    //环绕通知
    @Around("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("aroundPre..");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("aroundPost..");
    }
}

配置文件加入

<?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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-cop.xsd">
<!--开启注自动扫描-->
    <context:component-scan base-package="com.bin.spring5"></context:component-scan>
<!--  开启自动生成代理对象  -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

或者 springConfig上新增注解@EnableAspectJAutoProxy（本文采用该方式）

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

@Component
@Configuration//声明是一个配置类
@EnableAspectJAutoProxy//开启自动生成代理
@ComponentScan(basePackages = "com.bin.spring5")//需要扫的包
public class SpringConfig {
}

测试执行

    @org.junit.Test
    public void aop(){
        ApplicationContext applicationContext =new AnnotationConfigApplicationContext(SpringConfig.class);
        Role role =(Role) applicationContext.getBean("role");
        role.add();
    }

输出结果

aroundPre..
before..
add
aroundPost..
after..
afterReturning..

异常通知没有执行 修改add方法

public void add(){
        System.out.println("add"+1/0);
    }

执行之后的结果可以发现环绕通知后置通知和后置通知没有出现

aroundPre..
before..
after..
aroundThrowing..

2.4.3公共的切入点提取

提取

    //提取切入点
    @Pointcut("execution(* com.bin.spring5.aop.anno.Role.add(..))")
    public void pointdemo(){}

    //前置通知
    @Before("pointdemo()")//引用切入点
    public void before(){
        System.out.println("before..");
    }

2.4.4 多个增强类设置优先级

• 在增强类上添加注解@Order(int),int越小优先级越高