死磕源码系列【BeanNameGenerator生成bean名称策略接口详解】

最新推荐文章于 2024-06-29 19:21:58 发布
最新推荐文章于 2024-06-29 19:21:58 发布
阅读量2.2k 收藏 4
点赞数 1
分类专栏： 【spring系列】 文章标签： BeanName Generator beanName生成 策略
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaomingyang/article/details/109187730
版权

本文包括bean name实现类源码详解，及自定义bean name生成策略源码原理详解

bean name生成策略三个实现类源码详解

BeanNameGenerator接口是BeanDefinition定义生成bean名称的策略接口；

public interface BeanNameGenerator {

	/**
	 * 为给定的BeanDefinition生成一个bean名称
	 */
	String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry);

}

看下BeanNameGenerator接口实现类UML关系图：

在这里插入图片描述

DefaultBeanNameGenerator是BeanNameGenerator接口的默认实现类：

public class DefaultBeanNameGenerator implements BeanNameGenerator {

	/**
	 * DefaultBeanNameGenerator实例常量，用于在AbstractBeanDefinitionReader类中属性beanNameGenerator的设置
	 */
	public static final DefaultBeanNameGenerator INSTANCE = new DefaultBeanNameGenerator();

	//通过BeanDefinitionReaderUtils工具类的generateBeanName方法生成指定BeanDefinition的bean名称
	@Override
	public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		return BeanDefinitionReaderUtils.generateBeanName(definition, registry);
	}

}

BeanDefinitionReaderUtils#generateBeanName代理方法源码：

	/**
	 * 为给定的顶级BeanDefinition定义生成一个bean名称，该名称在给定的bean工厂中是唯一的
	 */
	public static String generateBeanName(BeanDefinition beanDefinition, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		return generateBeanName(beanDefinition, registry, false);
	}

	/**
	 * 为给定的顶级BeanDefinition定义生成一个bean名称，该名称在给定的bean工厂中是唯一的
	 * @param BeanDefiniton定义
	 * @param 注册bean的工厂类
	 * @param isInnerBean 给定的BeanDefinition是注册为内部bean还是顶级bean(允许内部bean和顶级bean生成特殊名称)
	 */
	public static String generateBeanName(
			BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
			throws BeanDefinitionStoreException {
		//获取bean定义的类名
		String generatedBeanName = definition.getBeanClassName();
		if (generatedBeanName == null) {
			if (definition.getParentName() != null) {
        //当bean定义名称不存在并且存在父类时命名方式
				generatedBeanName = definition.getParentName() + "$child";
			}
			else if (definition.getFactoryBeanName() != null) {
        //读取生成该bean的factoryBean名称做前缀
				generatedBeanName = definition.getFactoryBeanName() + "$created";
			}
		}
		if (!StringUtils.hasText(generatedBeanName)) {
			throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
					"'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
		}

		if (isInnerBean) {
			// 当为内部类时使用#好分割和系统的唯一hash码作为后缀
			return generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
		}

		// 顶级bean,使用普通类名加唯一后缀
		return uniqueBeanName(generatedBeanName, registry);
	}

	/**
	 * 将给定的bean名称转换为给定bean工厂的唯一bean名称，如果有必要，附加一个唯一的计数器做后缀
	 */
	public static String uniqueBeanName(String beanName, BeanDefinitionRegistry registry) {
		String id = beanName;
		int counter = -1;

		// 增加计数器，直到id唯一
		String prefix = beanName + GENERATED_BEAN_NAME_SEPARATOR;
		while (counter == -1 || registry.containsBeanDefinition(id)) {
			counter++;
			id = prefix + counter;
		}
		return id;
	}

AnnotationBeanNameGenerator是BeanNameGenerator接口的实现类，用来生成被@Component注解或者其它@Component派生注解标注的bean；示例：被@Component注解标注的@Repository注解。

如果注释的值没有指示bean名称，那么将基于类的短名称（第一个字母消息）构建一个适当的名称。例如：com.xyz.FooServiceImpl类的bean名称是fooServiceImpl。

AnnotationBeanNameGenerator类源码：

public class AnnotationBeanNameGenerator implements BeanNameGenerator {

	/**
	 * 默认AnnotationBeanNameGenerator实例的方便常量，用于组件扫描目的（即@Componment注解及@ComponmentScan注解扫描包）bean名称生成
	 * @since 5.2
	 */
	public static final AnnotationBeanNameGenerator INSTANCE = new AnnotationBeanNameGenerator();
	//@Component注解类常量
	private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";

	private final Map<String, Set<String>> metaAnnotationTypesCache = new ConcurrentHashMap<>();


	@Override
	public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		if (definition instanceof AnnotatedBeanDefinition) {
      //通过注解的属性值获取bean名称
			String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
			if (StringUtils.hasText(beanName)) {
				//显式的找到bean名称
				return beanName;
			}
		}
		//如果注解未指定bean名称，则生成一个唯一的默认bean名称
		return buildDefaultBeanName(definition, registry);
	}

	/**
	 * 从类上的一个注释派生bean名称（即通过注解的属性value值来获取唯一的bean名称）
	 * @param annotatedDef the annotation-aware bean definition
	 * @return the bean name, or {@code null} if none is found
	 */
	@Nullable
	protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
		AnnotationMetadata amd = annotatedDef.getMetadata();
		Set<String> types = amd.getAnnotationTypes();
		String beanName = null;
		for (String type : types) {
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
			if (attributes != null) {
				Set<String> metaTypes = this.metaAnnotationTypesCache.computeIfAbsent(type, key -> {
					Set<String> result = amd.getMetaAnnotationTypes(key);
					return (result.isEmpty() ? Collections.emptySet() : result);
				});
        //检查给定的注释是否允许通过其注释的value属性构造bean名称
				if (isStereotypeWithNameValue(type, metaTypes, attributes)) {
					Object value = attributes.get("value");
					if (value instanceof String) {
						String strVal = (String) value;
						if (StringUtils.hasLength(strVal)) {
							if (beanName != null && !strVal.equals(beanName)) {
								throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
										"component names: '" + beanName + "' versus '" + strVal + "'");
							}
							beanName = strVal;
						}
					}
				}
			}
		}
		return beanName;
	}

	/**
	 * 检查给定的注释是否允许通过其注释的value属性构造bean名称
	 */
	protected boolean isStereotypeWithNameValue(String annotationType,
			Set<String> metaAnnotationTypes, @Nullable Map<String, Object> attributes) {

		boolean isStereotype = annotationType.equals(COMPONENT_ANNOTATION_CLASSNAME) ||
				metaAnnotationTypes.contains(COMPONENT_ANNOTATION_CLASSNAME) ||
				annotationType.equals("javax.annotation.ManagedBean") ||
				annotationType.equals("javax.inject.Named");

		return (isStereotype && attributes != null && attributes.containsKey("value"));
	}

	/**
	 * 从给定的bean定义派生一个默认的bean名称，即类名首字母小写
	 */
	protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		return buildDefaultBeanName(definition);
	}

	/**
	 * 从给定的bean定义派生一个默认的bean名称，即类名首字母小写
	 */
	protected String buildDefaultBeanName(BeanDefinition definition) {
		String beanClassName = definition.getBeanClassName();
		Assert.state(beanClassName != null, "No bean class name set");
		String shortClassName = ClassUtils.getShortName(beanClassName);
		return Introspector.decapitalize(shortClassName);
	}

}

