xs XMLSchema dom解析

谁借莪１个温暖的怀抱￠ 2022-06-11 02:08 208阅读 0赞

package Domjiexi;
    import java.io.File;  
    import java.io.FileOutputStream;  
    import java.io.IOException;  
      
    import javax.xml.parsers.DocumentBuilder;  
    import javax.xml.parsers.DocumentBuilderFactory;  
    import javax.xml.parsers.ParserConfigurationException;  
    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.dom.DOMResult;  
    import javax.xml.transform.dom.DOMSource;  
    import javax.xml.transform.stream.StreamResult;  
    import javax.xml.validation.Schema;  
    import javax.xml.validation.SchemaFactory;  
    import javax.xml.validation.Validator;  
    import javax.xml.xpath.XPath;  
    import javax.xml.xpath.XPathConstants;  
    import javax.xml.xpath.XPathExpressionException;  
    import javax.xml.xpath.XPathFactory;
    
    import org.apache.log4j.Logger;
    import org.w3c.dom.Document;  
    import org.w3c.dom.Element;  
    import org.w3c.dom.Node;  
    import org.w3c.dom.NodeList;  
    import org.w3c.dom.Text;
    import org.xml.sax.ErrorHandler;
    import org.xml.sax.SAXException;
    import org.xml.sax.SAXParseException;
    public class DomParser {
    	   Logger logger=Logger.getLogger(DomParser.class);
    	    private static final int FLAG_TRACE = 1;  
    	  
    	    private static final int FLAG_INSERT = 2;  
    	  
    	    private static final int FLAG_DELETE = 3;  
    	  
    	    private static final int FLAG_UPDATE = 4;  
    	  
    	    private static final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";  
    	  
    	    private static String W3C_XML_SCHEMA = "http://www.w3c.org/2001/XMLSchema";  
    	  
    	    private static String W3C_APACHE = "http://apache.org/xml/features/validation/schema";  
    	  
    	    File xmlFile = new File("src/student.xml");  
    	  
    	    DocumentBuilderFactory xmlfactory = null;  
    	  
    	    DocumentBuilder builder = null;  
    	  
    	    Document document = null;  
    	  
    	    Element root = null;  
    	  
    	    public DomParser() throws ParserConfigurationException, SAXException,  
    	            IOException {  
    	        xmlfactory = DocumentBuilderFactory.newInstance();  
    	        xmlfactory.setValidating(true);  
    	        xmlfactory.setNamespaceAware(true);  
    	        xmlfactory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);  
    	        xmlfactory.setFeature(W3C_APACHE, true);  
    	        xmlfactory.setIgnoringElementContentWhitespace(true);  
    	        builder = xmlfactory.newDocumentBuilder();
    	        builder.setErrorHandler(myErrorHandler()); 
    	        builder = xmlfactory.newDocumentBuilder();  
    	        document = builder.parse(xmlFile);  
    	        root = document.getDocumentElement();  
    	        removeWhilespace(root);  
    	    }  
    	  
    	    private void doSth(int flag) {  
    	        switch (flag) {  
    	        case FLAG_TRACE:  
    	            traceDomTree();  
    	            break;  
    	        case FLAG_INSERT:  
    	            insertOneNode();  
    	            break;  
    	        case FLAG_DELETE:  
    	            deleteOneNode();  
    	            break;  
    	        case FLAG_UPDATE:  
    	            updateOneNode();  
    	            break;  
    	        }  
    	    }  
    	  
    	    private void traceDomTree() {//遍历  
    	        NodeList children = root.getChildNodes();  
    	        for (int i = 0; i < children.getLength(); i++) {  
    	            Element child = (Element) children.item(i);  
    	            Element element = (Element) child.getFirstChild();  
    	            while (element.getNextSibling() != null) {  
    	                System.out.println(element.getTextContent());  
    	                element = (Element) element.getNextSibling();  
    	            }  
    	            System.out.println(element.getTextContent());  
    	        }  
    	    }  
    	    
    	    private void insertOneNode() {  
    	        Element theStudent = document.createElement("STUDENT");  
    	        theStudent.setAttribute("STUDENT_ID", "2003710201");  
    	  
    	        Element theElement = document.createElement("PASSWORD");  
    	        theElement.setTextContent("[137Joanna]");  
    	        theStudent.appendChild(theElement);  
    	  
    	        theElement = document.createElement("FIRST_NAME");  
    	        theElement.setTextContent("Chang");  
    	        theStudent.appendChild(theElement);  
    	  
    	        theElement = document.createElement("LAST_NAME");  
    	        theElement.setTextContent("Xiangzhong");  
    	        theStudent.appendChild(theElement);  
    	  
    	        theElement = document.createElement("MAJOR_NUMBER");  
    	        theElement.setTextContent("1");  
    	        theStudent.appendChild(theElement);  
    	  
    	        root.appendChild(theStudent);  
    	        
    	        try {  
    	            xml2File(root);  
    	            validate(root);  
    	            output(root);
    	        } catch (SAXException e) {  
    	            // TODO Auto-generated catch block  
    	            e.printStackTrace();  
    	        } catch (IOException e) {  
    	            // TODO Auto-generated catch block  
    	            e.printStackTrace();  
    	        } catch (TransformerException e) {  
    	            // TODO Auto-generated catch block  
    	            e.printStackTrace();  
    	        }  
    	    }  
    	  
    	    private void deleteOneNode() {  
    	        Element theStudent = (Element) selectSingleNode(  
    	                "/STUDENTS/STUDENT[@STUDENT_ID='3']", root);  
    	        output(theStudent.getParentNode());  
    	        Node root = theStudent.getParentNode();  
    	        root.removeChild(theStudent);  
    	        output(root);  
    	    }  
    	  
    	    private void updateOneNode() {  
    	        Element theStudent = (Element) selectSingleNode(  
    	                "/STUDENTS/STUDENT[FIRST_NAME='Miao']", root);  
    	        output(theStudent.getParentNode());  
    	        theStudent.getElementsByTagName("MAJOR_NUMBER").item(0).setTextContent(  
    	                "99999999999999999999");  
    	        output(theStudent.getParentNode());  
    	    }  
    	  
    	    private Node selectSingleNode(String expression, Object source) {  
    	        XPathFactory xPathFactory = XPathFactory.newInstance();  
    	        XPath xPath = xPathFactory.newXPath();  
    	        Node result = null;  
    	        try {  
    	            result = (Node) xPath.evaluate(expression, source,  
    	                    XPathConstants.NODE);  
    	        } catch (XPathExpressionException e) {  
    	            // TODO Auto-generated catch block  
    	            e.printStackTrace();  
    	        }  
    	        return result;  
    	    }  
    	  
    	    public static NodeList selectNodes(String express, Object source) {  
    	        NodeList result = null;  
    	        XPathFactory xpathFactory = XPathFactory.newInstance();  
    	        XPath xpath = xpathFactory.newXPath();  
    	        try {  
    	            result = (NodeList) xpath.evaluate(express, source,  
    	                    XPathConstants.NODESET);  
    	        } catch (XPathExpressionException e) {  
    	            e.printStackTrace();  
    	        }  
    	  
    	        return result;  
    	    }  
    	  
    	    private void xml2File(Node node) throws IOException, TransformerException {  
    	        TransformerFactory tFactory = TransformerFactory.newInstance();  
    	        Transformer transformar = tFactory.newTransformer();  
    	        File file = new File("src/student.xml");  
    	        file.createNewFile();  
    	        Source source = new DOMSource(node);  
    	        FileOutputStream out = new FileOutputStream(file);  
    	        transformar.transform(source, new StreamResult(out));  
    	    }  
    	  
    	    private void validate(Node node) throws SAXException, IOException {  
    	        SchemaFactory schemaFactory = SchemaFactory  
    	                .newInstance("http://www.w3.org/2001/XMLSchema");  
    	        File xsdFile = new File("src/students.xsd");  
    	        Schema schema = schemaFactory.newSchema(xsdFile);  
    	        Validator validator = schema.newValidator();  
    	        Source source = new DOMSource(node);  
    	        Result result = new DOMResult();  
    	        validator.validate(source, result);  
    	    }  
    	  
    	    private int removeWhilespace(Element element) {  
    	        int count = 0;  
    	        NodeList children = element.getChildNodes();  
    	        if (children.getLength() <= 1) {  
    	            return 0;  
    	        } else {  
    	            for (int i = children.getLength() - 1; i >= 0; i--) {  
    	                Node child = children.item(i);  
    	                if (child instanceof Text  
    	                        && ((Text) child).getData().trim().length() == 0) {  
    	                    element.removeChild(child);  
    	                    count++;  
    	                } else if (child instanceof Element) {  
    	                    count += removeWhilespace((Element) child);  
    	                }  
    	            }  
    	        }  
    	        return count;  
    	    }  
    	     
    	    // 解析错误处理
      public ErrorHandler myErrorHandler(){ 
        return   new ErrorHandler() {  
                @Override  
                public void warning(SAXParseException exception) throws SAXException {  
                    logger.warn(exception.getMessage());  
                }  
    
                @Override  
                public void fatalError(SAXParseException exception) throws SAXException {  
                    logger.error(exception.getMessage());  
                }  
    
                @Override  
                public void error(SAXParseException exception) throws SAXException {  
                    logger.error(exception.getMessage());  
                }  
            };  
        
    
      } 
    	    public static void output(Node node) {  
    	        TransformerFactory transFactory = TransformerFactory.newInstance();  
    	        try {  
    	            Transformer transformer = transFactory.newTransformer();  
    	            transformer.setOutputProperty("indent", "yes");  
    	  
    	            DOMSource source = new DOMSource();  
    	            source.setNode(node);  
    	            StreamResult result = new StreamResult();  
    	            result.setOutputStream(System.out);  
    	  
    	            transformer.transform(source, result);  
    	        } catch (TransformerConfigurationException e) {  
    	            e.printStackTrace();  
    	        } catch (TransformerException e) {  
    	            e.printStackTrace();  
    	        }  
    	    }  
    	  
    	    public static void main(String[] args) throws ParserConfigurationException,  
    	            SAXException, IOException {  
    	        DomParser parser = new DomParser();  
    	        //parser.doSth(FLAG_TRACE);  
    	       parser.doSth(FLAG_INSERT);  
    	       /*  parser.doSth(FLAG_DELETE);  
    	        parser.doSth(FLAG_UPDATE);*/  
    	    }  
    	  
    }

