SpringIOC容器的依赖来源都有哪些？这次一起捋清楚~

已于 2023-01-13 17:27:09 修改
阅读量690 收藏 1
点赞数
分类专栏： spring、boot、cloud 文章标签： spring java 后端
于 2022-12-14 21:38:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_art_xiang/article/details/128268336
版权

文章目录

一、依赖查找的依赖来源

1、自定义的BeanDefinition

1、使用xml方式配置的

<bean id="user" class="com...User">

2、使用@Bean

@Bean public User user(){...}

3、使用BeanDefinitionBuilder自己构建的

总之，一切用户自己定义的bean。（下面详细介绍）

2、外部化配置的单体对象

就是已初始化的外部 Java 对象，在 Spring 容器中是唯一的。（下面详细介绍）

3、Spring 內建 BeanDefintion

使用AnnotationConfigUtils定义的BeanDefintion

Bean 名称Bean 实例使用场景
org.springframework.context.annotation.internalConfigurationAnnotationProcessorConfigurationClassPostProcessor 对象处理 Spring 配置类
org.springframework.context.annotation.internalAutowiredAnnotationProcessorAutowiredAnnotationBeanPostProcessor 对象处理 @Autowired 以及 @Value注解
org.springframework.context.annotation.internalCommonAnnotationProcessorCommonAnnotationBeanPostProcessor 对象（条件激活）处理 JSR-250 注解，如 @PostConstruct 等
org.springframework.context.event.internalEventListenerProcessorEventListenerMethodProcessor对象处理标注 @EventListener 的Spring 事件监听方法

以下是AnnotationConfigUtils的registerAnnotationConfigProcessors方法定义这些BeanDefintion的过程：

// AnnotationConfigUtils定义的BeanDefintion
// org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, Object source) {

	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}

	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(8);

	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}

	return beanDefs;
}

使用AbstractApplicationContext定义的BeanDefinition

Bean 名称Bean 实例使用场景
environmentEnvironment 对象外部化配置以及 Profiles
systemPropertiesjava.util.Properties 对象Java 系统属性
systemEnvironmentjava.util.Map 对象操作系统环境变量
messageSourceMessageSource 对象国际化文案
lifecycleProcessorLifecycleProcessor 对象Lifecycle Bean 处理器
applicationEventMulticasterApplicationEventMulticaster 对象Spring 事件广播器

以下是AbstractApplicationContext的prepareBeanFactory、initMessageSource方法定义这些BeanDefintion的过程：

// 注册一些beanDefinatiton
// org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// Configure the bean factory with context callbacks.
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	// BeanFactory interface not registered as resolvable type in a plain factory.
	// MessageSource registered (and found for autowiring) as a bean.
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// Register early post-processor for detecting inner beans as ApplicationListeners.
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// Detect a LoadTimeWeaver and prepare for weaving, if found.
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// Register default environment beans.
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

// 注册国际化相关
// org.springframework.context.support.AbstractApplicationContext#initMessageSource
protected void initMessageSource() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
		this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
		// Make MessageSource aware of parent MessageSource.
		if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
			HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
			if (hms.getParentMessageSource() == null) {
				// Only set parent context as parent MessageSource if no parent MessageSource
				// registered already.
				hms.setParentMessageSource(getInternalParentMessageSource());
			}
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Using MessageSource [" + this.messageSource + "]");
		}
	}
	else {
		// Use empty MessageSource to be able to accept getMessage calls.
		DelegatingMessageSource dms = new DelegatingMessageSource();
		dms.setParentMessageSource(getInternalParentMessageSource());
		this.messageSource = dms;
		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
					"': using default [" + this.messageSource + "]");
		}
	}
}

加载注册好的bean-容器的refresh()方法

beandefination定义完之后，在AbstractApplicationContext的refresh()调用invokeBeanFactoryPostProcessors，将bean初始化。

// org.springframework.context.support.AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

详情请看springIOC容器经典启动过程：spring系列-注解驱动原理及源码-spring容器创建流程

二、依赖注入的依赖来源

1、依赖查找的所有来源

同上

2、非Spring容器管理的对象

注入时机

在springIOC启动的refresh()中，调用prepareBeanFactory方法，prepareBeanFactory中注册了这样几个依赖：

// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

使用时机

在依赖注入的DefaultListableBeanFactory类的doResolveDependency方法中：

