Spring之AOP篇

原创 已于 2023-10-16 16:15:17 修改 · 525 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #前端

于 2023-08-17 18:44:59 首次发布

目录

1.AOP简介

2.AOP特点

2.1思考

3.Spring的AOP专用术语

3.1目标  连接点  通知  代理

3.2切入点与适配器

4.Spring的前置通知

5.Spring的后置通知

6.Spring的环绕通知

7.Spring的异常通知

8.Spring的过滤通知

1.AOP简介

Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个关键特性，它允许开发者实现跨应用程序模块的横切关注点（cross-cutting concerns）的功能。横切关注点是指那些在应用程序的多个模块中重复出现的功能，如日志记录、性能监测、事务管理等。Spring AOP通过将这些横切关注点与主要应用程序逻辑分离开来，提供了更好的模块化和代码复用性。

在Spring AOP中，开发者可以使用通知（advice）来定义横切关注点的行为。通知有四种类型：

  1. 前置通知（Before Advice）：在目标方法执行之前执行的通知。
  2. 后置通知（After Returning Advice）：在目标方法成功执行后执行的通知。
  3. 异常通知（After Throwing Advice）：在目标方法抛出异常后执行的通知。
  4. 最终通知（After Advice）：无论目标方法的执行结果如何，都会执行的通知。

除了以上四种通知类型，Spring AOP还支持环绕通知（Around Advice），环绕通知可以在目标方法的前后都执行自定义的逻辑。

Spring AOP的核心概念是切面（Aspect）。一个切面由切点（Pointcut）和通知组成。切点定义了在应用程序中哪些类、哪些方法应该被应用切面的通知。通知定义了切面所提供的横切关注点的具体行为。

Spring AOP可以通过两种方式来实现：基于代理的模式和基于字节码增强的模式。基于代理的模式是通过生成代理对象来织入切面逻辑，而基于字节码增强的模式则是直接修改目标类的字节码来织入切面逻辑。

总的来说，Spring AOP提供了一种方便的方式来实现横切关注点的功能，并可以与Spring的IOC容器无缝集成，使得开发者能够更加灵活和高效地开发应用程序。 

2.AOP特点

Spring AOP具有以下特点：

  1. 非侵入性：Spring AOP以编程的方式实现横切关注点，而不需要修改原有的业务逻辑代码。开发者只需在配置文件或注解中定义切面和通知，然后让Spring框架自动完成织入操作。

  2. 模块化：Spring AOP可以将横切关注点的逻辑抽取到切面中，实现代码的模块化和复用。开发者可以通过定义多个切面来关注不同的横切关注点，而不需要在每个模块中都重复编写相同的代码。

  3. 松耦合：Spring AOP让开发者将横切关注点的逻辑与核心业务逻辑分开，实现了关注点与业务逻辑的解耦。这样一来，当横切关注点需要修改或扩展时，不会影响到核心业务代码的修改。

  4. 支持多种切点表达式：Spring AOP提供了丰富的切点表达式，开发者可以根据需要定义不同的切点，灵活地选择要织入切面的方法或类。

  5. 支持多种通知类型：Spring AOP支持多种类型的通知，如前置通知、后置通知、异常通知和最终通知。开发者可以根据不同的需求选择合适的通知类型来实现横切关注点的行为。

  6. 可扩展性：Spring AOP是一个可扩展的框架，可以与其他的AOP框架集成使用，如AspectJ。开发者可以利用AspectJ提供的更强大的切点表达式和通知类型来扩展Spring AOP的功能。

总的来说，Spring AOP通过提供非侵入性、模块化、松耦合的方式实现横切关注点的功能，为开发者提供了一种简便、灵活和可扩展的AOP解决方案。

2.1思考

AOP能解决什么问题？

参考于之前我们写的代码，假设我们需要做一个网上书城项目，那我们就必备一个书籍管理模块(BookAction，BookService)，如下：

模拟场景：

场景一：客户使用系统，上架了一本zf明令禁止售卖的书籍

场景二：对于平台方而言，客户已经下单并付款，工作人员出于私心，从中牟利。

