ConfigurationPropertiesBeanRegistrar Class — spring-boot Architecture

Source Code

core/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesBeanRegistrar.java lines 47–122

final class ConfigurationPropertiesBeanRegistrar {

	private static final ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

	private final BeanDefinitionRegistry registry;

	private final BeanFactory beanFactory;

	ConfigurationPropertiesBeanRegistrar(BeanDefinitionRegistry registry) {
		this.registry = registry;
		this.beanFactory = (BeanFactory) this.registry;
	}

	void register(Class<?> type) {
		MergedAnnotation<ConfigurationProperties> annotation = MergedAnnotations
			.from(type, SearchStrategy.TYPE_HIERARCHY)
			.get(ConfigurationProperties.class);
		register(type, annotation);
	}

	void register(Class<?> type, MergedAnnotation<ConfigurationProperties> annotation) {
		String name = getName(type, annotation);
		if (!containsBeanDefinition(name)) {
			registerBeanDefinition(name, type, annotation);
		}
	}

	private String getName(Class<?> type, MergedAnnotation<ConfigurationProperties> annotation) {
		String prefix = annotation.isPresent() ? annotation.getString("prefix") : "";
		return (StringUtils.hasText(prefix) ? prefix + "-" + type.getName() : type.getName());
	}

	private boolean containsBeanDefinition(String name) {
		return (this.beanFactory instanceof ListableBeanFactory listableBeanFactory
				&& listableBeanFactory.containsBeanDefinition(name));
	}

	private void registerBeanDefinition(String beanName, Class<?> type,
			MergedAnnotation<ConfigurationProperties> annotation) {
		Assert.state(annotation.isPresent(), () -> "No " + ConfigurationProperties.class.getSimpleName()
				+ " annotation found on  '" + type.getName() + "'.");
		try {
			BeanDefinitionHolder beanDefinition = createBeanDefinition(beanName, type);
			BeanDefinitionReaderUtils.registerBeanDefinition(beanDefinition, this.registry);
		}
		catch (Throwable ex) {
			throw new IllegalStateException(
					"Unable to create configuration properties bean definition '%s' (%s)".formatted(beanName, type),
					ex);
		}
	}

	private BeanDefinitionHolder createBeanDefinition(String beanName, Class<?> type) {
		AnnotatedGenericBeanDefinition definition = new AnnotatedGenericBeanDefinition(type);
		AnnotationConfigUtils.processCommonDefinitionAnnotations(definition);
		BindMethod bindMethod = ConfigurationPropertiesBean.deduceBindMethod(type);
		BindMethodAttribute.set(definition, bindMethod);
		if (bindMethod == BindMethod.VALUE_OBJECT) {
			definition.setInstanceSupplier(() -> ConstructorBound.from(this.beanFactory, beanName, type));
		}
		ScopeMetadata metadata = scopeMetadataResolver.resolveScopeMetadata(definition);
		definition.setScope(metadata.getScopeName());
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(definition, beanName);
		return applyScopedProxyMode(metadata, definitionHolder, this.registry);
	}

	static BeanDefinitionHolder applyScopedProxyMode(ScopeMetadata metadata, BeanDefinitionHolder definition,
			BeanDefinitionRegistry registry) {
		ScopedProxyMode mode = metadata.getScopedProxyMode();
		if (mode != ScopedProxyMode.NO) {
			return ScopedProxyUtils.createScopedProxy(definition, registry, mode == ScopedProxyMode.TARGET_CLASS);
		}
		return definition;
	}

}