Spring源码篇（十）@Bean怎么注册一个bean

于 2023-09-29 11:11:32 发布
阅读量243 收藏
点赞数 1
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/133413013
版权

文章目录

前言

配置类的解析之前有聊过，这篇也会涉及到一部分，因为@Bean本身也是配置类里的一个东西，本篇会着重解析@Bean注册bean的过程。

配置类里的@Bean解析

位置：org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

这一部分就是解析配置类的流程

image-20230926101731272

底层的解析逻辑在：org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

这里它解析了Component、componentScan、import、importSource、PropertySource、bean，那我们只看解析bean的部分.

sourceClass是什么

image-20230926102606825

这里我们会看到有一个sourceClass的对象，这个对象保存了配置类的资源，以及注解信息；

它怎么来的？

在外面那一层方法创建的

image-20230926161426852

image-20230926161907364

image-20230926162540389

上面这段，它做了一个判断，如果是java后缀结尾的化，就以Class.forName的方式加载class，然后解析得到StandardAnnotationMetadata对象，否则就是ASM根据类名解析class；

可是，在第二张图种，先判断了是否是StandardAnnotationMetadata类型，这个是因为，springBoot启动时我们的主函数类会进行注册，并且会通过JVM加载，而且只要是通过@Import引入的都会被JVM加载，也会变成StandardAnnotationMetadata，所以只要是直接引用了类，都会变成StandardAnnotationMetadata。

sourceClass有两个类型：

  1. StandardAnnotationMetadata：标准的注解元数据信息，这个是由反射操作的，所以，它会被加载到JVM中；

  2. SimpleMetadataReader：这个是由ASM技术解析字节码得到的，不会加载到JVM中；

测试示例：

@Component
public class Test {

    @Bean
    public Amend amend() {
        return new Amend();
    }
}


public class Test2 {

    public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {

        // ASM解析元数据
        MetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();
        MetadataReader simpleMetadata = metadataReaderFactory.getMetadataReader("com.meiya.whalex.ay.datajoinup.Test");

        Set<MethodMetadata> simpleMetas = simpleMetadata.getAnnotationMetadata().getAnnotatedMethods("org.springframework.context.annotation.Bean");

        System.out.println("是否加载 Test.class ：" + haveClass("com.meiya.whalex.ay.datajoinup.Test"));

        // 标准元数据获取
        AnnotatedTypeMetadata standardMetadata = AnnotationMetadata.introspect(Test.class);

        System.out.println("是否加载 Test.class ：" + haveClass("com.meiya.whalex.ay.datajoinup.Test"));

        Set<MethodMetadata> standardMetas = ((StandardAnnotationMetadata) standardMetadata).getAnnotatedMethods("org.springframework.context.annotation.Bean");

        System.out.println();
    }

    private static boolean haveClass(String className) throws NoSuchFieldException, IllegalAccessException {
        Field classes = ClassLoader.class.getDeclaredField("classes");
        classes.setAccessible(true);
        Vector<Class> o = (Vector)classes.get(ClassLoader.getSystemClassLoader());
        System.out.println("包含class:" + o.size() +"个");
        for (int i = 0; i < o.size(); i++) {
            Class<?> o1 = o.get(i);
            if (o1.getName().equals(className)) {
                return true;
            }
        }
        return false;
    }
}

image-20230926155525283

这两种方式获取得到的注解信息差不多，都能获取到注解，方法，返回类型等信息，不同的点在于是否加载到JVM，通过上面的示例，可以看到，使用ASM技术解析的并不会加载class；

解析@Bean方法

进入retrieveBeanMethodMetadata方法，这里是对这个元数据进行解析，刚刚说过，这个sourceClass是包含注解元数据信息的，那么这里的这个方法就是解析含有@Bean注解的方法，位置：

org.springframework.context.annotation.ConfigurationClassParser#retrieveBeanMethodMetadata