伪代码如下：

BookAction

BookService

//正常增删改查上架下架功能

add(book book){

        bookdao.add

}

del(book book){

        bookdao.del

}

edit(book book){

        bookdao.edit

}

list(book book){

        bookdao.list

}

up(book book){

//每个系统都会添加日志功能，也就是在每个业务模块操作板块，添加日志记录。

        //什么时间点谁调用了什么类的什么方法传了什么参数以及最终方法的返回值是什么

        datetime current = ...

        String username = req.getsession.getattribute("user").getUserid;

        String classNameMethodName = this.getClass().getMethod...

        String params = arrays.toString(...);

        String methodreturn = ...

        bookdao.up

        logDao.add(current,username,classNameMethodName,params,methodreturn);//日志

}

down(book book){

        bookdao.down

        logDao.add(current,username,classNameMethodName,params,methodreturn);//日志

}

那么上述代码有何不足之处呢？
如上所说，每个增删改上架下架功能都添加非业务 核心功能的日志功能代码，会重复冗余。

所以回到提问，AOP能解决什么问题？如下：

  1. 横切关注点的代码重复：在应用程序中，某些功能（如日志记录、异常处理、安全检查等）可能会在多个模块中重复出现。使用AOP可以将这些功能的实现抽取到切面中，避免代码的重复编写，提高代码的可维护性。

  2. 核心业务逻辑与非核心逻辑的耦合：在传统的编程模式中，核心业务逻辑与非核心逻辑（如事务管理、性能监测）往往混杂在一起，使得代码难以理解和修改。通过使用AOP，可以将非核心逻辑抽离出来，与核心业务逻辑解耦，使得代码更加清晰和易于维护。

  3. 跨层级的功能扩展：有时候需要在应用程序的多个层级（如控制层、服务层、持久层）中添加某些功能，例如权限验证、缓存管理等。使用AOP可以通过切面的方式统一织入这些功能，而不需要在每个层级中重复添加代码，提高代码的复用性和可扩展性。

  4. 业务逻辑的优化和统计：通过AOP可以方便地在应用程序中插入性能监测、统计分析等代码，实现对业务逻辑的优化和监控。例如，可以使用AOP在方法执行前记录开始时间，在方法执行后记录结束时间，计算方法的执行时间等。

  5. 异常处理和错误处理：AOP可以帮助处理应用程序中的异常情况。通过定义异常通知，可以在方法抛出异常时执行相应的处理逻辑，如记录日志、发送通知等。这样可以使得异常处理的逻辑与核心业务逻辑分离开来，提高代码的可读性和可维护性。

总的来说，AOP可以帮助提高代码的模块化和复用性，解耦核心业务逻辑与非核心逻辑，实现功能的统一扩展和优化，以及完成异常处理和错误处理等任务。它提供了一种灵活的编程方式，使得开发者能够更加高效地开发和维护应用程序。

3.Spring的AOP专用术语

  • 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.
  • 目标(Target)：被通知(被代理)的对象。注1：完成具体的业务逻辑
  • 通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)   注2：完成切面编程
  • 代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),例子：外科医生+护士注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的。

3.1目标  连接点  通知  代理

我们依照第二点的伪代码来进行罗列详细讲解，如下：

面向切面编程与原有代码运行模式的区别：

之前我们实现功能都是代码从上至下执行实现，但是现在加入了切面，也就是从上至下执行代码，执行到切面时停止了，先要找到通知，找到通知之后，再走接下来的代码。完整的功能是指，既执行了目标代码，也执行了通知，才是一个完整的功能（代理）。

往简单了讲，假设目标是一位明星 ，通知是经纪人，假设明星要拍一部电影，经纪人需要去接这部电影，但是经纪人不负责拍戏，真正做事的人是明星（目标）。但是完整的流程走下来，缺一不可。真正做事的是目标对象，缺了通知整个功能也不完整。就像网上书城系统，上架功能做完了，并不完整。应客户要求可能还需要一个监管功能。

完整的业务链：

