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

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

       在Spring AOP工作机制进一步理解（上篇）中，通过源码，分析了<aop:config>配置下的Spring AOP工作机制，本文在总结上篇的基础上，分析<aop:aspectj-autoproxy>配置下的工作机制。

<aop:aspectj-autoproxy>

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"/>
  	
	<!-- 扫描日志切面bean -->
	<context:component-scan base-package="org.test.aop"/>
  	
	<!-- 开启AOP注解方式 -->
	<aop:aspectj-autoproxy/>
		  
</beans>

解析

工作流程

        Spring xml的解析过程详见《Spring ioc容器启动流程—obtainFreshBeanFactory》，这里只涉及<aop:aspectj-autoproxy>的解析工作。AopNamespaceHandler会委托AspectJAutoProxyBeanDefinitionParser来进行解析工作，详细流程如下：


相关源码

/** AopConfigUtils.java */
// 注册AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition
// 其中cls的值为AnnotationAwareAspectJAutoProxyCreator.class
private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, Object source) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	// 判断是否已注册AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition
	// 其在beanFactory中对应的key为"org.springframework.aop.config.internalAutoProxyCreator"
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		return null;
	}
	// 创建且注册AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition
	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}


/** AopNamespaceUtils.java */
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
	if (sourceElement != null) {
		boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
		// 获取<aop:aspectj-autoproxy/>的proxy-target-class属性值
		if (proxyTargetClass) {
			// 设置AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition的proxyTargetClass属性为true
			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
		}
		// 获取<aop:aspectj-autoproxy/>的expose-proxy属性值
		boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
		if (exposeProxy) {
			// 设置AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition的exposeProxy属性为true
			AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
		}
	}
}

/** AopConfigUtils.java */
public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
	}
}

static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
	}
}


/** AopNamespaceUtils.java */
private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
	if (beanDefinition != null) {
		BeanComponentDefinition componentDefinition =
				new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
		parserContext.registerComponent(componentDefinition);
	}
}


/** AspectJAutoProxyBeanDefinitionParser.java */
private void extendBeanDefinition(Element element, ParserContext parserContext) {
	BeanDefinition beanDef =
			parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
	if (element.hasChildNodes()) {
		addIncludePatterns(element, parserContext, beanDef);
	}
}

生成代理对象

         在<aop:aspectj-autoproxy/>解析过程中，主要工作就是注册AnnotationAwareAspectJAutoProxyCreator RootBeanDefinition。

AnnotationAwareAspectJAutoProxyCreator对象实例化

         与<aop:config>方式一样。

InstantiationModelAwarePointcutAdvisorImpl对象实例化

         <aop:aspectj-autoproxy/>配置下所有@Aspect中Advice注解最终都会实例为InstantiationModelAwarePointcutAdvisorImpl对象，以进行AOP拦截。与<aop:config>方式一样，在生成业务userAction代理对象过程中，InstantiationModelAwarePointcutAdvisorImpl的实例化发生在resolveBeforeInstantiation环节，与<aop:config>方式不同的是，AnnotationAwareAspectJAutoProxyCreator覆盖了AspectJAwareAdvisorAutoProxyCreator的findCandidateAdvisors方法，自行实例化注解的PointcutAdvisor。下面解析只涉及AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors，其他过程忽略。

AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors基本流程


相关源码

/** AnnotationAwareAspectJAutoProxyCreator.java */
// <aop:aspectj-autoproxy/>注解方式下的PointcutAdvisor即InstantiationModelAwarePointcutAdvisorImpl对象实例化
protected List<Advisor> findCandidateAdvisors() {
	// 实例化<aop:config>的AspectJPointcutAdvisor
	List<Advisor> advisors = super.findCandidateAdvisors();
	// 实例化<aop:aspectj-autoproxy/>的InstantiationModelAwarePointcutAdvisorImpl
	advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
	return advisors;
}


