SpringAOP

最新推荐文章于 2025-07-21 23:12:51 发布

原创最新推荐文章于 2025-07-21 23:12:51 发布 · 116 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#代理模式 #java #spring

Spring AOP

主要内容

代理模式

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子：房客、中介、房东。对应于代理模式中即：客户类、代理类、委托类（被代理类）。为某一个对象（委托类）提供一个代理（代理类），用来控制对这个对象的访问。委托类和代理类有一个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。

生活中常见的代理情况：

租房中介、婚庆公司等

代理模式的两个设计原则：

代理类与委托类具有相似的行为（共同）
代理类增强委托类的行为

常用的代理模式：

静态代理
动态代理

静态代理

某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

代理的三要素

a、有共同的行为（结婚） - 接口

b、目标角色（新人） - 实现行为

c、代理角色（婚庆公司） - 实现行为增强目标对象行为

静态代理的特点

1 、目标角色固定

2 、在应用程序执行前就得到目标角色

3 、代理对象会增强目标对象的行为

4 、有可能存在多个代理引起"类爆炸"（缺点）

静态代理的实现

定义行为（共同）定义接口

目标对象（实现行为）

代理对象（实现行为、增强目标对象的行为）

定义行为

public interface Marry {
public void toMarry();
}

静态代理 ——> 目标对象

public class You implements Marry {
// 实现行为
@Override
public void toMarry() {
System.out.println("我要结婚了...");
}
}

静态代理 ——> 代理对象

public class MarryCompanyProxy implements Marry {
// 目标对象
private Marry marry;
// 通过构造器将目标对象传入
public MarryCompanyProxy(Marry marry) {
this.marry = marry;
}
// 实现行为
@Override
public void toMarry() {
// 增强行为
before();
// 执行目标对象中的方法
marry.toMarry();
// 增强行为
after();
}
/**
* 增强行为
*/
private void after() {

1. 1. 通过代理对象实现目标对象的功能

静态代理对于代理的角色是固定的，如dao层有 20 个dao类，如果要对方法的访问权限进行代理，此

时需要创建 20 个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。

动态代理

相比于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

动态代理的两种实现方式：

JDK 动态代理
CGLIB动态代理

动态代理的特点

System.out.println("新婚快乐，早生贵子！");
}
/**
* 增强行为
*/
private void before() {
System.out.println("场地正在布置中...");
}
}

// 目标对象

You you = new You();
// 构造代理角色同时传入真实角色
MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
// 通过代理对象调用目标对象中的方法
marryCompanyProxy.toMarry();

目标对象不固定
在应用程序执行时动态创建目标对象
代理对象会增强目标对象的行为

JDK动态代理

注：JDK动态代理的目标对象必须有接口实现newProxyInstance

Proxy类：

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

如下操作方法：

获取代理对象返回一个指定接口的代理类的实例方法调用分派到指定的调用处理程序。 (返回代理对象)

loader：一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces：一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果 我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这 组接口中的方法了h：一个InvocationHandler接口，表示代理实例的调用处理程序实现的接口。每个代理实例都具有一个 关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序 的 invoke 方法（传入InvocationHandler接口的子类）
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
public class JdkHandler implements InvocationHandler {
// 目标对象
private Object target; // 目标对象的类型不固定，创建时动态生成
// 通过构造器将目标对象赋值
public JdkHandler(Object target) {
this.target = target;
}
/**
* 1、调用目标对象的方法（返回Object）
* 2、增强目标对象的行为
* @param proxy 调用该方法的代理实例
* @param method 目标对象的方法
* @param args 目标对象的方法形参
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
// 增强行为
System.out.println("==============方法前执行");
// 调用目标对象的方法（返回Object）
Object result = method.invoke(target,args);
// 增强行为
System.out.println("方法后执行==============");

4. 2. 3. 通过代理对象实现目标对象的功能

注：JDK的动态代理依靠接口实现，如果有些类并没有接口实现，则不能使用JDK代理。

4. 3. CGLIB 动态代理

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

return result;
}

得到代理对象

* public static Object newProxyInstance(ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h)
* loader：类加载器
* interfaces：接口数组
* h：InvocationHandler接口 (传入InvocationHandler接口的实现类)
*
*
* @return
*/
public Object getProxy() {
return
Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInt
erfaces(),this);
}
}

// 目标对象

You you = new You();
// 获取代理对象
JdkHandler jdkHandler = new JdkHandler(you);
Marry marry = (Marry) jdkHandler.getProxy();
// 通过代理对象调用目标对象中的方法
marry.toMarry();
问：Java动态代理类中的invoke是怎么调用的？
答：在生成的动态代理类$Proxy0.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量
invocationHandler赋值，$Proxy0.class的static模块中创建了被代理类的方法，调用相应方法时方法
体中调用了父类中的成员变量InvocationHandler的invoke()方法。

1. 1. 添加依赖

在pom.xml文件中引入cglib的相关依赖

4. 3. 2. 定义类

