Spring Bean 名称暗藏玄机,这样取名就不会被代理

一些使用小细节就是在不断的源码探索中逐步发现的,今天就来和小伙伴们聊一下通过 beanName 的设置,可以让一个 bean 拒绝被代理!

1. 代码实践

假设我有如下一个切面:

java 复制代码
@Aspect
@EnableAspectJAutoProxy
@Component
public class LogAspect {
    @Pointcut("execution(* org.javaboy.demo.service.*.*(..))")
    public void pc() {

    }

    @Before("pc()")
    public void before(JoinPoint jp) {
        String name = jp.getSignature().getName();
        System.out.println(name + " 方法开始执行了...");
    }
}

这个切面要拦截的方法是 org.javaboy.demo.service 包下的所有类的所有方法,现在,这个包下有一个 BookService 类,内容如下:

java 复制代码
@Service("org.javaboy.demo.service.BookService.ORIGINAL")
public class BookService {

    public void hello() {
        System.out.println("hello bs");
    }
}

这个 BookService 的 beanName 我没有使用默认的 beanName,而是自己配置了一个 beanName,这个 beanName 的配置方式是 类名的完整路径+.ORIGINAL

当我们按照这样的规则给 bean 取名之后,那么即使当前 bean 已经包含在切点所定义的范围内,这个 bean 也不会被代理了。

这是 Spring5.1 开始的新玩法。

这种写法的原理是什么呢?

2. 原理分析

在 Spring 创建 Bean 的时候,小伙伴们都知道,bean 创建完成之后会去各种后置处理器(BeanPostProcessor)中走一圈,所以一般我们认为 BeanPostProcessor 是在 bean 实例创建完成之后执行。但是,BeanPostProcessor 中有一个特例 InstantiationAwareBeanPostProcessor,这个接口继承自 BeanPostProcessor,但是在 BeanPostProcessor 的基础之上,增加了额外的能力:

  1. 在 bean 实例化之前先做一些预处理,例如直接创建代理对象,代替后续的 bean 生成。
  2. 在 bean 实例化之后但是属性填充之前,可以自定义一些属性注入策略。

大致上就是这两方面的能力。

具体到代码上,就是在创建 bean 的 createBean 方法中:

java 复制代码
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	//省略。。。
	try {
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}
	try {
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
    //省略。。。
}

小伙伴们看,这里的 resolveBeforeInstantiation 方法就是给 BeanPostProcessor 一个返回代理对象的机会,在这个方法中,最终就会触发到 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 方法,我们来看看这里涉及到的跟 AOP 相关的 AbstractAutoProxyCreator#postProcessBeforeInstantiation 方法:

java 复制代码
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
	Object cacheKey = getCacheKey(beanClass, beanName);
	if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
		if (this.advisedBeans.containsKey(cacheKey)) {
			return null;
		}
		if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return null;
		}
	}
	// Create proxy here if we have a custom TargetSource.
	// Suppresses unnecessary default instantiation of the target bean:
	// The TargetSource will handle target instances in a custom fashion.
	TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
	if (targetSource != null) {
		if (StringUtils.hasLength(beanName)) {
			this.targetSourcedBeans.add(beanName);
		}
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
		Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
		this.proxyTypes.put(cacheKey, proxy.getClass());
		return proxy;
	}
	return null;
}

这个方法实际上干了两件事:

  1. 检查当前 bean 是否需要代理,如果不需要代理,那么就存入到一个 map 集合 advisedBeans 中,key 是 bean 的名字,value 如果为 true 则表示这个 bean 是需要代理的,value 为 false,则表示这个 bean 是不需要代理的。
  2. 如果有我们有自定义的 TargetSource,则根据自定义的 TargetSource 去创建代理对象。

这里我要和大家说的是第一点。

在判断一个 bean 是否需要代理的时候,主要依据两个方法:

  1. isInfrastructureClass:这个方法主要是检查当前 bean 是否是 Advice/Advisor/Pointcut 等类型,或者这个类上是否有 @Aspect 注解,这个松哥在之前的文章中其实和大家介绍过了:听说 Spring Bean 的创建还有一条捷径?
  2. shouldSkip:如果 isInfrastructureClass 方法返回 false,那么就要执行 shouldSkip 了,我们来仔细看下 shouldSkip 方法。
java 复制代码
@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
	// TODO: Consider optimization by caching the list of the aspect names
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	for (Advisor advisor : candidateAdvisors) {
		if (advisor instanceof AspectJPointcutAdvisor pointcutAdvisor &&
				pointcutAdvisor.getAspectName().equals(beanName)) {
			return true;
		}
	}
	return super.shouldSkip(beanClass, beanName);
}

这里首先找到系统中所有的切面,找到之后挨个遍历,遍历的时候判断如果当前要创建的 bean 刚好就是切面,那切面肯定是不需要代理的,直接返回 true。否则就会去调用父类的 shouldSkip 方法,我们再来瞅一眼父类的 shouldSkip 方法:

java 复制代码
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
	return AutoProxyUtils.isOriginalInstance(beanName, beanClass);
}
static boolean isOriginalInstance(String beanName, Class<?> beanClass) {
	if (!StringUtils.hasLength(beanName) || beanName.length() !=
			beanClass.getName().length() + AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX.length()) {
		return false;
	}
	return (beanName.startsWith(beanClass.getName()) &&
			beanName.endsWith(AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX));
}

父类 shouldSkip 方法主要是调用了一个静态工具方法 isOriginalInstance 来判断当前 bean 是否是一个不需要代理的 bean,这个具体的判断逻辑就是检查这个 beanName 是否按照 类名的完整路径+.ORIGINAL 的方式命名的,如果是则返回 true。

当 shouldSkip 方法返回 true 的时候,就会进入到 postProcessBeforeInstantiation 方法的 if 分支中,该分支将当前 beanName 存入到 advisedBeans 集合中,存储的 key 就是 beanName,value 则是 false,然后将方法 return。

当 bean 创建完成之后,再进入到 AbstractAutoProxyCreator#postProcessAfterInitialization 方法中处理的时候,就会发现这个 bean 已经存入到 advisedBeans 集合中,并且 value 是 false,这就意味着这个 bean 不需要代理,那么就针对该 bean 就不会进行 AOP 处理了,直接 return 即可。

好啦,一个小小细节,加深大家对 Spring AOP 的理解,感兴趣的小伙伴可以去试试哦~

相关推荐
吾日三省吾码3 小时前
JVM 性能调优
java
Estar.Lee3 小时前
查手机号归属地免费API接口教程
android·网络·后端·网络协议·tcp/ip·oneapi
弗拉唐4 小时前
springBoot,mp,ssm整合案例
java·spring boot·mybatis
oi775 小时前
使用itextpdf进行pdf模版填充中文文本时部分字不显示问题
java·服务器
2401_857610035 小时前
SpringBoot社团管理:安全与维护
spring boot·后端·安全
少说多做3435 小时前
Android 不同情况下使用 runOnUiThread
android·java
知兀5 小时前
Java的方法、基本和引用数据类型
java·笔记·黑马程序员
蓝黑20206 小时前
IntelliJ IDEA常用快捷键
java·ide·intellij-idea
Ysjt | 深6 小时前
C++多线程编程入门教程(优质版)
java·开发语言·jvm·c++