AOP面向切面编程，改变了我们原有的代码运行模式，原来是从上至下一路往下走，而面向切面编程时原有的代码走到连接点这个位置时，如果还有前置通知，先执行前置通知再执行目标对象。如果没有前置通知，就会执行目标对象，再执行后置通知，如有后置通知就会执行后置通知。

3.2切入点与适配器

  • 切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)
  • 适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

切入点是连接点的集合，比如我既要给书籍管理的新增功能要加监管日志功能，又要给订单管理添加日志功能。要给两个连接点加，那么我们应该写一个类似于以下格式的正则表达式：

com.kissship..controller.*.*Add(..))'

去匹配上那两个连接点。即：

切入点是连接点的集合。

适配器就是通知＋切入点。找到切入点是为了干嘛，不就是为了添加日志的功能（以上面实例来说），日志即通知。

4.Spring的前置通知

在讲解前，我们需要做一些准备工作，目录结构如下：

IBookBiz：

package com.kissship.aop.biz;

public interface IBookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);

	// 发表书评
	public void comment(String userName, String comments);
}

 BookBizImpl：

package com.kissship.aop.biz.impl;

import com.kissship.aop.biz.IBookBiz;
import com.kissship.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);
	}

}

异常类PriceException：

package com.kissship.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);
	}
	
}

配置spring-context.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byType"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


<!--    ioc的javabean-->
<!--    凡是在Spring配置文件spring-context.xml中配置,那么该类javabean就交给了Spring容器管理-->
    <bean class="com.kissship.ioc.web.UserAction" id="userAction">
        <property name="userService" ref="userService"></property>
<!--        <constructor-arg name="uname" value="扎克" ></constructor-arg>-->
<!--        <constructor-arg name="age" value="18" ></constructor-arg>-->
<!--        <constructor-arg name="hobby">-->
<!--        <list>-->
<!--            <value>唱，跳</value>-->
<!--            <value>Rap</value>-->
<!--            <value>篮球</value>-->
<!--        </list>-->
<!--        </constructor-arg>-->
    </bean>
    <bean class="com.kissship.ioc.web.GoodsAction" id="goodsAction">
        <property name="userService" ref="userServiceImpl1"></property>
<!--        <property name="gname" value="小文"></property>-->
<!--        <property name="age" value="19"></property>-->
<!--        <property name="peoples">-->
<!--            <list>-->
<!--                <value>印度飞饼</value>-->
<!--                <value>意大利炮</value>-->
<!--                <value>北京烤鸭</value>-->
<!--                <value>墨西哥卷</value>-->
<!--            </list>-->
<!--        </property>-->
    </bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl2" id="userService"></bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl1" id="userServiceImpl1"></bean>


<!--   aop相关的Javabean-->
    <!--目标对象-->
    <bean class="com.kissship.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
</beans>

最后建一个测试类Demo1进行测试：

package com.kissship.aop.demo;

import com.kissship.aop.biz.IBookBiz;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Kissship
 * @site www.Kissship.com
 * @company xxx公司
 * @create 2023-08-17-17:08
 */
public class Demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        IBookBiz bookBiz = (IBookBiz) context.getBean("bookBiz");
        bookBiz.buy("GG Bone","美丽的小姐",9.9d);
        bookBiz.comment("GG Bone","我叫Bone,GG Bone!");

    }
}

测试结果如下：

这是没有前置通知的演示效果，我们添加前置通知试试：

MyMethodBeforeAdvice：

package com.kissship.aop.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 买书、评论前加系统日志
 * @author Administrator
 *
 */
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，如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byType"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


<!--    ioc的javabean-->
<!--    凡是在Spring配置文件spring-context.xml中配置,那么该类javabean就交给了Spring容器管理-->
    <bean class="com.kissship.ioc.web.UserAction" id="userAction">
        <property name="userService" ref="userService"></property>