<?xml version="1.0" encoding="UTF-8"?>
    <STUDENTS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:noNamespaceSchemaLocation="students.xsd">
    	<STUDENT STUDENT_ID="1">
    		<PASSWORD>19841230</PASSWORD>
    		<FIRST_NAME>Xiangzhong</FIRST_NAME>
    		<LAST_NAME>Chang</LAST_NAME>
    		<MAJOR_NUMBER>7</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2">
    		<PASSWORD>19841230</PASSWORD>
    		<FIRST_NAME>Miao</FIRST_NAME>
    		<LAST_NAME>Wu</LAST_NAME>
    		<MAJOR_NUMBER>7</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="3">
    		<PASSWORD>19841230</PASSWORD>
    		<FIRST_NAME>Juntai</FIRST_NAME>
    		<LAST_NAME>Wang</LAST_NAME>
    		<MAJOR_NUMBER>7</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    	<STUDENT STUDENT_ID="2003710201">
    		<PASSWORD>[137Joanna]</PASSWORD>
    		<FIRST_NAME>Chang</FIRST_NAME>
    		<LAST_NAME>Xiangzhong</LAST_NAME>
    		<MAJOR_NUMBER>1</MAJOR_NUMBER>
    	</STUDENT>
    </STUDENTS>
    
    
    
     
         <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"    
            elementFormDefault="qualified">    
            <xs:element name="STUDENTS" type="students-type" />    
            <xs:complexType name="students-type">    
                <xs:sequence maxOccurs="unbounded">    
                    <xs:element name="STUDENT" type="student-type" />    
                </xs:sequence>    
            </xs:complexType>    
            <xs:complexType name="student-type">    
                <xs:sequence>    
                    <xs:element name="PASSWORD" type="xs:string" />    
                    <xs:element name="FIRST_NAME" type="xs:string" />    
                    <xs:element name="LAST_NAME" type="xs:string" />    
                    <xs:element name="MAJOR_NUMBER" type="xs:integer" />    
                    <xs:any minOccurs="0" />    
                </xs:sequence>    
                <xs:attribute name="STUDENT_ID" type="xs:integer" use="required"/>    
            </xs:complexType>    
        </xs:schema>