Struts源码学习XmlConfigurationProvider的loadPackages()方法递归调用

      最近在学习Struts2，在阅读源码的过程中，学习到了一些比较金典的算法逻辑，现在分享一个递归算法的使用：个人感觉这个算法非常的精妙，见识了递归算法使用的高明之处，现在将源码粘贴出来：

1、类：XmlConfigurationProvider的loadPackages方法，该方法主要是将配置文件(XML)文件中的package节点的配置信息读取出来：

    public void loadPackages() throws ConfigurationException {
        List<Element> reloads = new ArrayList<Element>();
        for (Document doc : documents) {
            Element rootElement = doc.getDocumentElement();
            NodeList children = rootElement.getChildNodes();
            int childSize = children.getLength();

            for (int i = 0; i < childSize; i++) {
                Node childNode = children.item(i);

                if (childNode instanceof Element) {
                    Element child = (Element) childNode;

                    final String nodeName = child.getNodeName();

                    if ("package".equals(nodeName)) {
                        PackageConfig cfg = addPackage(child);//该方法调用如下：
                        if (cfg.isNeedsRefresh()) {
                            reloads.add(child);
                        }
                    }
                }
            }
            loadExtraConfiguration(doc);
        }

        if (reloads.size() > 0) {
            reloadRequiredPackages(reloads);
        }

        for (Document doc : documents) {
            loadExtraConfiguration(doc);
        }

        documents.clear();
        configuration = null;
    }

addPackage方法如下：
调用了buildPackageContext方法，进行package的内容构造，包括，名字，命名空间，是否抽象，以及extends的名称，如果，该package需要刷新，则证明，当前的包的需要继承的包的名字，还没有被初始化到configure中，当所有的初始化，操作完成后，在进行这些需要重新加载的文件进行刷新，这时候，他的继承的包就可以找到了，就可以进行继承关系的实现了。

 /**
     * Create a PackageConfig from an XML element representing it.
     */
    protected PackageConfig addPackage(Element packageElement) throws ConfigurationException {
        PackageConfig.Builder newPackage = buildPackageContext(packageElement);//该方法参考如下

        if (newPackage.isNeedsRefresh()) {
            return newPackage.build();
        }
        
           --否则加载该包，是一个新的包,下面是加载这个包中的所有种类的配置文件
        if (LOG.isDebugEnabled()) {
            LOG.debug("Loaded " + newPackage);
        }

        // add result types (and default result) to this package
        addResultTypes(newPackage, packageElement);

        // load the interceptors and interceptor stacks for this package
        loadInterceptors(newPackage, packageElement);

        // load the default interceptor reference for this package
        loadDefaultInterceptorRef(newPackage, packageElement);

        // load the default class ref for this package
        loadDefaultClassRef(newPackage, packageElement);

        // load the global result list for this package
        loadGlobalResults(newPackage, packageElement);

        // load the global exception handler list for this package
        loadGobalExceptionMappings(newPackage, packageElement);

        // get actions
        NodeList actionList = packageElement.getElementsByTagName("action");

        for (int i = 0; i < actionList.getLength(); i++) {
            Element actionElement = (Element) actionList.item(i);
            addAction(actionElement, newPackage);
        }

        // load the default action reference for this package
        loadDefaultActionRef(newPackage, packageElement);

        PackageConfig cfg = newPackage.build();
           --最后，将该配置文件放入到list中，假如，某个的包的extend的名字为当前的包，就可以直接找出来
        configuration.addPackageConfig(cfg.getName(), cfg);
        return cfg;
    }

 

 /**
     * This method builds a package context by looking for the parents of this new package.
     * <p/>
     * If no parents are found, it will return a root package.
     */
    protected PackageConfig.Builder buildPackageContext(Element packageElement) {
        String parent = packageElement.getAttribute("extends");
        String abstractVal = packageElement.getAttribute("abstract");
        boolean isAbstract = Boolean.valueOf(abstractVal).booleanValue();
        String name = StringUtils.defaultString(packageElement.getAttribute("name"));
        String namespace = StringUtils.defaultString(packageElement.getAttribute("namespace"));


        if (StringUtils.isNotEmpty(packageElement.getAttribute("externalReferenceResolver"))) {
            throw new ConfigurationException("The 'externalReferenceResolver' attribute has been removed.  Please use " +
                    "a custom ObjectFactory or Interceptor.", packageElement);
        }

        PackageConfig.Builder cfg = new PackageConfig.Builder(name)
                .namespace(namespace)
                .isAbstract(isAbstract)
                .location(DomHelper.getLocationObject(packageElement));

        --判断是否有extend的节点，在这里，我们可以方法Struts2使用了其他类库分装的公共组件
           例如：StringUtils.isNotEmpty，同样还有StringUtils.isEmpty，对于StringUtils类，一个是apache提供的                    ，另一个是Spring提供的，这两个类的功能都非常的强大，几乎涵盖了所有的针对Srring和数组的操作，
        if (StringUtils.isNotEmpty(StringUtils.defaultString(parent))) { // has parents, let's look it up
            --buildParentsFromString方法的说明如下：
            List<PackageConfig> parents = ConfigurationUtil.buildParentsFromString(configuration, parent);

            if (parents.size() <= 0) {
                cfg.needsRefresh(true);
            } else {
                cfg.addParents(parents);
            }
        }

        return cfg;
    }

 

public static List<PackageConfig> buildParentsFromString(Configuration configuration, String parent) {
        if ((parent == null) || ("".equals(parent))) {
            return Collections.emptyList();
        }

        StringTokenizer tokenizer = new StringTokenizer(parent, ", ");
        List<PackageConfig> parents = new ArrayList<PackageConfig>();

        while (tokenizer.hasMoreTokens()) {
            String parentName = tokenizer.nextToken().trim();

            if (!"".equals(parentName)) {
          该方法与上面的configuration.addPackageConfig(cfg.getName(), cfg)方法可以说是遥相呼应
                PackageConfig parentPackageContext = configuration.getPackageConfig(parentName);

                if (parentPackageContext != null) {
                    parents.add(parentPackageContext);
                }
            }
        }

        return parents;
    }

在这里，开始介绍那个递归函数使用：他是loadPackages()方法中的

如果当前的需要重新加载的文件大于0，则进行重新加载。

 if (reloads.size() > 0) {
      reloadRequiredPackages(reloads);
 }

--递归的使用：

     if (reloads.size() > 0) {
            List<Element> result = new ArrayList<Element>();
            for (Element pkg : reloads) {
                   --再次调用，
                PackageConfig cfg = addPackage(pkg);
                if (cfg.isNeedsRefresh()) {
                       --判断父亲是否需要重新加载
                    result.add(pkg);
                }
            }
　　　　　　　　  如果当前的result的集合大于0，并且需要重新加载的包和再次加载的包的个数不一直，证明还没有循环完成，
            if ((result.size() > 0) && (result.size() != reloads.size())) {
                reloadRequiredPackages(result);
                return;
            }
            --在这里，递归正式调用结束
            // Print out error messages for all misconfigured inheritence packages
            if (result.size() > 0) {
                for (Element rp : result) {
                    String parent = rp.getAttribute("extends");
                    if (parent != null) {
                        List<PackageConfig> parents = ConfigurationUtil.buildParentsFromString(configuration, parent);
                        if (parents != null && parents.size() <= 0) {
                            LOG.error("Unable to find parent packages " + parent);
                        }
                    }
                }
            }
        }
    }

--总结：判断该递归方法的继续使用，使用了两个判定条件，如果，不成立，那么其他的就是无法找到父包的包了，这个算法非常的精妙。