private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
    // 获取配置类里的注解元数据信息
		AnnotationMetadata original = sourceClass.getMetadata();
    // 获取标注有@Bean注解的方法元数据信息列表
		Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
    // 存在@Bean标注的方法，并且，是属于是通过JVM加载的类才会进去
		if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
	// 这里就是ASM解析class（spring中解析class都是ASM，没有加载到JVM）
    // 因为判断中包含 StandardAnnotationMetadata 类型判断，这个类型是JVM加载后的类型
    // 虽然StandardAnnotationMetadata也能获取到注解元数据信息，但是因为JVM反射回来的元数据信息是无顺序的，在spring中@Bean注解是有顺序的，所以这里它做了ASM解析
			try {
				AnnotationMetadata asm =
						this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
				Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
				if (asmMethods.size() >= beanMethods.size()) {
					Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
					for (MethodMetadata asmMethod : asmMethods) {
						for (MethodMetadata beanMethod : beanMethods) {
							if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
								selectedMethods.add(beanMethod);
								break;
							}
						}
					}
					if (selectedMethods.size() == beanMethods.size()) {
						// All reflection-detected methods found in ASM method set -> proceed
						beanMethods = selectedMethods;
					}
				}
			}
			catch (IOException ex) {
				logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
				// No worries, let's continue with the reflection metadata we started with...
			}
		}
		return beanMethods;
	}

添加@Bean注解的方法信息

然后再回到一开始的那个地方：

位置：org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

image-20230926163620569

这里可以看到，它再拿到@Bean注解标注的方法元数据后就直接添加到配置类的beanMethod集合中，并没有再进一步的操作；

上面这是一种情况，另外还有一种情况，就是接口上的@Bean

比如说像这样：

public interface Test6 {

    @Bean
    default Log og(){
        return new Log();
    }
}

其实这Log也能被注册上去的，如下：

image-20230927154232334

	private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
        // 获取到配置类的接口列表，然后遍历
		for (SourceClass ifc : sourceClass.getInterfaces()) {
            // retrieveBeanMethodMetadata 和上面一样，就是解析@Bean的方法，然后生成beanMethod
			Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);
			for (MethodMetadata methodMetadata : beanMethods) {
				if (!methodMetadata.isAbstract()) {
					// 添加非抽象的方法
					configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
				}
			}
			processInterfaces(configClass, ifc);
		}
	}

注册

再所有的配置类都解析完后，后面还有一个loadBeanDefinitions的操作，这个操作会加载由@Import,@ImportRsource,@Import(ImportBeanRegister)导入的类；

位置：org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

image-20230926171415370

底层位置：org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

        // 判断是否需要跳过，判断是否有@Import导入的类和@Conditional一类的条件注解，还有是否有@Bean的方法信息
		if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}

        // 这里是判断@Import导入的类是否存在
		if (configClass.isImported()) {
// 存在就注册
            registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
        // 这里是按顺序对@Bean注册类
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}


 // @ImportResource注册     
        loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
        // @Import注册ImportBeanDefinitionRegistrar时
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}

着重看下loadBeanDefinitionsForBeanMethod

