Java/XML/XMLStreamReader

Debugging utilities for XmlStreamReader

 
/*   Copyright 2004 The Apache Software Foundation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *  limitations under the License.
 */
// Revised from xml beans
import javax.xml.stream.XMLStreamReader;
/**
 * debugging utilities for XmlStreamReader
 */
public final class XmlStreamUtils {
  public static String printEvent(XMLStreamReader xmlr) {
    StringBuffer b = new StringBuffer();
    b.append("EVENT:[" + xmlr.getLocation().getLineNumber() + "]["
        + xmlr.getLocation().getColumnNumber() + "] ");
    b.append(getName(xmlr.getEventType()));
    b.append(" [");
    switch (xmlr.getEventType()) {
    case XMLStreamReader.START_ELEMENT:
      b.append("<");
      printName(xmlr, b);
      for (int i = 0; i < xmlr.getNamespaceCount(); i++) {
        b.append(" ");
        String n = xmlr.getNamespacePrefix(i);
        if ("xmlns".equals(n)) {
          b.append("xmlns=\"" + xmlr.getNamespaceURI(i) + "\"");
        } else {
          b.append("xmlns:" + n);
          b.append("=\"");
          b.append(xmlr.getNamespaceURI(i));
          b.append("\"");
        }
      }
      for (int i = 0; i < xmlr.getAttributeCount(); i++) {
        b.append(" ");
        printName(xmlr.getAttributePrefix(i), xmlr.getAttributeNamespace(i), xmlr
            .getAttributeLocalName(i), b);
        b.append("=\"");
        b.append(xmlr.getAttributeValue(i));
        b.append("\"");
      }
      b.append(">");
      break;
    case XMLStreamReader.END_ELEMENT:
      b.append("</");
      printName(xmlr, b);
      for (int i = 0; i < xmlr.getNamespaceCount(); i++) {
        b.append(" ");
        String n = xmlr.getNamespacePrefix(i);
        if ("xmlns".equals(n)) {
          b.append("xmlns=\"" + xmlr.getNamespaceURI(i) + "\"");
        } else {
          b.append("xmlns:" + n);
          b.append("=\"");
          b.append(xmlr.getNamespaceURI(i));
          b.append("\"");
        }
      }
      b.append(">");
      break;
    case XMLStreamReader.SPACE:
    case XMLStreamReader.CHARACTERS:
      // b.append(xmlr.getText());
      int start = xmlr.getTextStart();
      int length = xmlr.getTextLength();
      b.append(new String(xmlr.getTextCharacters(), start, length));
      break;
    case XMLStreamReader.PROCESSING_INSTRUCTION:
      String target = xmlr.getPITarget();
      if (target == null)
        target = "";
      String data = xmlr.getPIData();
      if (data == null)
        data = "";
      b.append("<?");
      b.append(target + " " + data);
      b.append("?>");
      break;
    case XMLStreamReader.CDATA:
      b.append("<![CDATA[");
      if (xmlr.hasText())
        b.append(xmlr.getText());
      b.append("]]&gt;");
      break;
    case XMLStreamReader.ruMENT:
      b.append("<!--");
      if (xmlr.hasText())
        b.append(xmlr.getText());
      b.append("-->");
      break;
    case XMLStreamReader.ENTITY_REFERENCE:
      b.append(xmlr.getLocalName() + "=");
      if (xmlr.hasText())
        b.append("[" + xmlr.getText() + "]");
      break;
    case XMLStreamReader.START_DOCUMENT:
      b.append("<?xml");
      b.append(" version="" + xmlr.getVersion() + """);
      b.append(" encoding="" + xmlr.getCharacterEncodingScheme() + """);
      if (xmlr.isStandalone())
        b.append(" standalone="yes"");
      else
        b.append(" standalone="no"");
      b.append("?>");
      break;
    }
    b.append("]");
    return b.toString();
  }
  private static void printName(String prefix, String uri, String localName, StringBuffer b) {
    if (uri != null && !("".equals(uri)))
      b.append("["" + uri + ""]:");
    if (prefix != null && !("".equals(prefix)))
      b.append(prefix + ":");
    if (localName != null)
      b.append(localName);
  }
  private static void printName(XMLStreamReader xmlr, StringBuffer b) {
    if (xmlr.hasName()) {
      String prefix = xmlr.getPrefix();
      String uri = xmlr.getNamespaceURI();
      String localName = xmlr.getLocalName();
      printName(prefix, uri, localName, b);
    }
  }
  public static String getName(int eventType) {
    switch (eventType) {
    case XMLStreamReader.START_ELEMENT:
      return "START_ELEMENT";
    case XMLStreamReader.END_ELEMENT:
      return "END_ELEMENT";
    case XMLStreamReader.PROCESSING_INSTRUCTION:
      return "PROCESSING_INSTRUCTION";
    case XMLStreamReader.CHARACTERS:
      return "CHARACTERS";
    case XMLStreamReader.SPACE:
      return "SPACE";
    case XMLStreamReader.ruMENT:
      return "COMMENT";
    case XMLStreamReader.START_DOCUMENT:
      return "START_DOCUMENT";
    case XMLStreamReader.END_DOCUMENT:
      return "END_DOCUMENT";
    case XMLStreamReader.ENTITY_REFERENCE:
      return "ENTITY_REFERENCE";
    case XMLStreamReader.ATTRIBUTE:
      return "ATTRIBUTE";
    case XMLStreamReader.DTD:
      return "DTD";
    case XMLStreamReader.CDATA:
      return "CDATA";
    case XMLStreamReader.NAMESPACE:
      return "NAMESPACE";
    }
    return "UNKNOWN_EVENT_TYPE";
  }
  public static int getType(String val) {
    if (val.equals("START_ELEMENT"))
      return XMLStreamReader.START_ELEMENT;
    if (val.equals("SPACE"))
      return XMLStreamReader.SPACE;
    if (val.equals("END_ELEMENT"))
      return XMLStreamReader.END_ELEMENT;
    if (val.equals("PROCESSING_INSTRUCTION"))
      return XMLStreamReader.PROCESSING_INSTRUCTION;
    if (val.equals("CHARACTERS"))
      return XMLStreamReader.CHARACTERS;
    if (val.equals("COMMENT"))
      return XMLStreamReader.ruMENT;
    if (val.equals("START_DOCUMENT"))
      return XMLStreamReader.START_DOCUMENT;
    if (val.equals("END_DOCUMENT"))
      return XMLStreamReader.END_DOCUMENT;
    if (val.equals("ATTRIBUTE"))
      return XMLStreamReader.ATTRIBUTE;
    if (val.equals("DTD"))
      return XMLStreamReader.DTD;
    if (val.equals("CDATA"))
      return XMLStreamReader.CDATA;
    if (val.equals("NAMESPACE"))
      return XMLStreamReader.NAMESPACE;
    return -1;
  }
}

