yaofengdoit
yaofengdoit

spring5源码分析系列（五）——IOC容器的初始化（三）

前言：上一篇讲到了DocumentLoader将Bean定义资源转换为Document对象，此篇我们继续后面的内容。

(9)XmlBeanDefinitionReader解析载入的Bean定义资源文件

XmlBeanDefinitionReader类中的doLoadBeanDefinitions方法是从特定XML文件中实际载入Bean定义资源的方法，该方法在载入Bean定义资源之后将其转换为Document对象，接下来调用registerBeanDefinitions启动Spring IOC容器对Bean定义的解析过程，registerBeanDefinitions方法源码如下：

//按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构  
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {  
    //得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析  
    BeanDefinitionDocumentReader documentReader =  createBeanDefinitionDocumentReader(); 
    //获得容器中注册的Bean数量  
    int countBefore = getRegistry().getBeanDefinitionCount(); 
    //解析过程入口，这里使用了委派模式，BeanDefinitionDocumentReader只是个接口,具体的解析实现过程由实现类DefaultBeanDefinitionDocumentReader完成  
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); 
    //统计解析的Bean数量  
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

Bean定义资源的载入解析分为以下两个过程：
首先，通过调用XML解析器将Bean定义资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析；
其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。 按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。

(10)DefaultBeanDefinitionDocumentReader对Bean定义的Document对象解析

BeanDefinitionDocumentReader接口通过registerBeanDefinitions方法调用其实现类DefaultBeanDefinitionDocumentReader对Document对象进行解析，解析的代码如下：

//根据Spring DTD对Bean的定义规则解析Bean定义Document对象  
@Override  
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {  
    //获得XML描述符  
    this.readerContext = readerContext; logger.debug("Loading bean definitions"); 
    //获得Document的根元素  
    Element root = doc.getDocumentElement();    
    doRegisterBeanDefinitions(root);
}  
  
protected void doRegisterBeanDefinitions(Element root) {  
    //具体的解析过程由BeanDefinitionParserDelegate实现，  
    //BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素  
    BeanDefinitionParserDelegate parent = this.delegate; 
    this.delegate = createDelegate(getReaderContext(), root, parent);  
    if (this.delegate.isDefaultNamespace(root)) { 
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE); 
        if (StringUtils.hasText(profileSpec)) { 
          String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec,BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
          if(!getReaderContext().getEnvironment().
                                 acceptsProfiles(specifiedProfiles)) { 
               if (logger.isInfoEnabled()) { 
                logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + getReaderContext().getResource()); 
                } 
                return; 
            } 
        } 
    } 
    //在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性  
    preProcessXml(root); 
    //从Document的根元素开始进行Bean定义的Document对象  
    parseBeanDefinitions(root, this.delegate); 
    //在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性  
    postProcessXml(root);  
    this.delegate = parent;
}  
  
//创建BeanDefinitionParserDelegate，用于完成真正的解析过程  
protected BeanDefinitionParserDelegate createDelegate(  
 XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {  
    BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);    
    //BeanDefinitionParserDelegate初始化Document根元素  
    delegate.initDefaults(root, parentDelegate); 
    return delegate;
}  
  
//使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象  
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {  
    //Bean定义的Document对象使用了Spring默认的XML命名空间  
    if (delegate.isDefaultNamespace(root)) { 
        //获取Bean定义的Document对象根元素的所有子节点  
        NodeList nl = root.getChildNodes(); 
        for (int i = 0; i < nl.getLength(); i++) { 
            Node node = nl.item(i); 
            //获得Document节点是XML元素节点  
            if (node instanceof Element) { 
                Element ele = (Element) node; 
                //Bean定义的Document的元素节点使用的是Spring默认的XML命名空间  
                if (delegate.isDefaultNamespace(ele)) { 
                    //使用Spring的Bean规则解析元素节点  
                    parseDefaultElement(ele, delegate); 
                } 
                else { 
                //没有使用Spring默认的XML命名空间，则使用用户自定义的解
                //析规则解析元素节点  
                delegate.parseCustomElement(ele); 
                } 
            } 
        } 
    } 
    else { 
        //Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的解析规则解析Document根节点  
        delegate.parseCustomElement(root); 
    }
}  
  