FullyQualifiedAnnotationBeanNameGenerator类源码：

FullyQualifiedAnnotationBeanNameGenerator类是AnnotationBeanNameGenerator类的一个扩展用于生成类的全限定类名作为bean名称，

public class FullyQualifiedAnnotationBeanNameGenerator extends AnnotationBeanNameGenerator {

	@Override
	protected String buildDefaultBeanName(BeanDefinition definition) {
		String beanClassName = definition.getBeanClassName();
		Assert.state(beanClassName != null, "No bean class name set");
		return beanClassName;
	}

}
bean name自定义生成策略源码原理解析

在后置beanfactory容器回调接口实现类ConfigurationClassPostProcessor中定义有三个变量：

//使用类的全限定名作为bean的默认生成策略
public static final AnnotationBeanNameGenerator IMPORT_BEAN_NAME_GENERATOR =
			new FullyQualifiedAnnotationBeanNameGenerator();
			
	/* 使用短类名作为默认bean名称生成策略 */
	private BeanNameGenerator componentScanBeanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;

	/* 使用类的全新定名作为bean默认生成策略 */
	private BeanNameGenerator importBeanNameGenerator = IMPORT_BEAN_NAME_GENERATOR;	
  //是否是本地xml配置的BeanNameGenerator生成器
	private boolean localBeanNameGeneratorSet = false;

ConfigurationClassPostProcessor#setBeanNameGenerator方法设置自定义bean name生成器，这个setter通常只适用于将ConfigurationClassPostProcessor后处理器配置为XML中的独立bean定义，例如：不使用专用的AnnotatiionConfig*应用程序上下文或者context:annotation-config标签，针对应用程序上下文指定的任何bean名称生成器都将优先于此处的设置（此方法只适合Spring中通过xml配置的形式，springboot可以忽略）。

	public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
		Assert.notNull(beanNameGenerator, "BeanNameGenerator must not be null");
		this.localBeanNameGeneratorSet = true;
		this.componentScanBeanNameGenerator = beanNameGenerator;
		this.importBeanNameGenerator = beanNameGenerator;
	}

