Sping AOP 源码解析（二、创建 AOP 代理——获取增强器）

最新推荐文章于 2022-09-15 15:02:37 发布
最新推荐文章于 2022-09-15 15:02:37 发布
阅读量118 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyxabcdef/article/details/111938457
版权

基本思路分析

AspectJAwareAdvisorAutoProxyCreator 实现了 BeanPostProcessor 接口，可以在其父类 AbstractAutoProxyCreator 中找到 postProcessAfterInitialization 方法。

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	if (bean != null) {
		// 根据给点的 bean 的 class 和 name 构建 key，格式：beanClassName_beanName
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
			// 如果适合被代理，则需要封装指定 bean
			return wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
	// 已经处理过，跳过
	if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
		return bean;
	}
	// 无须增强
	if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
		return bean;
	}
	// 给点的 bean 类是否代表一个基础设施类，基础设施类不应该被代理
	// 配置的指定的 bean 也不需要被代理
	if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	// 存在增强方法则创建代理
	// Create proxy if we have advice.
	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
	if (specificInterceptors != DO_NOT_PROXY) {
		this.advisedBeans.put(cacheKey, Boolean.TRUE);
		// 创建代理
		Object proxy = createProxy(
				bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
		this.proxyTypes.put(cacheKey, proxy.getClass());
		return proxy;
	}

	this.advisedBeans.put(cacheKey, Boolean.FALSE);
	return bean;
}

创建代理的步骤主要包含两个步骤：

  1. 获取增强方法或者增强器；
  2. 根据获取的增强进行代理。

下面我们就这两步进行详细分析。

获取增强器

protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
	List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
	if (advisors.isEmpty()) {
		return DO_NOT_PROXY;
	}
	return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
	extendAdvisors(eligibleAdvisors);
	if (!eligibleAdvisors.isEmpty()) {
		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
	}
	return eligibleAdvisors;
}

protected List<Advisor> findCandidateAdvisors() {
	// 这里调用父类方法，保证了对 XML 配置的支持
	// Add all the Spring advisors found according to superclass rules.
	List<Advisor> advisors = super.findCandidateAdvisors();
	// Build Advisors for all AspectJ aspects in the bean factory.
	if (this.aspectJAdvisorsBuilder != null) {
		// 这里是对注解的支持
		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
	}
	return advisors;
}

public List<Advisor> findAdvisorBeans() {
	// 判断是否有缓存
	// Determine list of advisor bean names, if not cached already.
	String[] advisorNames = this.cachedAdvisorBeanNames;
	if (advisorNames == null) {
		// 没有缓存，获取所有的 beanName
		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the auto-proxy creator apply to them!
		advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
				this.beanFactory, Advisor.class, true, false);
		this.cachedAdvisorBeanNames = advisorNames;
	}
	if (advisorNames.length == 0) {
		return new ArrayList<>();
	}
	
	List<Advisor> advisors = new ArrayList<>();
	// 循环所有的 beanName 找到对应的增强方法
	for (String name : advisorNames) {
		// 忽略不合法的 bean，由子类定义规则，这里默认返回 true
		if (isEligibleBean(name)) {
			if (this.beanFactory.isCurrentlyInCreation(name)) {
				if (logger.isTraceEnabled()) {
					logger.trace("Skipping currently created advisor '" + name + "'");
				}
			}
			else {
				try {
					advisors.add(this.beanFactory.getBean(name, Advisor.class));
				}
				...
			}
		}
	}
	return advisors;
}