它有几个步骤：

  1. 获取基础信息：配置类、@Bean方法元数据、方法名

  2. 是否跳过：Conditional判断

  3. 获取beanName：取@Bean属性name，如果没有，就取方法名作为beanName

  4. 注册别名：同样是@Bean属性name，如果存在就注册

  5. 是否覆盖的校验，它覆盖的规则是：

    1. 同样由@Bean方式注册的（ConfigurationClassBeanDefinition），同一个配置类中，beanName相同，最先注册的，也就是写在最前面的为准，写在后面的都不会注册
    2. 如果存在相同的bean，如果先注册的是通过class扫描注册的，继续注册
    3. 如果存在相同的bean，其权限不是应用级别（role != 0），继续注册
    4. 如果存在相同的bean，beanFactory的allowBeanDefinitionOverriding=false，默认false，那么报错

  6. 创建beanDefinition（ConfigurationClassBeanDefinition）

    1. 设置方法元数据
    2. beanClassName（实例方法时设置）或者是beanClass（静态方法时设置）
    3. 工厂方法名
    4. 自动注入模式为构造器注入
    5. @Required校验开关，打开（true）
    6. 公共注解@Lazy,@Primary,@DependsOn,@Role,@Description这些注解的设置，设置到beanDefinition
    7. 设置是否自动注入autowire，默认不自动注入
    8. 设置initMethod``destroyMethod方法
    9. 设置代理模式，然后如果要进行代理，怎会创建一个proxy的beanDefinition

  7. 注册beanDefinition

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    // 1. 获取基础信息
    // 获取@Bean的配置类 
		ConfigurationClass configClass = beanMethod.getConfigurationClass();
    // 获取方法元数据信息
		MethodMetadata metadata = beanMethod.getMetadata();
    // 获取方法名
		String methodName = metadata.getMethodName();

		// 2. 是否需要跳过，也是Conditional判断
		if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
			configClass.skippedBeanMethods.add(methodName);
			return;
		}
		if (configClass.skippedBeanMethods.contains(methodName)) {
			return;
		}
    // 3. 获取beanName
		// 获取注解@Bean的属性信息
		AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
		Assert.state(bean != null, "No @Bean annotation attributes");

		// 找出name属性的值
    // 注意，@Bean的name属性是一个数组，也就是对于这个bean可以有多个别名
		List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
    // 取name数组中的第一个为beanName，或者取方法名
		String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

    // 4. 注册别名：为这个bean注册别名
		for (String alias : names) {
			this.registry.registerAlias(beanName, alias);
		}
	// 5. 是否覆盖的校验，它覆盖的规则是：
    // 判断已存在的bean否是配置类ConfigurationClassBeanDefinition（由@Bean注册的），且对应的配置类的全类名相同 return true（不继续注册）
    // 判断已存在的bean是否是扫描得到的beanDefinition(ScannedGenericBeanDefinition)，return false（继续注册）
    // 判断已存在的bean是否是应用级别的bean（role == 0），role != 0  return false（继续注册）
    // 判断已存在的bean是否是bean工厂（DefaultListableBeanFactory），当allowBeanDefinitionOverriding=true时，return true, 默认false，（继续注册）
		if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
            // @Bean方法的beanName == 这个配置类的beanName
            // beanName不唯一，因为是同一个类里出现beanName不唯一的请情况，所以直接抛出异常
			if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
				throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
						beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
						"' clashes with bean name for containing configuration class; please make those names unique!");
			}
			return;
		}
	// 6. 创建beanMethod的beanDefinition
    // 6.1 设置方法元数据
    // 创建一个配置类的bean定义（ConfigurationClassBeanDefinition）
		ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
    // 这里其实就是用metadata进行赋值
		beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
	// 6.2 beanClassName（实例方法时设置）或者是beanClass（静态方法时设置）
    // 6.3 设置工厂方法名
    // 从这里可以看出@Bean支持静态方法
		if (metadata.isStatic()) {
			// 设置配置类的class，或者是className，就看是否用ASM解析
			if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
				beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
			}
			else {
				beanDef.setBeanClassName(configClass.getMetadata().getClassName());
			}
            // 设置唯一的工厂方法名，也就是@Bean的方法名称
			beanDef.setUniqueFactoryMethodName(methodName);
		}
		else {
			// 非静态方法的@Bean方法
            // 设置工厂bean名称为配置类的名称
			beanDef.setFactoryBeanName(configClass.getBeanName());
            // 设置唯一的工厂方法名，也就是@Bean的方法名称
			beanDef.setUniqueFactoryMethodName(methodName);
		}

    // 这里是JVM加载后才会走的
		if (metadata instanceof StandardMethodMetadata) {
			beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
		}
	// 6.4 自动注入模式为构造器注入
// 设置注入模式为构造器注入
    beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
		
    // 6.5 @Required校验开关，打开（true）
 // 指定RequiredAnnotationBeanPostProcessor后置处理器的校验跳过，
    // 也就是@Required的检查，不过这个注解后面是要被废弃的，我看的版本是5.2.6
    beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
				SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
