Spring AOP的实现原理

已于 2023-10-14 10:59:46 修改
阅读量264 收藏 6
点赞数 6
分类专栏： Spring 文章标签： spring java 后端 maven intellij-idea servlet
于 2023-08-18 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74268571/article/details/132341802
版权

目录

前言

一、Spring的aop的概念

AOP是什么

横切关注点

AOP的特点

AOP带来的好处

二、AOP的实现原理

1、基于代理的实现

2、切点

3、切面

4、通知

5、织入

三、Spring AOP concepts（AOP术语）

思维导图

【术语】：

适配器

四、常用通知

前置通知（Before advice）：

​编辑 后置通知（After returning advice）：

​编辑 环绕通知（Around advice）：

异常通知（After throwing advice）： 

 过滤通知（Filtering Notifications advice）：

前言

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底层原理到这就结束啦，希望各位大佬能一键三连哦！！

孤留光乩
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
Spring AOP 技术实现原理
xdpcxq的专栏
01-20 666
Spring AOP的实现基于代理模式，通过代理对象来包装目标对象，实现切面逻辑的注入。通过本文，我们深入了解了Spring AOP是如何基于JDK动态代理和CGLIB代理技术实现的。通过详细的示例演示，希望读者能更清晰地理解Spring AOP的底层原理，并在实际项目中灵活应用这一强大的技术。
Spring 之 AOP 原理详解
20年码农
04-14 2054
AOP是一种编程范式，用于在不修改原始代码的情况下向现有应用程序添加新功能。这种编程方式将应用程序分成许多独立的部分，称为切面。这些切面可以在应用程序的不同位置进行编写和维护，从而提高了应用程序的可重用性和可维护性。AOP主要用于实现横切关注点（Cross-Cutting Concerns），例如日志记录、性能监测、事务管理等。通过AOP，我们可以将这些关注点与应用程序的其他部分分离开来，从而使应用程序更加模块化和易于维护。
Spring中AOP的实现原理
qq_44918331的博客
03-11 1万+
一、什么是 AOP ？ AOP（Aspect-Oriented Programming，面向方面编程），对 OOP（Object-Oriented Programming，面向对象编程） 【OOP与AOP】 概念 AOP（Aspect-Oriented Programming，面向方面编程） OOP（Object-Oriented Programming，面向对象编程） 方向 OOP 定义从上到下的关系 AOP 定义从左到右的关系 【两个部分】 核心关注点 业务处理的主要流程
Spring AOP的实现方式与原理
最新发布
做梦都想要三十万年薪~
04-18 3046
Spring AOP原理
spring源码解析之AOP原理
韩猿外的博客
06-05 769
上一步我发现AnnotationAwareAspectJAutoProxyCreator在所有bean创建时进行了拦截，执行其中的postProcessBeforeInstantiation方法，接下来我们继续通过断点调试查看该方法的进行的操作。我们继续完善之前的流程.。创建代理对象过程中，会先创建一个代理工厂，获取到所有的增强器（通知方法），将这些增强器和目标类注入代理工厂，再用代理工厂创建对象。我们细看创建代理对象的过程，发现在创建之前首先会根据切入点表达式对增强器进行一一匹配，最终拿到所有的增强器。
Java－由源代码分析Spring AOP的实现原理
了解➔熟悉➔掌握➔精通
12-08 422
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 什么是AOP AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许
Spring——Spring AOP原理
庄小焱
03-30 2141
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
Spring AOP实现原理解析
08-28
Spring AOP实现原理解析 Spring AOP（Aspect-Oriented Programming）是一种面向方面编程的技术，它可以将公共行为封装到一个可重用模块中，以减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可...
深入浅析Spring 的aop实现原理
09-02
AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。本文给大家介绍Spring 的aop实现原理，感兴趣的朋友一起学习吧
Java框架篇?spring AOP 实现原理
12-22
什么是AOP 　AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共...
Spring框架系列(9) - Spring AOP实现原理详解之AOP切面的实现.doc
07-08
Spring AOP 实现原理详解之 AOP 切面的实现 Spring AOP 是基于 IOC 的 Bean 加载来实现的，本文主要介绍 Spring AOP 原理解析的切面实现过程。AOP 切面的实现是将切面类的所有切面方法根据使用的注解生成对应 ...
Spring AOP实现原理
qq_43012298的博客
01-19 415
Spring AOP是基于代理模式的，它在运行时动态地创建代理对象，并根据定义的切面和通知来增加额外的行为。通过使用JDK动态代理或CGLIB，Spring能够将通知应用到目标对象的方法上。深入理解和使用Spring AOP能够让您在不改变现有业务逻辑代码的情况下，增加如日志、事务管理、安全控制等横切关注点。
Spring API 接口和自定义类来实现AOP（Spring学习笔记十）
weixin_59096327的博客
03-30 487
全称是 Aspect Oriented Programming 即：面向切面编程。是OOP（面向对象编程）的延续，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。简单的说他就是把我们程序重复的代码抽取出来，在需要执行的时候使用动态代理技术在不修改源码的基础上，对我们的已有方法进行增强。AOC在Spring中的作用创建自定义类和方法System.out.println("====切面之前执行====");System.out.println("====切面之后执行====");
【spring系列】之17:spring aop工程流程
licwzy的博客
10-20 291
AOP：【动态代理】 * 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式； * * 1、导入aop模块；Spring AOP：(spring-aspects) * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx） * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行； * 通知方法： * .
Spring 框架之 AOP 原理剖析
good7ob的博客
05-29 158
在软件开发中，面向切面编程（Aspect-Oriented Programming，简称 AOP）是一种重要的编程范式，它可以帮助我们更好地解耦复杂的系统，提高代码的可维护性。本文详细介绍了 Spring AOP 的原理和实践，包括 AOP 的基本概念、Spring AOP 的实现原理以及如何在 Spring 框架中使用 AOP。在 Spring 框架中，AOP 是一个核心组件，本文将为你剖析 Spring AOP 的原理，带你领略 AOP 的魅力。
Spring AOP的三种实现方式
热门推荐
BAI20010904的博客
01-14 1万+
目录 一、什么是AOP 二、Spring AOP的三种实现方式 1.通过Spring API实现AOP （1）编写业务接口和实现类 （2）编写增强类，并实现Spring API相关接口的方法 （3）在resource目录下新建applicationContext文件，实现java类的创建和aop的织入 （4）编写测试类 2.通过自定义类来实现（推荐） （1）自定义切入类 （2）去spring中配置 （3）编写测试类 3.使用注解实现 （1）自定义增强类（注解实现） （2）..
Spring系列之AOP实现的两种方式
u013733643的博客
04-08 2701
AOP常用的实现方式有两种，一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）。 首先复习下AOP中一些比较重要的概念： Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行 。Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。一般都是按照一定的约定规则来表示的，如正则表达式等。切点是由一类连接点组成。Advice（通知)：还是说的通俗点，就是在指定切点上
springaop实现原理
05-10
Spring AOP实现原理主要是基于动态代理，它通过代理对象来控制访问目标对象的过程。当我们在应用中使用AOP时，Spring会在运行时动态地创建一个代理对象，该代理对象包含了目标对象的所有方法，并且可以在目标对象的方法执行前后加入额外的逻辑。 Spring AOP的实现过程分为以下几步： 1.定义切点：指定在哪些方法上应用AOP。 2.定义通知：在方法执行前、后或出现异常时执行的代码。 3.创建代理对象：Spring使用JDK动态代理或CGLib动态代理技术创建代理对象。 4.代理对象调用目标对象：代理对象拦截目标对象的方法调用，并在执行通知之后再调用目标对象的方法。 在实际应用中，我们可以通过配置文件或注解的方式来定义切点和通知，Spring会根据配置自动生成代理对象。 总之，Spring AOP实现原理主要是基于动态代理和切面编程思想，通过代理对象控制访问目标对象的过程，并在方法执行前后加入额外的逻辑，实现了面向切面编程的目的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值