Beispielcode-Analyse der Klasse zur Überprüfung der Richtigkeit von XML-Dateien

Oft müssen unsere Anwendungen oder Webprogramme xml-Dateien zur Konfiguration verwenden und das endgültige Programm muss von Kunden verwendet werden, sodass die XML möglicherweise auch vom Kunden geschrieben werden muss Der Kunde muss es schreiben. Andernfalls gibt es keine Garantie dafür, dass die XML-Datei absolut korrekt ist. Ihre Hauptfunktion besteht darin, zu überprüfen, ob die XML-Datei der definierten XSD-Spezifikation entspricht

package common.xml.validator;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.net.URL;

import javax.xml.XMLConstants;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.xml.sax.SAXException;

/** *//**
* @author suyuan
*
*/
public class XmlSchemaValidator {

　　private boolean isValid = true;
　　private String xmlErr = "";

　　public boolean isValid() {
　　　　return isValid;
　　}

　　public String getXmlErr() {
　　　　return xmlErr;
　　}

　　public XmlSchemaValidator()
　　{
　　}

　　
　　public boolean ValidXmlDoc(String xml,URL schema)
　　{
　　　　StringReader reader = new StringReader(xml);
　　　　return ValidXmlDoc(reader,schema);
　　}

　　public boolean ValidXmlDoc(Reader xml,URL schema)
　　{
　　　　try {
　　　　　　InputStream schemaStream = schema.openStream();
　　　　　　Source xmlSource = new StreamSource(xml);
　　　　　　Source schemaSource = new StreamSource(schemaStream);
　　　　　　return ValidXmlDoc(xmlSource,schemaSource);

　　　　} catch (IOException e) {
　　　　　　isValid = false;
　　　　　　xmlErr = e.getMessage();
　　　　　　return false;
　　　　}
　　}

　　public boolean ValidXmlDoc(String xml,File schema)
　　{
　　　　StringReader reader = new StringReader(xml);
　　　　return ValidXmlDoc(reader,schema);
　　}

　　public boolean ValidXmlDoc(Reader xml,File schema)
　　{
　　　　try {
　　　　　　FileInputStream schemaStream = new FileInputStream(schema);
　　　　　　Source xmlSource = new StreamSource(xml);
　　　　　　Source schemaSource = new StreamSource(schemaStream);
　　　　　　return ValidXmlDoc(xmlSource,schemaSource);

　　　　} catch (IOException e) {
　　　　　　isValid = false;
　　　　　　xmlErr = e.getMessage();
　　　　　　return false;
　　　　}
　　}

　　public boolean ValidXmlDoc(Source xml,Source schemaSource)
　　{
　　　　try {　　　　　　　SchemaFactory schemafactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
　　　　　　if(xml==null||xml.equals(""))
　　　　　　{　　
　　　　　　　　return false;
　　　　　　}
　　　　　　Schema schema =　schemafactory.newSchema(schemaSource);
　　　　　　Validator valid =　schema.newValidator();
　　　　　　valid.validate(xml);
　　　　　　return true;

　　　　} catch (SAXException e) {
　　　　　　isValid = false;
　　　　　　xmlErr = e.getMessage();
　　　　　　return false;
　　　　}
　　　　catch (IOException e) {
　　　　　　isValid = false;
　　　　　　xmlErr = e.getMessage();
　　　　　　return false;
　　　　}
　　　　catch (Exception e) {
　　　　　　isValid = false;
　　　　　　xmlErr = e.getMessage();
　　　　　　return false;
　　　　}
　　}
}

Klasse ist wie folgt:

package common.xml.validator;

import java.io.*;
import java.net.URL;

public class testXmlValidator {

　　/** *//**
　　 * @param args
　　 */
　　public static void main(String[] args) {
　　　　InputStream XmlStream = testXmlValidator.class.getResourceAsStream("test.xml");
　　　　Reader XmlReader = new InputStreamReader(XmlStream);
　　　　URL schema =testXmlValidator.class.getResource("valid.xsd");
　　　　XmlSchemaValidator xmlvalid = new XmlSchemaValidator();
　　　　System.out.println(xmlvalid.ValidXmlDoc(XmlReader, schema));
　　　　System.out.print(xmlvalid.getXmlErr());
　　}

}

