Spring Aop原理

最新推荐文章于 2025-06-21 11:21:59 发布
转载 最新推荐文章于 2025-06-21 11:21:59 发布 · 201 阅读 · 0
文章标签：

#AOP

AOP实现原理

　　Spring 为解耦而生，其中AOP（面向切面编程）是很浓重的一笔。

　　本文来探讨一下AOP实现的原理。

一. 概述

　　代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
　　按照代理的创建时期，代理类可以分为两种。

  • 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
  • 动态代理：在程序运行时，运用反射机制动态创建而成。

　　另外还有Cglib动态代理，它是针对类实现的代理。

二. 静态代理

1.  Count.java 

复制代码 
 1 /** 
 2 * 定义一个账户接口 
 3 */  
 4 public interface Count {  
 5     // 查看账户方法  
 6     public void queryCount();  
 7   
 8     // 修改账户方法  
 9     public void updateCount();    
10 }
复制代码

2.  CountImpl.java

复制代码 
 1 import net.battier.dao.Count;  
 2 /** 
 3  * 委托类(包含业务逻辑) 
 4  */  
 5 public class CountImpl implements Count {  
 6   
 7     @Override  
 8     public void queryCount() {  
 9         System.out.println("查看账户方法...");  
10   
11     }  
12 
13     @Override  
14     public void updateCount() {  
15         System.out.println("修改账户方法...");  
16     }  
17 }
复制代码

3.  CountProxy.java  

复制代码 
 1 import net.battier.dao.Count;  
 2 /** 
 3  * 这是一个代理类（增强CountImpl实现类） 
 4  */  
 5 public class CountProxy implements Count {  
 6     private CountImpl countImpl;  
 7     /** 
 8      * 覆盖默认构造器 
 9      *  
10      * @param countImpl 
11      */  
12     public CountProxy(CountImpl countImpl) {  
13         this.countImpl = countImpl;  
14     }  
15   
16     @Override  
17     public void queryCount() {  
18         System.out.println("事务处理之前");  
19         // 调用委托类的方法;  
20         countImpl.queryCount();  
21         System.out.println("事务处理之后");  
22     }  
23   
24     @Override  
25     public void updateCount() {  
26         System.out.println("事务处理之前");  
27         // 调用委托类的方法;  
28         countImpl.updateCount();  
29         System.out.println("事务处理之后");  
30     }  
31 }
复制代码

4.  TestCount.java

复制代码 
 1 import net.battier.dao.impl.CountImpl;  
 2 import net.battier.dao.impl.CountProxy;    
 3 /** 
 4  *测试Count类 
 5  */  
 6 public class TestCount {  
 7     public static void main(String[] args) {  
 8         CountImpl countImpl = new CountImpl();  
 9         CountProxy countProxy = new CountProxy(countImpl);  
10         countProxy.updateCount();  
11         countProxy.queryCount();  
12     }  
13 }
复制代码

　　观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

三. 动态代理

　　与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

JDK动态代理中包含一个接口和一个类： 

1).InvocationHandler接口

1 public interface InvocationHandler {
2     public Object invoke(Object proxy, Method method, Object[] args)
3         throws Throwable;
4 }

参数说明： 
Object proxy：指被代理的对象。 
Method method：要调用的方法 
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

2).Proxy类： 

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

复制代码 
1 public static Object newProxyInstance(ClassLoader loader,
2                                           Class<?>[] interfaces,
3                                           InvocationHandler h)
4         throws IllegalArgumentException
5     {
6         /**************
7         *具体内容略去**
8         **************/
9     }
复制代码

参数说明： 
ClassLoader loader：类加载器 
Class<?>[] interfaces：得到全部的接口 
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器：

  • Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
  • Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
  • AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

动态代理示例：

1.  BookFacade.java

1 public interface BookFacade {  
2     public void addBook();  
3 }

2.  BookFacadeImpl.java 

复制代码 
1 import net.battier.dao.BookFacade;  
2   
3 public class BookFacadeImpl implements BookFacade {  
4   
5     @Override  
6     public void addBook() {  
7         System.out.println("增加图书方法。。。");  
8     }  
9 }
复制代码

3.  BookFacadeProxy.java 

