BeanDefinitionParserDelegate学习

简介

  1. Spring中的BeanDefinitionParserDelegate是一个解析器委托类,主要作用是解析Spring的配置文件。这个类通过反射实例化bean,然后注册进bean工厂。
  2. 具体来说,BeanDefinitionParserDelegate专门解析由xml转成Document的类,Document里面是以beans为根节点的Spring配置文件的全部内容。该类中的parseBeanDefinitionElement方法负责解析以bean开头的配置,包括id和name等属性。
  3. 同时,BeanDefinitionParserDelegate还会检查id和name是否有与其他对象的重复,以保持唯一性。此外,这个类还提供了其他一些方法和属性,用于配置和定制bean的定义和解析过程。

主要属性

	public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
	//布尔类型的值
	public static final String TRUE_VALUE = "true";
	//布尔类型的值
	public static final String FALSE_VALUE = "false";
	//设置默认值
	public static final String DEFAULT_VALUE = "default";
	//bean的描述信息 简介
	public static final String DESCRIPTION_ELEMENT = "description";
	//不自动注入
	public static final String AUTOWIRE_NO_VALUE = "no";
	//根据bean的名称自动注入
	public static final String AUTOWIRE_BY_NAME_VALUE = "byName";
	//根据类型自动注入
	public static final String AUTOWIRE_BY_TYPE_VALUE = "byType";
	//bean的构造函数标签
	public static final String AUTOWIRE_CONSTRUCTOR_VALUE = "constructor";
	//autodetect属性用于自动检测和配置Bean。
	// 具体来说,autodetect属性可以用于自动检测并注册Bean到Spring容器中,而不需要显式地定义Bean的配置。
	//例如,在使用Spring Boot时,可以通过在Spring配置文件中设置autodetect属性为true,来自动检测并配置应用程序中的Bean。
	// 当Spring Boot启动时,它会扫描应用程序中的类,并自动检测符合特定条件的Bean,然后将它们注册到Spring容器中。
	public static final String AUTOWIRE_AUTODETECT_VALUE = "autodetect";
	//bean的名称
	public static final String NAME_ATTRIBUTE = "name";
	//代表bean标签
	public static final String BEAN_ELEMENT = "bean";

	//bean的唯一标识
	public static final String ID_ATTRIBUTE = "id";
	//当前bean的父亲
	public static final String PARENT_ATTRIBUTE = "parent";
	//类的类型 这里要指定类的全限定名
	public static final String CLASS_ATTRIBUTE = "class";
	//是否是抽象类
	public static final String ABSTRACT_ATTRIBUTE = "abstract";
	//bean作用域 默认为singleton
	public static final String SCOPE_ATTRIBUTE = "scope";
	//单例
	private static final String SINGLETON_ATTRIBUTE = "singleton";
	//是否延迟初始化当前bean 默认为false 表示容器启动时初始化当前bean,设置为true 则第一次使用当前bean时初始化当前bean
	public static final String LAZY_INIT_ATTRIBUTE = "lazy-init";
	//自动装配模式 取值 no byName byType constructor autodetect
	public static final String AUTOWIRE_ATTRIBUTE = "autowire";
	//自动装配候选者,默认为 true,表示该 bean 可以作为自动装配候选者;设置为 false 则表示该 bean 不参与自动装配。
	public static final String AUTOWIRE_CANDIDATE_ATTRIBUTE = "autowire-candidate";
	//当有多个相同类型的bean时,当前bean primary=true 会优先使用这个bean,也称为主bean
	public static final String PRIMARY_ATTRIBUTE = "primary";
	//beanA依赖与beanB 可以使用该属性
	public static final String DEPENDS_ON_ATTRIBUTE = "depends-on";
	//bean 初始化方法
	public static final String INIT_METHOD_ATTRIBUTE = "init-method";
	//bean 销毁方法
	public static final String DESTROY_METHOD_ATTRIBUTE = "destroy-method";
	//指定调用实例工厂的方法名称
	public static final String FACTORY_METHOD_ATTRIBUTE = "factory-method";
	//指定实例工厂引用名称
	public static final String FACTORY_BEAN_ATTRIBUTE = "factory-bean";
	//bean 构造函数标签
	public static final String CONSTRUCTOR_ARG_ELEMENT = "constructor-arg";
	//下标 比如构造函数第一个参数下标为0
	public static final String INDEX_ATTRIBUTE = "index";
	//类型,比如参数的类型,bean的类型
	public static final String TYPE_ATTRIBUTE = "type";

	//property标签
	public static final String PROPERTY_ELEMENT = "property";
	//引用bean的属性
	public static final String REF_ATTRIBUTE = "ref";
	//指定值的属性
	public static final String VALUE_ATTRIBUTE = "value";
	//<aop:config> 元素中的属性
	//这个属性用于指定一个方法,该方法会在代理实例上查找。这通常用于查找代理上的某个方法。
	//默认情况下,该方法是在代理实例上查找与目标对象上的方法具有相同名称和参数的方法。
	public static final String LOOKUP_METHOD_ELEMENT = "lookup-method";
	//<aop:config> 元素中的属性
	//  这个属性用于指定一个方法,该方法将被代理实例上的方法替换。这通常用于拦截代理实例上的某个方法,并执行自定义的逻辑。
	// 默认情况下,该方法是在代理实例上查找与目标对象上的方法具有相同名称和参数的方法。
	public static final String REPLACED_METHOD_ELEMENT = "replaced-method";

	//引用标签
	public static final String REF_ELEMENT = "ref";

	//引用标签中bean是一个属性,指定引用那个bean
	public static final String BEAN_REF_ATTRIBUTE = "bean";
	//引用标签中parent是一个属性 指定父亲
	public static final String PARENT_REF_ATTRIBUTE = "parent";
	//value标签
	public static final String VALUE_ELEMENT = "value";
	//null标签
	public static final String NULL_ELEMENT = "null";
	//数组标签
	public static final String ARRAY_ELEMENT = "array";
	//list集合标签
	public static final String LIST_ELEMENT = "list";
	//set集合标签
	public static final String SET_ELEMENT = "set";
	//Map集合标签
	public static final String MAP_ELEMENT = "map";
	//Entry实体标签
	public static final String ENTRY_ELEMENT = "entry";
	//key标签
	public static final String KEY_ELEMENT = "key";
	//key 属性
	public static final String KEY_ATTRIBUTE = "key";

	//Properties 标签
	public static final String PROPS_ELEMENT = "props";
	//Properties 标签
	public static final String PROP_ELEMENT = "prop";

	//指定bean别名的标签
	public static final String QUALIFIER_ELEMENT = "qualifier";
	//属性标签
	public static final String QUALIFIER_ATTRIBUTE_ELEMENT = "attribute";

