03_spring_依赖来源

最新推荐文章于 2024-05-09 21:21:48 发布
最新推荐文章于 2024-05-09 21:21:48 发布
阅读量220 收藏
点赞数 1
分类专栏： spring学习 文章标签： spring spring boot bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hqq1256881740/article/details/112752365
版权

注：以下内容为学习《小马哥讲Spring核心编程思想》的个人笔记

依赖查找的来源

查找来源

来源配置元数据
Spring BeanDefinition用户来定义，例如xml配置，注解配置或者通过API来调用。总而言之，是用户来构建BeanDefinition的，例如

@Bean public User user(){…}
BeanDefinitionBuilder
单例对象spring 内置的一些BeanDefinition，通常通过API实现

Spring 內建 BeanDefintion

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

定义源码见：org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable 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<>(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));
		}

		// 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;
	}

Spring 內建单例对象

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

上述的内建的单例对象都是通过API调用进行注册，源码可见

org.springframework.context.support.AbstractApplicationContext#createEnvironment

org.springframework.context.support.AbstractApplicationContext#initMessageSource

org.springframework.context.support.AbstractApplicationContext#initLifecycleProcessor

org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster

个人总结

总之，依赖查找来源要么是用户来创建（日常使用中写的Service），要么是spring内置中的创建（例如上述中内置的Bean）。而Spring内置中创建有两种方式，一种是创建BeanDefintion，然后通过BeanDefintion创建。一种是直接通过构造方法（new一个），然后调用**beanFactory.registerSingleton();**来进行创建。

依赖注入的来源

注入来源

来源配置元数据
Spring BeanDefinition用户来定义，例如xml配置，注解配置或者通过API来调用。总而言之，是用户来构建BeanDefinition的，例如

@Bean public User user(){…}
BeanDefinitionBuilder
单例对象spring 内置的一些BeanDefinition，通常通过API实现
非Spring容器管理对象

非Spring容器管理对象通过**beanFactory.registerResolvableDependency();**来创建，通过该接口创建的对象，在依赖查找（beanFactory.getBean()）中查找不到，但是依赖注入（@Autowire）时可以进行注入。内置的调用见源码：

/**
	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());
		}
	}

Spring 容器管理和游离对象

来源Spring Bean对象生命周期管理配置元信息使用场景
Spring BeanDefinition是是有依赖查找，依赖注入
单体对象是否无依赖查找，依赖注入
Resolvable Dependency否否无依赖注入
  • Spring BeanDefinition：通过 BeanDefinition 来创建的对象是有配置元信息的，因为BeanDefinition 就是它的配置元信息。作为用户定义的Bean（例如日常代码中的service），当然是Spring Bean对象，接受spring对它的生命周期管理。
  • 单体对象：指的是 Spring 中内置的一些对象，不通过 BeanDefinition来创建，直接通过构造方法（new 一个）创建，因此没有配置元信息。通过 beanFactory.registerSingleton(); 进行注册，是Spring Bean对象，但是没有生命周期管理（我猜是应用停止时才会销毁，所以不需要进行管理了）
  • Resolvable Dependency：通过beanFactory.registerResolvableDependency(); 进行注册，不是 Spring Bean对象，仅能依赖注入

Spring BeanDefinition 作为依赖来源

要素

  • 元数据：BeanDefinition
  • 注册：BeanDefinitionRegistry#registerBeanDefinition
  • 类型：延迟和非延迟
  • 顺序：Bean 生命周期顺序按照注册顺序

接口

BeanDefinition 的注册接口见org.springframework.beans.factory.support.BeanDefinitionRegistry，接口信息如下：

package org.springframework.beans.factory.support;

import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.core.AliasRegistry;

public interface BeanDefinitionRegistry extends AliasRegistry {

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

	// 移除 BeanDefinition
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 获取 BeanDefinition
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 判断是否包含 BeanDefinition
	boolean containsBeanDefinition(String beanName);

	// 获取 BeanDefinitionNames，记录了 BeanDefinition 的注册顺序
	String[] getBeanDefinitionNames();

	// 获取 BeanDefinition 的数量
	int getBeanDefinitionCount();

	/**
	 * Determine whether the given bean name is already in use within this registry,
	 * i.e. whether there is a local bean or alias registered under this name.
	 * @param beanName the name to check
	 * @return whether the given bean name is already in use
	 */
	boolean isBeanNameInUse(String beanName);

}

BeanDefinitionRegistry接口的实现类见 org.springframework.beans.factory.support.DefaultListableBeanFactory

单例对象作为依赖来源

要素

  • 来源：外部普通 Java 对象（不一定是 POJO）
  • 注册：SingletonBeanRegistry#registerSingleton

限制

  • 无生命周期管理
  • 无法实现延迟初始化 Bean

接口