//使用Spring的Bean规则解析Document元素节点  
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {  
    //如果元素节点是导入元素，进行导入解析  
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {         
        importBeanDefinitionResource(ele); 
    } 
    //如果元素节点是别名元素，进行别名解析  
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {     
        processAliasRegistration(ele); 
    } 
    //元素节点既不是导入元素，也不是别名元素，即普通的元素，按照Spring的Bean规则解析元素  
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {      
        processBeanDefinition(ele, delegate); 
    } 
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { 
        // recurse doRegisterBeanDefinitions(ele); 
    }
}  
  
//解析导入元素，从给定的导入路径加载Bean定义资源到Spring IoC容器中  
protected void importBeanDefinitionResource(Element ele) {  
    //获取给定的导入元素的location属性  
    String location = ele.getAttribute(RESOURCE\_ATTRIBUTE); 
    //如果导入元素的location属性值为空，则没有导入任何资源，直接返回  
    if (!StringUtils.hasText(location)) {   
        getReaderContext().error("Resource location must not be empty", ele); 
        return; 
    }  
    // Resolve system properties: e.g. "${user.dir}" 
    //使用系统变量值解析location属性值  
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);  
    Set actualResources = new LinkedHashSet<>(4);  
    // Discover whether the location is an absolute or relative URI 
    //标识给定的导入元素的location是否是绝对路径  
    boolean absoluteLocation = false; 
    try { 
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute(); 
    } 
    catch (URISyntaxException ex) { 
        //给定的导入元素的location不是绝对路径  
    } 
    //给定的导入元素的location是绝对路径  
    if (absoluteLocation) { 
        try { 
            //使用资源读入器加载给定路径的Bean定义资源  
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); 
            if (logger.isDebugEnabled()) { 
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]"); 
            } 
        } 
        catch (BeanDefinitionStoreException ex) {       
            getReaderContext().error( "Failed to import bean definitions from URL location [" + location + "]", ele, ex); 
        } 
    } 
    else { 
        //给定的导入元素的location是相对路径  
        try { 
            int importCount; 
            //将给定导入元素的location封装为相对路径资源  
            Resource relativeResource = getReaderContext().getResource().createRelative(location); 
            //封装的相对路径资源存在  
            if (relativeResource.exists()) { 
                //使用资源读入器加载Bean定义资源  
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource); actualResources.add(relativeResource); 
            } 
            //封装的相对路径资源不存在  
            else { 
                //获取Spring IOC容器资源读入器的基本路径  
                String baseLocation = getReaderContext().getResource().getURL().toString(); 
                //根据Spring IOC容器资源读入器的基本路径加载给定导入路径的资源 
                importCount = getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location), actualResources); 
            } 
            if (logger.isDebugEnabled()) { 
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]"); } } catch (IOException ex) { getReaderContext().error("Failed to resolve current resource location", ele, ex); 
            } 
            catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", ele, ex); 
            } 
        } 
    Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]); 
    //在解析完元素之后，发送容器导入其他资源处理完成事件  
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}  
  
//解析别名元素，为Bean向Spring IoC容器注册别名  
protected void processAliasRegistration(Element ele) {  
    //获取别名元素中name的属性值  
    String name = ele.getAttribute(NAME_ATTRIBUTE); 
    //获取别名元素中alias的属性值  
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE); 
    boolean valid = true; 
    //别名元素的name属性值为空  
    if (!StringUtils.hasText(name)) { 
        getReaderContext().error("Name must not be empty", ele); 
        valid = false; 
    } 
    //别名元素的alias属性值为空  
    if (!StringUtils.hasText(alias)) { 
        getReaderContext().error("Alias must not be empty", ele); 
        valid = false; 
    } 
    if (valid) { 
        try { 
            //向容器的资源读入器注册别名  
            getReaderContext().getRegistry().registerAlias(name, alias); 
        } 
        catch (Exception ex) { 
            getReaderContext().error("Failed to register alias '" + alias + "' for bean with name '" + name + "'", ele, ex); 
        } 
        //在解析完元素之后，发送容器别名处理完成事件  
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); 
    }
}  
  
