src/org/objectweb/cjdbc/common/xml/XmlValidator.java

説明を見る。

package org.objectweb.cjdbc.common.xml;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.ArrayList;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.controller.core.ControllerConstants;
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.ext.LexicalHandler;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

public class XmlValidator extends DefaultHandler
    implements
      ErrorHandler,
      LexicalHandler
{

  private XMLReader parser;
  private String    pathToDtd;
  private boolean   isXmlValid = false;
  private boolean   isDtdValid = false;
  private String    xmlContent;
  private ArrayList errors;
  private ArrayList warnings;
  
  public static void main(String args[]) throws Exception
  {
    if(args.length<1 || args.length >2)
    {
      System.out.println("usage: XmlValidator [xmlFile] ([dtd]) ");
      System.exit(0);
    }
    
    String fileName = args[0];
    String dtdName = ControllerConstants.C_JDBC_DTD_FILE;
    if(args.length == 2)
      dtdName = args[1];
    else
      System.out.println("Using default DTD:"+ControllerConstants.C_JDBC_DTD_FILE);
    
    File dtd = null;
    dtd = new File(ClassLoader.getSystemResource(dtdName).getFile());
    File xmlFile = null;
    try
    {
      xmlFile = new File(ClassLoader.getSystemResource(fileName).getFile());
    }
    catch (RuntimeException e)
    {
      xmlFile = new File(fileName);
    }
    
    if(!dtd.exists())
    {
      System.out.println("Cannot find specified dtd");
      System.exit(1);
    }
    if(!xmlFile.exists())
    {
      System.out.println("Cannot find specified xml file");
      System.exit(1);
    }
    
    System.out.println("Validating:\tFile:" + xmlFile.getName() + " with dtd:" + dtd.getName());
    
    // Validate xml and dtd
    XmlValidator validator = new XmlValidator(dtd.getAbsolutePath(),new FileReader(xmlFile));
    
    // Display Results
    if (!validator.isDtdValid())
      System.out.println("[FAILED:Dtd is not valid]");
    else if (!validator.isXmlValid())
      System.out.println("[FAILED:xml is not valid]");
    else if (validator.isXmlValid())
      System.out.println("[OK]");

    if (validator.getLastException() != null)
    {
      ArrayList errors = validator.getExceptions();
      for (int i = 0; i < errors.size(); i++)
        System.out.println("\t(parsing error):"
            + ((Exception) errors.get(i)).getMessage());
    }
  }

  public XmlValidator(String pathToDtd, String xml)
  {
    validate(pathToDtd, xml);
  }

  public XmlValidator(String pathToDtd, FileReader file) throws IOException
  {
    // Read the file
    BufferedReader in = new BufferedReader(file);
    StringBuffer xml = new StringBuffer();
    String line;
    do
    {
      line = in.readLine();
      if (line != null)
        xml.append(line.trim());
    }
    while (line != null);
    xmlContent = xml.toString();
    validate(pathToDtd, xmlContent);
  }

  public String getXmlContent()
  {
    return xmlContent;
  }

  public void validate(String pathToDtd, String xml)
  {
    System.setProperty("org.xml.sax.driver",
        "org.apache.crimson.parser.XMLReaderImpl");
    errors = new ArrayList();
    warnings = new ArrayList();
    try
    {
      // Store dtd reference
      this.pathToDtd = pathToDtd;
      // Instantiate a new parser
      parser = XMLReaderFactory.createXMLReader();
      // Activate validation
      parser.setFeature("http://xml.org/sax/features/validation", true);
      // Install error handler
      parser.setErrorHandler(this);
      // Install document handler
      parser.setContentHandler(this);
      parser.setProperty("http://xml.org/sax/properties/lexical-handler", this);
      // Install local entity resolver
      parser.setEntityResolver(this);
      InputSource input = new InputSource(new StringReader(xml));
      parser.parse(input);
    }
    catch (Exception e)
    {
      //throw new Exception("Xml document can not be validated.");
      //e.printStackTrace();
      addError(e);
      isXmlValid = false;
    }
  }

  public InputSource resolveEntity(String publicId, String systemId)
      throws SAXException
  {

    File dtd = new File(pathToDtd);
    if (dtd.exists())
    {
      try
      {
        FileReader reader = new FileReader(dtd);
        return new InputSource(reader);
      }
      catch (Exception e)
      { //impossible
      }
    }

    InputStream stream = XmlValidator.class
        .getResourceAsStream("/" + pathToDtd);
    if (stream == null)
    {
      SAXException sax = new SAXException(Translate.get(
          "virtualdatabase.xml.dtd.not.found", pathToDtd));
      addError(sax);
      throw sax;
    }

    return new InputSource(stream);
  }

  public void error(SAXParseException exception) throws SAXException
  {
    addError(exception);
  }

  public void fatalError(SAXParseException exception) throws SAXException
  {
    addError(exception);
  }

  public void warning(SAXParseException exception) throws SAXException
  {
    warnings.add(exception);
  }

  public void endDocument() throws SAXException
  {
    if (errors.size() == 0)
      this.isXmlValid = true;
  }

  public boolean isValid()
  {
    return isXmlValid && isDtdValid;
  }

  public Exception getLastException()
  {
    if (errors.size() == 0)
      return null;
    else
      return (Exception) errors.get(errors.size() - 1);
  }

  public ArrayList getExceptions()
  {
    return errors;
  }

  public void comment(char[] ch, int start, int length) throws SAXException
  {
  }

  public void endCDATA() throws SAXException
  {
  }

  public void endDTD() throws SAXException
  {
    if (errors.size() == 0)
    {
      isDtdValid = true;
    }
    else
    {
      isDtdValid = false;
    }
  }

  public void endEntity(String name) throws SAXException
  {
  }

  public void startCDATA() throws SAXException
  {
  }

  public void startDTD(String name, String publicId, String systemId)
      throws SAXException
  {
  }

  public void startEntity(String name) throws SAXException
  {
  }

  public boolean isDtdValid()
  {
    return isDtdValid;
  }

  public void setDtdValid(boolean isDtdValid)
  {
    this.isDtdValid = isDtdValid;
  }

  public boolean isXmlValid()
  {
    return isXmlValid;
  }

  public void setXmlValid(boolean isXmlValid)
  {
    this.isXmlValid = isXmlValid;
  }

  private void addError(Exception e)
  {
    errors.add(e);
  }

  public ArrayList getWarnings()
  {
    return warnings;
  }
}

---