spring（三）：Spring的AOP

一、AOP

1.1 什么是AOP

AOP： 全称是 Aspect Oriented Programming，即： 面向切面编程。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.2 AOP的作用

在程序运行期间，不修改源码对已有方法进行增强。

优势

• 减少代码重复
• 提高开发效率
• 维护方便

二、动态代理

2.1 动态代理特点

字节码随用随创建，随用随加载。

它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。

装饰者模式就是静态代理的一种体现。

2.2 基于接口的动态代理

2.2.1 概念

1.涉及的类：Proxy

• 提供者：JDK官方

2.如何创建代理对象

• 使用Proxy类中的newProxyInstance方法

3.创建代理对象的要求

• 被代理类至少实现一个接口，如果没有则不能使用

4.newProxyInstance方法的参数：

• 1、ClassLoader 类加载器

  •   用于加载代理对象字节码，代理谁就写谁.getClass().getClassLoader(),固定写法
    

• 2、Class[] 字节码数组

  •   代理谁就写谁.getClass().getInterfaces(),固定写法
    

• 3、InvocationHandler 用于提供增强的代码

  •   它是让我们写如何代理，我们一般都是写一个该接口的实现类
    

  •   通常是匿名内部类，但不是必须的
    

  •   此接口的实现类都是谁用谁写
    

2.2.2 代码实现

1.创建一个生产者接口和其实现类

可以将其看成一个工厂，负责生产和售后

package proxy;

/**
 * @author konley
 * @date 2020-08-18 20:42
 * 对生产厂家要求的接口
 */
public interface IProducer {
    /**
     * description: 销售
     *
     * @param money
     * @return void
     */
    public void saleProduct(float money);

    /**
     * description: 售后
     *
     * @param money
     * @return void
     */
    public void afterService(float money);
}

package proxy;

/**
 * @author konley
 * @date 2020-08-18 20:40
 * 一个生产者
 */
public class Producer implements IProducer{
    /**
     * description: 销售
     * @param money
     * @return void
     */
    @Override
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }

    /**
     * description: 售后
     * @param money
     * @return void
     */
    @Override
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱"+money);
    }
}

2.创建一个消费者测试类

package proxy;

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

/**
 * @author konley
 * @date 2020-08-18 20:45
 * 模拟一个消费者，和一个基于接口的代理
*/
public class Client {
    public static void main(String[] args) {
        //注意这里需要final修饰，因为它被匿名内部类所访问
        final Producer producer = new Producer();
        //创建一个代理，增强producer
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    /**
                     * description: 执行被代理对象的任何接口方法都会经过该方法
                     * @param proxy 代理对象的引用
                     * @param method 当前执行的方法
                     * @param args 当前执行方法所需的参数
                     * @return java.lang.Object 和被代理对象方法有相同的返回值
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;
                        //1.获取方法执行的参数
                        Float money = (Float)args[0];
                        //2.判断当前是不是销售
                        String sale = "saleProduct";
                        if(sale.equals(method.getName())){
                            //中间商赚差价
                            returnValue = method.invoke(producer,money*0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(5999f);
    }
}

2.4 基于子类的动态代理

2.4.1 概念

一、基于子类的动态代理

• 涉及到的类：Enhancer
• 提供者：第三方库 cglib

二、如何创建代理对象：

• 使用Enhancer类中的create方法

三、创建代理对象的要求：

• 被代理类不能是最终类，即不能用final修饰

四、create方法的参数

• Class 字节码

  •   它用于指定被代理对象的字节码，被代理对象.getClass()
    

• Callback 用于提供增强的代码

  •   它是让我们写如何代理，我们一般都是写一个该接口的实现类
    

  •   通常是匿名内部类，但不是必须的
    

  •   此接口的实现类都是谁用谁写
    

  •   我们一般写的是**该接口的子接口实现类 MethodInterceptor**
    

2.4.2 代码实现

1.导入cglib依赖

<dependencies>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

2.创建一个生产者实现类

此时不需要接口了

package cglib;

import proxy.IProducer;

/**
 * @author konley
 * @date 2020-08-18 20:40
 * 一个生产者，此时不实现接口
 */
public class Producer {
    /**
     * description: 销售
     * @param money
     * @return void
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }

    /**
     * description: 售后
     * @param money
     * @return void
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱"+money);
    }
}

3.创建一个消费者测试类

package cglib;

import com.sun.org.apache.bcel.internal.generic.FALOAD;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import proxy.IProducer;

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

/**
 * @author konley
 * @date 2020-08-18 20:45
 * 模拟一个消费者，和一个基于子类的代理
 */
public class Client {
    public static void main(String[] args) {
        //创建一个生产者，这里不能用final
        Producer producer = new Producer();
        Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * description: 执行被代理对象的任何方法都会经过该方法
             * @param o 代理对象的引用
             * @param method 方法
             * @param objects 参数
             * @param methodProxy 当前执行方法的代理方法（套娃）
             * @return java.lang.Object
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //执行正确的代码
                Object returnValue = null;
                //1.获取方法的执行参数
                float money = (Float)objects[0];
                String sale = "saleProduct";
                if(sale.equals(method.getName())){
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(10000f);
    }
}

三、Spring的AOP

3.1 AOP相关术语

• Joinpoint：连接点
  • 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点
  • 即该类的方法
• Pointcut：切入点
  • 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
  • 即连接点中，需要增强的方法（点）
• Advice：通知/增强
  • 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知 ,通知的类型有前置通知,后置通知,异常通知,最终通知,环绕通知
  • 即要如何增强，怎么增强
• Introduction：引介
  • 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
• Target：目标对象
  • 代理的目标对象
• Weaving：织入
  • 是指把增强应用到目标对象来创建新的代理对象的过程
  • spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入
• Proxy：代理
  • 一个类被 AOP 织入增强后，就产生一个结果代理类
• Aspect：切面
  • 是切入点和通知（引介）的结合

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3.2 环境搭建

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
</dependencies>

3.3 基于XML的AOP实现

3.3.1 创建业务层接口和实现类

package service;

/**
 * @author konley
 * @date 2020-08-18 23:01
 * 账户的业务层接口
 */
public interface IAccountService {
    /**
     * description: 模拟保存账户
     * @return void
     */
    void saveAccount();

    /**
     * description: 模拟更新账户
     * @param i
     * @return void
     */
    void updateAccount(int i);

    /**
     * description: 删除账户
     * @return int
     */
    int deleteAccount();
}

package service.impl;

import service.IAccountService;

/**
 * @author konley
 * @date 2020-08-18 23:03
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    @Override
    public void saveAccount() {
        //int i = 1/0;此时没有后置通知，只有异常通知
        System.out.println("执行了保存");
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新:"+i);
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

3.3.2 创建代理类

这里模拟写日志

package utils;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author konley
 * @date 2020-08-18 23:05
 * 记录日志的工具类，使用了四种通知类型
 */
public class Logger {
    /**
     * description: 前置通知
     * @return void
     */
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了...");
    }
    /**
     * description: 后置通知
     * @return void
     */
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了...");
    }

    /**
     * description: 异常通知
     * @return void
     */
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了...");
    }

    /**
     * description: 最终通知
     * @return void
     */
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了...");
    }

