一、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();
    }
}