Spring AOP工作机制进一步理解（下篇）

最新推荐文章于 2022-12-12 21:51:04 发布
最新推荐文章于 2022-12-12 21:51:04 发布
阅读量754 收藏
点赞数
分类专栏： Spring 文章标签： spring aop 工作机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Architect0719/article/details/53418451
版权

        前面通过源码，分析了<aop:aspectj-autoproxy>、<aop:config>配置下的spring AOP工作机制，本文分析AutoProxyCreator、ProxyFactoryBean配置下的工作机制。

BeanNameAutoProxyCreator

Spring xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
						http://www.springframework.org/schema/context  
						http://www.springframework.org/schema/context/spring-context-3.0.xsd
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<!-- 用户业务逻辑bean -->
  	<bean id="userAction" class="org.test.aop.UserAction"/>

	<!-- MethodBeforeAdvice bean -->
	<bean id="aopMethodBeforeAdvice" class="org.test.aop.AopMethodBeforeAdvice"/>
 
	<!-- BeanNameAutoProxyCreator配置 -->
	<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames">
			<value>
				*Action
			</value>
		</property>
		<property name="interceptorNames">
			<value>aopMethodBeforeAdvice</value>
		</property>
		<property name="optimize">
			<value>true</value>
		</property>
	</bean>

</beans>

解析

       xml配置中的BeanNameAutoProxyCreator、AopMethodBeforeAdvice都是以bean的形式解析，且注册到beanFactory，详见 《Spring ioc容器启动流程—obtainFreshBeanFactory》。

生成代理对象

BeanNameAutoProxyCreator对象实例化

       AbstractAutoProxyCreator实现了BeanPostProcessor接口，BeanPostProcessor对象实例化发生在AbstractApplicationContext.refresh()的registerBeanPostProcessors步骤。在所有AOP的配置中，这点是一样的。

BeanNameAutoProxyCreator生成代理类实例

       与<aop:config>方式基本流程一样。区别在于，BeanNameAutoProxyCreator配置在AbstractAutoProxyCreator.createProxy的buildAdvisors步骤中获取Advisors的方式：

/** AbstractAutoProxyCreator.java */
// 获取Advisors，用于AOP拦截机制
protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
	// BeanNameAutoProxyCreator配置在resolveInterceptorNames中实例化PointcutAdvisor，且为DefaultPointcutAdvisor
	Advisor[] commonInterceptors = resolveInterceptorNames();

	List<Object> allInterceptors = new ArrayList<Object>();
	// BeanNameAutoProxyCreator配置下specificInterceptors的length为0
	if (specificInterceptors != null) {
		allInterceptors.addAll(Arrays.asList(specificInterceptors));
		if (commonInterceptors != null) {
			if (this.applyCommonInterceptorsFirst) {
				allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
			}
			else {
				allInterceptors.addAll(Arrays.asList(commonInterceptors));
			}
		}
	}
	if (logger.isDebugEnabled()) {
		int nrOfCommonInterceptors = (commonInterceptors != null ? commonInterceptors.length : 0);
		int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
		logger.debug("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
				" common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
	}

	Advisor[] advisors = new Advisor[allInterceptors.size()];
	for (int i = 0; i < allInterceptors.size(); i++) {
		advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
	}
	return advisors;
}

// BeanNameAutoProxyCreator中显示指明interceptorNames属性，根据interceptor的名称实例化Advice，包装为DefaultPointcutAdvisor
private Advisor[] resolveInterceptorNames() {
	ConfigurableBeanFactory cbf = (this.beanFactory instanceof ConfigurableBeanFactory) ?
			(ConfigurableBeanFactory) this.beanFactory : null;
	List<Advisor> advisors = new ArrayList<Advisor>();
	for (String beanName : this.interceptorNames) {
		if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
			Object next = this.beanFactory.getBean(beanName);
			advisors.add(this.advisorAdapterRegistry.wrap(next));
		}
	}
	return advisors.toArray(new Advisor[advisors.size()]);
}

DefaultAdvisorAutoProxyCreator