ConfigurationClassPostProcessor#processConfigBeanDefinitions方法（只展示bean name名称生成策略部分代码）：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		...

		//检测通过封闭的应用程序上下文提供的任何自定义bean名称生成策略
		SingletonBeanRegistry sbr = null;
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
      //springboot 中localBeanNameGeneratorSet默认是false
			if (!this.localBeanNameGeneratorSet) {
        //获取自定义的bean name生成策略
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
						AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
				if (generator != null) {
          //设置组件扫描bean name生成策略
					this.componentScanBeanNameGenerator = generator;
          //设置import bean name生成策略
					this.importBeanNameGenerator = generator;
				}
			}
		}
		...
		
	}

到这里会有一个疑问内部自定义bean name生成策略bean org.springframework.context.annotation.internalConfigurationBeanNameGenerator（AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR）是如何注入到IOC容器之中的？那我们看下启动类SpringApplication#run方法，方法中内嵌prepareContext方法，prepareContext方法内嵌postProcessApplicationContext方法：

	protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    //此处会判定bean name生成策略是否为空
		if (this.beanNameGenerator != null) {
    //此处 将上一步中的疑问，自定义bean name生成策略注入到IOC容器		
      context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,this.beanNameGenerator);
		}
		。。。
	}

此段代码我们看到了如何将bean name自定义生成策略注入到IOC容器之中，那么beanNameGenerator生成策略是如何获取呢？beanNameGenerator是SpringApplication类的一个属性，提供了setter方法：

	public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
		this.beanNameGenerator = beanNameGenerator;
	}

此处的setter方法就是我们设置自定义bean name生成器的入口，示例如下：

@SpringBootApplication
public class QuartzBootStrap {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(QuartzBootStrap.class);
      		//MySelfBeanNameGenerator是自定义bean name生成策略
        application.setBeanNameGenerator(new MySelfBeanNameGenerator());
        application.run(args);
    }
}

至此，springboot如何自定义bean name生成策略，此处的设置是全局的，不包括指定配置类的bean name生成策略。

自定义生成bean name策略实现类：

public class MySelfBeanNameGenerator implements BeanNameGenerator {
    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        System.out.println("--------"+definition.getBeanClassName());
        return definition.getBeanClassName();
    }
}

GitHub源码：https://github.com/mingyang66/spring-parent

