Spring AOP的实现原理

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: Spring AOP的实现原理

前言

一、Spring的aop的概念

AOP是什么

  1. AOP(面向切面编程)是一种编程范式,用于将横切关注点与业务逻辑分离。横切关注点是指在应用程序中多个模块或组件中重复出现的功能,如日志记录、事务管理、安全性等。通过AOP,可以将这些横切关注点抽象出来,以便在需要的地方进行重用。
  2. AOP(面向切面编程)是一种编程范式,用于将横切关注点与业务逻辑分离。横切关注点是指在应用程序中多个模块或组件中重复出现的功能,如日志记录、事务管理、安全性等。通过AOP,可以将这些横切关注点抽象出来,以便在需要的地方进行重用。

横切关注点

  • 与业务主要流程关系不大的部分
  • 经常发生在核心关注点的多处,而各处都是基本相似的功能
  • 如权限认证、日志、事务处理

AOP的特点

  1. 横向切面:AOP 的主要目的是解决横向切面的问题,即对多个对象的同种操作进行统一的处理,比如日志记录、性能统计、事务处理等。
  2. 切面集中处理:AOP 将切面的逻辑从业务逻辑中分离出来,实现了切面的集中处理。这样可以更好地实现代码的模块化和重用。
  3. 低侵入性:AOP 对原有业务逻辑的侵入性较小,只需要在切面中进行逻辑编写,不需要对原有类进行大量修改,提高了代码的可维护性和可扩展性。
  4. 动态代理:AOP 通过动态代理实现了切面的实现,在运行期间动态生成代理对象,实现了透明化的切面处理。
  5. 面向接口编程:AOP 一般采用面向接口编程的方式,使应用与具体实现相分离,提高了系统的可扩展性和可维护性。
  6. 与OOP关联性弱:AOP 与 OOP(面向对象编程)有较弱的关联性,可以与任何编程语言和编程模型兼容,提高了代码的通用性和移植性。

AOP带来的好处

  • 模块化:通过将横切关注点与业务逻辑分离,可以提高代码的模块化和可维护性。
  • 重用性:可以将横切关注点作为独立的模块进行重用,减少了代码的重复编写。
  • 解耦性:AOP可以将横切关注点与业务逻辑解耦,使得代码更加清晰和可读。
  • 灵活性:通过AOP,可以在不修改原始代码的情况下,动态地添加、修改或删除横切关注点。
  • 可维护性:将横切关注点抽象出来,使得对其进行修改或调整更加方便和可控。

二、AOP的实现原理

1、基于代理的实现

Spring使用动态代理技术来实现AOP。当一个bean被代理时,Spring会根据该bean实现的接口或父类创建一个代理对象,然后拦截目标方法的调用,并在目标方法的前后加入额外的行为,从而实现AOP。

2、切点

切点是AOP中的重要概念,它定义了需要被切入的连接点,即目标对象中哪些方法需要被拦截。Spring AOP中,切点可以使用AspectJ切点表达式来定义。AspectJ切点表达式可以匹配目标对象的方法,由此确定了需要被织入增强逻辑的方法,是AOP执行的入口。、

3、切面

切面定义了横切逻辑的实现,它是一个包含了advice和pointcut的类。Advice是指增强逻辑,它定义了需要织入目标方法前、后或者代替目标方法执行的代码,可以使用before、after、around等方式实现;Pointcut是指切点,它定义了对哪些方法进行拦截。

4、通知

通知是切面中的实际增强逻辑,它是指在特定的切点上执行的具体操作,Spring AOP中常见的Advice有before、after、after-returning、after-throwing和around等。

5、织入

织入是指将切面应用到目标对象的过程。Spring AOP支持三种织入方式,分别是编译时织入、类加载时织入和运行时织入。

在运行时织入时,Spring AOP使用动态代理实现,即在目标对象的方法执行的前、后或者代替目标方法执行增加了额外的逻辑。而JDK动态代理的机制是利用反射来动态生成代理类,这个代理类实现了需要代理的接口,并在InvocationHandler的中的回调方法中执行目标方法的前、后或者代替目标方法执行额外的逻辑。

三、Spring AOP concepts(AOP术语)

【术语】:

切面(Aspect):

一个关注点的模块化,这个关注点可能会横切多个对象。

事务管理是 J2EE 应用中一个关于横切关注点的很好列子。

在 Spring AOP 中,切面可以使用基于模式或者基于 @Aspect 注解的方式来实现。

