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();
    }
}
posted @   konley  阅读(12)  评论(0)  编辑  收藏  举报
相关博文：
·  Spring学习 - 03 Spring AOP
·  spring（一）：概述与基于XML的IOC配置
·  Spring之AOP和事务管理
·  Spring-day03
·  Spring AOP快速上手
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
点击右上角即可分享
微信分享提示
AI IDE Trae