/** BeanFactoryAspectJAdvisorsBuilder.java */
public List<Advisor> buildAspectJAdvisors() {
	List<String> aspectNames = null;

	synchronized (this) {
		aspectNames = this.aspectBeanNames;
		if (aspectNames == null) {
			List<Advisor> advisors = new LinkedList<Advisor>();
			aspectNames = new LinkedList<String>();
			// 获取beanFactory及其循环上级的所有bean
			String[] beanNames =
					BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
			for (String beanName : beanNames) {
				if (!isEligibleBean(beanName)) {
					continue;
				}
				// We must be careful not to instantiate beans eagerly as in this
				// case they would be cached by the Spring container but would not
				// have been weaved
				Class beanType = this.beanFactory.getType(beanName);
				if (beanType == null) {
					continue;
				}
				// 判断beanType及其循环super Class\interface是否带@Aspect
				// 采用(clazz.getAnnotation(annotationType)!= null)判断
				if (this.advisorFactory.isAspect(beanType)) {
					aspectNames.add(beanName);
					AspectMetadata amd = new AspectMetadata(beanType, beanName);
					if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
						MetadataAwareAspectInstanceFactory factory =
								new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
						// 获取Advisors
						List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
						// 缓存classAdvisors
						if (this.beanFactory.isSingleton(beanName)) {
							this.advisorsCache.put(beanName, classAdvisors);
						}
						else {
							this.aspectFactoryCache.put(beanName, factory);
						}
						advisors.addAll(classAdvisors);
					}
					else {
						// Per target or per this.
						if (this.beanFactory.isSingleton(beanName)) {
							throw new IllegalArgumentException("Bean with name '" + beanName +
									"' is a singleton, but aspect instantiation model is not singleton");
						}
						MetadataAwareAspectInstanceFactory factory =
								new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
						this.aspectFactoryCache.put(beanName, factory);
						advisors.addAll(this.advisorFactory.getAdvisors(factory));
					}
				}
			}
			this.aspectBeanNames = aspectNames;
			return advisors;
		}
	}

	if (aspectNames.isEmpty()) {
		return Collections.EMPTY_LIST;
	}
	// 从缓存中获取advisors
	List<Advisor> advisors = new LinkedList<Advisor>();
	for (String aspectName : aspectNames) {
		List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
		if (cachedAdvisors != null) {
			advisors.addAll(cachedAdvisors);
		}
		else {
			MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
			advisors.addAll(this.advisorFactory.getAdvisors(factory));
		}
	}
	return advisors;
}

/** ReflectiveAspectJAdvisorFactory */
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory maaif) {
	final Class<?> aspectClass = maaif.getAspectMetadata().getAspectClass();
	final String aspectName = maaif.getAspectMetadata().getAspectName();
	validate(aspectClass);

	// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
	// so that it will only instantiate once.
	final MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
			new LazySingletonAspectInstanceFactoryDecorator(maaif);

	final List<Advisor> advisors = new LinkedList<Advisor>();
	for (Method method : getAdvisorMethods(aspectClass)) {
		// 实例化<aop:aspectj-autoproxy/>注解方式下的PointcutAdvisor即InstantiationModelAwarePointcutAdvisorImpl
		Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
		if (advisor != null) {
			advisors.add(advisor);
		}
	}

	// If it's a per target aspect, emit the dummy instantiating aspect.
	if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
		Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
		advisors.add(0, instantiationAdvisor);
	}

	// Find introduction fields.
	for (Field field : aspectClass.getDeclaredFields()) {
		Advisor advisor = getDeclareParentsAdvisor(field);
		if (advisor != null) {
			advisors.add(advisor);
		}
	}

	return advisors;
}

// 获取aspectClass及其循环super Class\interface的不带@Pointcut的方法
private List<Method> getAdvisorMethods(Class<?> aspectClass) {
	final List<Method> methods = new LinkedList<Method>();
	// 回调doWith
	ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
		public void doWith(Method method) throws IllegalArgumentException {
			// 不包括pointcuts
			if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
				methods.add(method);
			}
		}
	});
	// 排序
	Collections.sort(methods, METHOD_COMPARATOR);
	return methods;
}