xsd-Datei ist wie folgt definiert:

<xs:schema id="XSDSchemaTest"
　xmlns:xs="http://www.w3.org/2001/XMLSchema"
　 elementFormDefault="qualified"
　attributeFormDefault="unqualified"
>

<xs:simpleType name="FamilyMemberType">
　<xs:restriction base="xs:string">
　 <xs:enumeration value="384" />
　 <xs:enumeration value="385" />
　 <xs:enumeration value="386" />
　 <xs:enumeration value="" />
　</xs:restriction>
</xs:simpleType>

　 <xs:element name="Answer">
　　 <xs:complexType>
　　<xs:sequence>
　　　<xs:element name="ShortDesc" type="FamilyMemberType" />
　　　<xs:element name="AnswerValue" type="xs:int" />
　　 </xs:sequence>
　　　</xs:complexType>
　　 </xs:element>

</xs:schema>

Das verifizierte XML-Beispiel ist wie folgt:

<?xml version="1.0" encoding="utf-8" ?>

<Answer>
　　<ShortDesc>385</ShortDesc>
　　<AnswerValue>1</AnswerValue>
</Answer>

Dies ist die Java-Version der Klasse,

C# Die Klassendatei lautet wie folgt (geschrieben von einem alten Amerikaner, meine Klasse wird basierend auf seiner Klasse übersetzt):

using System;
using System.Xml;
using System.Xml.Schema;
using System.IO;

namespace ProtocolManager.WebApp
{
　　/**//// <summary>
　　/// This class validates an xml string or xml document against an xml schema.
　　/// It has public methods that return a boolean value depending on the validation
　　/// of the xml.
　　/// </summary>
　　public class XmlSchemaValidator
　　{
　　　　private bool isValidXml = true;
　　　　private string validationError = "";

　　　　/**//// <summary>
　　　　/// Empty Constructor.
　　　　/// </summary>
　　　　public XmlSchemaValidator()
　　　　{

　　　　}

　　　　/**//// <summary>
　　　　/// Public get/set access to the validation error.
　　　　/// </summary>
　　　　public String ValidationError
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　return "<ValidationError>" + this.validationError + "</ValidationError>";
　　　　　　}
　　　　　　set
　　　　　　{
　　　　　　　　this.validationError = value;
　　　　　　}
　　　　}

　　　　/**//// <summary>
　　　　/// Public get access to the isValidXml attribute.
　　　　/// </summary>
　　　　public bool IsValidXml
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　return this.isValidXml;
　　　　　　}
　　　　}

　　　　/**//// <summary>
　　　　/// This method is invoked when the XML does not match
　　　　/// the XML Schema.
　　　　/// </summary>
　　　　/// <param name="sender"></param>
　　　　/// <param name="args"></param>
　　　　private void ValidationCallBack(object sender, ValidationEventArgs args)
　　　　{
　　　　　　// The xml does not match the schema.
　　　　　　isValidXml = false;
　　　　　　this.ValidationError = args.Message;
　　　　}　

　　　　/**//// <summary>
　　　　/// This method validates an xml string against an xml schema.
　　　　/// </summary>
　　　　/// <param name="xml">XML string</param>
　　　　/// <param name="schemaNamespace">XML Schema Namespace</param>
　　　　/// <param name="schemaUri">XML Schema Uri</param>
　　　　/// <returns>bool</returns>
　　　　public bool ValidXmlDoc(string xml, string schemaNamespace, string schemaUri)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　// Is the xml string valid?
　　　　　　　　if(xml == null || xml.Length < 1)
　　　　　　　　{
　　　　　　　　　　return false;
　　　　　　　　}

　　　　　　　　StringReader srXml = new StringReader(xml);
　　　　　　　　return ValidXmlDoc(srXml, schemaNamespace, schemaUri);
　　　　　　}
　　　　　　catch(Exception ex)
　　　　　　{
　　　　　　　　this.ValidationError = ex.Message;
　　　　　　　　return false;
　　　　　　}
　　　　}