    /**
     * description: 环绕通知
        spring为我们提供了一个接口：ProceedingJoinPoint
        proceed()，此方法相当于明确调用切入点方法
        该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会提供实现类
     它是spring框架为我们提供的一种可以在代码中手动控制增强方法，而不用一个一个去xml配置
     * @return Object
     */
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            //得到切入点方法所需的参数
            Object[] args = pjp.getArgs();
            System.out.println("前置通知：Logger类中的aroundPrintLog方法开始记录日志了...");
            //调用业务层方法（切入点方法）
            rtValue = pjp.proceed(args);
            System.out.println("后置通知：Logger类中的aroundPrintLog方法开始记录日志了...");
        }catch (Throwable throwable) {
            System.out.println("异常通知：Logger类中的aroundPrintLog方法开始记录日志了...");
            throwable.printStackTrace();
        } finally {
            System.out.println("最终通知：Logger类中的aroundPrintLog方法开始记录日志了...");
        }
        return rtValue;
    }
}

3.3.3 xml配置

1. 使用 <aop:config> 标签表明开始AOP的配置

2. 使用 <aop:aspect> 标签表明配置切面

   1. id属性：给切面一个唯一标志
   2. ref属性：指定通知类bean的id

3. 在 <aop:aspect> 标签的内部使用对应标签来配置通知的类型

   1. method属性：用于指定Logger类中哪个方法是某通知
   2. pointcut属性：用于指定切入点表达式，指的是对业务层哪些方法进行增强

切入点表达式写法：

切入点表达式写法：
	关键字：execution（表达式）
	表达式：访问修饰符 返回值 包名...类名.方法名（参数列表）
	
	标准表达式写法：
		public void service.impl.AccountServiceImpl.saveAccount()
	访问修饰符可以省略
		void service.impl.AccountServiceImpl.saveAccount()
	返回值可以使用通配符，表示任意返回值
    	* service.impl.AccountServiceImpl.saveAccount()
	包名可以使用通配符表示任意包，有几级包就要写几个*.
		* *.*.AccountServiceImpl.saveAccount()
	包名可以使用..表示当前包及其子包
		* *..AccountServiceImpl.saveAccount()
	类名和方法名都可以使用通配符实现通配
		* *..*.saveAccount()
		* *..AccountServiceImpl.*()