单例对象的注册接口见org.springframework.beans.factory.config.SingletonBeanRegistry，接口信息如下：

package org.springframework.beans.factory.config;

import org.springframework.lang.Nullable;

public interface SingletonBeanRegistry {

   // 注册Bean
   void registerSingleton(String beanName, Object singletonObject);

   // 获取Bean
   @Nullable
   Object getSingleton(String beanName);

   // 判断是否包含
   boolean containsSingleton(String beanName);

   // 获取单例对象注册的名字，也是按照注册顺序
   String[] getSingletonNames();

   // 获取单例对象注册的数目
   int getSingletonCount();

   /**
    * Return the singleton mutex used by this registry (for external collaborators).
    * @return the mutex object (never {@code null})
    * @since 4.2
    */
   Object getSingletonMutex();

}

SingletonBeanRegistry 接口的实现类见org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#registerSingleton

非 Spring 容器对象作为依赖来源

要素

  • 注册：ConfigurableListableBeanFactory#registerResolvableDependency

限制

  • 无生命周期管理
  • 无法实现延迟初始化 Bean
  • 无法通过依赖查找

接口

非 Spring 容器对象注册的接口见 org.springframework.beans.factory.config.ConfigurableListableBeanFactory，实现类为org.springframework.beans.factory.support.DefaultListableBeanFactory#registerResolvableDependency，代码如下：

@Override
	public void registerResolvableDependency(Class<?> dependencyType, @Nullable 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() + "]");
			}
            /**
            将该对象加入 resolvableDependencies 中，key为类的类型，value是对象
            private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
            **/
			this.resolvableDependencies.put(dependencyType, autowiredValue);
		}
	}

外部化配置作为依赖来源

要素

  • 类型：非常规 Spring 对象依赖来源

限制

  • 无生命周期管理
  • 无法实现延迟初始化 Bean
  • 无法通过依赖查找

接口

外部化配置的接口见org.springframework.beans.factory.config.AutowireCapableBeanFactory#resolveDependency，具体实现见

	// org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency
	@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
                // 处理外部化配置的注入
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

有用的广告

​ 我是程序员，也热爱投资。个人认为，程序员这种职业（大部分是青春饭）非常适合投资，在年轻的积累本金，35岁后能过有睡后收入，想想就美滋滋。当然，如果没有专业的投资知识就是在股市中韭菜的份，这里推广下我学习投资知识的地方。简单说明下，这两个群都不会荐股，只是告诉你投资理念和知识，授人以鱼不如授人以渔，如果对投资感兴趣的人，我相信你会觉得相见恨晚。

老齐的读书圈：里面包含了几百本书籍，主要包括投资类，格局类，经营管理类三种。感兴趣的可以听听，三天内无条件可以退款。强烈推荐
在这里插入图片描述

齐俊杰的粉丝群：主要是对市场的解读，当然里面主要考虑的是周期的定位以及资产配置的相关知识。感兴趣的也可以进来听听，
在这里插入图片描述

