xmltreefactory.java

jsp + xmｌ实现ｔｒｅｅｖｉｅｗ

            throw new TreeFactoryException("There are no tree decriptions.");
        }
        for (int k = 0; k < a_element.getChildNodes().getLength(); k++) {
            Node a_node = a_element.getChildNodes().item(k);

            if (a_node.getNodeType() == Node.ELEMENT_NODE && a_node.getNodeName().equalsIgnoreCase(XMLTreeConstant.TREE)) {
                Wrapper a_wrapper = generateTree((Element) a_node);
                a_map.put(a_wrapper.getStructureModel().getName(), a_wrapper);
            }
        }
        return a_map;
    }

    private Wrapper generateTree(Element p_element) throws TreeFactoryException {
        if (p_element.getChildNodes().getLength() == 0) {
            LOG.error("TreeModel can not be empty.");
            throw new TreeFactoryException("TreeModel can not be empty.");
        }
        TreeModel a_treeStructure = new TreeModel();
        String a_treeName = p_element.getAttribute(XMLTreeConstant.TREE_NAME);
        a_treeStructure.setName(a_treeName);

        List a_openNodes = null;
        for (int k = 0; k < p_element.getChildNodes().getLength(); k++) {
            Node a_node = p_element.getChildNodes().item(k);

            if (a_node.getNodeType() != Node.ELEMENT_NODE) {
                continue;
            }

            if (a_node.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE)) {
                Element a_rootNode = (Element) a_node;
                DefaultTreeNode a_rootTreeNode = getTreeNode(a_rootNode);
                if (a_rootTreeNode != null) {
                    a_treeStructure.setRootNode(a_rootTreeNode);
                }
            }
            if (a_node.getNodeName().equalsIgnoreCase(XMLTreeConstant.OPEN_NODE)) {

                a_openNodes = getOpenNodes((Element) a_node);

            }
        }
        DefaultTreeStateModel a_stateModel = new DefaultTreeStateModel();
        if (a_openNodes != null) {
            for (Iterator a_it = a_openNodes.iterator(); a_it.hasNext();) {
                JSPTreeNodeImpl a_treeNode = (JSPTreeNodeImpl) a_it.next();
                a_stateModel.addOpened(a_treeNode.hashCode());
            }
        }
        Wrapper a_wrapper = new Wrapper(a_treeStructure, a_stateModel);
        return a_wrapper;
    }

    private DefaultTreeNode getTreeNode(Element p_element) throws TreeFactoryException {
        DefaultTreeNode a_treenode = new DefaultTreeNode();
        JSPTreeNodeImpl a_jspTreeNode = getJSPTreeNode(p_element);
        a_treenode.setData(a_jspTreeNode);
        fillNode(a_treenode, p_element);
        return a_treenode;
    }

    private void fillNode(DefaultTreeNode treenode, Node node) throws TreeFactoryException {
        NodeList nodelist = node.getChildNodes();
        if (nodelist != null && nodelist.getLength() > 0) {
            for (int i = 0; i < nodelist.getLength(); i++) {
                Node node1 = nodelist.item(i);
                if (node1.getNodeType() == Node.ELEMENT_NODE && node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE)) {
                    DefaultTreeNode treenode1 = new DefaultTreeNode();
                    JSPTreeNodeImpl jsptreenodeimpl = getJSPTreeNode(node1);
                    if (jsptreenodeimpl != null) {
                        treenode1.setData(jsptreenodeimpl);
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("adding new node " + jsptreenodeimpl.getId() + " to tree");
                        }
                    }
                    treenode.addChild(treenode1);
                    fillNode(treenode1, node1);
                }
            }

        }
    }

    private JSPTreeNodeImpl getJSPTreeNode(Node node) throws TreeFactoryException {

        NamedNodeMap a_attributeMap = node.getAttributes();
        if (a_attributeMap == null) {
            throw new TreeFactoryException("Node does not have id");
        }
        JSPTreeNodeImpl a_jspTreeNode = new JSPTreeNodeImpl();
        for (int i = 0; i < a_attributeMap.getLength(); i++) {
            Node node1 = a_attributeMap.item(i);
            if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_ID)) {
                a_jspTreeNode.setId(node1.getNodeValue());
            } else if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_LABEL)) {
                a_jspTreeNode.setLabel(node1.getNodeValue());
            } else if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_HREF)) {
                a_jspTreeNode.setHref(node1.getNodeValue());
            } else if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_CONTEXT_RELATIVE)) {
                String a_nodeValue = node1.getNodeValue();
                if (a_nodeValue.equals("false")) {
                    a_jspTreeNode.setContextRelative(false);
                }
            } else if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_TARGET)) {
                a_jspTreeNode.setTarget(node1.getNodeValue());
            } else if (node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE_SKIN)) {
                a_jspTreeNode.setSkinName(node1.getNodeValue());
            } else {
                a_jspTreeNode.addProperty(node1.getNodeName(), node1.getNodeValue());
            }
        }

        if (a_jspTreeNode.getId() == null) {
            throw new TreeFactoryException("Node does not have id");
        }
        return a_jspTreeNode;
    }

    private List getOpenNodes(Element p_element) {
        List a_list = new ArrayList();
        NodeList nodelist = p_element.getChildNodes();
        if (nodelist != null && nodelist.getLength() > 0) {
            for (int i = 0; i < nodelist.getLength(); i++) {
                Node node1 = nodelist.item(i);
                if (node1.getNodeType() == Node.ELEMENT_NODE
                        && node1.getNodeName().equalsIgnoreCase(XMLTreeConstant.NODE)) {

                    String a_id = ((Element) node1).getAttribute(XMLTreeConstant.NODE_ID);

                    JSPTreeNodeImpl jsptreenodeimpl = new JSPTreeNodeImpl(a_id);
                    a_list.add(jsptreenodeimpl);
                }
            }

        }
        return a_list;
    }

    private Document getDocument() throws TreeFactoryException {
        InputStream a_inputStream = null;

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        if (classLoader == null) {
            classLoader = this.getClass().getClassLoader();
        }
        a_inputStream = classLoader.getResourceAsStream(m_pathToXMLTree);
        if (LOG.isInfoEnabled()) {
            LOG.info("XML tree path: " + m_pathToXMLTree);
        }

        if (a_inputStream == null) {
            throw new TreeFactoryException("XML file with path: " + m_pathToXMLTree + " was not found.");
        }

        try {
            DocumentBuilderFactory a_builderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder a_documentBuilder = a_builderFactory.newDocumentBuilder();
            return a_documentBuilder.parse(a_inputStream);
        } catch (FileNotFoundException e) {
            LOG.error("XML file with path: " + m_pathToXMLTree + " was not found.");
            throw new TreeFactoryException("XML file with path: " + m_pathToXMLTree + " was not found.", e);
        } catch (FactoryConfigurationError e) {
            throw new TreeFactoryException("", e);
        } catch (ParserConfigurationException e) {
            throw new TreeFactoryException("", e);
        } catch (SAXException e) {
            throw new TreeFactoryException("", e);
        } catch (IOException e) {
            throw new TreeFactoryException("", e);
        } finally {
            if (a_inputStream != null) {
                try {
                    a_inputStream.close();
                } catch (IOException ignored) {
                }
            }
        }
    }

    private class Wrapper {

        private TreeStructureModel structureModel = null;

        private TreeStateModel stateModel = null;

        public Wrapper(TreeStructureModel structureModel, TreeStateModel stateModel) {
            this.structureModel = structureModel;
            this.stateModel = stateModel;
        }

        public TreeStructureModel getStructureModel() {
            return structureModel;
        }

        public TreeStateModel getStateModel() {
            return stateModel;
        }

    }

}