Spring源码-xml解析bean(2)

最新推荐文章于 2021-08-13 09:50:43 发布
最新推荐文章于 2021-08-13 09:50:43 发布
阅读量230 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gq0811/article/details/107902590
版权

在xml解析bean(1)中针对自定义标签，通过aop的例子做了解释，下面来继续追踪parseDefaultElement这个方法的解析思路：

关键类：

  • DefaultBeanDefinitionDocumentReader
  • BeanDefinitionParserDelegate
  • DefaultListableBeanFactory

时序图：

（一）DefaultBeanDefinitionDocumentReader

DefaultBeanDefinitionDocumentReader～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)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

可以看到，默认标签这么几个 ：

  • import
  • alias
  • bean
  • beans

 可以从最常用的bean标签来进行后续流程的分析：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		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));
		}
	}

在processBeanDefinition中，主要是做了

（1）根据元素做了解析，然后返回了一个holder对象

 

（二）BeanDefinitionParserDelegate

看下具体的BeanDefinitionParserDelegate～parseBeanDefinitionElement实现：

 
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
        return parseBeanDefinitionElement(ele, null);
    }
 
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        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));
        }
        //id是优先作为beanName的
        String beanName = id;
        //如果此时没有设置id，而且有设置别名，就把第一个作为beanName，其他继续作为别名
        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");
            }
        }
 
        if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);
        }
 
        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;
    }



protected void checkNameUniqueness(String beanName, List<String> aliases, Element beanElement) {
		String foundName = null;

		if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) {
			foundName = beanName;
		}
		if (foundName == null) {
			foundName = CollectionUtils.findFirstMatch(this.usedNames, aliases);
		}
		if (foundName != null) {
			error("Bean name '" + foundName + "' is already used in this <beans> element", beanElement);
		}

		this.usedNames.add(beanName);
		this.usedNames.addAll(aliases);
	}

 

parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean)中主要做了这么几件事：

  1. 获取bean的name和id。如果有name属性，就把name中的内容作为aliases属性。String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; " name用",; "分隔。
  2. 检测是否名字重复了，也就是说bean的id和别名aliases是不能重复的。usedNames会存放所有的名称。具体检测是否重复的方法是checkNameUniqueness。
  3. 调用parseBeanDefinitionElement获取该bean的AbstractBeanDefinition
  4. 根据上面这些信息来组装出一个BeanDefinitionHolder返回

 

parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean)中：

    //重写的parseBeanDefinitionElement方法，带着beanName
	@Nullable
	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 {
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			parseMetaElements(ele, bd);
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			parseConstructorArgElements(ele, bd);
			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;
	}

 

   获取className以及parent信息，然后根据className和parent构造出一个AbstractBeanDefinition，调用的方法是createBeanDefinition：

public static AbstractBeanDefinition createBeanDefinition(
            @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
 
        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setParentName(parentName);
        if (className != null) {
            if (classLoader != null) {
                bd.setBeanClass(ClassUtils.forName(className, classLoader));
            }
            else {
                bd.setBeanClassName(className);
            }
        }
        return bd;
    }

  这里会根据classLoader做判断，classLoader是从AbstractBeanDefinitionReader中取的beanClassLoader字段。

  如果beanClassLoader不为空，就用beanClassLoader加载类；如果为空，则只设置calssName，在更下游读取类。

然后在parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean)中继续分支流程：主要有parseBeanDefinitionAttributes、parseMetaElements、parseConstructorArgElements，都是解析参数并放到AbstractBeanDefinition的实例bd中。

首先来看parseBeanDefinitionAttributes

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

这里parseBeanDefinitionAttributes就是对各个属性做了相应的解析，然后放到bd里面去。比如常用的“depends-on”、“init-method”等attribute属性。

  parseMetaElements是对“meta”标签的解析：

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
        NodeList nl = ele.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
                Element metaElement = (Element) node;
                String key = metaElement.getAttribute(KEY_ATTRIBUTE);
                String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
                BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
                attribute.setSource(extractSource(metaElement));
                attributeAccessor.addMetadataAttribute(attribute);
            }
        }

parseConstructorArgElements是对“constructor-arg”标签的解析：

 public void parseConstructorArgElements(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, CONSTRUCTOR_ARG_ELEMENT)) {
                parseConstructorArgElement((Element) node, bd);
            }
        }

  到这个地方，BeanDefinitionParserDelegate的parseBeanDefinitionElement就基本结束了。

  然后回到DefaultBeanDefinitionDocumentReader～processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)方法,走到了，BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

回到（一）DefaultBeanDefinitionDocumentReader类中：

public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.
   String beanName = definitionHolder.getBeanName();
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // Register aliases for bean name, if any.
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
         registry.registerAlias(beanName, alias);
      }
   }
}

   调用了BeanDefinitionRegistry对象的register方法进行bean注册。走到这里，我们的bean已经解析完成了，也就是说，我们在xml里面配置的bean已经被解析好了，并且已经放到了内存BeanDefinitionHolder对象中了，当然现在还需要将解析好的bean注册到Spring容器中去，看下registerBeanDefinition的实现：

  因为前面我们是用DefaultListableBeanFactory加载的，所以我们进入