月_神
关注
专栏目录
ROOT.rar_ROOT_spring_spring struts sample
09-20
在Java Web开发中，这三者是经典的MVC（Model-View-Controller）框架组合，它们各自扮演着关键角色：Spring作为核心容器管理依赖，Hibernate负责对象关系映射（ORM），而Struts则处理HTTP请求和视图呈现。...
你不知道的Spring的依赖的查找和注入的来源
了不起的盖茨比的博客
11-25 946
前面的博客我们已经介绍完了spring的依赖的查找和注入的方式，这篇博客我们主要介绍下spring的依赖的查找和注入的来源。
查看某个三方依赖jar包是在哪个pom引入的(springboot+idea)
本作者：想花
07-13 4194
使用idea的maven依赖图查看功能寻找是哪个pom引入的。然后使用ctrl F搜索，然后双击打开这个jar。可以看出是引入的关系，然后排除即可。这个类是在哪个jar包下。
SpringIOC容器的依赖来源都有哪些？这次一起捋清楚~
秃了也弱了
12-14 713
1、使用xml方式配置的
python pip安装依赖的常用软件源：清华源、阿里源、中科大源、豆瓣源
热门推荐
振华OPPO的博客世界
06-04 2万+
镜像源就是把官方的源作为一个镜像，你可以在这下载软件。比如ubuntu官方源在国外，下载软件可能会很慢，这时候就需要换成国内的镜像源。
python pip 下载依赖包源地址镜像
gaogsf的博客
07-26 3831
使用清华源等国内源下载速度很快，但是修改pip默认镜像源后，有的包可能只有默认源有。只能临时使用默认源安装：(pip默认镜像地址：https://pypi.org/simple)4.单击下图中的“Manage Repositories”按钮，1.将依赖包导出至requirements文件。2.从requirements文件中导入依赖包。pip install -i 四、PyCharm依赖包导入导出方法。二、有的包只能使用pip默认源下载。3.单击下图中添加“+”，一、更换pip为国内源。
Spring_Hibernate_Struts_example.rar_spring struts
09-19
Spring作为全面的轻量级应用框架，提供了依赖注入（DI）和面向切面编程（AOP）等功能，使得组件之间的耦合度大大降低。Hibernate是一个强大的对象关系映射（ORM）框架，它简化了数据库操作，使开发者可以专注于业务...
myMVC.rar_spring_springframework
09-21
1. **配置文件**：如`applicationContext.xml`或`dispatcher-servlet.xml`，这些文件用于定义Spring容器的bean及其依赖关系，以及设置Spring MVC的相关配置。 2. **控制器类**：使用@Controller注解的Java类，这些...
wa-spring1-SpringProject.zip_spring mvc 例子
09-24
在压缩包中，"www.pudn.com.txt"可能是项目说明文档或者下载来源的记录，而"SpringProject"很可能是项目源代码的根目录，包含着所有相关的Java源代码、配置文件、资源文件等。 为了充分利用这个例子，开发者可以...
spring-net-2.0.0.7z.zip_NHibernate_spring.net 框架
09-21
Spring.NET是中国著名的开源软件框架，它是.NET平台上的一个企业级应用框架，其设计灵感来源于Java领域的Spring Framework。Spring.NET提供了一整套服务，包括依赖注入（Dependency Injection，DI）、面向切面编程...
Cydia文件+依赖 .rar
07-12
Cydia文件+依赖 .rar 用于恢复cydia
Depends依赖工具 所有系统亲测可用
05-16
Depends依赖工具 所有系统亲测可用
Cydia至尊依赖包
10-07
IPHONE ipad iOS5.1.1完美越狱后，解决Cydia不能更新源的至尊依赖包。
centos7 安装wps 依赖源libXss.so.1()(64bit)
Redhat_yan
03-14 1372
手动搜索发现https://pkgs.org/download/libXss.so.1()(64bit)可以下载。centos 在安装wps时会提示：依赖检测失败： libXss.so.1()(64bit)被需要。选择合适自己的系统，这里以centos7为例。进入后下拉到Download选择二进制文件。yum 或者apt安装依赖失败。
Spring-依赖来源
最新发布
qq_43259860的博客
05-09 1099
这个时候注册会报错，如果启动了，我们可不可以把这个注册写到refresh之后呢？不可以因为这个时候上面的@Autowired 注入的时候找不到这个bean也会报错，所以通过回调函数的方式来处理，当Factory创建好以后进行注册。这个方法后面会有这样一段代码，前者是存储了beanName和beanDefinition 后者是为了保证顺序，因为后者是一个ArrayList。我们看到这里还有一把锁，是因为这个方法可能会被单独使用，但是其实这里锁的是同一个对象，如果是同一个线程内没有额外加锁。
【spring设计思想】4-依赖查找/依赖注入的数据来源
David_lou的专栏
06-05 576
spring最基本的功能-依赖注入/依赖查找。 依赖注入：比如我们平时用到的注解注入@Autowried/@Inject/@Value 依赖查找：applicationContext.getBean()或者是beanFactory.getBean();等 那么我们的依赖到底是保存在什么地方了呢。 来源一：beanFactory/beanDefinitionMap; 来源二：ApplicationContext； 来源三：Environment; 来源一beanFactory主要保存的是spri
Spring IoC 依赖来源
通往神秘的道路的专栏
09-12 363
依赖查找的来源 查找来源 来源 配置元数据 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 依赖来源(1)
songhao007的博客
09-20 181
@[TOC](第七章：Spring IoC 依赖来源(1)) 1. 依赖查找的来源 查找来源 Spring 內建 BeanDefintion Spring 內建单例对象 2. 依赖注入的来源 注入来源 3. Spring 容器管理和游离对象 • 依赖对象 4. Spring BeanDefinition 作为依赖来源 要素 • 元数据：BeanDefinition • 注册：BeanDefinitionRegistry#registerBeanDefinition • 类型：延迟和非延迟 • 顺序
Spring系列：IOC依赖的三个方向来源
NIO4444
11-14 485
来源 1. 自定义Bean(自己用xml配置或注解配置的bean) 2. 内部容器依赖的Bean(非自己定义的Bean,spring容器初始化的Bean) 内建即 Built-in，是由 Spring IoC 容器内部生成的 Bean 或组件。比如BeanFactory 3.内部容器所构建的依赖(非Bean,不可通过获取依赖查找Bean的方法来获取(getBean(XXX))) 比如Environment对象 区别 内建依赖,无法通过依赖查找查询; 其他类型的bean 两者都可以查.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值