连接点(Joinpoint):

在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。

在 Spring AOP 中,一个连接点总是表示一个方法的执行。

切入点(Pointcut):

匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如:当执行某个特定名称的方法时)。

切入点表达式如何和连接点匹配是 AOP 的核心:Spring 缺省使用 Aspect 切入点语法。

引入(Introduction):

用来给一个类型声明额外的方法或属性(也被称为连接类型声明(inter-type declaration))

Spring 允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,可以使用引入来使一个 bean 实现 isModified 接口,以便简化缓存机制。

目标对象(Target Object):

被一个或者多个切面所通知的对象,也被称为通知(advised)对象。

既然 Spring AOP 是通过运行时代理实现的。这个对象永远是一个被代理(proxied)对象。

AOP 代理(AOP Proxy):

AOP 框架创建的对象,用来实现切面契约(例如,通知方法执行等等)。

在 Spring 中,AOP 代理可以是 JDK 动态代理或者 CGLIB 代理。

织入(Weaving):

把切面连接到其它的应用程序类型或者对象上,并创建一个被通知的对象。这些可以在编译时(例如使用 AspectJ 编译器),类加载时和运行时完成。Spring 和其他纯 Java AOP 框架一样,在运行时完成织入。

通知(Advice):

在切面的某个特定的连接点上执行的动作。其中包括“around”、“before” 和 “after” 等不同类型的通知。

许多 AOP 框架(包括 Spring)都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链。

适配器

适配器(Adapter)是一种结构型设计模式,用于将两个不兼容的接口协同工作。适配器模式的核心思想是解决新旧接口之间的兼容性问题,让不同接口之间能够无缝衔接。

作用:把一个接口(源接口)转换成另一个接口(目标接口),以满足目标接口的需求。适配器模式一般分为类适配器和对象适配器两种实现方式。

适配器模式中的三个角色:

  1. 目标接口(Target):定义客户端使用的与特定领域相关的接口,客户端只能看到这个接口而不知道具体实现。
  2. 源接口(Adaptee):需要被适配的接口,即客户端需要调用的接口,但由于与客户端的接口不兼容而无法直接使用。
  3. 适配器(Adapter):用于将源接口转换成目标接口的中间件,把客户端的请求传递给适配者,完成客户端需要的功能。

适配器模式常用于系统升级或接口变更时,通过适配器来实现旧接口向新接口的转换,以保证系统的兼容性和稳定性。

四、常用通知

定义一个接口

package com.ctb.aop.biz;
public interface IBookBiz {
  // 购书
  public boolean buy(String userName, String bookName, Double price);
  // 发表书评
  public void comment(String userName, String comments);
}

实现接口

package com.ctb.aop.biz.impl;
import com.ctb.aop.biz.IBookBiz;
import com.ctb.aop.exception.PriceException;
public class BookBizImpl implements IBookBiz {
  public BookBizImpl() {
    super();
  }
  public boolean buy(String userName, String bookName, Double price) {
    // 通过控制台的输出方式模拟购书
    if (null == price || price <= 0) {
      throw new PriceException("book price exception");
    }
    System.out.println(userName + " buy " + bookName + ", spend " + price);
    return true;
  }
  public void comment(String userName, String comments) {
    // 通过控制台的输出方式模拟发表书评
    System.out.println(userName + " say:" + comments);
  }
}

异常处理类

package com.ctb.aop.exception;
public class PriceException extends RuntimeException {
  public PriceException() {
    super();
  }
  public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    super(message, cause, enableSuppression, writableStackTrace);
  }
  public PriceException(String message, Throwable cause) {
    super(message, cause);
  }
  public PriceException(String message) {
    super(message);
  }
  public PriceException(Throwable cause) {
    super(cause);
  }
}

测试类

package com.ctb.aop.demo;
import com.ctb.aop.biz.IBookBiz;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 彪
 * @remark
 * @create  2023-08-17 15:54
 */
public class Demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring_context.xml");
//        IBookBiz bookBiz= (IBookBiz) context.getBean("bookBiz");
        IBookBiz bookBiz= (IBookBiz) context.getBean("bookProxy");
        bookBiz.buy("死仔","死亡药剂",9.9d);
        bookBiz.comment("死仔","爽歪歪");
    }
}

前置通知(Before advice):

@Before