// 关键方法：findAutowireCandidates
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
	if (isRequired(descriptor)) {
		raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
	}
	return null;
}

// org.springframework.beans.factory.support.DefaultListableBeanFactory#findAutowireCandidates
protected Map<String, Object> findAutowireCandidates(
		String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

	String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
			this, requiredType, true, descriptor.isEager());
	Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);
	// 这里的resolvableDependencies 就是上面注册的ResolvableDependency
	for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
		if (autowiringType.isAssignableFrom(requiredType)) {
			Object autowiringValue = this.resolvableDependencies.get(autowiringType);
			autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
			if (requiredType.isInstance(autowiringValue)) {
				result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
				break;
			}
		}
	}
	for (String candidate : candidateNames) {
		if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
			addCandidateEntry(result, candidate, descriptor, requiredType);
		}
	}
	if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) {
		// Consider fallback matches if the first pass failed to find anything...
		DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
		for (String candidate : candidateNames) {
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor)) {
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		if (result.isEmpty()) {
			// Consider self references as a final pass...
			// but in the case of a dependency collection, not the very same bean itself.
			for (String candidate : candidateNames) {
				if (isSelfReference(beanName, candidate) &&
						(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
						isAutowireCandidate(candidate, fallbackDescriptor)) {
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
		}
	}
	return result;
}

再回过头来看prepareBeanFactory方法中注册时调用的registerResolvableDependency方法，我们发现确实是直接将k-v值放到resolvableDependencies中：

// org.springframework.beans.factory.support.DefaultListableBeanFactory#registerResolvableDependency
@Override
public void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue) {
	Assert.notNull(dependencyType, "Dependency type must not be null");
	if (autowiredValue != null) {
		if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
			throw new IllegalArgumentException("Value [" + autowiredValue +
					"] does not implement specified dependency type [" + dependencyType.getName() + "]");
		}
		this.resolvableDependencies.put(dependencyType, autowiredValue);
	}
}

这四个对象没法用BeanFactory.getBean获取到？

这四个对象，虽然也是依赖注入到了IOC容器中，但是我们不能用BeanFactory.getBean的方式获取。

如果直接调用getBean，会报Bean找不到的错误-NoSuchBeanException。

实例


import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.io.ResourceLoader;
import javax.annotation.PostConstruct;

/**
 * 依赖来源示例
 */
public class DependencySourceDemo {

    // 注入在 postProcessProperties 方法执行，早于 setter注入，也早于 @PostConstruct
    @Autowired
    private BeanFactory beanFactory;

    @Autowired
    private ResourceLoader resourceLoader;

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    // 由源码我们得出：后三个是同一个东西
    @PostConstruct
    public void initByInjection() {
        System.out.println("beanFactory == applicationContext " + (beanFactory == applicationContext));
        System.out.println("beanFactory == applicationContext.getBeanFactory() " + (beanFactory == applicationContext.getAutowireCapableBeanFactory()));
        System.out.println("resourceLoader == applicationContext " + (resourceLoader == applicationContext));
        System.out.println("ApplicationEventPublisher == applicationContext " + (applicationEventPublisher == applicationContext));
    }

    // 使用getBean 方法查找，是查不到的，只能使用@Autowired自动注入获取
    @PostConstruct
    public void initByLookup() {
        getBean(BeanFactory.class);
        getBean(ApplicationContext.class);
        getBean(ResourceLoader.class);
        getBean(ApplicationEventPublisher.class);
    }

    private <T> T getBean(Class<T> beanType) {
        try {
            return beanFactory.getBean(beanType);
        } catch (NoSuchBeanDefinitionException e) {
            System.err.println("当前类型" + beanType.getName() + " 无法在 BeanFactory 中查找!");
        }
        return null;
    }


    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(DependencySourceDemo.class);

        // 启动 Spring 应用上下文
        applicationContext.refresh();

        // 依赖查找 DependencySourceDemo Bean
        DependencySourceDemo demo = applicationContext.getBean(DependencySourceDemo.class);

        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }
}

执行结果：

