6、Spring中AOP的底层实现--动态代理

最新推荐文章于 2022-10-16 13:20:06 发布
最新推荐文章于 2022-10-16 13:20:06 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35798336/article/details/112466111
版权

1、基于一个用户account转账带来的思考

  1. domain层

    public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;

    public Integer getId() {return id;}
    public void setId(Integer id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Float getMoney() {return money;}
    public void setMoney(Float money) {this.money = money;}

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

  2. service层

    public interface IAccountService {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}

    
/**
 * 账户的业务层实现类
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;
    private TransactionManager txManager;
	//set方法，使用容器导入
    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }
	//set方法，使用容器导入
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }

    }
    
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作

            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);
            int i=1/0;
            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }
}

  3. utils层

    public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

    
/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 释放连接
     */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

  4. 配置文件

    <?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"
       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">

     <!-- 配置Service -->
    <bean id="accountService" class="com.chen.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/nba"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="com.chen.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="txManager" class="com.chen.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>

  5. 测试类

    package com.itheima.test;

import com.itheima.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 使用Junit单元测试：测试我们的配置
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    private  IAccountService as;

    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }

}

2、以上案例带来的问题

​ 以上代码已经用事务完成了代码的提交和回滚，但是与之同时，我们发现代码之中有大量的开启事务、提交事务、回滚操作、释放连接等操作。且业务层的方法于事务层的方法过度耦合，试想一下，若要以上代码再描述account的增、删、改，是否又需要进行大量重复代码的描写。又或者，当你事务类的方法有一个命名不是特别规范，那你是不是又要回头改所有业务层中引用事务的方法名。

​ 因此这个问题便需要动态代理来实现

3、动态代理

​ 字节码随用随创建，随用随加载。这是一个动态的过程。

​ 而静态代理是字节码一上来便创建，并完成了加载。

  1. 基于接口的动态代理

    提供者：JDK 官方的 Proxy 类。

    要求：被代理类最少实现一个接口。

  2. 基于子类的动态代理

    提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。 要求：被代理类不能用 final 修饰的类（最终类）。

3.1、基于接口动态代理的Proxy类

  1. 创建的方式是Proxy.newProxyInstance（三个参数）
    1. ClassLoader：和被代理对象使用相同的类加载器
    2. Interfaces：和被代理对象具有相同的行为。实现相同的接口。
    3. InvocationHandler：如何代理。
  2. InvocationHandler的三个参数（Object proxy, Method method, Object[] args）
    1. proxy：代理对象的引用
    2. method：当前执行的方法对象
    3. args：执行方法所需的参数
  3. 需要注意的是
    1. Proxy.newProxyInstance的返回值应该为目标对象的接口对象
    2. final修饰符

3.2、基于动态代理的修改

  1. 创建Service的代理对象的工厂

    package com.chen.factory;

import com.chen.service.IAccountService;
import com.chen.utils.TransactionManager;

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

/**
 * 用于创建Service的代理对象的工厂
 */
public class BeanFactory {

    private IAccountService accountService;

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }


    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 获取Service代理对象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),//被代理对象使用相同的类加载器
 accountService.getClass().getInterfaces(),//和被代理对象具有相同的行为
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }
                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

  2. service的修改

   public class AccountServiceImpl implements IAccountService {

       private IAccountDao accountDao;
       
       public void setAccountDao(IAccountDao accountDao) {
           this.accountDao = accountDao;
       }
       
       @Override
       public List<Account> findAllAccount() {
          return accountDao.findAllAccount();
       }
       
       @Override
       public void transfer(String sourceName, String targetName, Float money) {
           System.out.println("transfer....");
               //2.1根据名称查询转出账户
               Account source = accountDao.findAccountByName(sourceName);
               //2.2根据名称查询转入账户
               Account target = accountDao.findAccountByName(targetName);
               //2.3转出账户减钱
               source.setMoney(source.getMoney()-money);
               //2.4转入账户加钱
               target.setMoney(target.getMoney()+money);
               //2.5更新转出账户
               accountDao.updateAccount(source);
               //2.6更新转入账户
               accountDao.updateAccount(target);
       	}
       }