实现MethodInterceptor接口

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
public class CglibInterceptor implements MethodInterceptor {
// 目标对象
private Object target;
// 通过构造器传入目标对象
public CglibInterceptor(Object target) {
this.target = target;
}
/**
* 获取代理对象
* @return
*/
public Object getProxy() {
// 通过Enhancer对象的create()方法可以生成一个类，用于生成代理对象
Enhancer enhancer = new Enhancer();
// 设置父类 (将目标类作为其父类)
enhancer.setSuperclass(target.getClass());
// 设置拦截器 回调对象为本身对象
enhancer.setCallback(this);
// 生成一个代理类对象，并返回
return enhancer.create();
}
/**
* 拦截器
* 1 、目标对象的方法调用
* 2 、增强行为
* @param object 由CGLib动态生成的代理类实例
* @param method 实体类所调用的被代理的方法引用
* @param objects 参数值列表
* @param methodProxy 生成的代理类对方法的代理引用
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object object, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
// 增强行为
System.out.println("==============方法前执行");

调用方法

JDK代理与CGLIB代理的区别

JDK动态代理实现接口，Cglib动态代理继承思想

JDK动态代理（目标对象存在接口时）执行效率高于Ciglib

如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理

Spring AOP

日志处理带来的问题

我们有一个Pay(接口) 然后两个实现类DollarPay和RmbPay，都需要重写pay()方法, 这时我们需要对pay方法进行性能监控，日志的添加等等怎么做？

// 调用目标对象的方法（返回Object）
Object result = methodProxy.invoke(target,objects);
// 增强行为
System.out.println("方法后执行==============");
return result;
}
}
// 目标对象
You you = new You();
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
Marry marry = (Marry) cglibInterceptor.getProxy();
marry.toMarry();
User user = new User();
CglibInterceptor cglibInterceptor = new CglibInterceptor(user);
User u = (User) cglibInterceptor.getProxy();
u.test();

最容易想到的方法

对每个字符方法均做日志代码的编写处理，如下面方式

缺点: 代码重复太多, 添加的日志代码耦合度太高（如果需要更改日志记录代码功能需求，类中方法需要全部改动，工程量浩大）

使用装饰器模式 /代理模式改进解决方案

装饰器模式：动态地给一个对象添加一些额外的职责。

代理模式：以上刚讲过。于是得出以下结构：仔细考虑过后发现虽然对原有内部代码没有进行改动，对于每个类做日志处理，并引用目标类，但是如果待添加日志的业务类的数量很多，此时手动为每个业务类实现一个装饰器或创建对应的代理类，同时代码的耦合度也加大，需求一旦改变，改动的工程量也是可想而知的。

有没有更好的解决方案，只要写一次代码，对想要添加日志记录的地方能够实现代码的复用，达到松耦合的同时，又能够完美完成功能？

答案是肯定的，存在这样的技术，aop已经对其提供了完美的实现！

什么是AOP？

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop关注的不再是程序代码中某个类，某些方法，而aop考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所以称之为切面。联想大家吃的汉堡（中间夹肉）。那么aop是怎么做到拦截整个面的功能呢？考虑前面学到的servlet filter /* 的配置，实际上也是aop 的实现。

AOP能做什么？

AOP主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。

AOP的特点

降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
提高了代码的复用性。
提高系统的扩展性。（高版本兼容低版本）
可以在不影响原有的功能基础上添加新的功能

AOP的底层实现

动态代理（JDK + CGLIB）

AOP基本概念

Joinpoint（连接点）

被拦截到的每个点，spring中指被拦截到的每一个方法，spring aop一个连接点即代表一个方法的执行。

Pointcut（切入点）

对连接点进行拦截的定义（匹配规则定义规定拦截哪些方法，对哪些方法进行处理），spring 有专门的表达式语言定义。

Advice（通知）

拦截到每一个连接点即（每一个方法）后所要做的操作

Aspect（切面）

切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

Target（目标对象）

被代理的目标对象

（织入）

将切面应用到目标对象并生成代理对象的这个过程即为织入

Introduction（引入）

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

Spring AOP的实现

Spring AOP环境搭建

前置通知（前置增强）— before() 执行方法前通知
返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
异常抛出通知（异常抛出增强）— afetrThrow()
最终通知 — after 无论方法是否发生异常，均会执行该通知。
环绕通知 — around 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类
型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的
返回值或抛出异常来结束执行。

坐标依赖引入

添加spring.xml的配置

添加命名空间

注解实现

定义切面

<!--Spring AOP-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

切面
切入点和通知的抽象（与面向对象中的类相似）
定义切入点和通知（切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）

@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是一个切面
public class LogCut {
/**
* 切入点：
* 匹配规则。规定什么方法被拦截、需要处理什么方法
* 定义切入点
* @Pointcut("匹配规则")
*
* Aop 切入点表达式简介
* 1. 执行任意公共方法：
* execution(public *(..))
* 2. 执行任意的set方法
* execution(* set*(..))
* 3. 执行com.xxxx.service包下任意类的任意方法
* execution(* com.xxxx.service.*.*(..))
* 4. 执行com.xxxx.service 包 以及子包下任意类的任意方法
* execution(* com.xxxx.service..*.*(..))
*
* 注：表达式中的第一个* 代表的是方法的修饰范围
* 可选值：private、protected、public （* 表示所有范围）
*/
@Pointcut("execution (* com.xxxx.service..*.*(..) )")
public void cut(){}

/**
声明前置通知 并将通知应用到定义的切入点上
目标类方法执行前 执行该通知
*/

@Before(value = "cut()")
public void before() {
System.out.println("前置通知.....");
}

/**
声明返回通知 并将通知应用到定义的切入点上
目标类方法（无异常）执行后 执行该通知
*/
@AfterReturning(value = "cut()")
public void afterReturn() {
System.out.println("返回通知.....");
}

/**
声明最终通知 并将通知应用到定义的切入点上
目标类方法（无异常或有异常）执行后 执行该通知
*/
@After(value = "cut()")
public void after() {
System.out.println("最终通知.....");
}

/**

- 声明异常通知 并将通知应用到定义的切入点上
- 目标类方法出现异常时 执行该通知
  */
  @AfterThrowing(value="cut()",throwing = "e")
  public void afterThrow(Exception e) {
  System.out.println("异常通知....." + " 异常原因：" + e.getCause());
  }

/**

- 声明环绕通知 并将通知应用到切入点上
- 方法执行前后 通过环绕通知定义相应处理
- 需要通
- @param pjp
- @return
  */
  @Around(value = "cut()")
  public Object around(ProceedingJoinPoint pjp) {
  System.out.println("前置通知...");

Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");

配置文件（spring.xml）

XML实现

定义切面

System.out.println("最终通知...");
return object;
}
}