//解析Bean定义资源Document对象的普通元素  
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {  
    // BeanDefinitionHolder是对BeanDefinition的封装，即Bean定义的封装类  
    //对Document对象中元素的解析由BeanDefinitionParserDelegate实现  
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); 
    if (bdHolder != null) { 
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); 
        try { 
            //向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IOC容器注册的入口  
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); 
        } 
        catch (BeanDefinitionStoreException ex) {       
            getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); 
        } 
        //在完成向Spring IOC容器注册解析得到的Bean定义之后，发送注册事件  
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); 
    }
}

通过上述Spring IOC容器对载入的Bean定义Document解析可以看出，我们使用Spring时，在Spring配置文件中可以使用元素来导入IOC容器所需要的其他资源，Spring IOC容器在解析时会首先将指定导入的资源加载进容器中。
使用别名时，Spring IOC容器首先将别名元素所定义的别名注册到容器中。对于既不是元素，又不是元素的元素，即Spring配置文件中普通的元素的解析由BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法来实现。

(11)BeanDefinitionParserDelegate解析Bean定义资源文件中的元素

Bean定义资源文件中的和元素解析在DefaultBeanDefinitionDocumentReader中已经完成，对Bean定义资源文件中使用最多的元素交由BeanDefinitionParserDelegate来解析，其解析实现的源码如下：

//解析元素的入口  
@Nullable  
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {  
    return parseBeanDefinitionElement(ele, null);
}  
  
//解析Bean定义资源文件中的元素，这个方法中主要处理元素的id，name和别名属性  
@Nullable  
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {  
    //获取元素中的id属性值  
    String id = ele.getAttribute(ID_ATTRIBUTE); 
    //获取元素中的name属性值  
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
    //获取元素中的alias属性值  
    List aliases = new ArrayList<>();  
    //将元素中的所有name属性值存放到别名中  
    if (StringUtils.hasLength(nameAttr)) { 
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); 
        aliases.addAll(Arrays.asList(nameArr));
    }  
    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"); 
        } 
    }  
    //检查元素所配置的id或者name的唯一性，containingBean标识  
    //元素中是否包含子元素  
    if (containingBean == null) { 
        //检查元素所配置的id、name或者别名是否重复  
        checkNameUniqueness(beanName, aliases, ele); 
    }  
    //详细对元素中配置的Bean定义进行解析的地方  
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); 
    if (beanDefinition != null) { 
        if (!StringUtils.hasText(beanName)) { 
            try { 
                if (containingBean != null) { 
                    //如果元素中没有配置id、别名或者name，且没有包含子元素  
                    //元素，为解析的Bean生成一个唯一beanName并注册  
                    beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); 
                } 
                else { 
                    //如果元素中没有配置id、别名或者name，且包含了子元素 
                    //元素，为解析的Bean使用别名向IOC容器注册  
                    beanName = this.readerContext.generateBeanName(beanDefinition); 
                    //为解析的Bean使用别名注册时，为了向后兼容，Spring1.2/2.0，给别名添加类名后缀  
                    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); 
    } 
    //当解析出错时，返回null  
    return null;
}  
  
protected void checkNameUniqueness(String beanName, List 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  element", beanElement); 
    }  
    this.usedNames.add(beanName); 
    this.usedNames.addAll(aliases);
}   

//详细对元素中配置的Bean定义其他属性进行解析  
//由于上面的方法中已经对Bean的id、name和别名等属性进行了处理  
//该方法中主要处理除这三个以外的其他属性数据  
@Nullable  
public AbstractBeanDefinition parseBeanDefinitionElement(  
Element ele, String beanName, @Nullable BeanDefinition containingBean) {       //记录解析的  
    this.parseState.push(new BeanEntry(beanName));  
    //这里只读取元素中配置的class名字，然后载入到BeanDefinition中去  
    //只是记录配置的class名字，不做实例化，对象的实例化在依赖注入时完成  
    String className = null;  
    //如果元素中配置了parent属性，则获取parent属性的值  
    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 { 
        //根据元素配置的class名称和parent属性值创建BeanDefinition  
        //为载入Bean定义信息做准备  
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);  
        //对当前的元素中配置的一些属性进行解析和设置，如配置的单态(singleton)属性等  
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);         //为元素解析的Bean设置description信息  
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));  
        //对元素的meta(元信息)属性解析  
        parseMetaElements(ele, bd); 
        //对元素的lookup-method属性解析  
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); 
        //对元素的replaced-method属性解析  
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());  
        //解析元素的构造方法设置  
        parseConstructorArgElements(ele, bd); 
        //解析元素的设置  
        parsePropertyElements(ele, bd); 
        //解析元素的qualifier属性  
        parseQualifierElements(ele, bd);  
        //为当前解析的Bean设置所需的资源和依赖对象  
        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(); 
    }  
    //解析元素出错时，返回null  
    return null;
}