/** ReflectionUtils.java */
public static void doWithMethods(Class<?> clazz, MethodCallback mc) throws IllegalArgumentException {
	doWithMethods(clazz, mc, null);
}
public static void doWithMethods(Class<?> clazz, MethodCallback mc, MethodFilter mf)
		throws IllegalArgumentException {

	// 获取Declared Methods
	Method[] methods = clazz.getDeclaredMethods();
	for (Method method : methods) {
		if (mf != null && !mf.matches(method)) {
			continue;
		}
		try {
			mc.doWith(method);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException("Shouldn't be illegal to access method '" + method.getName()
					+ "': " + ex);
		}
	}
	if (clazz.getSuperclass() != null) {
		// 循环super Class
		doWithMethods(clazz.getSuperclass(), mc, mf);
	}
	else if (clazz.isInterface()) {
		for (Class<?> superIfc : clazz.getInterfaces()) {
			// 循环interface
			doWithMethods(superIfc, mc, mf);
		}
	}
}

/** ReflectiveAspectJAdvisorFactory.java */
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif,
		int declarationOrderInAspect, String aspectName) {

	validate(aif.getAspectMetadata().getAspectClass());

	AspectJExpressionPointcut ajexp =
			getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());
	if (ajexp == null) {
		return null;
	}
	// PointcutAdvisor对象实例化，<aop:aspectj-autoproxy/>注解方式下的PointcutAdvisor
	return new InstantiationModelAwarePointcutAdvisorImpl(
			this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);
}

// 获取candidateAdviceMethod的advice注解，提取Pointcut，返回AspectJExpressionPointcut
private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
	AspectJAnnotation<?> aspectJAnnotation =
			AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
	if (aspectJAnnotation == null) {
		return null;
	}
	AspectJExpressionPointcut ajexp =
			new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);
	ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
	return ajexp;
}

/** AbstractAspectJAdvisorFactory.java */
protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method) {
	//所有Advice注解
	Class<? extends Annotation>[] classesToLookFor = new Class[] {
			Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
	// 循环查找匹配Advice的AspectJAnnotation
	for (Class<? extends Annotation> c : classesToLookFor) {
		AspectJAnnotation foundAnnotation = findAnnotation(method, c);
		if (foundAnnotation != null) {
			return foundAnnotation;
		}
	}
	return null;
}

private static <A extends Annotation> AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
	A result = AnnotationUtils.findAnnotation(method, toLookFor);
	if (result != null) {
		// 获取到annotation则直接返回AspectJAnnotation
		return new AspectJAnnotation<A>(result);
	}
	else {
		return null;
	}
}

/** AnnotationUtils.java */
public static <A extends Annotation> A findAnnotation(Method method, Class<A> annotationType) {
	// 获取到annotation则直接返回
	A annotation = getAnnotation(method, annotationType);
	Class<?> clazz = method.getDeclaringClass();
	if (annotation == null) {
		// 在clazz的interface中查找带annotationType的method
		annotation = searchOnInterfaces(method, annotationType, clazz.getInterfaces());
	}
	while (annotation == null) {
		// 在clazz的super Class中查找带annotationType的method
		clazz = clazz.getSuperclass();
		if (clazz == null || clazz.equals(Object.class)) {
			break;
		}
		try {
			Method equivalentMethod = clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
			annotation = getAnnotation(equivalentMethod, annotationType);
		}
		catch (NoSuchMethodException ex) {
			// No equivalent method found
		}
		if (annotation == null) {
			annotation = searchOnInterfaces(method, annotationType, clazz.getInterfaces());
		}
	}
	return annotation;
}

public static <A extends Annotation> A getAnnotation(Method method, Class<A> annotationType) {
	Method resolvedMethod = BridgeMethodResolver.findBridgedMethod(method);
	// 利用Class.getAnnotation方法获取Annotation Class
	A ann = resolvedMethod.getAnnotation(annotationType);
	if (ann == null) {
		for (Annotation metaAnn : resolvedMethod.getAnnotations()) {
			ann = metaAnn.annotationType().getAnnotation(annotationType);
			if (ann != null) {
				break;
			}
		}
	}
	return ann;
}

