Validação XML usando schema XSD

Programação Java
#1

Fala galera, boa tarde.
Eu sei que este é um tópico meio repetido no GUJ, mas gostaria de saber mais sobre a validação de XML usando os schemas XSD, por exemplo encontrei um código que deveria fazer essa validação passando diretamente o xml e o xsd, mas uma constante do código parece não existir no java 6 ( me corrijam se estiver enganado!!!).
Encontrei esse código na web:

[code]import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.net.URL;

import javax.xml.XMLConstants;
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;

public class ValidadorXMLCte {

/**
 * Valida o xml com base no xsd.
 * 
 * @param xsdFile
 *            Arquivo xsd
 * @param xml
 *            XML a ser validado
 * @throws SAXException
 *             se o xml não for válido
 * @throws IOException
 *             se ocorrer algum erro durante a validação
 */
public static void validate(String xsdFile, String xml)
		throws SAXException, IOException {
	SchemaFactory schemaFactory = SchemaFactory 
			.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); // MAS PARECE QUE O W3C_XML_SCHEMA_NS_URI não existe mais, existe algum substituto?
	URL url = ClassLoader.getSystemResource(xsdFile);
	Schema schema = schemaFactory.newSchema(new File(url.getFile()));
	Validator validator = schema.newValidator();
	validator.validate(new StreamSource(new StringReader(xml)));
}

}[/code]

#2

Você deu sorte…tá rolando um tópico justamente sobre isso aqui cara http://www.guj.com.br/java/242250-onde-se-postar … você deveria dar uma olhada

#3

Pô cara engraçado que encontrei um tópico de uma menina relativamente bonita fora do local e ninguem questionou ela e etc…
Até onde vai a coragem e a falta de sutileza de alguns usuários mais experientes do fórum?
Fica meio complicado saber se minha dúvida é básica ou avançada atualmente não sei a que nível esse tipo de dúvida se encaixa.

Mas valeu a “atenção”

Ps: peço a algum moderador que encerre este tópico antes de maiores polêmicas…

#4

Na verdade todos os tópicos que tem uma seta ao lado esquerdo foram movidos para suas respectivas áreas…
O que você citou está agora em off-Topic…

#5

Movido para o fórum de Java Avançado.
E, sim, eu também movi o tópico da menina bonita muito antes de você postar.

#6

Eu nunca consegui fazer a validação XSD funcionar direito no Java. Só através de APIs como o Castor.
Também nunca usei muito XML em Java. E, o pouco que eu usei, não precisa tanto assim dessa validação a ponto de me fazer procurar mais a fundo. =/

#7

Valeu Vini…
Peço desculpas ao pessoal do guj pelo atrito ai, mas algumas atitudes como a que foi tomada no inicio do tópico não colaboram em nada no crescimento do fórum(claro em minha opinião).

#8

Olá

Bom independente que seja o tópico, a questão é a sua dúvida, mas se for possível verificar antes é ideal para o fórum.
Mas que seja, caso não tenha esclarecido, vou tentar ajudar.

Fiz um post sobre esse assunto, creio que ajude no que está querendo.

Validação feita pelo SAX…

Um exemplo de XSD

    <?xml version="1.0" encoding="ISO-8859-1"?>  
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">  
      
        <xs:element name="howto">  
            <xs:complexType>  
                <xs:sequence>  
                    <xs:element name="topic" maxOccurs="unbounded">  
                        <xs:complexType>  
                            <xs:sequence>  
                                <xs:element name="title" type="xs:string" />  
                                <xs:element name="number" type="xs:integer" />  
                                <xs:element name="url" type="httpURI" />  
                            </xs:sequence>  
                        </xs:complexType>  
                    </xs:element>  
                </xs:sequence>  
            </xs:complexType>  
        </xs:element>  
      
        <xs:simpleType name="httpURI">  
            <xs:restriction base="xs:anyURI">  
                <xs:pattern value="http://.*" />  
            </xs:restriction>  
        </xs:simpleType>  
      
    </xs:schema>

Um exemplo do XML baseado neste XSD


    <?xml version="1.0" encoding="ISO-8859-1"?>  
    <howto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="howto howto.xsd">  
        <topic>  
            <title>Java</title>  
            <number>10</number>  
            <url>http://www.rgagnon.com/topics/java-xml.html</url>  
        </topic>  
        <topic>  
            <title>PowerBuilder</title>  
            <number>12</number>  
            <url>http://www.rgagnon.com/topics/pb-powerscript.htm</url>  
        </topic>  
        <topic>  
            <title>Javascript</title>  
            <number>1</number>  
            <url>http://www.rgagnon.com/topics/js-language.html</url>  
        </topic>  
        <topic>  
            <title>VBScript</title>  
            <number>8</number>  
            <url>http://www.rgagnon.com/topics/wsh-vbs.html</url>  
        </topic>  
    </howto>