注意：在解析元素过程中没有创建和实例化Bean对象，只是创建了Bean对象的定义类BeanDefinition，将元素中的配置信息设置到BeanDefinition中作为记录，当依赖注入时才使用这些记录信息创建和实例化具体的Bean对象。 我们在使用Spring的元素时，配置最多的是属性，因此我们下面继续分析源码，了解Bean的属性在解析时是如何设置的。

(12)BeanDefinitionParserDelegate解析元素

BeanDefinitionParserDelegate在解析调用parsePropertyElements方法解析元素中的属性子元素，解析源码如下：

//解析元素中的子元素  
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); 
        } 
    }
}  
  
//解析元素  
public void parsePropertyElement(Element ele, BeanDefinition bd) {  
    //获取元素的名字  
    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 { 
        //如果一个Bean中已经有同名的property存在，则不进行解析，直接返回。  
        //即如果在同一个Bean中配置同名的property，则只有第一个起作用  
        if (bd.getPropertyValues().contains(propertyName)) { error("Multiple 'property' definitions for property '" + propertyName + "'", ele); 
            return; 
        } 
        //解析获取property的值  
        Object val = parsePropertyValue(ele, bd, propertyName); 
        //根据property的名字和值创建property实例  
        PropertyValue pv = new PropertyValue(propertyName, val); 
        //解析元素中的属性  
        parseMetaElements(ele, pv); 
        pv.setSource(extractSource(ele));   
        bd.getPropertyValues().addPropertyValue(pv); 
    } 
    finally { 
        this.parseState.pop(); 
    }
}  
  
//解析获取property值  
@Nullable  
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {  
    String elementName = (propertyName != null) ? " element for property '" + propertyName + "'" : " 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); 
        //子元素不是description和meta属性  
        if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) && !nodeNameEquals(node, META_ELEMENT)) { 
            if (subElement != null) { 
                error(elementName + " must not contain more than one sub-element", ele); 
            } 
            else { 
                //当前元素包含有子元素  
                subElement = (Element) node; 
            } 
        } 
    }  
    //判断property的属性值是ref还是value，不允许既是ref又是value  
    boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE); 
    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，创建一个ref的数据对象RuntimeBeanReference  
    //这个对象封装了ref信息  
    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的数据对象是被当前的property对象所引用  
        ref.setSource(extractSource(ele)); return ref; 
    } 
    //如果属性是value，创建一个value的数据对象TypedStringValue  
    //这个对象封装了value信息  
    else if (hasValueAttribute) { 
        //一个持有String类型值的对象  
        TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE)); 
        //设置这个value数据对象是被当前的property对象所引用  
        valueHolder.setSource(extractSource(ele)); 
        return valueHolder; 
    } 
    //如果当前元素还有子元素  
    else if (subElement != null) { 
        //解析的子元素  
        return parsePropertySubElement(subElement, bd); 
    } 
    else { 
        //propery属性中既不是ref，也不是value属性，解析出错返回null  
        error(elementName + " must specify a ref or value", ele); 
        return null; 
    }
}

通过对上述源码的分析，可以了解在Spring配置文件中，元素中元素的相关配置是如何处理的：
ref被封装为指向依赖对象一个引用；
value配置都会封装成一个字符串类型的对象；
ref和value都通过“解析的数据类型属性值.setSource(extractSource(ele));”方法将属性值引用与所引用的属性关联起来。

在方法的最后对于元素的子元素通过parsePropertySubElement方法解析。

(13)解析元素的子元素

源码如下：