立小言先森
关注
专栏目录
小明学Spring Framework容器启动系列——Bean名称生成策略
小明的博客
03-16 360
Spring BeanBean名称生成策略1. 前言2. Bean名称生成策略2.1 默认Bean名称生成策略2.2 注解Bean名称生成策略2.3 类全称的bean名称策略 1. 前言 Spring容器中，每一个Bean都必须要有一个唯一的名称，这个名称就是Bean在容器中的唯一标识，查找或者修改Bean的都必须要通过Bean名称这个唯一索引进行（我们知道Spring容器可以通过Bean名称和类型查找Bean，即使是按照Bean的类型查找Bean，也会先根据Bean的类型查找Bean的名称，然后再根据b
BeanNameGenerator
awds18338701279的博客
11-05 440
BeanNameGenerator public interface BeanNameGenerator { String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry); } 参数为BeanDefinition 和 BeanDefinitionRegistry 类型，此处可以反映出spring需要的bean 是BeanDefinition。definition 是被生成名字的BeanDefi.
Spring Bean名称内部生成工具
最新发布
Deep Water Slow
06-29 115
【代码】Spring Bean名称内部生成工具。
一文了解BeanNameGenerator
08-30 601
在springboot的项目中，我们会使用到很多的注解，比如@Service，@Bean等，添加这些注解SpringBoot框架会帮忙创建bean，并且用唯一的名字来区分，那我们就来看看源是怎么实现的吧。
Spring 中三种 BeanName 生成器！
江南一点雨的专栏
09-12 555
无论我们是通过 XML 文件，还是 Java 代码，亦或是包扫描的方式去注册 Bean，都可以不设置 BeanName，而 Spring 均会为之提供默认的 beanName，今天我们就来看看 Spring 中三种处理不同情况的 beanName 生成器。
Spring源码之BeanNameGenerator
weixin_42496727的博客
07-25 247
从图中可以看到，ComponentScans的属性为value，而value又包含了一个长度为4的AnnotationAttributes的数组。这里正是在上面配置类中使用的注解ComponentScans和Configuration，其中我们还使用了Configuration，但是其是作为ComponentScans的value属性而存在。因为上面的扫描的第一个注解为ComponentScans，它的value值是不被允许指定为bean的名称的。它的value值是可以指定bean的名称的。
死磕spring源码系列-SpringAop十分钟快速入门
08-30
死磕spring源码系列-SpringAop十分钟快速入门
死磕spring源码系列-深度解析spring aop
08-30
死磕spring源码系列-深度解析spring_aop
死磕以太坊源码分析全部文章
01-30
一共大概20篇文章，适合智能合约开发工程师，区块链开发工程师，底层公链开发工程师 阅读，希望可以帮助到你们，如果发现哪里有不对的 地方，希望可以给出指正。
【死磕Java集合】-集合源码分析.pdf
03-14
Java集合框架源码分析 Java集合框架是Java语言中一个非常重要的组件，提供了多种数据结构和算法来存储和操作数据。在Java集合框架中，LinkedList、ArrayList、HashMap、TreeMap等都是非常常用的数据结构。本文将对...
死磕Spring系列之二,bean标签的解析和BeanDefinition的注册
weixin_44195108的博客
03-22 180
到现在环境已经配置完毕，已经可以跑一个简单的HELLOWORLD了。正式进入源码阅读的阶段。使用过Spring的都知道，我们只需要在配置文件中配置好对象规则（比如类，依赖，属性…)，然后我们就可以在程序中使用对象了。 我们可以做一个假设，如果让我们写一个程序，根据XML配置信息，生成想要的对象。 可以简单想象成： XML:某产品的设计图纸 工厂类：生产流水线 对象：想要的产品。 生产流水线，想要根...
NameGenerator:建立一个名字生成器
04-25
名称生成器 现场直播 信息 逻辑完美运行，我怀疑您会在其中找到重复的名称。 大部分名称都是乱七八糟的，但老实说，它确实会产生一些令人惊奇的幻想名称。 CSS并不是最好的，但是它可以工作。 贡献者/大助手XD 不和谐服务器上的人。
spring系列——BeanNameGenerator接口（bean名字生成器）
dgh112233的博客
11-05 5175
目录 1、BeanNameGenerator 接口 2、AnnotationBeanNameGenerator 类 3、DefaultBeanNameGenerator 类 spring容器是通过bean Name去管理着大量的bean，而且不出错。 首先看看spring是如何为每个bean生成名字的，BeanNameGenerator接口是bean名字生成器的入口，下面是类图： ...
springboot生成自定义beanNameGenerator且手写时容易出现的bug
hz90s的博客
04-13 4330
附上我的github项目源码：https://github.com/hzprivate/studyAll 查看springboot-beanNameGenerator项目 阅读spring官方文档时，看到了一个beanNameGenerator： 当一个组件作为扫描过程的一部分被自动检测时，它的bean名称由该扫描程序所知道的BeanNameGenerator策略生成。默认情况下，任何...
第二章 第一节 spring-beans之BeanNameGenerator深入详解
weixin_34343689的博客
04-26 895
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring的beanName生成器AnnotationBeanNameGenerator
qq_57756904的博客
10-08 1293
总之，AnnotationBeanNameGenerator是一个用于生成基于注解的Spring组件的Bean名称的类。你可以使用它的默认行为，也可以自定义生成规则，以满足你的项目需求。这对于解决命名冲突或将特定的命名约定应用于组件扫描非常有用。
使用springboot启动监听器ApplicationContextInitializer实现外部jar包设置BeanNameGenerator，解决控制层beanName冲突问题
CoderOu
01-12 1070
解决方案直通车 注：如果不看解决思路，只看解决方案的，可以滚动到最后面查看解决方案！ 最新在搭建springcldoualibaba微服务架构，由于习惯了之前的写法（控制层将后台，APP端，小程序端，公众号端分包管理，所以同一个业务的控制器，又懒得每个控制器指定一个名字，对于spring来说，类名一样，那么名字就一样，则会启动报错），则自定义了BeanNameGenerator，之前对于单体springboot项目来说，指定这个很简单，如下所示 @SpringBootApplication(nameGen
自定义BeanNameGenerator生成规则
Thrive的博客
01-29 2093
先创建一个CustomeBeanNameGenerator类实现BeanNameGenerator接口重写generateBeanName方法@Override//定义Bean的名称//1.判断当前bean的定义信息是否是注解的//2.把definition转成注解的bean定义信息//2.获取注解Bean定义的元信息//3.获取定义信息中的所有注解//4.遍历types集合//5.得到注解的属性。
MySQL为何不宜设Null值？——死磕MySQL系列解析
"这篇文档是《死磕MySQL系列》的第十八篇，主要讨论了在MySQL中不建议为字段设置Null值的原因，并通过一个实际的案例进行了解析。" 在MySQL数据库设计中，通常建议避免将字段的默认值设置为Null，这背后有几个重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值