public List<Advisor> buildAspectJAdvisors() {
	List<String> aspectNames = this.aspectBeanNames;

	if (aspectNames == null) {
		synchronized (this) {
			aspectNames = this.aspectBeanNames;
			if (aspectNames == null) {
				List<Advisor> advisors = new ArrayList<>();
				aspectNames = new ArrayList<>();
				// 获取所有的 beanName
				String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
						this.beanFactory, Object.class, true, false);
				// 循环所有 beanName
				for (String beanName : beanNames) {
					// 忽略不合法的 bean，由子类定义规则，这里默认返回 true
					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.
					// 获取对应 bean 类型
					Class<?> beanType = this.beanFactory.getType(beanName);
					if (beanType == null) {
						continue;
					}
					// 如果存在 Aspect 注解
					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);
							// 解析标记 AspectJ 注解中的增强方法
							List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
							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.emptyList();
	}
	
	// 解析缓存中的 beanName
	List<Advisor> advisors = new ArrayList<>();
	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;
}

由于是采用了注解的方式，所以这里列出了 AnnotationAwareAspectJAutoProxyCreator 中的源码。从 getAdvicesAndAdvisorsForBean 到 findEligibleAdvisors 再到 findCandidateAdvisors 函数。AnnotationAwareAspectJAutoProxyCreator 类中的 findCandidateAdvisors 函数通过调用父类方法，保留了对 XML 配置的支持，同时添加了 buildAspectJAdvisors 函数，对注解添加支持。buildAspectJAdvisors 函数的大致流程如下：

  1. 获取所有 beanName，这一步骤中所有在 beanFactory 中注册的 bean 都会被提取出来。
  2. 遍历所有 beanName，并找出声明 AspectJ 注解的内，进行进一步的处理。
  3. 对标记为 AspectJ 注解的内进行增强器的提取。
  4. 将提取结果加入缓存。

上述函数最主要的功能由 getAdvisors 函数实现，下面给出源码。

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
	// 获取类
	Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
	// 获取 name
	String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
	// 验证
	validate(aspectClass);

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

	List<Advisor> advisors = new ArrayList<>();
	for (Method method : getAdvisorMethods(aspectClass)) {
		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);
	}

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

	return advisors;
}

首先完成了对增强器的获取，包括获取注解以及根据注解生成增强的步骤，然后考虑在配置中可能会将增强延迟初始化，需要在首位加入同步实例化增强器以保证增强使用之前的实例化，最后是对 DeclareParents 的获取。

普通增强器的获取

普通增强器是通过 getAdvisor 函数获取的。

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
			int declarationOrderInAspect, String aspectName) {
	validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
	// 切点信息获取
	AspectJExpressionPointcut expressionPointcut = getPointcut(
			candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
	if (expressionPointcut == null) {
		return null;
	}
	// 根据切点信息生成增强器
	return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
			this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

第一步，切点信息的获取。切点信息就是注解中的表达式信息。如 @Before(“test()”) 中的 “test()”。

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
		AspectJAnnotation<?> aspectJAnnotation =
	
	// 获取方法上的注解	
	AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
	if (aspectJAnnotation == null) {
		return null;
	}
	
	// 通过 AspectJExpressionPointcut 实例封装获取的信息
	AspectJExpressionPointcut ajexp =
			new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
	// 提取注解中的表达式	
	ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
	if (this.beanFactory != null) {
		ajexp.setBeanFactory(this.beanFactory);
	}
	return ajexp;
}

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
	// private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
	// 		Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};
	// 查看敏感的注解类
	for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
		// 获取指定方法上的注解并使用 AspectJAnnotation 封装
		AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
		if (foundAnnotation != null) {
			return foundAnnotation;
		}
	}
	return null;
}

第二步，根据切点信息生成增强。利用 InstantiationModelAwarePointcutAdvisorImpl 类封装，如果不是延迟加载的话，就通过 instantiateAdvice 函数进行加载。