（三）DefaultListableBeanFactory#registerBeanDefinition

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 {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("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.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

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

   检测是否已经有同名的bean被注册过了，如果被注册过了那么就要抛出异常，因为Spring不支持同名bean存在。通过各种的判断后，如果不抛异常，这个bean会被存储到beanDefinitionMap中，同时也会放到beanDefinitionNames中。

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

   

总结：

(1)在DefaultBeanDefinitionDocumentReader通过标签判断走哪种解析，如果是bean标签的解析就走BeanDefinitionParserDelegate.

(2)在BeanDefinitionParserDelegate中执行parseBeanDefinitionElement，最终返回一个BeanDefinitionHolder对象，包括beanDefinition, beanName, aliasesArray属性。此时代表bean的各个属性已经被解析好了，放在内存中了（BeanDefinitionHolder对象）。

(3)接下来是注册到Spring容器中去。即调用DefaultListableBeanFactory#registerBeanDefinition，通过各种的判断后，如果不抛异常，这个bean会被存储到beanDefinitionMap中，同时也会放到beanDefinitionNames中。

 

备注：

<bean>标签的id和name解释：

       id和name本质上其实是相同的，都可以唯一地标识一个bean。区别是id只能定义一个值，name可以定义多个值（separated by a comma (,), semicolon (;), or white space）。

  1. 配置一个bean的时候，可以不设置id，也可以不设置name，spring默认会使用类的全限定名作为bean的标识符。
  2. 如果设置id属性，那么id就是bean的唯一标识符，在spring容器中必需唯一。
  3. 如果仅设置name属性，那么name就是bean的唯一标识符，必需在容器中唯一。
  4. 如果同时设置id和name，那么id是唯一标识符，name是别名。如果id和name的值相同，那么spring容器会自动检测并消除冲突：让这个bean只有标识符，而没有别名。
  5. name属性设置多个值且不设置id属性，那么第一个被用作标识符，其他的被视为别名。如果设置了id，那么name的所有值都是别名。
  6. 不管是标识符，还是别名，在容器中必需唯一。因为标识符和别名，都是可以用来获取bean的，如果不唯一，显然不知道获取的到底是哪儿一个bean

BeanDefinitionParserDelegate#

gq0811
关注
spring 源码研究---bean包-- xml解析成bean对象
zghwaicsdn的专栏
03-10 3329
/** * BeanDefinitionReader * 把一个Resource资源或者一个String定位符加载成一个BeanDefinition对象 * 实现该接口可以设置不同的加载实现，及对BeanDefinition的format * 当然你也不一定非要实现这个接口，可以通过其他方式加载bean * * 接口方法： * 1.加在一个资源Resou
spring源码解析------xml方式解析加载bean
xudong的博客
09-21 366
前言 最近有点顿悟，可能是面试的时候经历的多，感觉之前的学习有点浅尝辄止，对于底层的东西自己没有动手实现，现在把spring 以及后续的springboot进行一下梳理，我们首先解析源码然后手写实现过程，感受一下其中的趣味。 我将通过两种方式说明： BeanFactory: bean组件 ApplicationContext:context组件，该组件扩展了bean组件，是我们常用的。 本文...
Jaxb2 实现JavaBean与xml互转
04-18
NULL 博文链接：https://zhuchengzzcc.iteye.com/blog/1838702
使用SAX解析XML封装实体Bean
weixin_33804582的博客
10-19 145
  新的项目需要对用户权限进行控制，经过和项目经理商量我们决定使用XML文件存储权限代码和层次关系，这样比较方便也便于维护，使用SAX读取XML文件，我发现在读取的时候可以顺便将XML文件中的内容封装为实体Bean，便于页面使用JSTL进行迭代。  一、XML结构 我的XML结构为这样的 &lt;root&gt;  &lt;basemenu  id="" name="基础信息" u...
用Digester解析xml到bean
xiehongdong2009的专栏
07-04 155
假设有下列xml文件: &lt;?xml version='1.0' encoding='utf-8'?&gt; &lt;address-book&gt; &lt;contact myType="individual"&gt; &lt;name&gt;Zane Pasolini&lt;/name&gt; &lt;address&gt;999 W
spring源码-2022-08-14spring源码spring源码spring源码
08-14
在2022年8月14日更新的Spring源码中，我们可以深入理解其设计理念和实现机制。 Spring框架的主要组成部分包括： 1. **核心容器**：这是Spring的基础，主要包括BeanFactory和ApplicationContext。BeanFactory负责...
Spring源码深度解析第二版
最新发布
11-15
Spring源码深度解析第二版 Spring是一款广泛应用于Java企业级应用程序的开源框架，旨在简化Java应用程序的开发和部署。Spring框架的核心主要包括了IoC容器、AOP、MVC框架等模块。 第1章 Spring整体架构和环境搭建 ...
spring-demo:spring原始解析-源码解析
03-24
《Spring框架源码解析——深度探索spring-demo》 在IT领域，Spring框架是Java开发者最为广泛应用的轻量级框架之一，其强大的功能和灵活的设计深受赞誉。本文将深入探讨"spring-demo:spring原始解析"这一主题，带领...
spring学习----工厂Bean
04-06
在Spring中，Bean是IoC容器管理的对象，它们通常由Spring配置元数据（如XML或Java配置）定义。Bean可以通过简单的构造函数、工厂方法或工厂Bean来创建。 工厂Bean是实现了`org.springframework.beans.factory....
Spring 源码分析（Bean的初始化）
12-21
在Spring框架中，Bean的初始化是一个至关重要的过程，它涉及到从XML配置文件或者注解中读取Bean的定义，解析并构建Bean实例。本篇文章主要分析了Spring如何通过`ClassPathXmlApplicationContext`来启动和初始化Bean...
XMLBean 详解
12-03
XMLBean详解, 一、关于XML解析 二、XMLBean简介 三、准备XMLBean和XML文档 四、XMLBean使用步骤 ..... 六、利用XMLBean写XML文件
xml与javabean之间的互转
12-14
主要用于开发中常见的xml与javabean之间的数据互转，减少重复代码的编写，支持xml对应字段中的集合数据类型(只能为list)。现不支持bean转换成xml时不指定字段所对应xml元素结点名称的情况，所有的字段必需指定生成xml时所对应的结点名称(即使想字段名就是xml结点属性名)。
xml和java bean互相转换工具包(简单易用)
01-25
xml 与 bean 互相转换 工具类 1、bean类的属性需要遵守BEAN规范，否则 无法 读存BEAN值。 2、bean类的属性如果 是集合 只支持数组以及List、Map、Set。 3、bean类属性(boolean除外)前面两个字母要么全部小写，要么全部大写，否则 无法读存BEAN值。 4、bean类boolean属性(Boolean无此要求)，前面三个字母需要小写，否则 无法读存BEAN值。 5、bean里面的属性如何仍然是bean，则可以递归解析拼装。 使用举例： 1、根据类生成XML配置文件模板 String beanClass2xml = XbeanUtil.beanClass2xml(Bean.class, null); 2、根据XML文件生成BEAN String xml=getXmlData(); VisitRecord bean = (VisitRecord)XbeanUtil.xml2Bean(VisitRecord.class, xml); 3、根据bean对象以及bean的所有属性值生成xml文件。 String bean2xml = XbeanUtil.bean2xml(bean, null); 使用前请将附件jar包放入classpath。 如有任何疑问，请联系coynnbai@163.com。源代码包及详细使用文档后续整理，欢迎使用和测试本工具包。
Spring4.3.x 浅析xml配置的解析过程（4）——解析bean标签及其所有子标签
chyohn的博客
02-09 1946
概述 在使用ResourceLoader创建Resource对象一节中，我们探讨了Spring如何正确的查找我们指定的配置文件并为配置文件生成Resource对象。 在使用DocumentLoader创建Document对象一节中，我们又已经解析了Spring通过xerces如何把Resource对象中的XML内容转换成Document对象。 在浅析Spring4使用XmlBeanDef
通过XML装配Bean(二)
u014785687的博客
07-29 225
Spring可以借助属性的set方法来配置属性的值，以实现setter方式的注入。在Spring中我们可以使用<\property>元素配置Bean的属性。<\property>元素为属性的Setting方法所提供的功能与<\constructor-arg>元素为构造器所提供的功能是一样的。只不过一个是通过构造参数来注入值，另一个是通过调用属性的setter方法来注入值。一、注入字面量值 首先使用
Spring Bean定义的加载解析过程之XML源码
狐言
08-13 227
Bean定义的加载解析过程之XMLBeanDefinition接口Bean定义详解BeanDefinition的常用方法BeanDefinition的继承体系BeanDefinitionRegistry接口XML的加载和解析过程Spring中扩展XML标签 BeanDefinition接口 Bean定义详解 /** * A BeanDefinition describes a bean instance, which has property values, * constructor argument
java 解析XML生成bean
weixin_33924312的博客
04-28 261
XML： <?xmlversion="1.0"encoding="UTF-8"?><books><book><name>java</name><prise>99.0</prise><author>11</author&g...
spring源码解析-从xml配置文件中获取bean
Light_shine的专栏
10-10 906
在spring的实际应用中，我们经常将bean定义在xml的配置文件当中，那么，spring是如何从xml加载bean的呢?今天我们将从源码的层面进行简单的解读。
Spring-2-Bean之xml
SevenSongyun的博客
01-18 207
一、Bean的实例化方式 Bean的实例化有三种方式： 通过构造函数实例化（常用） 通过静态工厂实例化 通过实例工厂实例化 1. 通过构造函数实例化（常用） <bean id="bean1" class="com.seven.entity.Bean1"/> 2. 通过静态工厂实例化 准备一个静态工厂： package com.seven.factory; import co...
Spring框架源码解析：XML配置与Bean注册
在开始深入源码之前，了解为什么要查看Spring源码至关重要。对于开发者来说，理解Spring如何控制事务、处理请求以及实现AOP（面向切面编程）能够增强对框架的掌握，提高开发效率。 高效阅读源码的方法是针对具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值