SpringAOP

最新推荐文章于 2025-07-23 18:50:18 发布
原创 最新推荐文章于 2025-07-23 18:50:18 发布 · 116 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#代理模式 #java #spring

Spring AOP

主要内容

代理模式

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

生活中常见的代理情况：

租房中介、婚庆公司等

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

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

  2. 代理类增强委托类的行为

常用的代理模式：

  1. 静态代理

  2. 动态代理

静态代理

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

代理的三要素

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. 通过代理对象实现目标对象的功能

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

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

动态代理

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

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

  1. JDK 动态代理

  2. CGLIB动态代理

动态代理的特点

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

// 目标对象

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

  1. 目标对象不固定

  2. 在应用程序执行时动态创建目标对象

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

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. 添加依赖

在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的特点

  1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）

  2. 提高了代码的复用性。

  3. 提高系统的扩展性。（高版本兼容低版本）

  4. 可以在不影响原有的功能基础上添加新的功能

AOP的底层实现

动态代理（JDK + CGLIB）

AOP基本概念

Joinpoint（连接点）

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

Pointcut（切入点）

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

Advice（通知）

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

Aspect（切面）

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

Target（目标对象）

被代理的目标对象

（织入）

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

Introduction（引入）

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

Spring AOP的实现

Spring AOP环境搭建

  1. 前置通知 （前置增强）— before() 执行方法前通知
  2. 返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
  3. 异常抛出通知（异常抛出增强）— afetrThrow()
  4. 最终通知 — after 无论方法是否发生异常，均会执行该通知。
  5. 环绕通知 — 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总结

代理模式实现三要素

  1. 接口定义

  2. 目标对象与代理对象必须实现统一接口

  3. 代理对象持有目标对象的引用 增强目标对象行为

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

  1. 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建

  2. 动态代理：在程序运行期动态创建目标对象对应代理对象。

  3. jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。

  4. cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。

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

Aop 理解

  1. 面向切面，相比oop 关注的是代码中的层 或面

  2. 解耦，提高系统扩展性

  3. 提高代码复用

Aop 关键词

  1. 连接点:每一个方法

  2. 切入点:匹配的方法集合

  3. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象

  4. 通知:几种通知

  5. 目标对象:被代理对象

  6. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程

  7. 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程

<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>
Spring AOP 详解
2301_80035594的博客
10-19 6234
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP
2301_81096101的博客
03-22 1367
AOP（Aspect-Oriented Programming）即面向切面编程，是一种通过预编译或动态代理技术，将横切关注点（如日志、安全校验）与业务逻辑分离的编程范式。
spring AOP详解
是程序喵呀
11-07 3539
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
Spring Aop
会写Bug的攻城狮
08-30 1803
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
【JavaEE】Spring AOP的注解实现
yj20040627的博客
05-25 1万+
基于注解@annotation 和 execution 的方式实现SPring AOP
Spring AOP详解
2302_77758423的博客
07-21 1752
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP术语
yuehua00的专栏
11-11 1704
Spring AOP 中的核心术语和概念包括切面、通知、切入点、连接点、引介、目标对象、代理对象、织入、通知方法、切点表达式、切面优先级、织入器、AOP 代理和 AOP 框架。理解这些术语有助于更好地掌握 Spring AOP 的使用和原理，从而在实际开发中有效地应用 AOP 技术。通过合理使用 AOP，可以提高代码的模块化程度和可维护性，减少重复代码，提高开发效率。
Spring AOP 使用详解
lzz的博客
11-14 1525
Spring AOP 使用详解。核心概念+实现示例+注意事项
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
spring aop实现接口参数变更前后对比和日志记录
05-12
spring aop实现接口参数变更前后对比和日志记录完整代码，拿到项目代码，只需要做数据库连接的修改即可运行起来使用，代码案例详细，真是可靠，代码原文地址：...
【Java】Reflection反射（代理模式）
最新发布
m0_74244697的博客
07-23 248
代理模式通过引入代理对象控制对真实对象的访问，分为静态代理和动态代理。静态代理在编译时确定代理类，每个目标类需对应一个代理类；动态代理在运行时生成，灵活性更高，包括JDK代理（基于接口）和CGLIB代理（基于继承，无需接口）。JDK代理通过InvocationHandler实现方法拦截，CGLIB通过MethodInterceptor实现。代理模式增强了系统扩展性，静态代理适用于简单场景，动态代理适合复杂需求。
零基础数据结构与算法——第五章：高级算法-回溯算法&N皇后问题
qqxhb 资源共享
07-21 1006
文章摘要 回溯算法是一种通过试错思想解决问题的算法，它探索所有可能的解空间，遇到无效解时回退并尝试其他路径。该算法适用于组合、排列、子集、路径等问题，如经典的N皇后问题。回溯算法采用深度优先搜索策略，通过递归实现，其核心步骤包括定义解空间、确定终止条件、遍历可能选择以及回溯恢复状态。虽然实现简单且能穷尽所有解，但时间复杂度较高，通常为指数级。N皇后问题展示了回溯算法的典型应用，通过逐行放置皇后并检查冲突，最终找到所有合法解。该算法在解决约束满足类问题时表现出色，但需注意其性能限制。
一维DP深度解析
07-21 1315
动态规划（Dynamic Programming，DP）是算法设计中的重要思想，通过将复杂问题分解为重叠子问题，并利用子问题的解高效推导原问题答案。其中一维动态规划是最基础也最常用的形式——仅需一个一维数组存储子问题的解，就能“以空间换时间”解决一系列经典问题。
CCF编程能力等级认证GESP—C++8级—20250628
QD_Jason的博客
07-19 1044
CCF编程能力等级认证GESP—C++8级—20250628
设计模式-代理模式
2301_79108772的博客
07-23 455
先创建目标对象，然后调用newProxyInstance()方法，传入目标对象的Class对象，再传入生成的代理对象需要实现的接口（TargetObject定义的类也需要实现相关接口），最终传入一个-InvocationHandler接口实现类，实现invoke方法，invoke方法会传入method参数和args参数（method参数就是劫持的调用方法对象，args参数就是劫持函数对象接收的参数列表），在invoke方法中进行实现代理类的逻辑。
Spring aop
06-28
###Spring AOP 的概念 AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，旨在通过分离横切关注点来提高模块化程度。在 Spring 框架中，AOP 被广泛用于实现诸如日志记录、事务管理、安全性等通用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值