复制代码 
 1 import java.lang.reflect.InvocationHandler;  
 2 import java.lang.reflect.Method;  
 3 import java.lang.reflect.Proxy;  
 4 /** 
 5  * JDK动态代理代理类 
 6  */  
 7 public class BookFacadeProxy implements InvocationHandler {  
 8     private Object target;  
 9     /** 
10      * 绑定委托对象并返回一个代理类 
11      * @param target 
12      * @return 
13      */  
14     public Object bind(Object target) {  
15         this.target = target;  
16         //取得代理对象  
17         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
18                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
19     }  
20   
21     @Override  
22     /** 
23      * 调用方法 
24      */  
25     public Object invoke(Object proxy, Method method, Object[] args)  
26             throws Throwable {  
27         Object result=null;  
28         System.out.println("事物开始");  
29         //执行方法  
30         result=method.invoke(target, args);  
31         System.out.println("事物结束");  
32         return result;  
33     }  
34 }
复制代码

4.  TestProxy.java

复制代码 
 1 import net.battier.dao.BookFacade;  
 2 import net.battier.dao.impl.BookFacadeImpl;  
 3 import net.battier.proxy.BookFacadeProxy;  
 4   
 5 public class TestProxy {  
 6     public static void main(String[] args) {  
 7         BookFacadeProxy proxy = new BookFacadeProxy();  
 8         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
 9         bookProxy.addBook();  
10     }    
11 }
复制代码

　　但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

四. Cglib动态代理

　　JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 

示例如下：

1.  BookFacadeCglib.java 

1 public interface BookFacade {  
2     public void addBook();  
3 }

2.  BookCadeImpl1.java 

复制代码 
1 /** 
2  * 这个是没有实现接口的实现类 
3  */  
4 public class BookFacadeImpl1 {  
5     public void addBook() {  
6         System.out.println("增加图书的普通方法...");  
7     }  
8 }
复制代码

3.  BookFacadeProxy.java

复制代码 
 1 import net.sf.cglib.proxy.Enhancer;  
 2 import net.sf.cglib.proxy.MethodInterceptor;  
 3 import net.sf.cglib.proxy.MethodProxy;    
 4 /** 
 5  * 使用cglib动态代理  
 6  */  
 7 public class BookFacadeCglib implements MethodInterceptor {  
 8     private Object target;  
 9   
10     /** 
11      * 创建代理对象 
12      *  
13      * @param target 
14      * @return 
15      */  
16     public Object getInstance(Object target) {  
17         this.target = target;  
18         Enhancer enhancer = new Enhancer();  
19         enhancer.setSuperclass(this.target.getClass());  
20         // 回调方法  
21         enhancer.setCallback(this);  
22         // 创建代理对象  
23         return enhancer.create();  
24     }  
25   
26     @Override  
27     // 回调方法  
28     public Object intercept(Object obj, Method method, Object[] args,  
29             MethodProxy proxy) throws Throwable {  
30         System.out.println("事物开始");  
31         proxy.invokeSuper(obj, args);  
32         System.out.println("事物结束");  
33         return null;  
34     }  
35 }
复制代码

4.  TestCglib.java

复制代码 
 1 import net.battier.dao.impl.BookFacadeImpl1;  
 2 import net.battier.proxy.BookFacadeCglib;  
 3   
 4 public class TestCglib {  
 5       
 6     public static void main(String[] args) {  
 7         BookFacadeCglib cglib=new BookFacadeCglib();  
 8         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
 9         bookCglib.addBook();  
10     }  
11 }

 






参考：http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html#3460821




                

        

    

    
  



    



                



	

		

			

				
					
【微服务】Spring Aop原理深入解析

				
			

			

				

					congge
				

				

					12-17
					
					1万+
					
				

			

		

		

			
				
spring原理深度解析

			
		

	



                

            
              



	

		

			

				
					
Spring AOP的实现原理

				
			

			

				

					《两个菜鸟程序员》
				

				

					06-15
					
					714
					
				

			

		

		

			
				
Spring的Aop原理

本文讲解Spring AOP的整体的流程。

一、基本术语：
前置通知：@Before    在执行方法之前执行
后置通知：@After   方法后执行
返回通知：@AfterReturning  方法执行完返回执行
异常通知：@AfterThrowing 出现异常的时候执行
环绕通知：@Around 环绕通知
在切面类上加入@Aspect说明这个类是通知类
在配置类上用@EnableAspectJAutoProxy开启通知的功能
二、@EnableAspectJAutoProx

			
		

	



              


  
              

                


	

		

			

				
					
spring AOP原理

				
			

			

				

					beckham
				

				

					01-05
					
					2708
					
				

			

		

		

			
				