参数列表
	可以直接写数据类型
	基本类型写名称 int
		* *..AccountServiceImpl.*(int)
	引用类型写包名.类名的方式 java.lang.String
		* *..AccountServiceImpl.*(java.lang.String)
	可以使用通配符，表示必须要有参数
		* *..AccountServiceImpl.*(*)
	可以使用..代表所有参数的情况
		* *..AccountServiceImpl.*(..)
	全通配写法：
		* *..*.*.*(..)
	实际开发中切入点表达式的通常写法
	切到业务层实现类下的所有方法
		* service.impl.*.*(..)

示例

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


    <!--配置spring的ioc，把service对象配置进来-->
    <bean id="accountService" class="service.impl.AccountServiceImpl"></bean>

    <!--1.把通知的bean也交给spring来管理-->
    <bean id="logger" class="utils.Logger"></bean>

    <!--2.使用aop:config标签表明开始AOP的配置-->
    <aop:config>
        <!--配置切入点表达式：简化通知的pointcut，在通知标签里用pointcut-ref配置
                id属性 用于指定表达式的唯一标识
                expression属性 用于指定表达式内容
                必须在切面之前使用
        -->
        <aop:pointcut id="pt1" expression="execution(* service.*.*(..))"/>

        <!--3.使用aop:aspect标签表明配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置前置通知 在切入点方法执行之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"/>

            <!--配置后置通知 在切入点方法正常执行之后执行-->
            <aop:after method="afterReturningPrintLog" pointcut-ref="pt1"/>

            <!--配置异常通知 在切入点方法产生异常之后执行-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"/>

            <!--配置最终通知 不管切入点方法是否正常执行都会执行 -->
            <aop:after-returning method="afterPrintLog" pointcut-ref="pt1"/>

            <!--配置环绕通知 相当于增强通知-->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

</beans>

3.3.4 测试类

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

/**
 * @author konley
 * @date 2020-08-18 23:26
 * 测试AOP配置
 */
public class AOPTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        IAccountService as = app.getBean("accountService", IAccountService.class);
        as.saveAccount();
        as.updateAccount(1);
        as.deleteAccount();
    }
}

3.4 基于注解的AOP实现

3.3.1 创建业务层接口和实现类

package service;

/**
 * @author konley
 * @date 2020-08-18 23:01
 * 账户的业务层接口
 */
public interface IAccountService {
    /**
     * description: 模拟保存账户
     * @return void
     */
    void saveAccount();

    /**
     * description: 模拟更新账户
     * @param i
     * @return void
     */
    void updateAccount(int i);

    /**
     * description: 删除账户
     * @return int
     */
    int deleteAccount();
}

package service.impl;

import org.springframework.stereotype.Service;
import service.IAccountService;

/**
 * @author konley
 * @date 2020-08-18 23:03
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新:"+i);
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

3.3.2 创建代理类

package utils;

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

/**
 * @author konley
 * @date 2020-08-18 23:05
 * 记录日志的工具类，提供了公共的代码
 * 注解建议使用环绕通知
 */
@Component("logger")
//表示当前类是一个切面
@Aspect
public class Logger {
    /**
     * description:配置切点表达式
     */
    @Pointcut("execution(* service.impl.*.*())")
    private void  pt1(){
    }

    /**
     * description: 前置通知
     * @return void
     */
    @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了...");
    }
    /**
     * description: 后置通知
     * @return void
     */
    @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了...");
    }

    /**
     * description: 异常通知
     * @return void
     */
    @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了...");
    }

    /**
     * description: 最终通知
     * @return void
     */
    @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了...");
    }

    /**
     * description: 环绕通知
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            //得到切入点方法所需的参数
            Object[] args = pjp.getArgs();
            System.out.println("前置通知：Logger类中的aroundPrintLog方法开始记录日志了...");
            //调用业务层方法（切入点方法）
            rtValue = pjp.proceed(args);
            System.out.println("后置通知：Logger类中的aroundPrintLog方法开始记录日志了...");
        }catch (Throwable throwable) {
            System.out.println("异常通知：Logger类中的aroundPrintLog方法开始记录日志了...");
            throwable.printStackTrace();
        } finally {
            System.out.println("最终通知：Logger类中的aroundPrintLog方法开始记录日志了...");
        }
        return rtValue;
    }
}

3.3.3 在xml配置文件中开启注解

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

    <!--1.开启注解扫描-->
    <context:component-scan base-package="service,utils"></context:component-scan>

    <!--2.配置开启spring注解AOP支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

3.3.4 测试类

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

/**
 * @author konley
 * @date 2020-08-18 23:26
 * 测试AOP配置
 */
public class AOPTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        IAccountService as = app.getBean("accountService", IAccountService.class);
        as.saveAccount();
        as.updateAccount(1);
        as.deleteAccount();
    }
}