在某连接点之前执行的通知,但这个通知不能阻止了连接点之前的执行流程(除非它抛出一个异常)。

实现前置通知接口

package com.ctb.aop.advice;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
 * 买书、评论前加系统日志
 * @author biao
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
  @Override
  public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
//    在这里,可以获取到目标类的全路径及方法及方法参数,然后就可以将他们写到日志表里去
    String target = arg2.getClass().getName();
    String methodName = arg0.getName();
    String args = Arrays.toString(arg1);
    System.out.println("【前置通知:系统日志】:"+target+"."+methodName+"("+args+")被调用了");
  }
}

spring_context.xml

 <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口,目标对象的接口         
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
            </list>
        </property>
    </bean>

测试结果

后置通知(After returning advice):

@After-returning

在某连接点正常完成后执行的通知,例如,一个方法么有抛出任何异常,正常返回。

实现后置通知接口

package com.ctb.aop.advice;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
 * 买书返利
 * @author biao
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
  @Override
  public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
    String target = arg3.getClass().getName();
    String methodName = arg1.getName();
    String args = Arrays.toString(arg2);
    System.out.println("【后置通知:买书返利】:"+target+"."+methodName+"("+args+")被调用了,"+"该方法被调用后的返回值为:"+arg0);
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口,目标对象的接口          
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
            </list>
        </property>
    </bean>

测试结果

环绕通知(Around advice):

@Around

包围一个连接点的通知,如方法调用,这是最强大的一种通知类型。

实现环绕通知接口

