xmlutil.java

dgbas公文管理核心java源码

/*
 * Copyright (c) 1989-2003 Jasson Technology. All Rights Reserved.
 * Version: 1.0
 * Date: 2003/10/00
 * Author: Joe Kuei
 * Note:
 */

package com.jasson.common;

import java.io.File;
import java.io.IOException;
import java.util.Properties;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XmlUtil {
    public static final String DEFAULT_ENCODING = "UTF-8";


    
    
    
    
    
    

    public XmlUtil() {
    }

    public static final Document parseXmlFile(String filename,
                                              boolean validating,
                                              boolean coalesce,
                                              boolean ignoreComments,
                                              boolean expandEntityReference) throws
        XmlException {
        Document document = null;
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setValidating(validating);
            factory.setCoalescing(coalesce);
            factory.setIgnoringComments(ignoreComments);
            factory.setExpandEntityReferences(expandEntityReference);
            document = factory.newDocumentBuilder().parse(new File(filename));
        }
        catch (ParserConfigurationException ex) {
            throw new XmlException(ex.getMessage());
        }
        catch (IOException ex) {
            throw new XmlException(ex.getMessage());
        }
        catch (SAXException ex) {
            throw new XmlException(ex.getMessage());
        }
        catch (FactoryConfigurationError ex) {
            throw new XmlException(ex.getMessage());
        }
        return document;
    }

    public static final Document parseXmlFile(String filename,
                                              boolean validating) throws
        XmlException {
        return parseXmlFile(filename, validating, false, false, false);
    }

    public static final Document parseXmlFile(String filename,
                                              boolean validating,
                                              boolean coalesce) throws
        XmlException {
        return parseXmlFile(filename, validating, coalesce, false, false);
    }

    public static final Document parseXmlFile(String filename,
                                              boolean validating,
                                              boolean coalesce,
                                              boolean ignoreComments) throws
        XmlException {
        return parseXmlFile(filename, validating, coalesce, ignoreComments, false);
    }

    public static Document createDomDocument() throws XmlException {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.newDocument();
            return document;
        }
        catch (ParserConfigurationException ex) {
            throw new XmlException(ex.getMessage());
        }
        catch (FactoryConfigurationError ex) {
            throw new XmlException(ex.getMessage());
        }
    }

    public static void createXmlFile(String filename, Document document,
                                     Properties properties) throws XmlException {
        System.out.println("createXmlFile");                             	
        System.out.println(filename); 
        Source source = new DOMSource(document);
        File file = new File(filename);
        Result result = new StreamResult(file);
        Transformer transformer = createTransformer();

        if (properties != null) {
            transformer.setOutputProperties(properties);
            //transformer.setOutputProperty(OutputKeys.CDATA_SECTION_ELEMENTS,CDATA);
            //transformer.createCDATASection(CDATA);
            //System.out.println(CDATA);
            
            //transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM,"http://www.w3.org/TR/html4/strict.dtd");

        }
        else {
            transformer.setOutputProperty(OutputKeys.INDENT,"yes");
            transformer.setOutputProperty(OutputKeys.CDATA_SECTION_ELEMENTS," " );
            transformer.setOutputProperty(OutputKeys.ENCODING, "BIG5");
           // document.createCDATASection(CDATA);
            
        }
        try {
            transformer.transform(source, result);
        }
        catch (TransformerException ex) {
            throw new XmlException(ex.getMessage());
        }
    }

    public static void createXmlFile(String filename, Document document) throws
        XmlException {
        createXmlFile(filename, document, null);
    }

    public static Transformer createTransformer() throws XmlException {
        try {
            TransformerFactory transformerFactory = TransformerFactory.
                newInstance();
            return transformerFactory.newTransformer();
        }
        catch (TransformerConfigurationException ex) {
            throw new XmlException(ex.getMessage());
        }
        catch (TransformerFactoryConfigurationError ex) {
            throw new XmlException(ex.getMessage());
        }
    }

    public static Element getChild(Element element, String name,
                                   boolean optional) throws XmlException {
        for (Node child = element.getFirstChild(); child != null;
             child = child.getNextSibling()) {
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                if ( ( (Element) child).getTagName().equals(name)) {
                    return (Element) child;
                }
            }
        }
        if (!optional) {
            throw new XmlException(name + " element expected as child of " +
                                   element.getTagName() + ".");
        }
        return null;
    }

    public static boolean getAttributeAsBoolean(Element element, String name,
                                                boolean optional) throws
        XmlException {
        String value = element.getAttribute(name);
        if (value == null && !optional) {
            throw new XmlException("Attribute " + name + " of " +
                                   element.getTagName() + " expected.");
        }
        else{
            if (value.equals("true") || value.equals("on") ||
                value.equals("yes") || value.equals("琌") ||
                value.equals("Τ")) {
                return true;
            }
            else if (value.equals("false") || value.equals("off") ||
                     value.equals("no") || value.equals("