BeanDefinition解析

最新推荐文章于 2024-05-30 16:12:13 发布
最新推荐文章于 2024-05-30 16:12:13 发布
阅读量430 收藏
点赞数
文章标签： java 设计模式 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39053702/article/details/121388652
版权

BeanDefinition的解析就是将对bean的定义转换为spring内部的数据结构

准备两个类和spring的xml文件
UserService.java

public class UserService {

	private UserDto userDto;

	private Map<String,String> map;

	public UserDto getUserDto() {
		return userDto;
	}

	public void setUserDto(UserDto userDto) {
		this.userDto = userDto;
	}

	public Map<String, String> getMap() {
		return map;
	}

	public void setMap(Map<String, String> map) {
		this.map = map;
	}
}

UserDto.java

public class UserDto {
	String name;
	int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void initMethod(){
		System.out.println("initMethod start--------------");

	}
}

2.准备了一个bean.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:cache="http://www.springframework.org/schema/cache"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	   http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/cache
	   http://www.springframework.org/schema/cache/spring-cache.xsd
	   http://www.springframework.org/schema/aop
	   https://www.springframework.org/schema/aop/spring-aop.xsd">
	   
	<bean id="userService" class="service.UserService">
		<property name="map">
			<map>
				<entry key="name" value="test"/>
				<entry key="age" value="20"/>
			</map>
		</property>
		<property name="userDto" ref="userDto"></property>
	</bean>

	<!--创建bean-->
	<bean id="userDto" class="dto.UserDto" init-method="initMethod" name="dto" lazy-init="true">
		<property name="age" value="20"/>
		<property name="name" value="保质期已过"/>
 	</bean>

main方法

public static void main(String[] args) {
		//1.资源定位
		Resource resource = new ClassPathResource("bean.xml");
		//2.创建IOC容器,这里使用DefaultListableBeanFactory作为IOC容器
		DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
		//3.读取BeanDefinition并注册到IOC容器中
		BeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
		reader.loadBeanDefinitions(resource);
	}

BeanDefinition解析大致过程
具体的过程是由BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader.registerBeanDefinitions方法实现

DefaultBeanDefinitionDocumentReader.java

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();//root代表根节点<beans>
		doRegisterBeanDefinitions(root);
	}

在doRegisterBeanDefinitions会调用parseBeanDefinitions方法，在parseBeanDefinitions中会调用parseDefaultElement方法

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {//节点的名称是bean
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

具体的解析过程会委托给BeanDefinitionParseDelegate.parseBeanDefinitionElement完成，这个类包含对bean规则定义的解析，比如bean属性（id,name,init-method等）的设定，property的设置

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//处理给定的bean定义——》BeanDefinition
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

parseBeanDefinitionElement方法

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		//获取bean的id,name属性
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isDebugEnabled()) {
				logger.debug("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}
		//检查beanName是否存在
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}
		//对Bean元素的详细解析
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						// Register an alias for the plain bean class name, if still possible,
						// if the generator returned the class name plus a suffix.
						// This is expected for Spring 1.2/2.0 backwards compatibility.
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

parseBeanDefinitionElement 方法

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			//创建BeanDefinition，为bean定义信息的载入做准备
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			//解析bean的属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			//解析bean的元素
			parseMetaElements(ele, bd);
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			//解析bean的构造函数
			parseConstructorArgElements(ele, bd);
			//解析property
			parsePropertyElements(ele, bd);
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

parseBeanDefinitionAttributes方法，完成对bean属性的解析，比如init-method,lazy-init等，如果没有设置属性会设置默认值

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}
		//设置scope
		else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
			bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
		}
		else if (containingBean != null) {
			// Take default from containing bean in case of an inner bean definition.
			bd.setScope(containingBean.getScope());
		}

		if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
			bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
		}
		//设置懒加载
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		//设置自动注入
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));

		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}

		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if (isDefaultValue(autowireCandidate)) {
			String candidatePattern = this.defaults.getAutowireCandidates();
			if (candidatePattern != null) {
				String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
				bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
			}
		}
		else {
			bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
		}

		if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
			bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
		}
		//设置初始化方法
		if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
			String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
			bd.setInitMethodName(initMethodName);
		}
		else if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}
		//设置销毁方法
		if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
			String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
			bd.setDestroyMethodName(destroyMethodName);
		}
		else if (this.defaults.getDestroyMethod() != null) {
			bd.setDestroyMethodName(this.defaults.getDestroyMethod());
			bd.setEnforceDestroyMethod(false);
		}

		if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
			bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
		}
		if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
			bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
		}

		return bd;
	}