// 6.6 设置公用注解的配置
    // @Lazy,@Primary,@DependsOn,@Role,@Description这些注解的设置，设置到beanDefinition
    
		AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

    // 6.7 @Bean里的autowire属性，默认不自动注入
    // 一般我们写@Bean的时候也是直接设置好了属性，但是这里可以通过设置@Bean的autowire属性，完成自动注入，但这样对于自定义的bean可能还是有限制
		Autowire autowire = bean.getEnum("autowire");
		if (autowire.isAutowire()) {
			beanDef.setAutowireMode(autowire.value());
		}

   // 可作为其他bean的注入的候选bean对象，@Bean中，这个属性默认为true
    // 所以，在某些场景中，我们可以设置这个属性为false，使之不能被其他bean注入
		boolean autowireCandidate = bean.getBoolean("autowireCandidate");
		if (!autowireCandidate) {
			beanDef.setAutowireCandidate(false);
		}
	// 6.8 设置`initMethod``destroyMethod`方法
    // 设置initMethod方法，这个是在bean生命周期中，在bean初始化后会调用的一个方法
    // 可以理解为一个bean创建的回调方法
		String initMethodName = bean.getString("initMethod");
		if (StringUtils.hasText(initMethodName)) {
			beanDef.setInitMethodName(initMethodName);
		}

    // 设置destroyMethod方法，同样是在bean生命周期中会被调用的一个方法
		String destroyMethodName = bean.getString("destroyMethod");
		beanDef.setDestroyMethodName(destroyMethodName);

    // 6.9 设置代理模式
		// ScopedProxyMode代理模式，可以设置jdk动态代理，cglib动态代理
    // 默认是不进行代理
		ScopedProxyMode proxyMode = ScopedProxyMode.NO;
    // 如果这个@Bean的方法有配置@Scope注解，那么会获取到，然后赋值
		AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
		if (attributes != null) {
            // 存在@Scope，获取值并设置到beanDefinition
			beanDef.setScope(attributes.getString("value"));
            // 赋值
			proxyMode = attributes.getEnum("proxyMode");
			if (proxyMode == ScopedProxyMode.DEFAULT) {
				proxyMode = ScopedProxyMode.NO;
			}
		}

		// 如果需要代理，那么就会创建一个proxy的BeanDefinition
		BeanDefinition beanDefToRegister = beanDef;
		if (proxyMode != ScopedProxyMode.NO) {
			BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
					new BeanDefinitionHolder(beanDef, beanName), this.registry,
					proxyMode == ScopedProxyMode.TARGET_CLASS);
			beanDefToRegister = new ConfigurationClassBeanDefinition(
					(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
		}

		if (logger.isTraceEnabled()) {
			logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
					configClass.getMetadata().getClassName(), beanName));
		}
    // 7 进行注册
		this.registry.registerBeanDefinition(beanName, beanDefToRegister);
	}

总结

@Bean注册的过程

@Bean注入类的过程：

  1. 配置类解析，解析@ComponentScan,@ImportSource,@Import,@PropertySource,@Bean

  2. 添加：添加解析@Bean得到的BeanMethod到配置类中，包含接口里的默认方法

  3. 注册：在所有的配置类都解析完后，执行loadBeanDefinitions，遍历beanMethod

    1. 获取基础信息：配置类、@Bean方法元数据、方法名

    2. 是否跳过：Conditional判断

    3. 获取beanName：取@Bean属性name，如果没有，就取方法名作为beanName

    4. 注册别名：同样是@Bean属性name，如果存在就注册

    5. 是否覆盖的校验，它覆盖的规则是：

      1. 同样由@Bean方式注册的（ConfigurationClassBeanDefinition），同一个配置类中，beanName相同，最先注册的，也就是写在最前面的为准，写在后面的都不会注册
      2. 如果存在相同的bean，如果先注册的是通过class扫描注册的，继续注册
      3. 如果存在相同的bean，其权限不是应用级别（role != 0），继续注册
      4. 如果存在相同的bean，beanFactory的allowBeanDefinitionOverriding=false，默认false，那么报错

    6. 创建beanMethod的beanDefinition（ConfigurationClassBeanDefinition）

      1. 设置方法元数据
      2. beanClassName（实例方法时设置）或者是beanClass（静态方法时设置）
      3. 工厂方法名
      4. 自动注入模式为构造器注入
      5. @Required校验开关，打开（true）
      6. 公共注解@Lazy,@Primary,@DependsOn,@Role,@Description这些注解的设置，设置到beanDefinition
      7. 设置是否自动注入autowire，默认不自动注入
      8. 设置initMethod``destroyMethod方法
      9. 设置代理模式，然后如果要进行代理，怎会创建一个proxy的beanDefinition

    7. 注册beanDefinition

  4. bean生命周期 -> 实例化、初始化、代理、添加单例池

注意点

  1. @Bean标注的方法都在同一个配置类中，出现相同beanName，那么优先级以最先写的方法为准，后面的方法不会进行注册

  2. @Bean标注的方法不再同一个配置中，相同的beanName，属于重写注册的bean，需要设置spring.main.allowBeanDefinitionOverriding=true

  3. @Bean标注的方法可以时static修饰的（静态方法）

  4. @Bean默认是不自动注入的，但是它可以通过设置属性autowire完成自动注入

  5. 如果配置类实现里某个接口，而这个接口存在默认方法，且有@Bean注解，也会被注册