Spring 实现AOP是依赖JDK动态代理和CGLIB代理实现的。以下是JDK动态代理和CGLIB代理简单介绍    JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。    CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java

			
		

	





	

		

			

				
					
Spring AOP 的实现原理是什么？

					
最新发布

				
			

			

				

					专注于技术分享
				

				

					06-21
					
					673
					
				

			

		

		

			
				
特性JDK 动态代理CGLIB 代理核心技术Java 反射 (字节码增强 (Bytecode Enhancement)代理方式实现目标对象的所有接口继承目标对象，创建其子类前提条件目标对象必须实现接口目标对象不能是 final 类，方法不能是 finalSpring Boot 默认否是 (推荐)对代码影响无无理解 Spring AOP 是基于运行时动态代理这一核心原理，以及它与目标对象和代理对象的关系，是掌握 AOP 并解决类似“方法内部调用导致 AOP 失效”等问题的关键。

			
		

	



		

			
		



	

		

			

				
					
菜鸟学SSH——Spring容器AOP的实现原理——动态代理

				
			

			

				

					纸上得来终觉浅，绝知此事要躬行
				

				

					07-16
					
					9449
					
				

			

		

		

			
				
之前写了一篇关于IOC的博客——《Spring容器IOC解析及简单实现》，今天再来聊聊AOP。大家都知道Spring的两大特性是IOC和AOP。

IOC负责将对象动态的注入到容器，从而达到一种需要谁就注入谁，什么时候需要就什么时候注入的效果，可谓是招之则来，挥之则去。想想都觉得爽，如果现实生活中也有这本事那就爽歪歪了，至于有多爽，各位自己脑补吧；而AOP呢，它实现的就是容器的另一大好处了，就是可...

			
		

	





	

		

			

				
					
SpringAOP原理

				
			

			

				

					风雪夜归人的博客
				

				

					05-26
					
					268
					
				

			

		

		

			
				
AOP（Aspect Oriented Programming）面向切面编程是 Spring 框架最核心的组件之一，它通过对程序结构的另一种考虑，补充了 OOP（Object-Oriented Programming）面向对象编程。在 OOP 中模块化的关键单元是类，而在 AOP 中，模块化单元是切面。也就是说 AOP 关注的不再是类，而是一系列类里面需要共同能力的行为。
本文内容主要包括：
讲解 OOP 与 AOP 的简单对比，以及 AOP 的基础名词，比如面试中经常会被问到的 point cut、adv

			
		

	





	

		

			

				
					
SpringAOP的实现原理

				
			

			

				

					Peng_Zachary的博客
				

				

					04-19
					
					8879
					
				

			

		

		

			
				
一：SpringAOP的面向切面编程，是面向对象编程的一种补充，用于处理系统中分布的各个模块的横切关注点，比如说事务管理、日志、缓存等。它是使用动态代理实现的，在内存中临时为增强某个方法生成一个AOP对象，这个对象包含目标对象的所有方法，在特定的切入点做了增强处理，并回调原来的方法。

二、核心：

SpringAOP的动态代理主要由两种方式实现，JDK动态代理和cglib动态代理。JDK动态代理通过反射来接收代理的类，但是被代理的类必须实现接口，核心是InvocationHandler和Proxy类，cg

			
		

	





	

		

			

				
					
Spring AOP 原理剖析，这一篇就够

				
			

			

				

					12-22
				

			

		

		

			
				
Spring AOP 学习记录 AOP（面向切面编程）方面的知识又是看了忘忘了看，今天有空记录下AOP的知识点。主要分为以下几方面： ​		1、AOP相关术语 ​		2、基础知识及示例 ​		3、增强分类 1、AOP相关术语 连接点...

			
		

	





	

		

			

				
					
spring aop实现原理

				
			

			

				

					03-15
				

			

		

		

			
				
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927

			
		

	





	

		

			

				
					
Springaop原理及各种应用场景

				
			

			

				

					01-27
				

			

		

		

			
				
Spring AOP，全称Spring面向切面编程，是一种编程范式，旨在将关注点分离，尤其是将横切关注点（如日志、事务管理、安全等）与核心业务逻辑解耦。AOP使得这些功能可以作为独立的模块，称为切面（Aspect），并能够跨...

			
		

	





	

		

			

				
					
03-深入解析SpringAOP原理及源码-146914326.md

				
			

			

				

					05-07
				

			

		

		

			
				
在深入探索SpringAOP的原理和源码之前，我们首先要明确AOP究竟是什么。AOP，即面向切面编程（Aspect-Oriented Programming），是一种编程范式，旨在将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，以...

			
		

	





	

		

			

				
					
Spring——Spring AOP原理

				
			

			

				

					庄小焱
				

				

					03-30
					
					3688
					
				

			

		

		

			
				
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。

			
		

	





	

		

			

				
					
Spring AOP实现原理

				
			

			

				

					weixin_33713707的博客
				

				

					06-05
					
					176
					
				

			

		

		

			
				
一、AOP是什么？
AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表。本文会分别对Aspect...

			
		

	





	

		

			

				
					
Spring aop的实现原理

				
			

			

				

					goxingman的博客
				

				

					12-02
					
					253
					
				

			

		

		

			
				
Spring aop的实现原理
简介
　　前段时间写的java设计模式–代理模式，最近在看Spring Aop的时候，觉得于代理模式应该有密切的联系，于是决定了解下Spring Aop的实现原理。
说起AOP就不得不说下OOP了，OOP中引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。但是，如果我们需要为部分对象引入公共部分的时候，OOP就会引入大量重复的代码。例如...

			
		

	





	

		

			

				
					
深入探索spring技术内幕(五): 剖析spring AOP工作原理

				
			

			

				

					优秀并不晚
				

				

					10-04
					
					998
					
				

			

		

		

			
				
一、前言

AOP (Aspect Oriented Programing) - 面向切面编程，它主要用于日志记录、性能分析、安全控制、事务处理、异常处理等方面。

AOP主要使用JDK的反射和动态代理，AOP代理其实是由AOP框架动态生成的一个对象，该对象可作为目标对象使用，AOP代理包含了目标对象的全部方法，但AOP代理的方法与目标对象的方法存在差异：AOP方法在特定切入点添加了增强处

			
		

	





	

		

			

				
					
SpringAop原理

				
			

			

				

					同一片天空
				

				

					03-27
					
					438
					
				

			

		

		

			
				
SpringAop原理SpringAop前身先前的动态代理，定义代理类Aop的Aspect注解
SpringAop前身
Aop：: 面向切面编程  在不影响核心代码的前提下，可以在任意位置添加非核心代码。
AOP基于IOC基础，是对OOP的有益补充。
通过动态代理实现核心业务和非核心业务的一种抽取。比较麻烦。 可以使用spring 的aop来完成代理
AOP常用的术语有：通知、切点、和连接点
通知（Advice）：定义了切面是什么以及何时使用
Spring有5种通知类型：
Before——前置通知：在方法调

			
		

	





	

		

			

				
					
Spring框架系列之第三章 AOP

				
			

			

				

					qq_36595761的博客
				

				

					09-09
					
					596
					
				

			

		

		

			
				
AOP前奏
提出问题
情景：数学计算器
1)	要求
  ①执行加减乘除运算
  ②日志：在程序执行期间追踪正在发生的活动
  ③验证：希望计算器只能处理正数的运算