<aop:aspectj-autoproxy/>

切面
切入点和通知的抽象（与面向对象中的类相似）
定义切入点和通知（切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）

@Component // 将对象交给IOC容器去实例化
public class LogCut02 {
public void cut(){}

声明前置通知并将通知应用到定义的切入点上
目标类方法执行前执行该通知

public void before() {
System.out.println("前置通知.....");
}
/**
* 声明返回通知 并将通知应用到定义的切入点上
* 目标类方法（无异常）执行后 执行该通知
*
*/
public void afterReturn() {
System.out.println("返回通知.....");
}
/**
* 声明最终通知 并将通知应用到定义的切入点上
* 目标类方法（无异常或有异常）执行后 执行该通知
*
*/

配置文件（spring.xml）

public void after() {
System.out.println("最终通知.....");
}
/**
* 声明异常通知 并将通知应用到定义的切入点上
* 目标类方法出现异常时 执行该通知
*/
public void afterThrow(Exception e) {
System.out.println("异常通知....." + " 异常原因：" + e.getCause());
}

声明环绕通知并将通知应用到切入点上
方法执行前后通过环绕通知定义相应处理

* 需要通过显式调用对应的方法，否则无法访问指定方法 (pjp.proceed();)
* @param pjp
* @return
*/
public Object around(ProceedingJoinPoint pjp) {
System.out.println("前置通知...");
Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");
}
System.out.println("最终通知...");
return object;
}
}
<!--aop相关配置-->
<aop:config>
<!--aop切面-->
<aop:aspect ref="logCut02">
<!-- 定义aop 切入点 -->
<aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*
(..))"/>
<!-- 配置前置通知 指定前置通知方法名 并引用切入点定义 -->
<aop:before method="before" pointcut-ref="cut"/>
<!-- 配置返回通知 指定返回通知方法名 并引用切入点定义 -->
<aop:after-returning method="afterReturn" pointcut-ref="cut"/>
<!-- 配置异常通知 指定异常通知方法名 并引用切入点定义 -->

Spring AOP总结

代理模式实现三要素

接口定义
目标对象与代理对象必须实现统一接口
代理对象持有目标对象的引用增强目标对象行为

代理模式实现分类以及对应区别

静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
动态代理：在程序运行期动态创建目标对象对应代理对象。
jdk动态代理：被代理目标对象必须实现某一或某一组接口实现方式通过回调创建代理对象。
cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。

动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。

Aop 理解

面向切面，相比oop 关注的是代码中的层或面
解耦，提高系统扩展性
提高代码复用

Aop 关键词

连接点:每一个方法
切入点:匹配的方法集合
切面：连接点与切入点的集合决定了切面，横切关注点的抽象
通知:几种通知
目标对象:被代理对象
织入：程序运行期将切面应用到目标对象并生成代理对象的过程
引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程

<aop:after-throwing method="afterThrow" throwing="e" pointcut-
ref="cut"/>
<!-- 配置最终通知 指定最终通知方法名 并引用切入点定义 -->
<aop:after method="after" pointcut-ref="cut"/>
<!-- 配置环绕通知 指定环绕通知方法名 并引用切入点定义 -->
<aop:around method="around" pointcut-ref="cut"/>
</aop:aspect>
</aop:config>