private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
	Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
			this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
	return (advice != null ? advice : EMPTY_ADVICE);
}

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

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

	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 ...
	}

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

	AbstractAspectJAdvice springAdvice;
	// 根据不同的注解类型封装不同的增强器
	switch (aspectJAnnotation.getAnnotationType()) {
		case AtPointcut:
			// ...
			return null;
		case AtAround:
			springAdvice = new AspectJAroundAdvice(
					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
			break;
		case AtBefore:
			springAdvice = new AspectJMethodBeforeAdvice(
					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
			break;
		case AtAfter:
			springAdvice = new AspectJAfterAdvice(
					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
			break;
		case AtAfterReturning:
			springAdvice = new AspectJAfterReturningAdvice(
					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
			AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
			if (StringUtils.hasText(afterReturningAnnotation.returning())) {
				springAdvice.setReturningName(afterReturningAnnotation.returning());
			}
			break;
		case AtAfterThrowing:
			springAdvice = new AspectJAfterThrowingAdvice(
					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
			AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
			if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
				springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
			}
			break;
		default:
			throw ...
	}

	// Now to configure the advice...
	springAdvice.setAspectName(aspectName);
	springAdvice.setDeclarationOrder(declarationOrder);
	String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
	if (argNames != null) {
		springAdvice.setArgumentNamesFromStringArray(argNames);
	}
	springAdvice.calculateArgumentBindings();

	return springAdvice;
}

上述源码可以看出，Spring 会根据不同的注解生成不同的增强器。

增加同步实例化增强器

如果寻找的增强器不为空而且又配置了增强延迟初始化，那么就需要在首位加入同步实例化增强器。同步实例化增强器 SyntheticInstantiationAdvisor 源码如下：

/**
	 * Synthetic advisor that instantiates the aspect.
	 * Triggered by per-clause pointcut on non-singleton aspect.
	 * The advice has no effect.
	 */
@SuppressWarnings("serial")
protected static class SyntheticInstantiationAdvisor extends DefaultPointcutAdvisor {

	public SyntheticInstantiationAdvisor(final MetadataAwareAspectInstanceFactory aif) {
		super(aif.getAspectMetadata().getPerClausePointcut(), (MethodBeforeAdvice)
				(method, args, target) -> aif.getAspectInstance());
	}
}

获取 DeclareParents 注解

DeclareParents 主要用于引介增强的注解形式的实现，而其实现方式与普通增强很类似，使用 DeclareParentsAdvisor 进行封装。

private Advisor getDeclareParentsAdvisor(Field introductionField) {
	DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
	if (declareParents == null) {
		// Not an introduction field
		return null;
	}

	if (DeclareParents.class == declareParents.defaultImpl()) {
		throw new IllegalStateException("'defaultImpl' attribute must be set on DeclareParents");
	}

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

寻找匹配的增强器

前面已经完成了所有增强器的解析，但是还需要找到增强器和 Bean 之间的匹配关系。通过 findAdvisorsThatCanApply 函数实现。

protected List<Advisor> findAdvisorsThatCanApply(
		List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
	ProxyCreationContext.setCurrentProxiedBeanName(beanName);
	try {
		// 过滤已经得到的 advisors
		return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
	}
	finally {
		ProxyCreationContext.setCurrentProxiedBeanName(null);
	}
}

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
	if (candidateAdvisors.isEmpty()) {
		return candidateAdvisors;
	}
	List<Advisor> eligibleAdvisors = new ArrayList<>();
	// 首先处理引介增强
	for (Advisor candidate : candidateAdvisors) {
		if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
			eligibleAdvisors.add(candidate);
		}
	}
	boolean hasIntroductions = !eligibleAdvisors.isEmpty();
	for (Advisor candidate : candidateAdvisors) {
		// 引介增强已经处理
		if (candidate instanceof IntroductionAdvisor) {
			// already processed
			continue;
		}
		// 普通 bean 的处理
		if (canApply(candidate, clazz, hasIntroductions)) {
			eligibleAdvisors.add(candidate);
		}
	}
	return eligibleAdvisors;
}

findAdvisorsThatCanApply 函数的主要功能是寻找所有增强器中适用于当前 class 的增强器 。 引介增强与普通的增强处理是不一样的 ， 所以分开处理。 而对于真正的匹配在 canApply 中实现 。

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
	Assert.notNull(pc, "Pointcut must not be null");
	if (!pc.getClassFilter().matches(targetClass)) {
		return false;
	}

	MethodMatcher methodMatcher = pc.getMethodMatcher();
	if (methodMatcher == MethodMatcher.TRUE) {
		// No need to iterate the methods if we're matching any method anyway...
		return true;
	}

	IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
	if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
		introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
	}

	Set<Class<?>> classes = new LinkedHashSet<>();
	if (!Proxy.isProxyClass(targetClass)) {
		classes.add(ClassUtils.getUserClass(targetClass));
	}
	classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

	for (Class<?> clazz : classes) {
		Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
		for (Method method : methods) {
			if (introductionAwareMethodMatcher != null ?
					introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
					methodMatcher.matches(method, targetClass)) {
				return true;
			}
		}
	}

	return false;
}
SubaYasin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sping aop注解配置
04-29
sping aop注解配置
AOP获取加在方法上的自定义注解的注意事项
最新发布
qq_42108331的博客
06-27 806
AOP获取加在方法上的自定义注解的注意事项
Spring AOP 和 拦截器 获取类上与方法上的注解
TechnicianWang的博客
06-17 7687
在做一个跨过目标注解的鉴权功能时，想到了AOP与拦截器两种方式，其中 @HasPermission 是我自定义的注解，以下分别为AOP与拦截器获取访问目标类与方法上的注解的方法。由于我的系统在拦截器上配置了拦截过则，所以我选的是拦截器的方式，读者可根据自己的需求来。先通过ProceedingJoinPoint对象的 joinPoint.getSignature()方法获取到 Signature 的对象并强制类型转换为一个MethodSignature对象，通过 signature.getClass()方法获
Spring @Value注释
cunfen0516的博客
01-05 180
介绍： Spring @Value批注用于将值注入变量和方法参数。 我们可以读取spring环境变量或系统变量。 它还支持SpEL。 在本快速教程中，我们将探讨如何使用Spring @Value批注。 设定： 首先，我们在app.properties文件中定义一些属性： user.first.name=Sam user.stocks=50 user.address=California u...
spring aop获取方法上与类上的注解
一介码农
01-12 5418
今天正好在写一个自定义鉴权的包，是利用AOP实现的，其中我定义了两个注解，一个是`@Authorize `，作用是标记该接口或该控制层是需要什么身份、权限才可以访问。一个是`@Anonymous`，作用是标记该接口或该控制层是否可以匿名访问（跳过鉴权、登陆验证）。那么所以我就必须要获取到方法上与类上我所定义的注解。
切面AOP中获取方法的注解相关问题
qq_46940224的博客
07-24 1660
Aop中获取方法注解
Sping AOP编程
03-18
NULL 博文链接：https://gz383.iteye.com/blog/591084
test sping -aop.zip
04-10
spring-aop的一个小demo 可以直接拿来用的 大家可以试一下 clone一下 看看的 可以直接配置使用
sping_aop实现
06-03
sping_aop实现,通过自己定义的事务管理器,通过Spring中的aop进行实现
sping AOP 权限管理方案浅析
07-17
NULL 博文链接：https://guoweisong.iteye.com/blog/739345
spring中自定义注解(annotation)与AOP中获取注解
09-24
spring中自定义注解(annotation)与AOP中获取注解.通过实例演示自定义注解。
AOP处理类上或者方法上面的自定义或指定注解
进击的豌豆的博客
09-15 2217
AOP处理类上或者方法上面的自定义或指定注解
spring源码深度解析---创建AOP代理之寻找匹配的增强器
渔潭的博客
04-25 259
寻找匹配的增强器 前面的函数中已经完成了所有增强器的解析，但是对于所有增强器来讲，并不一定都适用于当前的Bean，还要挑取除适合的增强器，也就是满足我们配置的通配符的增强器。具体的实现在findAdvisorsThatCanApply中。我们回头看下AbstractAdvisorAutoProxyCreator中的findEligibleAdvisors方法，如下图所示： 这里使用了fin...
spring aop获取目标对象的方法对象
热门推荐
以蚂蚁的速度践行在通往架构师的道路上......
10-31 2万+
这两天在学习权限控制模块。以前看过传智播客黎活明老师的巴巴运动网视频教程，里面就讲到权限控制的解决方案，当时也只是看看视频，没有动手实践，虽说看过几遍，可是对于系统中的权限控制还是很迷茫，所以借着这次机会动手实践一下。     黎活明老师的巴巴运动网使用的框架是struts + spring + jpa,大致思路是使用自定义注解，在需要权限控制的方法前使用注解定义方法所需的权限，然后使用AOP拦
aop 获取方法入参_AOP方法拦截获取参数上的注解
weixin_39800971的博客
12-30 1802
获取参数注解在spring aop中,无论是前置通知的参数JoinPoint,还是环绕通知的参数ProceedingJoinPoint,都可以通过以下方法获得入参:MethodSignature signature= (MethodSignature) jp.getSignature();根据源码分析,MethodSignature封装了两个方法,一个获取方法的返回值类型,一个是获取封装的Meth...
Spring aop 注解方式怎么获得执行了目标的某个方法？
scanklm的专栏
11-24 1591
private void beforeTransationHandle(JoinPoint point) throws Exception{ //拦截的实体类 Object target = point.getTarget(); //拦截的方法名称 String methodName = point.getSignature().getName(); //拦截的方法参数 O
java自定义注解并定义AOP获取注解
weixin_44617722的博客
04-26 566
基础概念就先略过了，下面直接贴出一个简单的例子： 定义一个自定义注解 @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Auth { } 为这个注解定义切点实现具体逻辑(我是这样理解的) @Aspect @Component publi...
spring aop -- 获取注解值
wuhulala的休息室
04-23 8504
这两天在写安全框架 但是一直用method Invocation的话有点特别麻烦，看着不爽 用注解习惯了 现在一个需求就是我要拿到这个a方法上的printLog注解的desc值@PrintLog(desc = "i am a") public void a(){ }经过搜索引擎来一遍之后 发现了这种符合我需求的方法为了省事 我定义了这个注解的方法为切点@Before(“lo
AOP 切面的使用，以及如何在通知上获取切入方法的注解和参数
qq_30698633的博客
09-09 5364
1、自定义注解 @Retention(RetentionPolicy.RUNTIME) @Target(value=ElementType.METHOD) public @interface AdviceAnnotation { String name(); } 2、service层 public interface AdviceService { void study(String
Sping AOP中的JDK动态代理和CGLIB动态代理有何区别?
06-10
Spring AOP中的JDK动态代理和CGLIB动态代理是两种常用的实现动态代理的方式，它们的主要区别在于： 1. 实现方式不同：JDK动态代理是基于Java反射机制实现的，它通过接口来创建代理对象；而CGLIB动态代理是通过继承目标对象来创建代理对象。 2. 代理对象类型不同：JDK动态代理只能代理实现了接口的目标对象，而CGLIB动态代理则可以代理没有实现接口的目标对象。 3. 性能表现不同：JDK动态代理由于是基于接口实现的，所以生成的代理类相对较小，生成速度也比较快，但是只能代理接口中定义的方法；而CGLIB动态代理由于是基于继承实现的，所以生成的代理类相对较大，生成速度也比较慢，但是可以代理目标对象中的所有方法。 因此，在使用Spring AOP时，如果目标对象实现了接口，建议使用JDK动态代理；如果目标对象没有实现接口，可以使用CGLIB动态代理。同时，对于需要大量使用动态代理的应用场景，为了提升系统性能，也可以考虑使用AspectJ等其他的AOP框架。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值