2)	常规实现

3)	问题
  ①代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。
  ②代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。
动态代理
动态代理的原

			
		

	





	

		

			

				
					
spring  aop原理

				
			

			

				

					05-09
				

			

		

		

			
				
<think>好的，用户想了解Spring AOP的原理，特别是代理模式、动态代理和静态代理。首先，我需要回顾一下代理模式的基本概念，然后区分静态代理和动态代理的不同，再联系到Spring AOP是如何应用这些技术的。

首先，代理模式的定义。根据引用[1]，代理模式允许在不修改被代理对象的情况下，通过代理类进行功能增强。这里的关键是代理类分为静态和动态两种。静态代理需要手动创建代理类，而动态代理在运行时生成。用户可能想知道这两种代理在Spring AOP中的应用场景。

接下来，静态代理的细节。引用[1]提到静态代理的类在运行前已经存在，通常由程序员手动编写或工具生成。例如，假设有一个业务接口Subject和实现类RealSubject，静态代理类Proxy会实现Subject并持有RealSubject的引用，在方法调用前后添加逻辑。这种情况的缺点是每个被代理类都需要一个对应的代理类，导致代码冗余。

然后是动态代理，Spring AOP主要使用JDK动态代理和CGLIB。引用[2]指出JDK代理通过Proxy类生成代理对象，而CGLIB通过Enhancer创建。JDK动态代理要求目标类实现接口，利用InvocationHandler的invoke方法进行增强。CGLIB则通过继承目标类，重写方法来实现代理，适用于没有接口的情况。需要解释这两种方式的区别以及Spring如何选择使用哪一种。