beanFactory == applicationContext false
beanFactory == applicationContext.getBeanFactory() true
resourceLoader == applicationContext true
ApplicationEventPublisher == applicationContext true
当前类型org.springframework.beans.factory.BeanFactory 无法在 BeanFactory 中查找!
当前类型org.springframework.context.ApplicationContext 无法在 BeanFactory 中查找!
当前类型org.springframework.core.io.ResourceLoader 无法在 BeanFactory 中查找!
当前类型org.springframework.context.ApplicationEventPublisher 无法在 BeanFactory 中查找!
Disconnected from the target VM, address: ‘127.0.0.1:60775’, transport: ‘socket’
Process finished with exit code 0

三、各种bean的详细解释

1、自定义BeanDefinition注册流程

自定义的BeanDefinition是由BeanDefinitionRegistry进行注册的，BeanDefinitionRegistry接口提供了对BeanDefinition基本的增删改查接口：

public interface BeanDefinitionRegistry extends AliasRegistry {

	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	boolean containsBeanDefinition(String beanName);

	String[] getBeanDefinitionNames();

	int getBeanDefinitionCount();

	boolean isBeanNameInUse(String beanName);

}

BeanDefinitionRegistry的默认实现就是DefaultListableBeanFactory，我们看一下DefaultListableBeanFactory的bean注册方法——registerBeanDefinition：