parsePropertyElements完成对property的解析，获取元素后判断是否是elment,如果是的会调用parsePropertyElement进行元素和属性的解析，生成PropertyValue对象，将PropertyValue对象放入集合中，最后添加到BeanDefinition中

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}

parsePropertyElement解析Property节点

public void parsePropertyElement(Element ele, BeanDefinition bd) {
		//获取属性name的值，比如<property name="age" value="20"/> 获取到的就是“age”
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		this.parseState.push(new PropertyEntry(propertyName));
		try {
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
			//对元素value值的解析，ref,value,子元素
			Object val = parsePropertyValue(ele, bd, propertyName);
			//创建PropertyValue对象
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			//将PropertyValue对象放入集合中
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		}
	}

parsePropertyValue对value,ref,elment的解析

public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
		String elementName = (propertyName != null ?
				"<property> element for property '" + propertyName + "'" :
				"<constructor-arg> element");

		// Should only have one child element: ref, value, list, etc.
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
					!nodeNameEquals(node, META_ELEMENT)) {
				// Child element is what we're looking for.
				//Property中含有子元素
				if (subElement != null) {
					error(elementName + " must not contain more than one sub-element", ele);
				}
				else {
					subElement = (Element) node;
				}
			}
		}
		//ref属性
		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		//value属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		//如果两个属性都存在，则报错
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}
		//如果是ref属性，返回RuntimeBeanReference对象
		if (hasRefAttribute) {
			String refName = ele.getAttribute(REF_ATTRIBUTE);
			if (!StringUtils.hasText(refName)) {
				error(elementName + " contains empty 'ref' attribute", ele);
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
			ref.setSource(extractSource(ele));
			return ref;
		}
		//如果是value属性，返回TypedStringValue
		else if (hasValueAttribute) {
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		//如果还有子元素，则继续解析子元素，里面包含map,set,list的解析
		else if (subElement != null) {
			return parsePropertySubElement(subElement, bd);
		}
		else {
			// Neither child element nor "ref" or "value" attribute found.
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

parsePropertySubElement判断节点名称，这里以map集合为例，判断如果是map节点则调用parseMapElement，解析entry节点的属性key和value的值，将值放到新的map中并返回

public Map<Object, Object> parseMapElement(Element mapEle, @Nullable BeanDefinition bd) {
		String defaultKeyType = mapEle.getAttribute(KEY_TYPE_ATTRIBUTE);
		String defaultValueType = mapEle.getAttribute(VALUE_TYPE_ATTRIBUTE);

		List<Element> entryEles = DomUtils.getChildElementsByTagName(mapEle, ENTRY_ELEMENT);
		ManagedMap<Object, Object> map = new ManagedMap<>(entryEles.size());
		map.setSource(extractSource(mapEle));
		map.setKeyTypeName(defaultKeyType);
		map.setValueTypeName(defaultValueType);
		map.setMergeEnabled(parseMergeAttribute(mapEle));

		for (Element entryEle : entryEles) {
			// Should only have one value child element: ref, value, list, etc.
			// Optionally, there might be a key child element.
			NodeList entrySubNodes = entryEle.getChildNodes();
			Element keyEle = null;
			Element valueEle = null;
			for (int j = 0; j < entrySubNodes.getLength(); j++) {
				Node node = entrySubNodes.item(j);
				if (node instanceof Element) {
					Element candidateEle = (Element) node;
					if (nodeNameEquals(candidateEle, KEY_ELEMENT)) {
						if (keyEle != null) {
							error("<entry> element is only allowed to contain one <key> sub-element", entryEle);
						}
						else {
							keyEle = candidateEle;
						}
					}
					else {
						// Child element is what we're looking for.
						if (nodeNameEquals(candidateEle, DESCRIPTION_ELEMENT)) {
							// the element is a <description> -> ignore it
						}
						else if (valueEle != null) {
							error("<entry> element must not contain more than one value sub-element", entryEle);
						}
						else {
							valueEle = candidateEle;
						}
					}
				}
			}

			// Extract key from attribute or sub-element.
			Object key = null;
			boolean hasKeyAttribute = entryEle.hasAttribute(KEY_ATTRIBUTE);
			boolean hasKeyRefAttribute = entryEle.hasAttribute(KEY_REF_ATTRIBUTE);
			if ((hasKeyAttribute && hasKeyRefAttribute) ||
					(hasKeyAttribute || hasKeyRefAttribute) && keyEle != null) {
				error("<entry> element is only allowed to contain either " +
						"a 'key' attribute OR a 'key-ref' attribute OR a <key> sub-element", entryEle);
			}
			if (hasKeyAttribute) {
				key = buildTypedStringValueForMap(entryEle.getAttribute(KEY_ATTRIBUTE), defaultKeyType, entryEle);
			}
			else if (hasKeyRefAttribute) {
				String refName = entryEle.getAttribute(KEY_REF_ATTRIBUTE);
				if (!StringUtils.hasText(refName)) {
					error("<entry> element contains empty 'key-ref' attribute", entryEle);
				}
				RuntimeBeanReference ref = new RuntimeBeanReference(refName);
				ref.setSource(extractSource(entryEle));
				key = ref;
			}
			else if (keyEle != null) {
				key = parseKeyElement(keyEle, bd, defaultKeyType);
			}
			else {
				error("<entry> element must specify a key", entryEle);
			}

			// Extract value from attribute or sub-element.
			Object value = null;
			boolean hasValueAttribute = entryEle.hasAttribute(VALUE_ATTRIBUTE);
			boolean hasValueRefAttribute = entryEle.hasAttribute(VALUE_REF_ATTRIBUTE);
			boolean hasValueTypeAttribute = entryEle.hasAttribute(VALUE_TYPE_ATTRIBUTE);
			if ((hasValueAttribute && hasValueRefAttribute) ||
					(hasValueAttribute || hasValueRefAttribute) && valueEle != null) {
				error("<entry> element is only allowed to contain either " +
						"'value' attribute OR 'value-ref' attribute OR <value> sub-element", entryEle);
			}
			if ((hasValueTypeAttribute && hasValueRefAttribute) ||
				(hasValueTypeAttribute && !hasValueAttribute) ||
					(hasValueTypeAttribute && valueEle != null)) {
				error("<entry> element is only allowed to contain a 'value-type' " +
						"attribute when it has a 'value' attribute", entryEle);
			}
			if (hasValueAttribute) {
				String valueType = entryEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
				if (!StringUtils.hasText(valueType)) {
					valueType = defaultValueType;
				}
				value = buildTypedStringValueForMap(entryEle.getAttribute(VALUE_ATTRIBUTE), valueType, entryEle);
			}
			else if (hasValueRefAttribute) {
				String refName = entryEle.getAttribute(VALUE_REF_ATTRIBUTE);
				if (!StringUtils.hasText(refName)) {
					error("<entry> element contains empty 'value-ref' attribute", entryEle);
				}
				RuntimeBeanReference ref = new RuntimeBeanReference(refName);
				ref.setSource(extractSource(entryEle));
				value = ref;
			}
			else if (valueEle != null) {
				value = parsePropertySubElement(valueEle, bd, defaultValueType);
			}
			else {
				error("<entry> element must specify a value", entryEle);
			}

			// Add final key and value to the Map.
			map.put(key, value);
		}

		return map;
	}
保质期已过
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring源码学习二：BeanDefinition解析1
08-04
在实际应用中，Spring的BeanDefinition解析涉及到BeanDefinitionReader和BeanDefinitionRegistry两个组件。BeanDefinitionReader负责读取XML、Java配置或注解信息并创建BeanDefinition对象。BeanDefinitionRegistry...
Bean Definition 生成过程详解
小样
04-18 2294
1、目标： 个人认为spring项目启动过程主要分为两步，一个是bean Definition的获取，一个通过bean Definition生成bean。但是由于过程十分复杂我们先分析第一步。 2、bean Definition的种类分析 第一类：框架编写过程中硬编码到容器中的，大概是6个； 第二类：使用spring框架的程序员自己写的bean，比如被@component标注的对象； 第三类：从classpath视实际情况而自动装载的一些bean。包括tomcat 相关的，http相关的等；
BeanDefinition 及其构造方式 BeanDefinitionBuilder, AbstractBeanDefinition
JellyfishMIX 的博客
10-23 2719
BeanDefinition 是个接口，AbstractBeanDefinition 是这个接口的实现类，很多常见的 bean 属性在 AbstractBeanDefinition 中。这是经典的工厂模式，抽象出接口去规范工厂生产的实体类的行为。另外 GenericBeanDefinition 只是子类实现，大部分的属性在 AbstractBeanDefinition 中。/*** bean 对应的 class（用一个 Class 对象来表示）/*** bean 的作用范围。
深入解析Spring BeanDefinition：理解加载、解析与注册的全过程
最新发布
学而时习之，不亦说乎？温故而知新，可以为师矣！
05-30 1505
Spring框架中的BeanDefinition是描述Bean实例的基础配置单元，负责定义Bean的各种属性和依赖。本文将深入解析Spring BeanDefinition的源码，详细介绍其加载、解析和注册过程。我们将从Spring配置文件的读取开始，逐步剖析BeanDefinition的创建、解析、以及注册到BeanFactory的全过程。
BeanDefinition
hay23455的博客
06-12 1303
BeanDefinition 是实现扩展机制的基础，它提供了对 Bean 实例化和依赖注入过程的描述，从而使得开发者可以通过实现相应的接口来扩展 Spring 的功能。BeanDefinition 是实现 AOP 的基础，它定义了需要被代理的 Bean 实例以及代理所需的相关信息，从而实现了 AOP 功能。BeanDefinition 是 Spring 中的一个核心概念，它用于描述一个 Bean 实例的属性和行为，并提供了创建和管理 Bean 实例的基础信息。
spring启动流程 (3) BeanDefinition详解
xuguofeng2016的博客
07-04 742
BeanDefinition在Spring初始化阶段保存Bean的元数据信息，包括Class名称、Scope、构造方法参数、属性值等信息，本文将介绍一下BeanDefinition接口、重要的实现类，以及在Spring中的使用示例。
Spring多种加载Bean方式解析
08-30
Spring多种加载Bean方式...因此，怎么把xml标签解析为BeanDefinition（），入口是在org.springframework.beans.factory.xml.XmlBeanDefinitionReader这个类，但是实际干活的是在org.springframework.beans.factory.xml....
Spring中眼花缭乱的BeanDefinition.docx
06-26
在Spring中，当我们在XML配置或使用Java配置类时，定义的Bean信息会被解析成BeanDefinition对象，存储在容器中。 创建一个Java Bean是通过编写Java代码，然后由JVM的类加载器加载到内存。相比之下，创建一个Spring ...
Spring源码学习五：BeanDefinition装载1
08-04
在本篇文章中，我们将深入探讨 Spring 的源码，了解如何装载 BeanDefinition，并解析其实现细节。 BeanDefinition 的装载 在前一篇文章中，我们已经了解了 BeanDefinition 的概念和 importance。现在，我们将深入...
Spring源码学习四：BeanDefinition装载前奏曲1
08-04
总结来说，Spring的BeanDefinition装载过程涉及了从XML配置文件解析、BeanDefinition创建、BeanFactory初始化到Bean实例化的多个步骤。在学习源码时，应重点关注BeanDefinition的创建、加载和实例化过程，理解Spring...
Spring源码学习(五)---BeanDefinitions解析流程
https://juejin.cn/user/4248168663101239/posts
12-08 320
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录一. XmlBeanDefinitionReader二.DefaultBeanDefinitionDocumentReader1. doRegisterBeanDefinitions();三 . profile属性的使用四. 解析并注册BeanDefinition 一. XmlBeanDefinitionReader 在上一章Document文件配置读取后,需要注册Bean,当拥.
Spring BeanDefinition详解
qq_43460095的博客
07-27 1722
是最终全能实现类的基类，也是这些类的公同属性和公共逻辑的实现//默认的SCOPE，默认是单例publicstaticfinalStringSCOPE_DEFAULT="";//不进行自动装配publicstaticfinalintAUTOWIRE_NO=AutowireCapableBeanFactory.AUTOWIRE_NO;继承自AbstractBeanDefinition的全功能BeanDefinition实现类有httpshttpshttps。...
Spring源码分析三：Bean标签解析之BeanDefinition
小萌新的博客
05-03 581
文章目录（一）序言（二）Spring生成BeanDefinition1、Spring Bean解析入口2、Spring Bean内置标签解析（1）bean标签解析——processBeanDefinition方法（2）bean元素解析——parseBeanDefinitionElement方法（核心）①创建AbstractBeanDefinition实例②spring内置硬编码处理③解析元数据④解析lookup-method⑤解析replaced-method⑥解析构造函数参数⑦解析property子元素⑧
Spring补充（一）BeanDefinition详解
长安不及十里的博客
04-23 2503
AbstractBeanDefinition 是 BeanDefinition 的子抽象类，也是其他 BeanDefinition 类型的基类，其实现了接口中定义的一系列操作方法，并定义了一系列的常量属性，这些常量会直接影响到 Spring 实例化 Bean 时的策略。// 默认的 SCOPE，默认是单例 public static final String SCOPE_DEFAULT = "";
腾讯T6！万字长文体系化讲解Spring源码，码农：太透彻了，学会了
vip0809的博客
05-08 429
上一篇是分享的是《Spring SPI 机制总结》，这篇给大家分享《spring源码系列之BeanDefinition》，这篇文章略长，纯干货，大家准备好，发车啦。 【spring源码系列】之【BeanDefinition】 1. BeanDefinition简介 BeanDefinition有三个实现类，ChildBeanDefinition、GenericBeanDefinition、RootBeanDefinition，三者都继承AbstractBeanDefinition，对三个子类..
循环依赖问题终极解决方案
cj1561435010的博客
05-16 6413
今天下午给师兄抽云图数据的时候，报错了。 说到底还是C++太菜了，调试了一会才发现是写了个循环依赖，这四个字是这篇文章的重点。这个不是头文件重复包含的问题，看下面的图可能一下就明白了菜鸡犯的错。。。 事后看看，这不报错就有鬼了。。。这不就死锁了吗。。。 这时候突然想到Spring里面会不会有循环依赖这种问题，一想还是非常有可能的。比如你写的业务A需要调用到业务B的某个接口，而业务B的某个方法也需要调用业务A的某个接口。好了，又是类似之前的循环依赖。 网上说Spring依赖注入相当于有两种方式：1、set
Spring源码系列(三)BeanDefinition(二)
了不起的盖茨比的博客
09-22 563
1.写在前面 在上篇博客《Spring源码系列(二)BeanDefinition(一)》我们大概的介绍了下BeanDefinition接口中的一些属性，还有两个BeanDefinition的父接口。同时简单的介绍了下对应的实现类AbstractBeanDefinition。但是还有些属性没有介绍，这篇博客会把这些属性介绍了，同时会介绍一下BeanDefinition接口的一些实现类。还是那句话，Spring创建Bean都是根据这个BeanDefinition来的，所以要搞懂Spring的源码，必须要搞懂这些
Spring源码深度解析：BeanDefinition与自定义注解
在注解方式配置的BeanDefinition解析中，Spring主要利用AntPath模式扫描包下的.class文件，找到包含注解的类。这个过程涉及到Class.forName方法来动态加载类，并使用反射API获取注解信息。如果组件有自定义注解，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值