//解析元素中ref,value或者集合等子元素  
@Nullable  
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {  
    //如果没有使用Spring默认的命名空间，则使用用户自定义的规则解析内嵌元素  
    if (!isDefaultNamespace(ele)) { 
        return parseNestedCustomElement(ele, bd); 
    } 
    //如果子元素是bean，则使用解析元素的方法解析  
    else if (nodeNameEquals(ele, BEAN_ELEMENT)) { 
        BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd); 
        if (nestedBd != null) { nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd); 
        } 
        return nestedBd; 
    } 
    //如果子元素是ref，ref中只能有以下3个属性：bean、local、parent  
    else if (nodeNameEquals(ele, REF_ELEMENT)) { 
        // A generic reference to any name of any bean. 
        
        //可以不再同一个Spring配置文件中，具体请参考Spring对ref的配置规则  
        String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE); 
        boolean toParent = false; 
        if (!StringUtils.hasLength(refName)) { 
            // A reference to the id of another bean in a parent context.             
            //获取元素中parent属性值，引用父级容器中的Bean  
            refName = ele.getAttribute(PARENT_REF_ATTRIBUTE); 
            toParent = true; 
            if (!StringUtils.hasLength(refName)) { 
                error("'bean' or 'parent' is required for  element", ele); 
                return null; 
            } 
        } 
        if (!StringUtils.hasText(refName)) { 
            error(" element contains empty target attribute", ele);               
            return null; 
        } 
        //创建ref类型数据，指向被引用的对象  
        RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent); 
        //设置引用类型值是被当前子元素所引用  
        ref.setSource(extractSource(ele)); 
        return ref; 
    } 
    //如果子元素是，使用解析ref元素的方法解析  
    else if (nodeNameEquals(ele, IDREF_ELEMENT)) { 
        return parseIdRefElement(ele); 
    } 
    //如果子元素是，使用解析value元素的方法解析  
    else if (nodeNameEquals(ele, VALUE_ELEMENT)) { 
        return parseValueElement(ele, defaultValueType); 
    } 
    //如果子元素是null，为设置一个封装null值的字符串数据  
    else if (nodeNameEquals(ele, NULL_ELEMENT)) { 
        // It's a distinguished null value. Let's wrap it in a TypedStringValue 
        // object in order to preserve the source location.         
        TypedStringValue nullHolder = new TypedStringValue(null);   
        nullHolder.setSource(extractSource(ele)); 
        return nullHolder; 
    } 
    //如果子元素是，使用解析array集合子元素的方法解析  
    else if (nodeNameEquals(ele, ARRAY_ELEMENT)) { 
        return parseArrayElement(ele, bd); 
    } 
    //如果子元素是，使用解析list集合子元素的方法解析  
    else if (nodeNameEquals(ele, LIST_ELEMENT)) { 
        return parseListElement(ele, bd); 
    } 
    //如果子元素是，使用解析set集合子元素的方法解析  
    else if (nodeNameEquals(ele, SET_ELEMENT)) { 
        return parseSetElement(ele, bd); 
    } 
    //如果子元素是，使用解析map集合子元素的方法解析  
    else if (nodeNameEquals(ele, MAP_ELEMENT)) { 
        return parseMapElement(ele, bd); 
    } 
    //如果子元素是，使用解析props集合子元素的方法解析  
    else if (nodeNameEquals(ele, PROPS_ELEMENT)) { 
        return parsePropsElement(ele); 
    } 
    //既不是ref，又不是value，也不是集合，则子元素配置错误，返回null  
    else { 
        error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele); 
        return null;
    }
}

通过上述源码分析知道，在Spring配置文件中，对元素中配置的array、list、set、map、prop等各种集合子元素都通过上述方法解析，生成对应的数据对象，比如ManagedList、ManagedArray、ManagedSet等，这些Managed类是Spring对象BeanDefiniton的数据封装，对集合数据类型的具体解析有各自的解析方法实现，接下来对集合元素的解析方法进行源码分析，了解其实现过程。

(14)解析子元素

源码如下：

//解析集合子元素  
public List parseListElement(Element collectionEle, @Nullable BeanDefinition bd) {  
    //获取元素中的value-type属性，即获取集合元素的数据类型  
    String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE); 
    //获取集合元素中的所有子节点  
    NodeList nl = collectionEle.getChildNodes(); 
    //Spring中将List封装为ManagedList  
    ManagedList target = new ManagedList<>(nl.getLength());     
    target.setSource(extractSource(collectionEle)); 
    //设置集合目标数据类型  
    target.setElementTypeName(defaultElementType);  
    target.setMergeEnabled(parseMergeAttribute(collectionEle)); 
    //具体的元素解析  
    parseCollectionElements(nl, target, bd, defaultElementType); 
    return target;
}  
  