package com.ctb.aop.advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.Arrays;
/**
 * 环绕通知
 *  包含了前置和后置通知
 * 
 * @author biao
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation arg0) throws Throwable {
    String target = arg0.getThis().getClass().getName();
    String methodName = arg0.getMethod().getName();
    String args = Arrays.toString(arg0.getArguments());
    System.out.println("【环绕通知调用前:】:"+target+"."+methodName+"("+args+")被调用了");
//    arg0.proceed()就是目标对象的方法
    Object proceed = arg0.proceed();
    System.out.println("【环绕通知调用后:】:该方法被调用后的返回值为:"+proceed);
    return proceed;
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口,目标对象的接口          动态代理中的jdk代理与cglib代理有什么区别,代理模式,是什么样的,什么是动态代理,什么是静态代理
                                                 在编码中是怎么用到cglib代理和jdk代理的,在什么场景下用的
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
                <value>methodInterceptor</value>
            </list>
        </property>
    </bean>

测试结果

异常通知(After throwing advice):

@After-throwing

在方法抛出异常退出时执行的通知。

实现异常通知接口

package com.ctb.aop.advice;
import org.springframework.aop.ThrowsAdvice;
import com.ctb.aop.exception.PriceException;
/**
 * 出现异常执行系统提示,然后进行处理。价格异常为例
 * @author biao
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
  public void afterThrowing(PriceException ex) {
    System.out.println("【异常通知】:当价格发生异常,那么执行此处代码块!!!");
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <bean class="com.ctb.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口,目标对象的接口          动态代理中的jdk代理与cglib代理有什么区别,代理模式,是什么样的,什么是动态代理,什么是静态代理
                                                 在编码中是怎么用到cglib代理和jdk代理的,在什么场景下用的
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
                <value>methodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>
    </bean>

我们将测试类中的价格改成负数,进行异常测试

测试结果

过滤通知(Filtering Notifications advice):

@Filtering Notifications

根据一定的条件对通知进行筛选和过滤,只选择符合条件的通知进行处理或显示。

spring_context.xml

 <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <bean class="com.ctb.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="regexpMethodPointcutAdvisor">
        <property name="advice" ref="afterReturningAdvice"></property>
        <property name="pattern" value=".*buy"></property>
    </bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口,目标对象的接口         
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
<!--                <value>afterReturningAdvice</value>-->
                <value>regexpMethodPointcutAdvisor</value>
                <value>methodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>
    </bean>

在过滤通知中 ,我们可以在过滤通知配置中设置一些正则表达式,

减少不必要的干扰,提高工作效率,同时确保不会错过重要的通知。

测试结果

spring aop底层原理到这就结束啦,希望各位大佬能一键三连哦!!


相关实践学习
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
相关文章
|
19天前
|
缓存 Java 开发者
【Spring】原理:Bean的作用域与生命周期
本文将围绕 Spring Bean 的作用域与生命周期展开深度剖析,系统梳理作用域的类型与应用场景、生命周期的关键阶段与扩展点,并结合实际案例揭示其底层实现原理,为开发者提供从理论到实践的完整指导。
|
17天前
|
人工智能 Java 开发者
【Spring】原理解析:Spring Boot 自动配置
Spring Boot通过“约定优于配置”的设计理念,自动检测项目依赖并根据这些依赖自动装配相应的Bean,从而解放开发者从繁琐的配置工作中解脱出来,专注于业务逻辑实现。
|
18天前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程(AOP)通过分离横切关注点,如日志、安全和事务,提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持,核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类,集中处理通用逻辑;`@Pointcut` 则通过表达式定义通知的应用位置,提高代码可读性与复用性。二者结合,使开发者能清晰划分业务逻辑与辅助功能,简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入,与 Spring 容器无缝集成,支持依赖注入与声明式配置,是构建清晰、高内聚应用的理想选择。
243 0
|
4月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面(Aspect)、连接点(Join Point)、通知(Advice)、切点(Pointcut)等关键概念,解析了JDK动态代理与CGLIB代理的原理及对比,并深入探讨了通知执行链路和责任链模式的应用。同时,详细分析了AspectJ注解驱动的AOP解析过程,包括切面识别、切点表达式匹配及通知适配为Advice的机制,帮助理解Spring AOP的工作原理与实现细节。
|
30天前
|
人工智能 监控 安全
Spring AOP切面编程颠覆传统!3大核心注解+5种通知类型,让业务代码纯净如初
本文介绍了AOP(面向切面编程)的基本概念、优势及其在Spring Boot中的使用。AOP作为OOP的补充,通过将横切关注点(如日志、安全、事务等)与业务逻辑分离,实现代码解耦,提升模块化程度、可维护性和灵活性。文章详细讲解了Spring AOP的核心概念,包括切面、切点、通知等,并提供了在Spring Boot中实现AOP的具体步骤和代码示例。此外,还列举了AOP在日志记录、性能监控、事务管理和安全控制等场景中的实际应用。通过本文,开发者可以快速掌握AOP编程思想及其实践技巧。
|
1月前
|
Java 关系型数据库 数据库
深度剖析【Spring】事务:万字详解,彻底掌握传播机制与事务原理
在Java开发中,Spring框架通过事务管理机制,帮我们轻松实现了这种“承诺”。它不仅封装了底层复杂的事务控制逻辑(比如手动开启、提交、回滚事务),还提供了灵活的配置方式,让开发者能专注于业务逻辑,而不用纠结于事务细节。
|
1月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】?核心应用实战(上篇)
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇,我们将专注于Spring AOP的实际应用,通过具体的代码示例和场景分析,帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中,我们将深入探讨Spring AOP的实现原理和底层机制。 AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架中的核心特性之一,它能够帮助我们解决横切关注点(如日志记录、性能统计、安全控制、事务管理等)的问题,提高代码的模块化程度和复用性。
|
1月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】?从动态代理到源码剖析(下篇)
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层,实现了对目标对象访问的控制与增强,其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中,这种模式广泛用于实现功能扩展(如远程调用、延迟加载)、行为拦截(如权限校验、异常处理)等场景,为系统提供了更高的灵活性和可维护性。
|
5月前
|
存储 人工智能 自然语言处理
RAG 调优指南:Spring AI Alibaba 模块化 RAG 原理与使用
通过遵循以上最佳实践,可以构建一个高效、可靠的 RAG 系统,为用户提供准确和专业的回答。这些实践涵盖了从文档处理到系统配置的各个方面,能够帮助开发者构建更好的 RAG 应用。
2709 114
|
2月前
|
缓存 安全 Java
Spring 框架核心原理与实践解析
本文详解 Spring 框架核心知识,包括 IOC(容器管理对象)与 DI(容器注入依赖),以及通过注解(如 @Service、@Autowired)声明 Bean 和注入依赖的方式。阐述了 Bean 的线程安全(默认单例可能有安全问题,需业务避免共享状态或设为 prototype)、作用域(@Scope 注解,常用 singleton、prototype 等)及完整生命周期(实例化、依赖注入、初始化、销毁等步骤)。 解析了循环依赖的解决机制(三级缓存)、AOP 的概念(公共逻辑抽为切面)、底层动态代理(JDK 与 Cglib 的区别)及项目应用(如日志记录)。介绍了事务的实现(基于 AOP
115 0