　　　　/**//// <summary>
　　　　/// This method validates an xml document against an xml schema.
　　　　/// </summary>
　　　　/// <param name="xml">XmlDocument</param>
　　　　/// <param name="schemaNamespace">XML Schema Namespace</param>
　　　　/// <param name="schemaUri">XML Schema Uri</param>
　　　　/// <returns>bool</returns>
　　　　public bool ValidXmlDoc(XmlDocument xml, string schemaNamespace, string schemaUri)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　// Is the xml object valid?
　　　　　　　　if(xml == null)
　　　　　　　　{
　　　　　　　　　　return false;
　　　　　　　　}

　　　　　　　　// Create a new string writer.
　　　　　　　　StringWriter sw = new StringWriter();
　　　　　　　　// Set the string writer as the text writer to write to.
　　　　　　　　XmlTextWriter xw = new XmlTextWriter(sw);
　　　　　　　　// Write to the text writer.
　　　　　　　　xml.WriteTo(xw);
　　　　　　　　// Get
　　　　　　　　string strXml = sw.ToString();

　　　　　　　　StringReader srXml = new StringReader(strXml);

　　　　　　　　return ValidXmlDoc(srXml, schemaNamespace, schemaUri);
　　　　　　}
　　　　　　catch(Exception ex)
　　　　　　{
　　　　　　　　this.ValidationError = ex.Message;
　　　　　　　　return false;
　　　　　　}
　　　　}

　　　　/**//// <summary>
　　　　/// This method validates an xml string against an xml schema.
　　　　/// </summary>
　　　　/// <param name="xml">StringReader containing xml</param>
　　　　/// <param name="schemaNamespace">XML Schema Namespace</param>
　　　　/// <param name="schemaUri">XML Schema Uri</param>
　　　　/// <returns>bool</returns>
　　　　public bool ValidXmlDoc(StringReader xml, string schemaNamespace, string schemaUri)
　　　　{
　　　　　　// Continue?
　　　　　　if(xml == null || schemaNamespace == null || schemaUri == null)
　　　　　　{
　　　　　　　　return false;
　　　　　　}

　　　　　　isValidXml = true;
　　　　　　XmlValidatingReader vr;
　　　　　　XmlTextReader tr;
　　　　　　XmlSchemaCollection schemaCol = new XmlSchemaCollection();
　　　　　　schemaCol.Add(schemaNamespace, schemaUri);

　　　　　　try
　　　　　　{
　　　　　　　　// Read the xml.
　　　　　　　　tr = new XmlTextReader(xml);
　　　　　　　　// Create the validator.
　　　　　　　　vr = new XmlValidatingReader(tr);
　　　　　　　　// Set the validation tyep.
　　　　　　　　vr.ValidationType = ValidationType.Auto;
　　　　　　　　// Add the schema.
　　　　　　　　if(schemaCol != null)
　　　　　　　　{
　　　　　　　　　　vr.Schemas.Add(schemaCol);
　　　　　　　　}
　　　　　　　　// Set the validation event handler.
　　　　　　　　vr.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
　　　　　　　　// Read the xml schema.
　　　　　　　　while(vr.Read())
　　　　　　　　{
　　　　　　　　}

　　　　　　　　vr.Close();

　　　　　　　　return isValidXml;
　　　　　　}
　　　　　　catch(Exception ex)
　　　　　　{
　　　　　　　　this.ValidationError = ex.Message;
　　　　　　　　return false;
　　　　　　}
　　　　　　finally
　　　　　　{
　　　　　　　　// Clean up
　　　　　　　　vr = null;
　　　　　　　　tr = null;
　　　　　　}
　　　　}
　　}
}

Ich hoffe, der obige Kurs wird für alle hilfreich sein, natürlich mache ich ihn auch hier. Ein Zeichen, Sie können ihn bei Bedarf in Zukunft direkt verwenden, hehe

Das obige ist der detaillierte Inhalt vonBeispielcode-Analyse der Klasse zur Überprüfung der Richtigkeit von XML-Dateien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!