主要方法

parseBeanDefinitionElement()方法

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

		//别名集合
		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			//name可能有多个,需要转成数组
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			//name  也算是 一种别名
			aliases.addAll(Arrays.asList(nameArr));
		}

		//判断id是否存在与别名中,如果存在 则获取第一个别名
		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		if (containingBean == null) {
			//检查id的唯一性
			checkNameUniqueness(beanName, aliases, ele);
		}

		//将bean标签中的属性解析到BeanDefinition各个属性中
		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)) {
							//将beanName放入别名集合中
							aliases.add(beanClassName);
						}
					}
					if (logger.isTraceEnabled()) {
						logger.trace("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);
			//将beanDefinition,beanName 别名集合 封装成BeanDefinitionHolder
			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));

		//获取class属性
		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		//获取parent属性
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			//创建BeanDefinition 返回的是 GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			//解析bean标签上的属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			//设置bean的描述信息
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			//解析meta标签
			parseMetaElements(ele, bd);
			//解析lookup-method
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析replace-method
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			//解析构造函数
			parseConstructorArgElements(ele, bd);
			//解析property
			parsePropertyElements(ele, bd);
			//解析qualifier
			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()方法

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
		//判断是否有singleton属性 存在则报错
		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());
		}
		//获取abstract属性
		if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
			bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
		}
		//获取lazy-init 属性
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		//获取 autowire 属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		//获取 depends-on属性
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}
		//获取 autowire-candidate 属性
		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));
		}
		//解析primary
		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);
		}
		//解析destroy-mehtod
		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);
		}
		//解析factory-mehtod
		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;
	}
  • 17
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值