Event count

  
import java.io.File;
import java.io.FileInputStream;
import javax.xml.stream.EventFilter;
import javax.xml.stream.StreamFilter;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;
public class MainClass {
  public static void main(String[] args) throws Exception {
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    XMLStreamReader reader = inputFactory.createXMLStreamReader(new FileInputStream(new File("test.xml")));
    System.out.println(countEvents(reader));
    reader = inputFactory.createXMLStreamReader(new FileInputStream(new File("test.xml")));
    StreamFilter filter = new ElementOnlyFilter();
    reader = inputFactory.createFilteredReader(reader, filter);
    System.out.println(countEvents(reader));
  }
  private static int countEvents(XMLStreamReader reader) throws XMLStreamException {
    int counter = 1;
    while (reader.hasNext()) {
      reader.next();
      counter++;
    }
    return counter;
  }
}
class ElementOnlyFilter implements EventFilter, StreamFilter {
  public boolean accept(XMLEvent event) {
    return accept(event.getEventType());
  }
  public boolean accept(XMLStreamReader reader) {
    return accept(reader.getEventType());
  }
  private boolean accept(int eventType) {
    return eventType == XMLStreamConstants.START_ELEMENT
        || eventType == XMLStreamConstants.END_ELEMENT;
  }
}

Get event type from XMLStreamReader

  
import java.io.File;
import java.io.FileInputStream;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
public class MainClass {
  public static void main(String[] args) throws Exception {
    File file = new File("test.xml");
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    XMLStreamReader reader = inputFactory.createXMLStreamReader(new FileInputStream(file));
    while (reader.getEventType() == 6)
      reader.next();
    int eventTypeID = reader.next();
    System.out.println("Hello " + reader.getText());
  }
}

Get next from XMLStreamReader

  
import java.io.File;
import java.io.FileInputStream;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
public class MainClass {
  public static void main(String[] args) throws Exception {
    File file = new File("test.xml");
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    XMLStreamReader reader = inputFactory.createXMLStreamReader(new FileInputStream(file));
    while (reader.getEventType() == 6)
      reader.next();
    int eventTypeID = reader.next();
    System.out.println("Hello " + reader.getText());
  }
}