用针戳左手中指指头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【框架源码篇 04】Spring源码手写篇-Bean定义配置化
10-21
【框架源码篇 04】Spring源码手写篇-Bean定义配置化
【栖梧-源码-spring】@Bean从解析到注册到beanDefinitionMap
_sunshine的博客
08-14 1100
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Spring源码学习：spring使用@Bean方法注入对象时，beanName相同出现随机注入的问题
qq_36566262的博客
04-01 1500
目录前言1 现象2 源码探究3 测试3.1 实现接口情况3.2 去掉实现类或者删除接口中@Bean方法总结 前言 当我们在配置类中通过@Bean方法注入对象时，如果设置相同的beanName，会出现注入对象不一致的问题。 1 现象 前提：设置配置类Config，实现接口MyInterface（接口中必须有一个@Bean方法），同时配置类中设置两个@Bean方法，这两个@Bean名字设置为相同如下图： 设置主类如下： public static void main(String[] args) { An
（三）Spring框架原理之@Configuration及搭配注解接口源码分析（下）
Armyyyyy丶的博客
07-25 281
目录 一、源码分析 1.ConfigurationClassParser解析类 1.1 解析配置类的@Component注解 1.2 processPropertySource解析@PropertySources注解 1.3 ComponentScanAnnotationParser解析@ComponentScan注解 1.4 processImports解析@Import注解 1.5 retrieveBeanMethodMetadata解析获取@Bean注解 2.Configuration
@Component@Import@Bean加载顺序解析
yytree123的博客
02-24 4616
@Component@Import@Bean加载顺序解析
【Spring源代码阅读之六】处理配置类的@Import、@Bean、父接口方法的@Bean并解析，同时解析@ImportResource
weixin_42997554的博客
02-23 549
处理配置类的@Import、@Bean、父接口方法的@Bean并解析，同时解析@ImportResource导图开始处理ConfigurationClassParser#processImportsConfigurationClassParser#retrieveBeanMethodMetadataConfigurationClassParser#processInterfaces以下是解析Con...
Spring注册Bean的几种方式
qq_19286785的博客
03-09 2732
Spring中常用的几种注册Bean的方式
spring源码12: spring创建Bean
01-20
创建bean前准备 如果使用调试模式，跟进来下面代码倒不会有什么疑问，但是这一步代码的跳转确十分奇特，值得去探究一番。 在上一节讲到，首先spring在AbstractBeanFactory类中创建了ObjectFactory的对象，并重写了...
Spring 源码分析（Bean的初始化）
12-21
本篇文章是个人第一次看spring源码并总结，同时也参考了下面这篇博客。基本也是按照他的思路来理解的。这也算是第一版个人简易理解。也算是窥见spring的冰山一角，之后也会继续阅读下去。望各位多多支持。 本片博文...
spring IOC源码 – 单实例bean的循环依赖 源码及过程
12-21
现在有两个对象Water和Ice，这两个对象相互引用，代码如下： 代码 Ice类 package com.xiaolinzi.cyclicdepen; import org.springframework.beans.factory.annotation.Autowired; import org.springframework....
springBean加载过程源码解析文档，附有代码类名和行数
06-15
springBean加载过程源码解析文档，附有代码类名和行数
Spring_Bean对象的注册和注入
qq_53223625的博客
04-23 377
Controller(控制器存储)：做web开发使用，专门对web的请求响应进行处理 Service（服务存储）：做业务逻辑,为项目提供服务 Repository(仓库存储)：做数据访问操作，一般指操作数据库 Component（组件存储）：值一般组件，如果不属于以上三个功能，就是用这个注解 Configuration（配置存储）：企业级/大型项目启动时，需要加载配置很多东西，就需要用到
Spring中Bean定义的注册流程
qq_57756904的博客
10-07 1662
总的来说组件有委托类、后置处理器、解析器、包扫描器、资源加载/读取器、注册器、BeanFactory等组件，Spring的Bean定义注册流程如此，Bean初始化也差不多，包括MyBatis的初始化也用到其中的部分设计。图中主要是组件内部调用以及组件间的调用流程，当然在调用前如果非静态操作的话都是要做如构造初始化的。
Spring注解驱动开发---向Spring Ioc容器中注册Bean的7种方式
tian830937的专栏
09-16 380
Spring是一个非常强大的反转控制(IOC)框架，以帮助分离项目组件之间的依赖关系。因此可以说Spring容器对Bean的注册、管理可以说是它的核心内容，最重要的功能部分。因此本文主要介绍：向Spring容器注册Bean的多种方式向Spring IOC容器注册Bean 的7种方式。
Spring 源码解析 - Bean资源加载注册过程
小毕超博客
03-15 628
的使用情况，可以发现在容器关闭时也对其进行了上锁，主要就是为了防止放生冲突，在锁中可以看到又触发了很多方法，逻辑比较多，这里主要看。对象时会对已经初始化好的对象进行记录，因此这里可以用来判断容器是否初始化完成，如果容器已经初始化，则为了避免数据的不统一，这里对。中的命名空间是否是默认的还是自定义的，如果是自定义的则使用用户自定义的解析规则，否则使用默认的解析，由于前面例子中的。去容器中获取，如果容器中存在，并不允许覆盖，则抛出异常，还会判断容器中的。方法中，在该方法中，将读取资源文件为输入流，然后使用。
springboot找不到注册的bean
fo_xi的博客
09-04 1408
springboot找不到注册的bean
Spring注解式开发: Bean的注册
m0_55435847的博客
04-26 2250
Spring中的Bean的注册有很多种方式，但大多区别不大,首先启动spring这个IOC容器的方式就有两种分别是古老的用*.xml文件来启动还有现在主流用注解式@Configuration声明一个为配置类来启动Spring容器。 首先说明:得先大概会用Spring和SpringBoot(要不然可能会懵，只是可能会懵而已不用在意),因为SprinBoot里面就都是注解式开发 方式一（不推荐方式）: 用xml文件里面的<Bean>标签声明注册 (用*.xml文件启动Spring) x...
spring注册Bean注解使用
一个普普通通的博客
10-18 543
本文主要分享spring注解的使用
【Spring】Bean注册和注入
m0_56975154的博客
10-22 1475
这几个注解在 IOC 场景下，没有区别，都是将类注册进 Spring 库，但在其他场景一般这样用。当使用以下方法注入时，会注入进 NULL 值，而非对象，原因已在下面代码的注释中写出。使用注解注册 Bean 是注册进 Spring 提供的库，就不需要自建库了。使用 @Bean 修饰方法，@Configuration 修饰类。使用注解注册简而言之就是使用某个注解修饰类或方法，对其进行注册。使用工厂方法注册就是调用静态工厂方法注册 Bean。此方法注册就相当于 XML 中的工厂方法注册。
spring bean生命周期 源码
最新发布
09-26
Spring框架提供了对Bean的生命周期管理。在Spring源码中，Bean的生命周期由两个关键接口定义：BeanFactory和BeanPostProcessor。 BeanFactory是Spring的核心接口之一，它负责管理所有的Bean，并负责实例化、配置和管理它们的整个生命周期。BeanFactory接口定义了许多方法，如getBean()和registerBeanDefinition()，用于获取和注册Bean。 BeanPostProcessor是另一个重要的接口，它定义了在Bean初始化的不同阶段可以插入自定义逻辑的扩展点。通过实现BeanPostProcessor接口，开发人员可以在Bean的实例化、初始化和销毁等阶段插入自己的逻辑。BeanPostProcessor接口中定义了两个方法：postProcessBeforeInitialization()和postProcessAfterInitialization()。 在Spring的源码中，Bean的生命周期主要涉及以下几个重要的类和方法： 1. DefaultListableBeanFactory类：此类实现了BeanFactory接口，是Spring容器的核心实现类之一。它负责读取Bean的定义信息，并根据这些定义信息创建和管理Bean。 2. AbstractAutowireCapableBeanFactory类：此类是DefaultListableBeanFactory的子类，它提供了Bean的自动装配功能。它包含了Bean的实例化、属性注入、初始化和销毁等关键步骤。 3. AnnotationConfigApplicationContext类：此类是通过注解配置来创建Spring容器的一种方式。它根据指定的配置类，扫描注解并完成Bean的初始化和管理。 4. BeanDefinition类：此类定义了Bean的配置信息，包括Bean的类名、属性值和依赖关系等。在Bean的生命周期中，BeanDefinition起到了重要的作用。 以上只是Spring Bean生命周期源码的一部分，如果你对Spring Bean生命周期的源码感兴趣，建议你阅读Spring源码以获得更详细的了解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值