/** InstantiationModelAwarePointcutAdvisorImpl.java */
// new InstantiationModelAwarePointcutAdvisorImpl对象
public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp,
		MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName) {

	this.declaredPointcut = ajexp;
	this.method = method;
	this.atAspectJAdvisorFactory = af;
	this.aspectInstanceFactory = aif;
	this.declarationOrder = declarationOrderInAspect;
	this.aspectName = aspectName;

	if (aif.getAspectMetadata().isLazilyInstantiated()) {
		// Static part of the pointcut is a lazy type.
		Pointcut preInstantiationPointcut =
				Pointcuts.union(aif.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);

		// Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
		// If it's not a dynamic pointcut, it may be optimized out
		// by the Spring AOP infrastructure after the first evaluation.
		this.pointcut = new PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aif);
		this.lazy = true;
	}
	else {
		// singleton aspect.
		// 实例化的Advice
		this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
		// pointcut对象
		this.pointcut = declaredPointcut;
		this.lazy = false;
	}
}

// 实例化Advice
private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
	return this.atAspectJAdvisorFactory.getAdvice(
			this.method, pcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
}

/** ReflectiveAspectJAdvisorFactory.java */
// 获取candidateAdviceMethod上的Advice对象
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut ajexp,
		MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName) {

	Class<?> candidateAspectClass = aif.getAspectMetadata().getAspectClass();
	validate(candidateAspectClass);

	// candidateAdviceMethod上的注解对象
	AspectJAnnotation<?> aspectJAnnotation =
			AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
	if (aspectJAnnotation == null) {
		return null;
	}

	// If we get here, we know we have an AspectJ method.
	// Check that it's an AspectJ-annotated class
	if (!isAspect(candidateAspectClass)) {
		throw new AopConfigException("Advice must be declared inside an aspect type: " +
				"Offending method '" + candidateAdviceMethod + "' in class [" +
				candidateAspectClass.getName() + "]");
	}

	if (logger.isDebugEnabled()) {
		logger.debug("Found AspectJ method: " + candidateAdviceMethod);
	}

	AbstractAspectJAdvice springAdvice;

	// 根据Advice注解类型，实例化相应的Advice，用candidateAdviceMethod、ajexp、aif进行构造
	switch (aspectJAnnotation.getAnnotationType()) {
		case AtBefore: // @Before
			springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, ajexp, aif);
			break;
		case AtAfter: // @After
			springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, ajexp, aif);
			break;
		case AtAfterReturning: // @AfterReturning
			springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, ajexp, aif);
			AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
			if (StringUtils.hasText(afterReturningAnnotation.returning())) {
				springAdvice.setReturningName(afterReturningAnnotation.returning());
			}
			break;
		case AtAfterThrowing: // @AfterThrowing
			springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, ajexp, aif);
			AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
			if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
				springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
			}
			break;
		case AtAround: // @Around
			springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, ajexp, aif);
			break;
		case AtPointcut: // @Pointcut
			if (logger.isDebugEnabled()) {
				logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
			}
			return null;
		default:
			throw new UnsupportedOperationException(
					"Unsupported advice type on method " + candidateAdviceMethod);
	}

	// 配置Advice对象
	springAdvice.setAspectName(aspectName);
	springAdvice.setDeclarationOrder(declarationOrderInAspect);
	String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
	if (argNames != null) {
		// 设置参数名称
		springAdvice.setArgumentNamesFromStringArray(argNames);
	}
	springAdvice.calculateArgumentBindings();
	return springAdvice;
}