Spring xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
						http://www.springframework.org/schema/context  
						http://www.springframework.org/schema/context/spring-context-3.0.xsd
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
  	<!-- 用户业务逻辑bean -->
	<bean id="userAction" class="org.test.aop.UserAction"/>

	<!-- MethodBeforeAdvice bean -->
	<bean id="aopMethodBeforeAdvice" class="org.test.aop.AopMethodBeforeAdvice"/>

	<!-- DefaultAdvisorAutoProxyCreator配置 -->
	<bean id="regexpAdvisor2" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="pattern">
			<value>.*modiUser.*</value>
		</property>
		<property name="advice" ref="aopMethodBeforeAdvice">
		</property>
	</bean>
	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
              
</beans>

解析

        xml配置中的DefaultAdvisorAutoProxyCreator、RegexpMethodPointcutAdvisor、AopMethodBeforeAdvice都是以bean的形式解析，且注册到beanFactory。  

生成代理对象

DefaultAdvisorAutoProxyCreator生成代理类实例

       与<aop:config>方式一样。

        BeanNameAutoProxyCreator配置下的PointcutAdvisor实例化在AbstractAutoProxyCreator.buildAdvisors中发生、DefaultAdvisorAutoProxyCreator配置下的PointcutAdvisor实例化在AbstractAutoProxyCreator.getAdvicesAndAdvisorsForBean中发生，都是在AbstractAutoProxyCreator.postProcessAfterInitialization过程中完成。

ProxyFactoryBean

Spring xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
						http://www.springframework.org/schema/context  
						http://www.springframework.org/schema/context/spring-context-3.0.xsd
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">		
	<!-- 用户业务逻辑bean --> 
	<bean id="impl" class="org.test.aop.AopImpl"/>
	<!-- aroundInterceptor bean --> 
	<bean id="aroundInterceptor" class="org.test.aop.AopAroundInterceptor"/>  
	<!-- beforeInterceptor bean --> 	
	<bean id="beforeInterceptor" class="org.test.aop.AopBeforeInterceptor"/>  	
	<bean id="beforePatternInterceptor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">  
			<ref bean="beforeInterceptor"/>  
		</property>  
	 
		<property name="patterns">  
			<value>.*doabc.* </value>  
		</property>  
	</bean>   
	<!-- ProxyFactoryBean配置 --> 
	<bean id="proxyFactoryBean" 
	    class="org.springframework.aop.framework.ProxyFactoryBean">
	    <property name="proxyInterfaces">
	        <value>
	            org.test.aop.AopInterface
	        </value>
	    </property>
	    <property name="target"><ref local="impl"></ref> </property>
	    <property name="singleton"><value>true</value></property>
	    <property name="interceptorNames">
	        <list>
	        	<value>beforePatternInterceptor</value>
	            <value>aroundInterceptor</value>
	        </list>
	    </property>
	</bean>
             
</beans>

解析

        xml配置中的AopAroundInterceptor、RegexpMethodPointcutAdvisor、ProxyFactoryBean都是以bean的形式解析，且注册到beanFactory。

ProxyFactoryBean类结构继承图：


生成代理对象

         ProxyFactoryBean是FactoryBean，从其getObject()获取的Object是代理对象：

/** ProxyFactoryBean.java */
// 获取代理对象
public Object getObject() throws BeansException {
	// 实例化advice
	initializeAdvisorChain();
	if (isSingleton()) {
		// 获取Singleton代理对象
		return getSingletonInstance();
	}
	else {
		if (this.targetName == null) {
			logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
					"Enable prototype proxies by setting the 'targetName' property.");
		}
		// 获取Prototype代理对象
		return newPrototypeInstance();
	}
}

private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
	if (this.advisorChainInitialized) {
		return;
	}

	if (!ObjectUtils.isEmpty(this.interceptorNames)) {
		if (this.beanFactory == null) {
			throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
					"- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
		}

		// Globals can't be last unless we specified a targetSource using the property...
		if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
				this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
			throw new AopConfigException("Target required after globals");
		}

		// Materialize interceptor chain from bean names.
		for (String name : this.interceptorNames) {
			if (logger.isTraceEnabled()) {
				logger.trace("Configuring advisor or advice '" + name + "'");
			}

			if (name.endsWith(GLOBAL_SUFFIX)) {
				if (!(this.beanFactory instanceof ListableBeanFactory)) {
					throw new AopConfigException(
							"Can only use global advisors or interceptors with a ListableBeanFactory");
				}
				addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
						name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
			}

			else {
				// If we get here, we need to add a named interceptor.
				// We must check if it's a singleton or prototype.
				Object advice;
				if (this.singleton || this.beanFactory.isSingleton(name)) {
					// 实例化Advice
					advice = this.beanFactory.getBean(name);
				}
				else {
					// It's a prototype Advice or Advisor: replace with a prototype.
					// Avoid unnecessary creation of prototype bean just for advisor chain initialization.
					advice = new PrototypePlaceholderAdvisor(name);
				}
				addAdvisorOnChainCreation(advice, name); // Advice转化为Advisor
			}
		}
	}

	this.advisorChainInitialized = true;
}