//具体解析集合元素，、和都使用该方法解析  
protected void parseCollectionElements(  
 NodeList elementNodes, Collection target, @Nullable BeanDefinition bd, String defaultElementType) { 
    //遍历集合所有节点  
    for (int i = 0; i < elementNodes.getLength(); i++) { 
        Node node = elementNodes.item(i); 
        //节点不是description节点  
        if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) { 
            //将解析的元素加入集合中，递归调用下一个子元素  
            target.add(parsePropertySubElement((Element) node, bd, defaultElementType)); 
        } 
    }
}   
 
经过对Spring Bean定义资源文件转换的Document对象中的元素层层解析，Spring IOC现在已经将XML形式定义的Bean定义资源文件转换为Spring IOC所识别的数据结构——BeanDefinition，它是Bean定义资源文件中配置的POJO对象在Spring IOC容器中的映射，通过AbstractBeanDefinition为入口，可以看到IOC容器进行索引、查询和操作。 
 
 
通过Spring IOC容器对Bean定义资源的解析后，IOC容器大致完成了管理Bean对象的准备工作，即初始化过程，但是最为重要的依赖注入还没有发生，现在在IOC容器中BeanDefinition存储的只是一些静态信息，接下来需要向容器注册Bean定义信息才能全部完成IOC容器的初始化过程。 
 
 
IOC容器初始化内容较多，分了几篇来写，此为第三篇，欢迎关注其余内容，感谢！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(框架源码,spring)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                                
  • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor
                                    yangshangchuan
信息抽取HtmlExtractor精准抽取信息采集
                                    
    HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。 
   
HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。 
如
    
                                
    • 
                                
  • java编程思想 -- 多态
                                    百合不是茶
java多态详解
                                    
    一: 向上转型和向下转型 
面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
    
                                
    • 
                                
  • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系
                                    comsci
dp
                                    
     
      对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长.... 
 
      首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
    
                                
    • 
                                
  • storm 自定义 日志文件
                                    商人shang
stormclusterlogback
                                    
    Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 
1. 想要进行一些调试信息的输出 
2. 调试信息或者业务日志信息想要输出到一些固定的文件中 
  
不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
    
                                
    • 
                                
  • Extjs3 SpringMVC使用 @RequestBody 标签问题记录
                                    21jhf

                                    
    springMVC使用 @RequestBody(required = false) UserVO userInfo 
传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下： 
（由于使用了父类aaa
    
                                
    • 
                                
  • 一些排错方法
                                    文强chu
方法
                                    
    1、java.lang.IllegalStateException: Class invariant violation 
at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) 
at o
    
                                
    • 
                                
  • Swing中文件恢复我觉得很难
                                    小桔子
swing
                                    
           我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！ 
       用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
    
                                
    • 
                                
  • php 文件操作
                                    aichenglong
PHP读取文件写入文件
                                    
    1 写入文件 
@$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); 
if(!$fp){ 
 echo "open file error" ; 
 
exit; 
} 
$outputstring="date:"." \t tire:".$tire."
    
                                
    • 
                                
  • MySQL的btree索引和hash索引的区别
                                    AILIKES
数据结构mysql算法
                                    
    Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。           
可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
    
                                
    • 
                                
  • JAVA的抽象--- 接口 --实现
                                    百合不是茶

                                    
    抽象 接口 实现接口 
  
//抽象 类 ,方法 
  
//定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 
抽象的定义使用abstract 
  
abstract class A 定义一个抽象类 例如： 
//定义一个基类
public abstract class A{ 
  
  
//抽象类不能用来实例化，只能用来继承 
//
    
                                
    • 
                                
  • JS变量作用域实例
                                    bijian1013
作用域
                                    
