Exemple d'analyse de code de la classe de vérification de l'exactitude du fichier XML

Souvent, nos applications ou programmes Web doivent utiliser des fichiers xml pour la configuration, et le programme final doit être utilisé par les clients, donc le XML peut également devoir être écrit par le client, et le le client doit l'écrire. Sinon, il n'y a aucune garantie que le fichier XML soit absolument correct, j'ai donc écrit cette classe. Sa fonction principale est de vérifier si le fichier XML écrit est conforme à la spécification xsd définie.

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;
　　　　}
　　}
}

la classe est la suivante :

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());
　　}

}

le fichier xsd est défini comme suit :

<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>

L'exemple XML vérifié est le suivant :

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

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

Voici la version java de la classe,

C# Le fichier de la classe est le suivant (écrit par un vieil Américain, ma classe est traduite en fonction de sa classe) :

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;
　　　　　　}
　　　　}
　　}
}

J'espère que le cours ci-dessus sera utile à tout le monde, bien sûr, je le fais aussi ici. Une note, vous pouvez l'utiliser directement si nécessaire à l'avenir hehe

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!