// org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {

	Assert.hasText(beanName, "Bean name must not be empty");
	Assert.notNull(beanDefinition, "BeanDefinition must not be null");

	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			// 对beanDefinition做校验，其实使用BeanDefinitionBuilder时，调用builder方法时做过校验
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}

	// 看BeanDefinition 是否已被注册
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
	 	// 如果已经被注册，看BeanDefinition是否允许被覆盖，spring2.1被人为改成false
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
					"': There is already [" + existingDefinition + "] bound.");
		}
		// 看角色是否相等，角色其实并没有具体含义
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isWarnEnabled()) {
				logger.warn("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		else if (!beanDefinition.equals(existingDefinition)) {
			if (logger.isInfoEnabled()) {
				logger.info("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		// put进去
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else { // bean不存在
		if (hasBeanCreationStarted()) { // Bean是否已经开始创建？
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				if (this.manualSingletonNames.contains(beanName)) {
					Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
					updatedSingletons.remove(beanName);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else { // 存beanDefinition信息，使用map存，所以name是唯一的。
			// Still in startup registration phase
			this.beanDefinitionMap.put(beanName, beanDefinition); // 无序
			this.beanDefinitionNames.add(beanName); // 有序，bean按顺序初始化
			this.manualSingletonNames.remove(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

2、外部化配置的单体对象

外部化配置的单体对象无生命周期管理、无法实现延迟初始化Bean。

它是由SingletonBeanRegistry接口进行注册的，SingletonBeanRegistry接口实现了对singletonBean的处理，其默认实现是DefaultListableBeanFactory。

public interface SingletonBeanRegistry {

	void registerSingleton(String beanName, Object singletonObject);

	Object getSingleton(String beanName);

	boolean containsSingleton(String beanName);

	String[] getSingletonNames();

	Object getSingletonMutex();

}

我们来看registerSingleton方法的实现：

// org.springframework.beans.factory.support.DefaultListableBeanFactory#registerSingleton
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
	super.registerSingleton(beanName, singletonObject); // 调用父类的注册

	if (hasBeanCreationStarted()) {
		// Cannot modify startup-time collection elements anymore (for stable iteration)
		synchronized (this.beanDefinitionMap) {
			if (!this.beanDefinitionMap.containsKey(beanName)) {
				Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames.size() + 1);
				updatedSingletons.addAll(this.manualSingletonNames);
				updatedSingletons.add(beanName);
				this.manualSingletonNames = updatedSingletons;
			}
		}
	}
	else {
		// Still in startup registration phase
		if (!this.beanDefinitionMap.containsKey(beanName)) {
			this.manualSingletonNames.add(beanName);
		}
	}

	clearByTypeCache();
}

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#registerSingleton
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
	Assert.notNull(beanName, "'beanName' must not be null");
	synchronized (this.singletonObjects) {
		Object oldObject = this.singletonObjects.get(beanName);
		if (oldObject != null) {
			throw new IllegalStateException("Could not register object [" + singletonObject +
					"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
		}
		addSingleton(beanName, singletonObject);
	}
}

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton
protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) { // 加锁，可重入
		this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

我们再来看getBean的实现，我们发现，如果获取Singleton Bean获取到了，就不会走下面的逻辑了。如果没有获取到，就会获取普通的BeanDefination逻辑，这个逻辑会有一个将BeanDefination注册为Bean的逻辑，而Singleton Bean没有：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

	final String beanName = transformedBeanName(name);
	Object bean;

	// Eagerly check singleton cache for manually registered singletons.
	Object sharedInstance = getSingleton(beanName); // 获取Singleton Bean
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	...

3、非Spring容器管理的对象——ResolvableDependency

通过：ConfigurableListableBeanFactory#registerResolvableDependency 进行注册。

这种对象无生命周期管理、无法实现延迟初始化Bean、无法通过依赖查找。


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import javax.annotation.PostConstruct;

/**
 * ResolvableDependency 作为依赖来源
 */
public class ResolvableDependencySourceDemo {

    @Autowired
    private String value;

    @PostConstruct
    public void init() {
        System.out.println(value);
    }

    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(ResolvableDependencySourceDemo.class);

        applicationContext.addBeanFactoryPostProcessor(beanFactory -> {
            // 注册 Resolvable Dependency
            beanFactory.registerResolvableDependency(String.class, "Hello,World");
        });

        // 启动 Spring 应用上下文，会有注册BeanPostProcessor的回调
        applicationContext.refresh();

        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }

}

四、外部化配置作为依赖来源

1、实例

使用外部化的配置文件作为依赖来源，获取依赖对象时，只能通过@Value获取。

@Configuration
@PropertySource(value = "META-INF/default.properties",encoding="UTF-8")
public class ExternalConfigurationDependencySourceDemo {

    @Value("${user.id:-1}")
    private Long id;

    @Value("${usr.name}")
    private String name;

    @Value("${user.resource:classpath://default.properties}")
    private Resource resource;

    public static void main(String[] args) {

        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册 Configuration Class（配置类） -> Spring Bean
        applicationContext.register(ExternalConfigurationDependencySourceDemo.class);

        // 启动 Spring 应用上下文
        applicationContext.refresh();

        // 依赖查找 ExternalConfigurationDependencySourceDemo Bean
        ExternalConfigurationDependencySourceDemo demo = applicationContext.getBean(ExternalConfigurationDependencySourceDemo.class);

        System.out.println("demo.id = " + demo.id);
        System.out.println("demo.name = " + demo.name);
        System.out.println("demo.resource = " + demo.resource);

        // 显示地关闭 Spring 应用上下文
        applicationContext.close();
    }
}

2、原理

AutowiredAnnotationBeanPostProcessor也会处理@Value注解：

public AutowiredAnnotationBeanPostProcessor() {
	this.autowiredAnnotationTypes.add(Autowired.class);
	this.autowiredAnnotationTypes.add(Value.class);
	try {
		this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
				ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
		logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
	}
	catch (ClassNotFoundException ex) {
		// JSR-330 API not available - simply skip.
	}
}

当进行依赖注入时：

// org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
		Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

	InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
	try {
		Object shortcut = descriptor.resolveShortcut(this);
		if (shortcut != null) {
			return shortcut;
		}

		Class<?> type = descriptor.getDependencyType();
		// 此处的value值，就是@Value里面的表达式：${user.id}
		Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
		if (value != null) {
			if (value instanceof String) {
				// 获取配置文件中的值
				String strVal = resolveEmbeddedValue((String) value);
				BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
				value = evaluateBeanDefinitionString(strVal, bd);
			}

// org.springframework.beans.factory.support.AbstractBeanFactory#resolveEmbeddedValue
@Override
public String resolveEmbeddedValue(String value) {
	if (value == null) {
		return null;
	}
	String result = value;
	// 此处的StringValueResolver ，是可以通过EmbeddedValueResolverAware回调的
	for (StringValueResolver resolver : this.embeddedValueResolvers) {
		result = resolver.resolveStringValue(result);
		if (result == null) {
			return null;
		}
	}
	return result;
}

我们都知道，spring的aware接口都是一些回调接口：

public interface EmbeddedValueResolverAware extends Aware {

	/**
	 * Set the StringValueResolver to use for resolving embedded definition values.
	 */
	void setEmbeddedValueResolver(StringValueResolver resolver);

}
秃了也弱了。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
浅谈Spring IoC容器的依赖注入原理
08-27
主要介绍了浅谈Spring IoC容器的依赖注入原理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
IOC流程解析-循环依赖
qq_39339965的博客
04-25 986
Spring IOC 一系列文章下来，我们已经了解了整个spring IOC 核心refresh 方法的全部内容，这个方法名我是每篇文章都有提到，一定要记住。本次就聊一下IOC 的最后一个知识点：循环依赖的问题。 什么是循环依赖？ 很多小伙伴都在各种渠道听到过“循环依赖”这个词，也应该有一定了解，但是我这里还是要重新在具体描述一下循环依赖的概念。 循环依赖是指：在spring IOC 容器初始化的时候，记住是初始化，不是实例化，上篇文章IOC流程解析-实例化和初始化 就已近说过了spring 对于bean
Spring：IoC（控制反转、依赖注入、循环依赖）
燕双嘤
01-21 1520
1，IoC（Spring的核心和基础） 1.1，IoC原理 纵观所有的Java应用（从基于Applet的小应用到多层结构的企业级应用），这些应用中大量存在A对象调用B对象方法的情况，者请情况被Spring称为依赖，即A对象依赖B对象。对于Java应用而言，它们总是由一些相互调用的对象构成的，Spring把这种相互调用的关系称为依赖关系。假如A组件调用了B组件的方法，即可称A组件依赖B组件。 Spring框架的核心功能有两个： Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些J
Spring-依赖注入（IOC）
Bri0117的博客
09-12 753
SPRING 一、依赖注入（IOC） 1.什么是依赖注入 （1）我们经常说的控制反转（Inversion of Control —IOC）和依赖注入（Dependency Injection—DI），在Spring 环境下是等同的概念。 （2）控制反转是通过依赖注入实现的。 （3）所谓依赖注入指的是容器负责创建对象和维护对象间的依赖关系。而不是通过对象本身负责自己的创建和解决自己的依赖。 2.本质...
深入理解Spring IoC容器：解耦组件依赖，提升代码质量
2201_75630288的博客
03-19 123
在Java应用程序中，组件之间的依赖关系管理是开发过程中的重要问题。Spring IoC容器通过控制反转（IoC）和依赖注入（DI）机制解决了这个问题。本文将深入探讨Spring IoC容器的原理、使用方法和Bean的生命周期，包括Bean的实例化、初始化和销毁阶段。通过了解Spring IoC容器的工作原理，开发者可以轻松解耦组件依赖关系，提高代码质量、可维护性和可扩展性。
03_spring_依赖来源
hqq1256881740的博客
01-17 210
注：以下内容为学习《小马哥讲Spring核心编程思想》的个人笔记 依赖查找的来源 查找来源 来源 配置元数据 Spring BeanDefinition 用户来定义，例如xml配置，注解配置或者通过API来调用。总而言之，是用户来构建BeanDefinition的，例如@Bean public User user(){…}BeanDefinitionBuilder 单例对象 spring 内置的一些BeanDefinition，通常通过API实现 Spring 內建 BeanDefi
详解Spring IOC 容器启动流程分析
08-25
主要介绍了Spring IOC 容器启动流程分析,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Spring实现一个简单的SpringIOC容器
08-30
本篇文章主要介绍了Spring实现一个简单的SpringIOC容器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
用项目案例彻底理解SpringIOC容器
02-24
●运用工厂模式设计程序●理解JavaBean和POJO对象●理解控制反转思想●理解IOC容器在一个乡村小学校，一天只上三节课，有三名老师和一个校长。张老师负责教学生语文，王老师教学生数学，李老师教音乐，校长负责安排...
spring在IoC容器中装配Bean详解
08-28
主要介绍了spring在IoC容器中装配Bean详解，具有一定借鉴价值,需要的朋友可以参考下
Spring IoC依赖包
01-21
spring ioc开发最小依赖包4个，还包含两个辅助包commons-logging.jar和log4j.jar
ioc与依赖注入
weixin_71307869的博客
06-22 1383
IOC就是一个Spring特有的，用来装类对象的，就是我们用Spring框架时，不需要new对象了，不过我们需要让我们的Spring知道我们写了哪些配置和需要用什么，所以这时我们就要引用Spring的注解或者在配置xml文件上配置我们的类配置，就是在我们自己写的类上加上@Component、@Controller、@Service、@Repository等等这些让我们的Spring知道我们等下要调用有哪些类，让它先准备准备，等下我们需要用了，就getBean或者通过@Autowrite、@Resource来
Spring容器与依赖注入
晚来天欲雪
05-30 252
跟着B站《狂神说Java》学习顺带记录的笔记，视频地址：https://www.bilibili.com/video/BV1WE411d7Dv?spm_id_from=333.337.search-card.all.click 1、简介 1.1、历史与简介 历史 2002，首次推出了Spring的雏形，interface21 2004，Spring首次诞生，作者Rod Johnson 理念 使现有技术更加容易使用，本身是一个大杂烩 常见整合 SSH：Struct2 + Spring + hi
关于Spring IOC (DI-依赖注入)你需要知道的一切
热门推荐
zejian的博客
01-19 8万+
【版权申明】未经博主同意，不允许转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/54561302 出自【zejian的博客】 《Spring入门经典》这本无论对于初学者或者有经验的工程师还是很值一看的，最近花了点时间回顾了Spring的内容，在此顺带记录一下，本篇主要与spring IOC ，这篇博文
03 Spring IoC 依赖来源
hero_java的专栏
03-03 145
（1）Spring IoC 依赖来源： 自定义的Bean，通常是业务Bean,例如UserRepository对象,可以通过getBean获取 容器内建的Bean对象，不是我们自己业务方或者自己的应用来构建的，而是Spring 容器内部建立的,例如Environment、BeanDefinitions 和 Singleton Objects。可以通过getBean获取 容器内建的依赖，容器内非Bean，例如 BeanFactory，无法通过getBean获取。是通过AutowireCapableBea
Spring IOC 四种依赖注入
hwy499的博客
03-17 147
文章目录Spring IOC 四种依赖注入前期准备一、静态工厂二、实例工厂注入三、Set 方法注入四、通过构造方法注入 Spring IOC 四种依赖注入 前期准备 1、创建一个Maven工程 2、创建一个实体类 public class User { private Integer id; private String userName; private String passwo...
spring ioc的循环依赖问题
CaptainCats的博客
12-04 834
spring ioc的循环依赖通常是指bean与bean之间的相互依赖， 例如A持有对B的引用、B持有对A的引用，形成一个闭环，相对于这种我们一眼可以看出来的相互引用， 实际引用中可能比这复杂、也隐蔽的多， 要隐蔽、复杂的多， 形成一个环形依赖。其中，构造函数注入的循环依赖无法解决，只能抛出BeanCurrentlyCreationException异常， 在解决循环依赖时，spring采用的是提前暴露对象的方法。spring的循环依赖基于Java的引用传递， 当获得对象的引用时，对象属性可以延后设置， 而
什么是IOC以及依赖注入？
呼卓宇的博客
03-11 1601
以下文字从某论坛粘贴而来： 楼主：Spring 是干什么的？ 能具体举出一个例子吗？比如，写一个 留言板程序，会用到 Spring 吗？ 热心网友1：你接触 Java 13年了就只懂 if 、else 、for 这3个语句？！你怎么做到的？！ 楼主：因为所开发的网站（貌似不管多复杂的网站 都是 if 和 for ），都是 数据库的 增删改，按照 2000年的 ASP、PHP 语言 和 VB语言的...
Spring IoC 依赖来源
通往神秘的道路的专栏
09-12 335
依赖查找的来源 查找来源 来源 配置元数据 Spring BeanDefinition <bean id=“user” class=“org.geekbang…User”> @Bean public User user(){…} BeanDefinitionBuilder 单例对象 API 实现 Spring 內建 BeanDefintion Bean 名称 Bean 实例 使用场景 org.springframework.context.an
Spring IoC 的容器构建流程？
最新发布
07-16
Spring IOC容器构建流程如下： 1. 加载配置文件：Spring IOC容器首先需要加载配置文件，这些配置文件包含了Bean的定义和配置信息。 2. 创建Bean实例：Spring IOC容器根据配置文件中的Bean定义信息，创建Bean实例。 3. 设置Bean属性：Spring IOC容器将Bean实例的属性值设置到Bean实例中。 4. 注册Bean实例：Spring IOC容器将Bean实例注册到容器中，以便后续的使用。 5. 解析依赖关系：Spring IOC容器解析Bean实例之间的依赖关系，以便正确地创建Bean实例。 6. 初始化Bean实例：Spring IOC容器初始化Bean实例，包括调用Bean实例的初始化方法等。 7. 提供Bean实例：Spring IOC容器提供Bean实例给应用程序使用。 以上就是Spring IOC容器构建流程的基本步骤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秃了也弱了。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值