    <script> 
    var scope='hello'; 
    function a(){ 
       console.log(scope);   //undefined 
       var scope='world'; 
       console.log(scope);   //world 
       console.log(b);      
    
                                
    • 
                                
  • TDD实践（二）
                                    bijian1013
javaTDD
                                    
    实践题目：分解质因数 
Step1： 
单元测试： 
package com.bijian.study.factor.test;

import java.util.Arrays;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;

import com.bijian.
    
                                
    • 
                                
  • [MongoDB学习笔记一]MongoDB主从复制
                                    bit1129
mongodb
                                    
    MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。 
  事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。   本文介绍MongoDB的主从复制模式，需要指明
    
                                
    • 
                                
  • 【HBase五】Java API操作HBase
                                    bit1129
hbase
                                    
    import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.ha
    
                                
    • 
                                
  • python调用zabbix api接口实时展示数据
                                    ronin47

                                    
    zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
    
                                
    • 
                                
  • jsp取得绝对路径
                                    byalias
绝对路径
                                    
    在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下： 
 
一、使用${pageContext.request.contextPath} 
 
　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。 
 

    
                                
    • 
                                
  • Java定时任务调度：用ExecutorService取代Timer
                                    bylijinnan
java
                                    
    《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是： 
如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
    
                                
    • 
                                
  • SQL 优化原则
                                    chicony
sql
                                    
      
一、问题的提出 
　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
    
                                
    • 
                                
  • java 线程弹球小游戏
                                    CrazyMizzz
java游戏
                                    
    最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善 
 
 这里是提纲 
 1.线程弹球游戏实现 
 1.实现界面需要使用哪些API类 
 JFrame 
 JPanel 
 JButton 
 FlowLayout 
 Graphics2D 
 Thread 
 Color 
 ActionListener 
 ActionEvent 
 MouseListener 
 Mouse
    
                                
    • 
                                
  • hadoop jps出现process information unavailable提示解决办法
                                    daizj
hadoopjps
                                    
    hadoop jps出现process information unavailable提示解决办法       
jps时出现如下信息： 
3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 -- 
    
                                
    • 
                                
  • PHP图片水印缩放类实现
                                    dcj3sjt126com
PHP
                                    
      
<?php
class Image{

	private $path;


	function __construct($path='./'){
		$this->path=rtrim($path,'/').'/';
	}

	//水印函数，参数：背景图，水印图，位置，前缀,TMD透明度

	public function water($b,$l,$pos
    
                                
    • 
                                
  • IOS控件学习：UILabel常用属性与用法
                                    dcj3sjt126com
iosUILabel
                                    
    参考网站： 
http://shijue.me/show_text/521c396a8ddf876566000007 
http://www.tuicool.com/articles/zquENb 
http://blog.csdn.net/a451493485/article/details/9454695 
http://wiki.eoe.cn/page/iOS_pptl_artile_281
    
                                
    • 
                                
  • 完全手动建立maven骨架
                                    eksliang
javaeclipseWeb
                                    
    建一个 JAVA 项目 ： 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=App 
[-Dversion=0.0.1-SNAPSHOT] 
[-Dpackaging=jar] 
 
 
建一个 web 项目 ： 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=web-a
    
                                
    • 
                                
  • 配置清单
                                    gengzg
配置
                                    
    1、修改grub启动的内核版本
vi /boot/grub/grub.conf
将default 0改为1

拷贝mt7601Usta.ko到/lib文件夹

拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹

拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan
拷贝wifiget.sh到bin文件夹，chm
    
                                
    • 
                                
  • Windows端口被占用处理方法
                                    huqiji
windows
                                    
    以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
    
                                
    • 
                                
  • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！
                                    天梯梦
mobile
                                    
    CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
    
                                
    • 
                                
  • 简单工厂设计模式
                                    hm4123660
java工厂设计模式简单工厂模式
                                    
           简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 
    
                                
    • 
                                
  • maven笔记
                                    zhb8015
maven
                                    
    跳过测试阶段： 
mvn package -DskipTests 
临时性跳过测试代码的编译： 
mvn package -Dmaven.test.skip=true 
  
maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。 
  
指定测试类 
mvn test
    
                                
    • 
                                
  • 非mapreduce生成Hfile，然后导入hbase当中
                                    Stark_Summer
maphbasereduceHfilepath实例
                                    
    最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
    
                                
    • 
                                
  • jsp web tomcat 编码问题
                                    王新春
tomcatjsppageEncode
                                    
    今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： 
 
 

      <Connector port="8080" protocol="HTTP/1.1" 
               connectionTi
    
                                
    •