Get next tag from XMLStreamReader

  
import java.io.File;
import java.io.FileInputStream;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
public class MainClass {
  public static void main(String[] args) throws Exception {
    File file = new File("text.xml");
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    XMLStreamReader reader = inputFactory.createXMLStreamReader(new FileInputStream(file));
    int eventTypeID = reader.nextTag();
    eventTypeID = reader.nextTag();
    eventTypeID = reader.next();
    System.out.println("Hello " + reader.getText());
  }
}

Read Xml from StreamSource

 
/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
import java.io.IOException;
import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.stream.StreamSource;
import org.w3c.dom.Document;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
/**
 * Few simple utils to read DOM. This is originally from the Jakarta Commons
 * Modeler.
 * 
 * @author Costin Manolache
 */
public class Utils {
  public static Document readXml(StreamSource is) throws SAXException, IOException,
      ParserConfigurationException {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setValidating(false);
    dbf.setIgnoringComments(false);
    dbf.setIgnoringElementContentWhitespace(true);
    dbf.setNamespaceAware(true);
    // dbf.setCoalescing(true);
    // dbf.setExpandEntityReferences(true);
    DocumentBuilder db = null;
    db = dbf.newDocumentBuilder();
    db.setEntityResolver(new NullResolver());
    // db.setErrorHandler( new MyErrorHandler());
    InputSource is2 = new InputSource();
    is2.setSystemId(is.getSystemId());
    is2.setByteStream(is.getInputStream());
    is2.setCharacterStream(is.getReader());
    return db.parse(is2);
  }
}
class NullResolver implements EntityResolver {
  public InputSource resolveEntity(String publicId, String systemId) throws SAXException,
      IOException {
    return new InputSource(new StringReader(""));
  }
}

XML stream transform

 
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 * 
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License. You can obtain
 * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
 * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
 * Sun designates this particular file as subject to the "Classpath" exception
 * as provided by Sun in the GPL Version 2 section of the License file that
 * accompanied this code.  If applicable, add the following below the License
 * Header, with the fields enclosed by brackets [] replaced by your own
 * identifying information: "Portions Copyrighted [year]
 * [name of copyright owner]"
 * 
 * Contributor(s):
 * 
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don"t indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.OutputStream;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
/**
 * Padmaja Vedula
 */
public class StreamSrcStAXRst {
  static String fileName;
  public static void main(String[] args) {
    if (args.length != 3) {
      System.out.println("Usage: java " + StreamSrcStAXRst.class.getName()
          + " <XML that needs to be transformed>" + " <XSLT file>" + " <Output file>");
      System.exit(1);
    }
    try {
      transform(args);
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
  }
  private static void transform(String[] args) throws Exception {
    fileName = args[2].toString();
    FileInputStream xmlIn = new FileInputStream(args[0]);
    FileInputStream xsltIn = new FileInputStream(args[1]);
    FileOutputStream out = new FileOutputStream(args[2]);
    transform(xmlIn, xsltIn, out);
  }
  public static void transform(InputStream xmlIn, InputStream xsltIn, OutputStream out)
      throws Exception {
    javax.xml.transform.Source xmlSource = new javax.xml.transform.stream.StreamSource(xmlIn);
    javax.xml.transform.Result xmlResult = new javax.xml.transform.stax.StAXResult(XMLOutputFactory
        .newInstance().createXMLStreamWriter(new FileWriter(fileName)));
    javax.xml.transform.Source xsltSource = new javax.xml.transform.stream.StreamSource(xsltIn);
    javax.xml.transform.Source source = new javax.xml.transform.stream.StreamSource(xmlIn);
    // create an instance of TransformerFactory
    javax.xml.transform.TransformerFactory transFact = javax.xml.transform.TransformerFactory
        .newInstance();
    transFact.setAttribute("debug", new String("true"));
    transFact.setAttribute("translet-name", new String("suresh"));
    transFact.setAttribute("generate-translet", new String("true"));
    transFact.setAttribute("jar-name", new String("transletjar"));
    javax.xml.transform.Transformer trans = transFact.newTransformer(xsltSource);
    trans.transform(source, xmlResult);
  }
  private static XMLEventReader getXMLEventReader(String filename) {
    XMLInputFactory xmlif = null;
    XMLEventReader xmlr = null;
    try {
      xmlif = XMLInputFactory.newInstance();
      xmlif.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, Boolean.TRUE);
      xmlif.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE);
      xmlif.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);
      xmlif.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
      FileInputStream fis = new FileInputStream(filename);
      xmlr = xmlif.createXMLEventReader(filename, fis);
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    return xmlr;
  }
}