/** ReflectiveAspectJAdvisorFactory.java */
// 获取@DeclareParents Annotation对象
private Advisor getDeclareParentsAdvisor(Field introductionField) {
	DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
	if (declareParents == null) {
		// Not an introduction field
		return null;
	}

	if (DeclareParents.class.equals(declareParents.defaultImpl())) {
		// This is what comes back if it wasn't set. This seems bizarre...
		// TODO this restriction possibly should be relaxed
		throw new IllegalStateException("defaultImpl must be set on DeclareParents");
	}

	return new DeclareParentsAdvisor(
			introductionField.getType(), declareParents.value(), declareParents.defaultImpl());
}

AnnotationAwareAspectJAutoProxyCreator生成代理类实例

          与<aop:config>方式一样。

调用代理对象

          与<aop:config>方式一样。

         <aop:aspectj-autoproxy/>与<aop:config>方式本质区别是PointcutAdvisor对象实例化方式不一样：<aop:aspectj-autoproxy/>采用注解方式，而<aop:config>则采用显示的xml配置方式，集中体现在findCandidateAdvisors。

Spring---关于AOP机制的讲解
weixin_46816383的博客
04-05 1063
Spring---关于AOP机制的讲解一、什么是AOP二、AOP思想（面向切面）三、AOP中常用术语一览四、AOP的优势及作用五、基于xml的SpringAOP配置1、导入依赖2、接口3、目标类4、增强类/通知类5、applicationContext.xml6、测试7、运行结果8、另外一种写法：环绕增强（常用）六、基于注解的SpringAOP配置1、接口2、实现类3、切面类4、测试5、运行结果 一、什么是AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编
Spring AOP实现机制
08-02
**Spring AOP 实现机制详解** Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许程序员在不修改源代码的...通过深入理解Spring AOP的实现机制，我们可以更好地利用这一强大的工具，优化我们的应用程序。
Spring AOP工作机制
探索java技术、web技术
04-25 1151
Advice PointCut Advisor 生成代理类实例：       步骤： 1）将ProxyFactoryBean属性interceptorNames对应的bean转化为Advisor，加入到advisors中； 2）如果ProxyFactoryBean属性singleton为true，则ProxyFactoryBean
Spring高手之路22——AOP切面类的封装与解析
最新发布
weixin_30499315的博客
09-01 160
1. AOP是如何收集切面类并封装的？在Spring中，AOP（Aspect-Oriented Programming，面向切面编程）通过以下几个步骤收集切面类并进行封装：1. 定义切面类：切面类通过@Aspect注解来标记，表示这是一个切面。在切面类中定义通知（advice），例如@Before、@After、...
Spring AOP工作机制进一步理解（总结篇）
探索java技术、web技术
12-02 693
Spring AOP工作机制基本流程
aop 实现机制
obj_668793的博客
09-21 446
静态代理 角色分析： 抽象角色：一般会使用接口或者抽象类来解决。（比如说租房，中介和房东去实现租房的接口） 真实角色：被代理的角色。 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作。 客户：访问代码对象的人。 代码步骤： 1，接口 // 租房 public interface Rent { public void rent(); } 2，真实角色 //房东 public class Host implements Rent{ public vo...
Spring AOP机制
gis_zhouda的博客
11-06 251
看了很多Spring AOP的文章，该博文写的比较简单易懂，转载学习下。 转自：https://www.cnblogs.com/hongwz/p/5764917.html AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念...
深入理解spring的AOP机制原理
08-29
深入理解 Spring 的 AOP 机制原理 AOP（Aspect-Oriented Programming），即面向方面编程，是一种编程范式，它可以将横切关注点与业务逻辑分离开来。AOP 的主要思想是将系统中的公共功能抽象出来，形成一个独立的...
SpringAop的简单理解.pdf
02-28
SpringAOP(面向切面编程)是Spring框架的一个关键组件，它允许开发者通过定义切面来统一处理横切关注点，比如日志、安全等。它与AspectJ一样，目标是为了处理横切业务，但实现方式有所区别。AspectJ是一种更全面的AOP...
Spring AOP 16道面试题及答案.docx
06-29
总的来说，Spring AOP通过代理和通知机制，实现了横切关注点的模块化，使得业务逻辑与系统服务（如日志、事务等）解耦，提高了代码的可读性和可维护性。同时，引介功能进一步增强了切面的功能，可以为对象动态地添加...
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
谈谈对Spring的AOP机制
weixin_45723088的博客
10-14 159
谈到Spring,必然是它的核心两大功能，IOC和AOP. AOP:面向切面，其原理就是通过动态代理，代理类做一系列的切面处理。 动态代理有两种方式，JDK原生的和CG。（boot2之后用的就是CG） 这里注意，JDK原生的的本质是其通过接口的方式生成的代理类，而CG是通过子类继承父类的方式生成的代理类，如果是final不可继承的肯定是生成不了代理类。 AOP的运用场景：很多小白还不了解在什么时候用过AOP。 首先，事务的运用就是AOP,翻开Dao层的注解是不是有个@Transactional，你把@Tra
AOP是如何工作的
weixin_39098289的博客
06-22 263
一、AOP是什么 1、AOP就是面向切面编程，是一种适合在无需修改业务代码的前提下，对某个或某些业务增加统一的功能、比如日志记录、权限控制、事务管理等，能很好的使的代码解耦、提高开发效率 二、AOP的核心概念 1、Advice 可以理解为通知、建议，在Spring中通过定义Advice来定义代理逻辑 2、Pointcut Pointcut是切点，表示Advice对应的逻辑应用在那个类上、那个方法上 3、Advisor Advisor=Advice+Pointcut，表示代理逻辑和切点的一个整体，程序员可以通
Spring AOP工作机制进一步理解（下篇）
探索java技术、web技术
12-02 755
前面通过源码，分析了、配置下的spring AOP工作机制，本文分析AutoProxyCreator、ProxyFactoryBean配置下的工作机制。 AutoProxyCreator Spring xml配置文件 解析 工作流程 相关源码 生成代理对象 AnnotationAwareAspectJAutoProxyCreator对象实例化 I
Spring AOP工作机制进一步理解（上篇）
探索java技术、web技术
11-27 1248
什么是Spring AOP?          详细请见：http://blog.csdn.net/architect0719/article/details/53283763 Spring AOP源码分析          Spring可以通过、、AutoProxyCreator、ProxyFactoryBean配置方式实现AOP，下面进行详细分析： 解析        Sprin
08-你真的看懂了SpringAOP的运行机制吗？
互联网十年老兵
05-16 338
之前我们谈了Spring-IOC，这是非常巧妙的思想，今天我们继续来探讨Spring的另一个重要特性Spring-AOPAOP(Aspect Oriented Programming):面向切面编程什么是面向切面编程，我的理解是，在没有使用面向切面编程之前，我们是经常把业务的核心代码和非核心业务代码混搭在一起。我们以数据库的操作为例来说明：1，获取连接对象2，执行SQL（核心业务代码）3.1，如果...
Spring AOP源码研究笔记
Ydoing的专栏
12-31 1140
实现思路通过BeanPostProcessor的postProcessAfterInitialization方法，对初始化后的Bean创建代理。InstantiationModelAwarePointcutAdvisorImpl是Advisor的默认封装。MethodBeforeAdviceInterceptor是Before的默认实现。关键源码解析AbstractAutoProxyCreator类
Spring源码学习（三）IOC
vipchenwei的博客
05-27 227
Spring 最重要的概念是 IOC 和 AOP，其中IOC又是Spring中的根基： 创建IOC容器 初始化Bean 源码 // 加载spring上下文 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class); public AnnotationConfigApplicationContext(Class<?>... componen
跟着小马哥学系列之 Spring AOP（AspectJAdvisorFactory 详解）
qq_42419406的博客
05-18 2092
跟着小马哥学系列之 Spring AOP（ProxyProcessorSupport 详解）简介 学成路更宽，钱多少加班。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring AOP 编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 ...
深入理解Spring AOP代理机制
"本文将深入讲解Spring AOP代理模式，包括静态代理和动态代理的概念与实现。" 在软件开发中，AOP（Aspect Oriented Programming，面向切面编程...理解并熟练运用Spring AOP代理，可以显著提高代码的可读性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值