还要结合Spring AOP的源码，如引用[2]提到的AOP源码剖析部分。Spring在运行时决定使用哪种代理方式，如果目标类实现了接口，默认使用JDK代理，否则使用CGLIB。这涉及到AOP的配置和底层机制。

用户可能还关心AOP的应用场景，比如事务管理、日志记录等，这些通过代理模式实现，无需修改原有代码。需要举例说明，比如在方法执行前后加入事务控制，动态代理如何拦截方法调用并添加额外操作。

另外，需要确保回答结构清晰，分点说明原理、代理类型、实现方式以及Spring的选择策略。同时，生成的相关问题要围绕用户可能进一步询问的点，比如性能比较、配置方法或实际应用例子。

最后，检查引用是否正确应用，如引用[1]关于代理模式的分类，引用[2]关于Spring AOP的具体实现，引用[3]关于代理模式的角色。确保每个技术点都有对应的引用支持，增加回答的可信度。</think>### Spring AOP原理与代理模式解析

#### 一、代理模式的核心作用
代理模式通过代理对象控制对真实对象的访问，在**不修改原始代码**的前提下实现功能增强。其核心角色包括：
- **Subject**：定义业务接口（可以是接口或抽象类）[^3]
- **RealSubject**：具体业务实现类（被代理对象）
- **Proxy**：代理类，负责增强和控制对RealSubject的访问

#### 二、静态代理的实现方式
静态代理需**手动编写代理类**，代理关系在编译时确定。例如：
```java
// 业务接口
interface UserService {
    void save();
}

// 真实对象
class UserServiceImpl implements UserService {
    public void save() { /* 业务逻辑 */ }
}

// 静态代理类
class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    public void save() {
        System.out.println("前置增强");
        target.save(); // 调用真实对象方法
        System.out.println("后置增强");
    }
}
```
**缺点**：每个业务类需对应一个代理类，代码冗余度高[^1]。

#### 三、动态代理的实现机制
Spring AOP主要采用两种动态代理技术：
1. **JDK动态代理**（基于接口）
   - 要求目标类必须实现至少一个接口
   - 通过`java.lang.reflect.Proxy`生成代理对象
   - 核心类`InvocationHandler`实现方法拦截：
     ```java
     class JdkProxyHandler implements InvocationHandler {
         private Object target;
         
         public Object getProxy(Object target) {
             this.target = target;
             return Proxy.newProxyInstance(
                 target.getClass().getClassLoader(),
                 target.getClass().getInterfaces(),
                 this);
         }
         
         public Object invoke(Object proxy, Method method, Object[] args) {
             System.out.println("前置增强");
             Object result = method.invoke(target, args);
             System.out.println("后置增强");
             return result;
         }
     }
     ```

2. **CGLIB代理**（基于继承）
   - 通过生成目标类的子类实现代理
   - 使用`MethodInterceptor`接口：
     ```java
     class CglibInterceptor implements MethodInterceptor {
         public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) {
             System.out.println("前置增强");
             Object result = proxy.invokeSuper(obj, args);
             System.out.println("后置增强");
             return result;
         }
     }
     
     // 通过Enhancer创建代理
     Enhancer enhancer = new Enhancer();
     enhancer.setSuperclass(TargetClass.class);
     enhancer.setCallback(new CglibInterceptor());
     TargetClass proxy = (TargetClass)enhancer.create();
     ```
   - **优势**：可代理无接口的类[^2]

#### 四、Spring AOP的代理选择策略
| 条件                     | 使用的代理方式 |
|--------------------------|----------------|
| 目标类实现了至少一个接口 | JDK动态代理    |
| 目标类未实现任何接口     | CGLIB代理      |

**底层实现**：
- 通过`DefaultAopProxyFactory`类判断代理方式
- Spring Boot 2.x后默认强制使用CGLIB（可通过`spring.aop.proxy-target-class=true`配置）

#### 五、AOP核心流程
1. 解析切面定义（@Aspect）
2. 匹配连接点（Pointcut）
3. 生成代理对象
4. 编织增强逻辑（Advice）
5. 通过责任链模式执行拦截器链

#### 六、性能对比
- **JDK动态代理**：生成速度快，执行效率稍低
- **CGLIB**：生成速度慢，执行效率高（现代JVM差距已不明显）

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值