Classe java validando, note que usei o XMLReader, mas também posso não usar.

    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.IOException;  
    import java.io.InputStream;  
      
    import javax.xml.parsers.ParserConfigurationException;  
    import javax.xml.parsers.SAXParser;  
    import javax.xml.parsers.SAXParserFactory;  
      
    import org.xml.sax.Attributes;  
    import org.xml.sax.EntityResolver;  
    import org.xml.sax.ErrorHandler;  
    import org.xml.sax.InputSource;  
    import org.xml.sax.SAXException;  
    import org.xml.sax.SAXParseException;  
    import org.xml.sax.XMLReader;  
    import org.xml.sax.helpers.DefaultHandler;  
      
    public class SAXValidationXML {  
      
        private static final String URI_VALIDATION = "http://xml.org/sax/features/validation";  
        private static final String URI_SCHEMA = "http://apache.org/xml/features/validation/schema";  
      
        private static final String SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";  
        private static final String SCHEMA_SOURCE = "http://java.sun.com/xml/jaxp/properties/schemaSource";  
        private static final String XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";  
      
        private static final String FILE_XML = "howto.xml";  
        private static final String FILE_SCHEMA = "howto.xsd";  
      
        public SAXValidationXML() throws ParserConfigurationException, SAXException, IOException {  
            SAXParserFactory spf = SAXParserFactory.newInstance();  
            spf.setNamespaceAware(true);  
            spf.setValidating(true);  
            spf.setFeature(URI_VALIDATION, true);  
            spf.setFeature(URI_SCHEMA, true);  
      
            SAXParser sp = spf.newSAXParser();  
            sp.setProperty(SCHEMA_LANGUAGE, XML_SCHEMA);  
            sp.setProperty(SCHEMA_SOURCE, getFileInput(FILE_SCHEMA));  
      
              
            //XMLReader só valida.  
            XMLReader xmlReader = sp.getXMLReader();  
            xmlReader.setErrorHandler(new EHandler());  
            xmlReader.setEntityResolver(new EResolver());  
            xmlReader.parse(new InputSource(getFileInput(FILE_XML)));  
              
            //Se quiser usar para parsear o XML/Validar  
            //sp.parse(getFileInput(FILE_XML), new DHandler());  
        }  
      
        public static void main(String[] args) {  
            try {  
                new SAXValidationXML();  
            } catch (ParserConfigurationException e) {  
                e.printStackTrace();  
            } catch (SAXException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
      
        private class DHandler extends DefaultHandler {  
      
            @Override  
            public void startElement(String uri, String localName, String qName,  
                    Attributes attributes) throws SAXException {  
                super.startElement(uri, localName, qName, attributes);  
                System.out.println("QName " + qName);  
      
            }  
              
            /* 
             * Se preferir pode usar essa classe e implementar os metodos 
             * resolveEntity 
             * error 
             * warning 
             * fatalerror 
             *  
             * Implementando esses metodos não precisa utilizar o XMLREADER. 
             *  
             */  
              
            @Override  
            public InputSource resolveEntity(String publicId, String systemId) throws IOException, SAXException {  
                return new InputSource(getFileInput(FILE_XML));  
            }  
              
            @Override  
            public void error(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.error()");  
                System.err.println(e.getLineNumber() + ", " + e.getColumnNumber());  
            }  
      
            @Override  
            public void warning(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.warning()");  
            }  
      
            @Override  
            public void fatalError(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.fatalError()");  
            }  
      
        }  
       [/code]   
          
        //Essas duas classe são usadas somente para o XMLREADER.  
          [code]
        private class EResolver implements EntityResolver {  
            @Override  
            public InputSource resolveEntity(String publicId, String systemId)  
                    throws IOException, SAXException {  
                return new InputSource(getFileInput(FILE_XML));  
            }  
        }  
      
        private class EHandler implements ErrorHandler {  
      
            @Override  
            public void error(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.error()");  
                System.err.println(e.getLineNumber() + ", " + e.getColumnNumber());  
            }  
      
            @Override  
            public void warning(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.warning()");  
            }  
      
            @Override  
            public void fatalError(SAXParseException e) throws SAXException {  
                System.out.println("Main.ParserHandler.fatalError()");  
            }  
      
        }  
      
        private InputStream getFileInput(String name) throws FileNotFoundException {  
            return new FileInputStream(new File(name));  
        }  
      
    }

Anexei também o projeto para fazer testes.

Olhando mais um pouco sobre validações de xml e xsd, vi que tem uma API para isso, XMLBeans.
Não testei, mas vi que é uma ferramenta bastante poderosa.
Vale a pena dar uma espiada nela…

Segue os links

  1. http://javafree.uol.com.br/topic-851661-Validar-XML-com-SCHEMA.html
  2. http://emarineli.wordpress.com/2009/06/25/validaco...derosas-com-o-apache-xmlbeans/
  3. http://www.guj.com.br/java/32063-aprendendo-apache-xmlbeans
  4. http://robsonp.com/01/2011/xml-com-xmlbeans/

Espero ter ajudado
Flwss

#9

Valeu Thiago vou dar uma olhada ai e já posto o resultado.

Abraço

#10