<!--        <constructor-arg name="uname" value="扎克" ></constructor-arg>-->
<!--        <constructor-arg name="age" value="18" ></constructor-arg>-->
<!--        <constructor-arg name="hobby">-->
<!--        <list>-->
<!--            <value>唱，跳</value>-->
<!--            <value>Rap</value>-->
<!--            <value>篮球</value>-->
<!--        </list>-->
<!--        </constructor-arg>-->
    </bean>
    <bean class="com.kissship.ioc.web.GoodsAction" id="goodsAction">
        <property name="userService" ref="userServiceImpl1"></property>
<!--        <property name="gname" value="小文"></property>-->
<!--        <property name="age" value="19"></property>-->
<!--        <property name="peoples">-->
<!--            <list>-->
<!--                <value>印度飞饼</value>-->
<!--                <value>意大利炮</value>-->
<!--                <value>北京烤鸭</value>-->
<!--                <value>墨西哥卷</value>-->
<!--            </list>-->
<!--        </property>-->
    </bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl2" id="userService"></bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl1" id="userServiceImpl1"></bean>


<!--   aop相关的Javabean-->
    <!--目标对象-->
    <bean class="com.kissship.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.kissship.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.kissship.aop.biz.IBookBiz</value>
            </list>
        </property>
<!--        配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
            </list>
        </property>
    </bean>
</beans>

修改Demo1测试类进行测试：

package com.kissship.aop.demo;

import com.kissship.aop.biz.IBookBiz;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Kissship
 * @site www.Kissship.com
 * @company xxx公司
 * @create 2023-08-17-17:08
 */
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");
        System.out.println(bookBiz);
        bookBiz.buy("GG Bone","美丽的小姐",9.9d);
        bookBiz.comment("GG Bone","我叫Bone,GG Bone!");
    }
}

演示结果如下：

5.Spring的后置通知

新建一个MyAfterReturningAdvice通知类，如下：

package com.kissship.aop.advice;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 买书返利
 * @author Administrator
 *
 */
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：

往原本的XML代码中，通知注释下加入以下代码：

<bean class="com.kissship.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>

然后配置通知，加入：

<value>myAfterReturningAdvice</value>

完整xml配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byType"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


<!--    ioc的javabean-->
<!--    凡是在Spring配置文件spring-context.xml中配置,那么该类javabean就交给了Spring容器管理-->
    <bean class="com.kissship.ioc.web.UserAction" id="userAction">
        <property name="userService" ref="userService"></property>
<!--        <constructor-arg name="uname" value="扎克" ></constructor-arg>-->
<!--        <constructor-arg name="age" value="18" ></constructor-arg>-->
<!--        <constructor-arg name="hobby">-->
<!--        <list>-->
<!--            <value>唱，跳</value>-->
<!--            <value>Rap</value>-->
<!--            <value>篮球</value>-->
<!--        </list>-->
<!--        </constructor-arg>-->
    </bean>
    <bean class="com.kissship.ioc.web.GoodsAction" id="goodsAction">
        <property name="userService" ref="userServiceImpl1"></property>
<!--        <property name="gname" value="小文"></property>-->
<!--        <property name="age" value="19"></property>-->
<!--        <property name="peoples">-->
<!--            <list>-->
<!--                <value>印度飞饼</value>-->
<!--                <value>意大利炮</value>-->
<!--                <value>北京烤鸭</value>-->
<!--                <value>墨西哥卷</value>-->
<!--            </list>-->
<!--        </property>-->
    </bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl2" id="userService"></bean>
    <bean class="com.kissship.ioc.service.impl.UserServiceImpl1" id="userServiceImpl1"></bean>


<!--   aop相关的Javabean-->
    <!--目标对象-->
    <bean class="com.kissship.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.kissship.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.kissship.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>

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

然后我们接着再来测试一下，测试结果如下：

6.Spring的环绕通知

新建一个MyMethodInterceptor，如下：

package com.kissship.aop.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import java.util.Arrays;

/**
 * 环绕通知
 * 	包含了前置和后置通知
 * 
 * @author Administrator
 *
 */
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;
	}

}

然后跟前后置一样配置xml：

加入以下xml到固定位置，如下：

<!--通知-->
<bean class="com.kissship.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>

<!--        配置通知-->
<value>myMethodInterceptor</value>

然后回到Demo1进行测试，结果如下：