// 创建代理对象
private synchronized Object getSingletonInstance() {
	if (this.singletonInstance == null) {
		this.targetSource = freshTargetSource();
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class targetClass = getTargetClass();
			if (targetClass == null) {
				throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
			}
			setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
		}
		// Initialize the shared singleton instance.
		super.setFrozen(this.freezeProxy);
		this.singletonInstance = getProxy(createAopProxy());
	}
	return this.singletonInstance;
}

       <aop:aspectj-autoproxy>、<aop:config>、AutoProxyCreator、ProxyFactoryBean是spring AOP几种不同的应用场景，但AOP的核心流程一样。

Architect0719
关注
专栏目录
Spring AOP工作机制
探索java技术、web技术
04-25 1149
Advice PointCut Advisor 生成代理类实例：       步骤： 1）将ProxyFactoryBean属性interceptorNames对应的bean转化为Advisor，加入到advisors中； 2）如果ProxyFactoryBean属性singleton为true，则ProxyFactoryBean
aop 实现机制
obj_668793的博客
09-21 444
静态代理 角色分析： 抽象角色：一般会使用接口或者抽象类来解决。（比如说租房，中介和房东去实现租房的接口） 真实角色：被代理的角色。 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作。 客户：访问代码对象的人。 代码步骤： 1，接口 // 租房 public interface Rent { public void rent(); } 2，真实角色 //房东 public class Host implements Rent{ public vo...
Spring AOP工作机制进一步理解（总结篇）
探索java技术、web技术
12-02 692
Spring AOP工作机制基本流程
Spring AOP工作机制进一步理解（中篇）
探索java技术、web技术
11-30 1270
Spring AOP工作机制进一步理解（下篇）
跟着小马哥学系列之 Spring AOP（AbstractAutoProxyCreator 详解）
qq_42419406的博客
05-14 3444
跟着小马哥学系列之 Spring AOP（ProxyProcessorSupport 详解）简介AbstractAutoProxyCreator 功能 学成路更宽，吊打面试官。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring AOP 编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 AbstractAutoProxyCreato
Spring aop 性能监控器
04-20
在IT行业中，Spring AOP（面向切面编程）是一种强大的工具，它允许我们在不修改代码的情况下，对应用程序的特定部分进行拦截和增强。这在性能监控、日志记录、...结合源码学习，可以提升对Spring AOP机制的深入理解。
SpringAOP之探秘（动态代理、责任链模式、注解使用）
12-14
学习这些示例，你可以更深入地理解Spring AOP的工作原理，掌握如何使用动态代理和责任链模式来编写切面，以及如何通过注解简化AOP的配置和使用。这些知识对于任何涉及Spring框架的开发者来说都是至关重要的，因为...
征服Spring AOP—— @AspectJ
04-03
在压缩包文件"spring-aop-aspectj"中，可能包含了关于Spring AOP和@AspectJ的示例代码或文档，可以帮助你进一步理解和实践这些知识。通过学习和实践，你将能更好地掌握这一强大的工具，从而在你的IT职业生涯中征服...
初探spring aop内部实现 java
04-30
本篇文章将深入探讨Spring AOP的内部实现，以及如何通过源代码理解其DataSource实现和FactoryBean模式。 首先，让我们了解AOP的基本概念。AOP的核心思想是“切面”，它封装了特定的关注点，如日志记录、事务管理、...
应用Spring AOP（五）-------XML配置方式
08-02
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志...对于更复杂的需求，可以深入学习Spring AOP的源码，理解其底层实现机制，以便更好地利用这一强大工具。
Spring源码深度解析：十六、@Aspect方式的AOP下篇 - createProxy
最新发布
知行
12-12 625
/ 这里的入参 beanClass ：当前BeanClass, // beanName : 当前BeanName // specificInterceptors ： 中篇中寻找出来的 Advisor // targetSource : SingletonTargetSource 目标类是单例 拥有给定对象的TargetSource接口的实现。这是Spring AOP框架使用的TargetSource接口的默认实现。通常不需要在应用程序代码中创建此类的对象。
关于AOP的实现原理
m0_56065322的博客
11-20 4114
什么是AOP，AOP即面向切面编程，和OOP（面向对象编程）类似，也是一种编程思想。AOP采取横向抽取机制（动态代理），取代了传统纵向继承机制的重要性代码，其应用主要体现在事务处理，日志管理、权限控制、异常处理等方面。主要作用是分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少业务代码的侵入，增强代码的可读性和可维护性。简单的来说，AOP的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。AOP就是代理模式的典型应用。
Springboot 整合Shiro 轻量级权限框架，从数据库设计开始带你快速上手shiro
默默不代表沉默
04-26 2517
前言 shiro是一个轻量级的权限框架，该篇我将会从0到1快速教大家搭建出一套包含角色，权限登录校验的项目。 就算你没了解过，也能学会。跟着我把代码敲一遍，这个项目就是属于你的。 该篇文章比较啰嗦，篇幅较长，如果不是入门的初学者大可不必从头开始阅读（我一般的教程都会以从零开始的方式，所以都比较啰嗦）。 正文 数据库的准备（Mysql）： 在这是实践的案例里面，数据库表三...
SpringBoot整合Shiro权限框架
aa11dddd的博客
11-04 133
SpringBoot整合Shiro权限框架 1.导入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4.1</version> </dependency> 2.开始整合 把CustomRealm和SecurityManager等加入到s
Spring AOP 自动代理源码 DefaultAdvisorAutoProxyCreator
bugpool的博客
04-03 4830
前言 前面已经学习了ProxyFactory的源码，学习了如何手动硬编码使用最基础的Spring AOP，以及实现方式。这一节要学习自动代理DefaultAdvisorAutoProxyCreator源码。比起Spring AOP注解形式实现自动代理，我们之前学习的ProxyFactory还差以下2步： 代理时机：在Spring Ioc创建Bean的过程中，寻找合适的时机进行调用Spring A...
SpringBoot+Vue从零开始做网站6-集成shiro实现登录和权限控制
sunon_的博客
05-23 1623
到上一篇已经把前后端的项目底子搭好了，今天开始做功能，首先就是后台管理系统登录功能。 Shiro简介 Apache Shiro是一个轻量级的身份验证与授权Java安全框架。对比Spring Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用简单易用的Shiro就足够了，灵活性高。springboot本身是提供了对security的支持。springboot暂时没有集成shiro，这得自己配。 Shiro三个核心概念：Subject
AOP的实现机制
执着之道
10-18 605
附件中有本文的源代码和Pdf版。本文写的很长的原因，是不希望大家学习AOP时到处找资料，大家有时间可以按照本文动手实践下，相信会有非常大的收获的，有什么问题互相交流，有问必答！ 1 AOP各种的实现     AOP就是面向切面编程，我们可以从几个层面来实现AOP。 在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。    ...
Spring AOP : APC 自动代理创建器 AbstractAutoProxyCreator
Details Inside Spring
07-17 1648
概述 AbstractAdvisorAutoProxyCreator是Spring AOP提供的一个SmartInstantiationAwareBeanPostProcessor,它的作用是将符合条件的bean包装成代理对象,包装成代理对象的过程会在bean实例外面包裹相应的AOP拦截器。调用者对该bean的方法调用，其实首先发生在相应的代理上，经过层层包裹的AOP拦截器之后，才真正执行目标be...
spring boot第八次作业
a2534142998的博客
08-04 184
Shiro进行权限控制 1 . 添加依赖 org.apache.shiro shiro-spring 1.2.5 org.apache.shiro shiro-ehcache 1.2.5 2 . 编写Shiro配置类 package com.xbz.web.system.config; import at.pollux.thymeleaf.shiro.dialect.ShiroDialect; import org.apache.shiro.authc
深入理解Spring：IOC、AOP与BeanFactory解析
"这篇文章除了概述作者对Spring框架的理解，还强调了Spring在创建Bean时的工厂模式，特别是Prototype和Singleton作用域的区别，以及Spring的IoC（控制反转）和AOP（面向切面编程）核心特性。此外，文章提到了Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值