First, I started out with the main resource part, which you can find the basic to anywhere:

import java.io.InputStream;

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;

import org.apps.validator.Validate;

@POST
  @Path("get/validate_hazard")
  @Produces("text/html")
  @Consumes("application/xml")
  public String validateHazard( InputStream hazardXml )
  {
    return Validate.isValid(hazardXml);
  }

(Some code has been hacked down to necessary parts. Leave a comment if you need more complete code.)

I originally had this method accept a Bean that I then used for all my updating or adding. Having it put the data into an InputStream was what took me the longest to figure out, even though it seems so obvious to me now. I probably could have put it into an InputSource or SAXSource if I wanted, but I’m still experimenting. Either way, there are several ways to go about validating.

To start everything off, here is how the input XML looks:

<hazardbean>
  ...
  <create_date>2009-06-04</create_date>
  ...
</hazardbean>

And here is how my XSD looks:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:element name="hazardBean">
    <xs:complexType>
      <xs:sequence>
       ...
       <xs:element name="create_Date" type="xs:date" maxOccurs="1" />
       ...
      </xs:sequence>
    </xs:complexType>
 </xs:element>
</xs:schema>

The first way I found is relatively simple. You can read the original article I modified it from called The Java XML Validation API at IBM’s site. Here is my take on it:

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
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;

public static String validator(InputStream hazard)
{
  String result = "Failed.";
    try
    {
    // 1. Lookup a factory for the W3C XML Schema language
      SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");

    // 2. Compile the schema.
    // Here the schema is loaded from a java.io.File, but you could use
    // a java.net.URL or a javax.xml.transform.Source instead.
      File schemaLocation = new File("C:/xml/hazardBean.xsd");
    Schema schema = factory.newSchema(schemaLocation);

    // 3. Get a validator from the schema.
      Validator validator = schema.newValidator();

    // 4. Parse the document you want to check.
      Source source = new StreamSource(hazard);

    // 5. Check the document
        validator.validate(source);
        result = "XML is valid.";
    }
    catch (SAXException ex)
    {
        result = "XML is not valid because " + ex.getMessage();
    }
    catch (Exception ex)
    {
      result = "XML is not valid because " + ex.getMessage();
    }
    return result;
}

Pretty much the same thing their article covers. This will spit me out a nice error when something is not valid that explains why.

The next way that I tried using DOM:

import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

public static String validateXML(InputStream hazard)
  {
    String result = "Failed.";
    try
    {
      // parse an XML document into a DOM tree
      DocumentBuilderFactory parserFactory = DocumentBuilderFactory.newInstance();
      parserFactory.setNamespaceAware(true);
      parserFactory.setValidating(true);
      // set attributes to handle XML namespace
      parserFactory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
      parserFactory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaSource", "http://localhost:8080/xml/hazardBean.xsd");

      DocumentBuilder parser = parserFactory.newDocumentBuilder();
      parser.setErrorHandler(new Handler());

      parser.parse( hazard );

      result = "Success.";
      hazard.close();
    }
    catch (SAXException e)
    {
      m_logger.fatal( "Parsing Error: " + e.toString() );
    }
    catch (IOException e)
    {
      m_logger.fatal( "IO Error: " + e.toString() );
    }
    catch (Exception e)
    {
      m_logger.fatal( e.toString() );
    }
    return result;
  }

m_logger is just my companies logger class, a customized version of apache log4j.

IBM had another nice article on how to setup an ErrorHandler that I found quite useful. It took me a minute to realize that you have to build your own. (Again, if you would like to see the one I built, just ask in the comments. They are pretty self explanatory though.)

This brings me to the very last one. Using SAX to parse:

import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

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;

public static String validateXML(InputStream hazard)
  {
    String result = "Failed.";
    try
    {
      // Prepare parser for validating
      SAXParserFactory parserFactory = SAXParserFactory.newInstance();
      parserFactory.setNamespaceAware(true);
      parserFactory.setValidating(true);
      parserFactory.setFeature("http://apache.org/xml/features/validation/schema", true);

      SAXParser parser = parserFactory.newSAXParser();

      // Set namespace properties
      parser.setProperty("http://java.sun.com/xml/jaxp/properties/schemaLanguage",
                         "http://www.w3.org/2001/XMLSchema");
      parser.setProperty("http://java.sun.com/xml/jaxp/properties/schemaSource", "http://localhost:8080/restdemo/docs/hazardBean.xsd");

      // Get reader to parse XML
      XMLReader xmlReader = parser.getXMLReader();
      xmlReader.setErrorHandler(new Handler());
      xmlReader.parse( new InputSource(hazard) );

      // Close input source
      hazard.close();
    }
    catch (SAXException e)
    {
      m_logger.fatal( "Parsing Error: " + e.toString() );
    }
    catch (IOException e)
    {
      m_logger.fatal( "IO Error: " + e.toString() );
    }
    catch (Exception e)
    {
      m_logger.fatal( e.toString() );
    }
    return result;
  }

That’s about all there is to it. This works perfectly for REST services to make sure that the user inputs good data and leaves you with less error checking in the end. I hope this has been helpful to anyone else out there looking for a way to validate their XML against an XSD using Java.