7.Spring的异常通知

把书的价格改为负数，控制台报错，在没加异常通知前，效果如下：

加入异常通知，新建一个MyThrowsAdvice通知类，如下：

package com.kissship.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.kissship.aop.exception.PriceException;

/**
 * 出现异常执行系统提示，然后进行处理。价格异常为例
 * @author Administrator
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
	public void afterThrowing(PriceException ex) {
		System.out.println("【异常通知】：当价格发生异常，那么执行此处代码块！！！");
	}
}

 配置spring-context,xml：

<!--通知-->
    <bean class="com.kissship.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
<!--        配置通知-->
                <value>myThrowsAdvice</value>

添加异常通知后的效果如下：

  

8.Spring的过滤通知

把价格改回正常之后，我们执行会发现一个问题，如下：

我们通过过滤通知试着解决一下，如下（注：需把原有的后置通知注释）：

 <!--通知-->
<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="regexpMethodPointcutAdvisor">
        <property name="advice" ref="myAfterReturningAdvice"></property>
        <property name="pattern" value=".*buy"></property>
    </bean>

<!--        配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
<!--                <value>myAfterReturningAdvice</value>-->
                <value>regexpMethodPointcutAdvisor</value>
                <value>myMethodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>

测试结果如下：

可以看到在评论之后并没有买书返利的后置通知了。

最后Spring之AOP篇就到这里，祝大家在敲代码的路上一路通畅!

感谢大家的观看 !

死磕Spring之AOP篇 - Spring AOP常见面试题
m0_57077948的博客
03-14 1241
代理模式是一种结构性设计模式，通过代理类为其他对象提供一种代理以控制对这个对象的访问。AOP 代理是 AOP 框架中 AOP 的实现，主要分为静态代理和动态代理，如下：静态代理：代理类需要实现被代理类所实现的接口，同时持有被代理类的引用，新增处理逻辑，进行拦截处理，不过方法还是由被代理类的引用所执行。静态代理通常需要由开发人员在编译阶段就定义好，不易于维护。常用 OOP 继承和组合相结合AspectJ，在编辑阶段会织入 Java 字节码，且在运行期间会进行增强。
【Spring篇】Spring的Aop详解
m0_74202856的博客
10-23 5049
一个有趣爱睡觉的intp，期待和更多人分享自己所学知识的真诚大学生。
Spring之AOP（带你一篇文章搞定AOP）
浩泽学编程的博客
07-25 801
Spring的核心之一：AOPAOP：面向切面编程。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。通俗来说就是在不修改代码的情况下添加新的功能。底层通过动态代理实现：（1）有接口情况：使用JDK动态代理，即创建接口实现类的代理对象。（2）无接口情况：使用CGLIB动态代理，即创建当前类子类的代理对象。
Spring AOP详解
2303_80195175的博客
05-04 1501
面向切面编程（AOP，Aspect-Oriented Programming）是一种编程范式，旨在通过分离横切关注点（cross-cutting concerns）来提升代码的模块化。AOP 的核心思想横切关注点：指那些分散在多个模块中的通用功能（如日志、事务、安全等），传统OOP难以集中管理，导致代码冗余。切面（Aspect）：将横切关注点封装为独立模块，通过声明式或编程方式注入到业务逻辑中，实现关注点分离。关键概念切面（Aspect）封装横切逻辑的模块（如日志切面），包含通知和切点定义。
Spring之AOP切面编程
从基础到源码解析的学习记录
06-26 2008
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程它是面向对象编程的一种补充和完善它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。
Spring之AOP入门篇
热门推荐
楠黎倾风的博客
11-15 1万+
spring之AOP入门篇
【Spring】AOP
zhyhgx的博客
02-28 1653
AOP(Aspect Oriented Programming) 是一种编程范型，即面向切面编程。什么是面向切面编程？切面就是指某一类特定问题，所以AOP也可以理解为面向特定方法编程。面向编程旨在通过分离横切关注点来提高代码的模块化和可维护性，允许开发者将那些与业务逻辑无关，但又需要在多个地方使用的功能（如日志记录、事务管理、安全性等）从业务逻辑中分离出来。在前面我们的登录校验，用了拦截器，其实也是对AOP思想的一种实现。统一数据返回格式和统一异常处理也是AOP的一种实现。
Spring——AOP代理机制详解
qq_53574615的博客
10-24 944
切面的工作被称为通知，通知定义了切面是什么以及何时使用，除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。
Spring源码之AOP实现
qq_38706652的博客
08-20 2650
Spring源码之AOP
【Spring】Spring AOP
web13508588635的博客
12-09 923
前面我们学习了 SpringBoot 统一功能处理，这篇文章我将为大家分享 Spring 框架的第二大核心——AOP（第一大核心是 IOC）AOP（Aspect Oriented Programming）是一种编程范型，意为面向切面编程，什么是向切面编程呢？切面就是指某类特定问题，所以AOP也可以理解为面向特定法编程，它通过预编译和运行期动态代理的方式实现程序功能的统一维护。
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
全网最简单、通俗易理解SpringBoot教程，基础篇04-Spring之AOP面向切面编程
05-13
Spring框架对AOP的支持简化了AOP的实现，使得开发者可以专注于业务逻辑的开发，而不是通用功能的实现。AOP的核心概念包括切面（Aspect）、连接点（Joinpoint）、切入点（Pointcut）、通知（Advice）等。 切面是横切...
SpringSpring Aop基础入门
09-26
在Java社区中，Spring框架所提供的AOP支持是应用最为广泛的AOP实现之一。Spring AOP允许开发者将诸如日志记录、声明式事务、安全检查等跨多个点的系统服务从业务逻辑代码中分离出来，从而简化这些服务的管理与维护。...
Spring Boot + Spring AI快速体验
2509_94006535的博客
11-21 1028
Spring AI是Spring的一个子项目，是Spring专门面向于AI的应用框架。Spring AI 项目旨在简化整合人工智能功能的应用程序开发，避免不必要的复杂性。汲取了著名的 Python 项目 LangChain 和 LlamaIndex 的灵感，但 Spring AI 并不是这些项目的直接移植。该项目的成立的信念：下一波生成式人工智能应用程序不仅将面向Python开发人员，而且将在许多编程语言中无处不在。@Bean。
springboot接入deepseek深度求索 java
最新发布
2509_94082931的博客
11-23 296
以下是在springboot中接入aideepseek的过程。官网并没有java的示例。
My-Agent - 基于Java和Spring AI的智能体开发平台
持续分享有趣的技术干货
11-19 695
My-Agent是一个基于Java和SpringAI构建的智能体开发平台，采用前后端分离架构（React+SpringBoot），提供完整的AI智能体生命周期管理方案。核心特性包括：多模型支持（OpenAI/Ollama等）、可视化工作流编排、知识库检索（基于PgVector）以及工具集成扩展能力。平台采用模块化设计，支持流式对话、对话记忆管理等交互功能，并具备完善的监控与安全机制（JWT认证）。技术栈涵盖JDK21、SpringBoot3、MySQL8、PostgreSQL（PgVector）和Redis
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 436
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
Spring Boot 集成 Spring AI：实现大模型对话与MCP Client
iioSnail的博客
11-20 820
上篇文章中（Spring Boot 集成 Spring AI：实现可被大模型调用的 MCP Server），我们构建了一个MCP Server，提供了查询个人信息、查询订单信息、下单等操作。但是，上篇文章我们使用的是Cherry Studio作为客户端来与后端进行交互。实际生产中，让客户去下载Cherry Studio，然后配置MCP Server显然不显示。因此，本篇文章将会教会你如何使用 Spring AI 构建一个简单的聊天界面，并支持MCP Client.
Spring注解AOP编程示例教程
根据给定的文件信息，我们将详细探讨Spring框架中的AOP（面向切面编程）以及如何使用注解的方式来实现AOP编程。本篇知识点将围绕以下几个方面展开： ### 1. Spring框架简介 Spring是一个开源的Java平台，最初由Rod ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Kissship

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值