3. 测试类的修改

   ```java
   @RunWith(SpringJUnit4ClassRunner.class)
   @ContextConfiguration(locations = "classpath:bean.xml")
   public class AccountServiceTest {
   
       //因为此时有两个Service的bean在容器，Autowired无法指向，所以需要再加一个Qualifier注解
       @Autowired
       @Qualifier("proxyAccountService")
       private  IAccountService as;
   
       @Test
       public  void testTransfer(){
           as.transfer("aaa","bbb",100f);
       }
   
   }

  1. bean方法的配置文件修改

    <?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"
       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">

    <!-- 告知spring在创建容器时要扫描的包 -->
    <!--<context:component-scan base-package="com.itheima"></context:component-scan>-->

    <!--配置代理的service-->
    <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

    <!--配置beanfactory-->
    <bean id="beanFactory" class="com.chen.factory.BeanFactory">
        <!-- 注入service -->
        <property name="accountService" ref="accountService"></property>
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager"></property>
    </bean>

     <!-- 配置Service -->
    <bean id="accountService" class="com.chen.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.chen.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/nba"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="com.chen.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="txManager" class="com.chen.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>
别选瑶了
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Spring Aop的底层实现技术 --- Jdk动态代理原理
03-31
在 Spring AOP 中，JDK 动态代理技术被用于实现 AOP 的底层技术。通过使用 JDK 动态代理，Spring AOP 可以将横切逻辑和业务逻辑编织在一起，从而实现了 loose coupling 和高内聚的设计目标。 在 JDK 动态代理中，...
AOP底层原理之动态代理（JDK+CGLIB）
下雨打伞干嘛的博客
07-07 371
什么是代理？ 举个栗子：经纪人–>明星 律师–>委托人 房产中介–>卖方或买方 总结：代理拥有我们本身角色的属性与方法，我们需要做的一些工作，可以交由他们去完成，因为他们可以跟我们完成同样的事情。 什么时候我们会用到代理？ 一件我们没时间做但是又不得不做的事情；一件我们想做但是又不能去做的事情。就可以交由给代理去做。 翻译到代码中的意思就是：我想要调用一个类的方法，但是我自己本身不能去调用或者是受到限制，就可以交由代理去调用。 什么又是动态代理？ 代理只能在他自己擅长的方向上进行处理事务，
AOP的动态代理
xh_yj的博客
01-13 593
一、什么是AOP 1、面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重复性，同时提高了开发的效率。 2、通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。 3、列：实现登录权限功能中用到了AOP 二、AOP底层原理 1、Aop底层使用动态代理 （1）有两种情况动态代理   第一种 有接口情况，使用JDK动态代理   第二种没有接口情况，使用CGLIB动态代理 ...
AOP的底层原理：动态代理
admin3335的博客
10-16 1053
AOP的底层原理：动态代理
AOP的底层实现-CGLIB动态代理和JDK动态代理
836811384
10-20 984
AOP是目前Spring框架中的核心之一，在应用中具有非常重要的作用，也是Spring其他组件的基础。它是一种面向切面编程的思想。关于AOP的基础知识，相信多数童鞋都已经了如指掌，我们就略过这部分，来讲解下AOP的核心功能的底层实现机制：如何用动态代理来实现切面拦截。 AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面...
AOP动态代理
qq_50896786的博客
07-06 4485
目录1.IOC、AOP概念2.为何使用动态代理2.1 JDK原生动态代理 2.1.1 MathService接口类2.1.2 MathServiceImpl实现接口类2.1.3 ProxyFactory动态代理工厂2.1.4 测试类2.2 cglib动态代理 2.2.1 MathServiceImpl类2.2.2 ProxyFactory动态代理工厂2.2.3 测试类3.AOP动态代理3.1 添加对应依赖3.2 配置spring.xml文件3.3 MathService接口类 3.4 MathService
spring-aop底层1
08-03
【Spring-AOP底层详解】 Spring AOP，即Spring的面向切面编程，是Spring框架中的一个重要组成部分，它提供了一种在运行时动态插入代码的能力，主要用于处理横切关注点，如日志记录、事务管理、权限校验等，从而降低...
动态代理，JDK实现动态代理，springAOP初学理解动态代理。代码实现
12-20
在Spring AOP中，当目标对象实现了接口时，Spring默认使用JDK动态代理；如果没有实现接口，则使用CGLIB。通过动态代理，Spring可以在方法调用前后添加额外的行为，如切面（Aspect）中的前置通知（Before Advice）、...
Spring AOP的底层实现技术
04-03
Spring AOP基于两种代理机制实现：JDK动态代理和CGLIB代理。JDK动态代理适用于实现了接口的目标对象，通过反射机制创建一个代理类来拦截方法调用。而CGLIB是在运行时动态生成一个目标类的子类，从而实现对方法的...
springIOC及AOP底层原理Demo实现
最新发布
11-13
具体实现上，Spring AOP有两种实现方式：基于代理的AOP和基于ASM字节码的AOP。基于代理的AOP主要使用JDK动态代理或CGLIB库生成目标对象的代理对象，代理对象在方法调用时拦截并执行通知。而基于字节码的AOP则在运行...
AOP底层实现原理，动态代理如何动态
weixin_30299709的博客
07-08 130
代理 指定另外一个主体代替原来的某个主体去执行某个事物 代理执行的人 需要代理的人 需要代理的事情是一定要做的 但是被代理的人没有时间或自己做的不专业 静态代理： 父母朋友帮忙物色找对象 代理人掌握需求，专门为一个人服务 动态代理：媒婆，婚介所：专业介绍， 不限制你的要求，只是尽量匹配 运行时确定的被代理对象的机制 AOP，没有任何限制，只要是个java类，就可以代理，配置结合反射 JDK P...
AOP 实现的原理简析
weixin_34033624的博客
05-28 174
AOP简介 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 AOP应用范围日志记录，跟踪，优化和监控,事务的处理,持久化,如数据库连接池的管理,系统统一的认证、权限管理等.AOP的实现 AOP实现可以分为两种: 1.静态织入(Aspect...
AOP的底层实现---动态代理
weixin_48093379的博客
07-03 220
OOP面向对象的思想是纵向的，在一个纵向的业务逻辑处理中，想要拓展功能时，只能修改原有的代码。而AOP思想的横向的，可以做到无侵入式的拓展业务逻辑，妙处在于对切面（aspect）的处理，减低耦合。在具体分工是，OOP负责主体业务流程，AOP负责增强类的统一逻辑。但当方法发生嵌套调用时，被嵌套的方法是不会被执行切入的。 AOP的使用方法 1、导入aspectjweaver依赖 //笔者导入的gav <dependency> <groupId>org.aspectj</gr
aop的底层实现，动态代理是如何动态，假如有100个对象，如何动态的为这100个对象代理
wlg9527的博客
05-19 867
AOP：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术 AOP应用范围 日志记录，跟踪，优化和监控,事务的处理,持久化,如数据库连接池的管理,系统统一的认证、权限管理等. AOP的实现 AOP实现可以分为两种: 1.静态织入(AspectJ) 在代码的编译阶段植入Pointcut的内容 ,优点是性能好 2.动态代理(Spring) 在代码执行阶段,在内存中截获对象,动态的插入Pointcut的内容,优点是不需要额外的
AOP底层_动态代理
cai_ing的博客
07-21 186
1、 对于实现了接口的被代理对象而言，AOP进行切面编程，会利用jdk的动态代理完成代理对象的生成，实际上容器启动为MyMathCalculator创建的对象是一个代理对象class com.sun.proxy.$Proxy12，所以不能用本类MyMathCalculator.class从容器中获取，由于代理对象和被代理对象共同实现了接口，所以根据类型获取代理对象的话要根据实现的接口类型获取， 2、 对于没有实现接口的被代理对象，IOC容器中存在的是class com.atguigu.impl.MyMath
Spring AOP底层实现原理-动态代理
眼映星辰的博客
10-24 724
AOP是什么？ spring框架的核心之一AOP，面向切面编程是一种编程思想。我对于面向切面编程的理解是：可以让我们动态的控制程序的执行流程及执行结果。spring框架对AOP的实现是为了使业务逻辑之间实现分离，分离主业务逻辑及次要业务逻辑，进而降低系统间的耦合度。 spring框架对于这种编程思想的实现基于两种动态代理模式，分别是 JDK动态代理 及 CGLIB的动态代理，这两种动态代理的区别是...
AOP（动态代理）底层实现原理（重点！！！）
Javaer
04-19 540
AOP底层实现原理 1.Aop解决的两个核心问题 1.Aop如何创建动态代理类？（动态字节码技术） 2.Spring工厂如何加工创建代理对象？ 2.动态代理类的创建 2.1 JDK的动态代理 编码 //1 创建原始对象 UserService userService = new UserServiceImpl(); //2 JDK创建动态代理 /* */ InvocationHandler handler = ne
Spring 学习 （四）三种代理模式（动态代理AOP底层实现的两种方式）
杨大侠不是奥特曼的博客
09-27 830
目录 Java代理模式 一、静态代理 二、AOP底层原理的两种实现方式 （一）动态代理（又叫JDK代理（实现接口）） JDK代理底层原理： （二）CGlib动态代理（继承类） 我们用CGLib代理就需要知道 动态代理技术是整个java技术中最重要的一个技术，它是学习java框架的基础，不会动态代理技术，那么在学习Spring这些框架时是学不明白的。 Java代理模式 代理(Pr...
AOP底层原理（JDK动态代理实现）
m0_61465063的博客
01-05 199
AOP底层使用动态代理 有两种情况动态代理 第一种有接口情况，使用JDK动态代理 第二种无接口情况，使用CGKIB动态代理 这里来演示第一种情况 1我们先定义一个接口 public interface UserDao { public int add(int a,int b); public String update(String s); } 2定义接口的实现类 public class UserDaoIm implements UserDao{ @Override pub
Spring-Aop的底层是怎么实现的
06-10
总的来说，Spring AOP 的底层实现主要依赖于动态代理技术和反射机制，通过代理对象拦截目标对象的方法调用，并根据切面配置文件或注解中的切点和通知类型，添加相应的增强逻辑，从而实现对目标对象的增强。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值