в 18:01, 31 мая 2010

2010-05-31T18:01:43Z

Новая страница

== Catch XMLStreamException ==



<source lang="java">

import java.io.FileInputStream;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;

class StaxCursorTest {
public static void main(String[] args) throws Exception {
String filename = "yourXML.xml";
XMLInputFactory xmlif = null;
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_COALESCING, Boolean.FALSE);
try {
XMLStreamReader xmlr = xmlif.createXMLStreamReader(filename,new FileInputStream(filename));
int eventType = xmlr.getEventType();
printStartDocument(xmlr);
while (xmlr.hasNext()) {
eventType = xmlr.next();
printStartElement(xmlr);
printEndElement(xmlr);
printText(xmlr);
printPIData(xmlr);
printComment(xmlr);
}
} catch (XMLStreamException ex) {
System.out.println(ex.getMessage());
if (ex.getNestedException() != null) {
ex.getNestedException()
.printStackTrace();
}
}
}
public static final String getEventTypeString(int eventType) {
switch (eventType) {
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.ruMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE , " + eventType;
}
private static void printEventType(int eventType) {
System.out.println("EVENT TYPE(" + eventType + ") = " + getEventTypeString(eventType));
}
private static void printStartDocument(XMLStreamReader xmlr) {
if (xmlr.START_DOCUMENT == xmlr.getEventType()) {
System.out.println(
"<?xml version=\"" + xmlr.getVersion() + "\""
+ " encoding=\"" + xmlr.getCharacterEncodingScheme() + "\""
+ "?>");
}
}
private static void printComment(XMLStreamReader xmlr) {
if (xmlr.getEventType() == xmlr.ruMENT) {
System.out.print("");
}
}
private static void printText(XMLStreamReader xmlr) {
if (xmlr.hasText()) {
System.out.print(xmlr.getText());
}
}
private static void printPIData(XMLStreamReader xmlr) {
if (xmlr.getEventType() == XMLEvent.PROCESSING_INSTRUCTION) {
System.out.print(
"<?" + xmlr.getPITarget() + " " + xmlr.getPIData() + "?>");
}
}
private static void printStartElement(XMLStreamReader xmlr) {
if (xmlr.isStartElement()) {
System.out.print("<" + xmlr.getName().toString());
printAttributes(xmlr);
System.out.print(</codeTitle><cnTitle></cnTitle><codeKeywords></codeKeywords><codeComments></codeComments>");
}
}
private static void printEndElement(XMLStreamReader xmlr) {
if (xmlr.isEndElement()) {
System.out.print("</" + xmlr.getName().toString() + </codeTitle><cnTitle></cnTitle><codeKeywords></codeKeywords><codeComments></codeComments>");
}
}
private static void printAttributes(XMLStreamReader xmlr) {
int count = xmlr.getAttributeCount();
if (count > 0) {
for (int i = 0; i < count; i++) {
System.out.print(" ");
System.out.print(xmlr.getAttributeName(i).toString());
System.out.print("=");
System.out.print("\"");
System.out.print(xmlr.getAttributeValue(i));
System.out.print("\"");
}
}
count = xmlr.getNamespaceCount();
if (count > 0) {
for (int i = 0; i < count; i++) {
System.out.print(" ");
System.out.print("xmlns");
if (xmlr.getNamespacePrefix(i) != null) {
System.out.print(":" + xmlr.getNamespacePrefix(i));
}
System.out.print("=");
System.out.print("\"");
System.out.print(xmlr.getNamespaceURI(i));
System.out.print("\"");
}
}
}
}
</source>



== Get information as an XMLEvent object when using cursor approach ==



<source lang="java">

import java.io.FileInputStream;
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.StartElement;
import javax.xml.stream.events.XMLEvent;
import javax.xml.stream.util.XMLEventAllocator;
import com.sun.xml.internal.stream.events.XMLEventAllocatorImpl;

class CursorApproachEventObject {
static XMLEventAllocator allocator = null;
public static void main(String[] args) throws Exception {
String filename = "yourXML.xml";
XMLInputFactory xmlif = XMLInputFactory.newInstance();
xmlif.setEventAllocator(new XMLEventAllocatorImpl());
allocator = xmlif.getEventAllocator();
XMLStreamReader xmlr = xmlif.createXMLStreamReader(filename,new FileInputStream(filename));
int eventType = xmlr.getEventType();
while (xmlr.hasNext()) {
eventType = xmlr.next();
if ((eventType == XMLStreamConstants.START_ELEMENT)&& xmlr.getLocalName().equals("Book")) {
StartElement event = getXMLEvent(xmlr).asStartElement();
System.out.println("EVENT: " + event.toString());
}
}
}
private static XMLEvent getXMLEvent(XMLStreamReader reader)
throws XMLStreamException {
return allocator.allocate(reader);
}
}
</source>



== STAX cursor ==



<source lang="java">

import java.io.FileInputStream;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;

class StaxCursorTest {
public static void main(String[] args) throws Exception {
String filename = "yourXML.xml";
XMLInputFactory xmlif = null;
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_COALESCING, Boolean.FALSE);
try {
XMLStreamReader xmlr = xmlif.createXMLStreamReader(filename,new FileInputStream(filename));
int eventType = xmlr.getEventType();
printStartDocument(xmlr);
while (xmlr.hasNext()) {
eventType = xmlr.next();
printStartElement(xmlr);
printEndElement(xmlr);
printText(xmlr);
printPIData(xmlr);
printComment(xmlr);
}
} catch (XMLStreamException ex) {
System.out.println(ex.getMessage());
if (ex.getNestedException() != null) {
ex.getNestedException()
.printStackTrace();
}
}
}
public static final String getEventTypeString(int eventType) {
switch (eventType) {
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.ruMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE , " + eventType;
}
private static void printEventType(int eventType) {
System.out.println("EVENT TYPE(" + eventType + ") = " + getEventTypeString(eventType));
}
private static void printStartDocument(XMLStreamReader xmlr) {
if (xmlr.START_DOCUMENT == xmlr.getEventType()) {
System.out.println(
"<?xml version=\"" + xmlr.getVersion() + "\""
+ " encoding=\"" + xmlr.getCharacterEncodingScheme() + "\""
+ "?>");
}
}
private static void printComment(XMLStreamReader xmlr) {
if (xmlr.getEventType() == xmlr.ruMENT) {
System.out.print("");
}
}
private static void printText(XMLStreamReader xmlr) {
if (xmlr.hasText()) {
System.out.print(xmlr.getText());
}
}
private static void printPIData(XMLStreamReader xmlr) {
if (xmlr.getEventType() == XMLEvent.PROCESSING_INSTRUCTION) {
System.out.print(
"<?" + xmlr.getPITarget() + " " + xmlr.getPIData() + "?>");
}
}
private static void printStartElement(XMLStreamReader xmlr) {
if (xmlr.isStartElement()) {
System.out.print("<" + xmlr.getName().toString());
printAttributes(xmlr);
System.out.print(</codeTitle><cnTitle></cnTitle><codeKeywords></codeKeywords><codeComments></codeComments>");
}
}
private static void printEndElement(XMLStreamReader xmlr) {
if (xmlr.isEndElement()) {
System.out.print("</" + xmlr.getName().toString() + </codeTitle><cnTitle></cnTitle><codeKeywords></codeKeywords><codeComments></codeComments>");
}
}
private static void printAttributes(XMLStreamReader xmlr) {
int count = xmlr.getAttributeCount();
if (count > 0) {
for (int i = 0; i < count; i++) {
System.out.print(" ");
System.out.print(xmlr.getAttributeName(i).toString());
System.out.print("=");
System.out.print("\"");
System.out.print(xmlr.getAttributeValue(i));
System.out.print("\"");
}
}
count = xmlr.getNamespaceCount();
if (count > 0) {
for (int i = 0; i < count; i++) {
System.out.print(" ");
System.out.print("xmlns");
if (xmlr.getNamespacePrefix(i) != null) {
System.out.print(":" + xmlr.getNamespacePrefix(i));
}
System.out.print("=");
System.out.print("\"");
System.out.print(xmlr.getNamespaceURI(i));
System.out.print("\"");
}
}
}
}
</source>



== StAX is a technology similar to SAX. ==



<source lang="java">

import java.io.FileReader;
import java.io.Reader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamReader;
public class XMLStreamReaderDemo {
public static void main(String[] args) throws Exception {
XMLInputFactory factory = XMLInputFactory.newInstance();
Reader fileReader = new FileReader("source.xml");
XMLStreamReader reader = factory.createXMLStreamReader(fileReader);
while (reader.hasNext()) {
process(reader);
reader.next();
}
}
private static void process(XMLStreamReader reader) {
int eventType = reader.getEventType();
switch (eventType) {
case XMLStreamConstants.START_ELEMENT:
System.out.println("Start element: " + reader.getLocalName());
int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
String name = reader.getAttributeLocalName(i);
String value = reader.getAttributeValue(i);
System.out.println("\tAttribute name/value: " + name + "/" + value);
}
break;
case XMLStreamConstants.END_ELEMENT:
System.out.println("End element: " + reader.getLocalName());
break;
case XMLStreamConstants.CHARACTERS:
System.out.println("Text: " + reader.getText());
break;
default:
break;
}
}
}
</source>



== Stax XML cursor read ==



<source lang="java">

import java.io.FileReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;
public class STAXCursorRead {
public static void main(String args[]) throws Exception {
XMLInputFactory xmlif = XMLInputFactory.newInstance();
XMLStreamReader xmlsr = xmlif.createXMLStreamReader(new FileReader("points.xml"));
int eventType;
while (xmlsr.hasNext()) {
eventType = xmlsr.next();
switch (eventType) {
case XMLEvent.START_ELEMENT:
System.out.println(xmlsr.getName());
break;
case XMLEvent.CHARACTERS:
System.out.println(xmlsr.getText());
break;
default:
break;
}
}
}
}
</source>



== Stax XML iterator read ==



<source lang="java">

import java.io.FileReader;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.events.XMLEvent;
public class STAXIteratorRead {
public static void main(String args[]) throws Exception {
XMLInputFactory xmlif = XMLInputFactory.newInstance();
XMLEventReader xmler = xmlif.createXMLEventReader(new FileReader("yourFile.xml"));
XMLEvent event;
while (xmler.hasNext()) {
event = xmler.nextEvent();
if (event.isStartElement()) {
System.out.println(event.asStartElement().getName());
} else if (event.isCharacters()) {
System.out.println(event.asCharacters().getData());
}
}
}
}
</source>



== Streaming XML Parser: Stax Event ==



<source lang="java">

import java.io.FileInputStream;
import javax.xml.stream.*;
import javax.xml.stream.events.*;
import javax.xml.namespace.QName;

public class EventParse {
public static void main(String[] args) throws Exception {
String filename = "yourXML.xml";
XMLInputFactory factory = XMLInputFactory.newInstance();
System.out.println("FACTORY: " + factory);
XMLEventReader r = factory.createXMLEventReader(filename,new FileInputStream(filename));
while (r.hasNext()) {
XMLEvent e = r.nextEvent();
System.out.println(e.toString());
}
}
public static final String getEventTypeString(int eventType) {
switch (eventType) {
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.ruMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE " + "," + eventType;
}
}
</source>



== Streaming XML Parser: Stax Event Filter ==



<source lang="java">

import java.io.*;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import javax.xml.stream.*;
import javax.xml.stream.events.*;
import java.util.Date;
import javax.xml.namespace.QName;

public class MyStreamFilter implements javax.xml.stream.StreamFilter {
public static void main(String[] args) throws Exception {
String filename = "yourXML.xml";
XMLInputFactory xmlif = null;
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);
System.out.println("FACTORY: " + xmlif);
System.out.println("filename = " + filename);
FileInputStream fis = new FileInputStream(filename);
XMLStreamReader xmlr = xmlif.createFilteredReader(xmlif.createXMLStreamReader(fis),new MyStreamFilter());
int eventType = xmlr.getEventType();
printEventType(eventType);
while (xmlr.hasNext()) {
eventType = xmlr.next();
printEventType(eventType);
printName(xmlr, eventType);
printText(xmlr);
if (xmlr.isStartElement()) {
printAttributes(xmlr);
}
printPIData(xmlr);
}
}
public static final String getEventTypeString(int eventType) {
switch (eventType) {
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.ruMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
}
return "UNKNOWN_EVENT_TYPE";
}
private static void printEventType(int eventType) {
System.out.print("EVENT TYPE(" + eventType + "):");
System.out.println(getEventTypeString(eventType));
}
private static void printName(
XMLStreamReader xmlr,
int eventType) {
if (xmlr.hasName()) {
System.out.println("HAS NAME: " + xmlr.getLocalName());
} else {
System.out.println("HAS NO NAME");
}
}
private static void printText(XMLStreamReader xmlr) {
if (xmlr.hasText()) {
System.out.println("HAS TEXT: " + xmlr.getText());
} else {
System.out.println("HAS NO TEXT");
}
}
private static void printPIData(XMLStreamReader xmlr) {
if (xmlr.getEventType() == XMLEvent.PROCESSING_INSTRUCTION) {
System.out.println(" PI target = " + xmlr.getPITarget());
System.out.println(" PI Data = " + xmlr.getPIData());
}
}
private static void printAttributes(XMLStreamReader xmlr) {
if (xmlr.getAttributeCount() > 0) {
System.out.println("\nHAS ATTRIBUTES: ");
int count = xmlr.getAttributeCount();
for (int i = 0; i < count; i++) {
QName name = xmlr.getAttributeName(i);
String namespace = xmlr.getAttributeNamespace(i);
String type = xmlr.getAttributeType(i);
String prefix = xmlr.getAttributePrefix(i);
String value = xmlr.getAttributeValue(i);
System.out.println("ATTRIBUTE-PREFIX: " + prefix);
System.out.println("ATTRIBUTE-NAMESP: " + namespace);
System.out.println("ATTRIBUTE-NAME: " + name.toString());
System.out.println("ATTRIBUTE-VALUE: " + value);
System.out.println("ATTRIBUTE-TYPE: " + type);
}
} else {
System.out.println("HAS NO ATTRIBUTES");
}
}
public boolean accept(XMLStreamReader reader) {
if (!reader.isStartElement() && !reader.isEndElement()) {
return false;
} else {
return true;
}
}
}
</source>



== Using XMLEventFactory to create xml document ==



<source lang="java">

import java.util.Arrays;
import java.util.List;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndDocument;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
public class XMLEventWriterDemo {
public static void main(String[] args) throws Exception {
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
XMLEventWriter writer = outputFactory.createXMLEventWriter(System.out);
XMLEventFactory xmlEventFactory = XMLEventFactory.newInstance();
StartDocument startDocument = xmlEventFactory.createStartDocument("UTF-8", "1.0");
writer.add(startDocument);
StartElement startElement = xmlEventFactory.createStartElement("", "", "My-list");
writer.add(startElement);
Attribute attribute = xmlEventFactory.createAttribute("version", "1");
List attributeList = Arrays.asList(attribute);
List nsList = Arrays.asList();
StartElement startElement2 = xmlEventFactory.createStartElement("", "", "Item",
attributeList.iterator(), nsList.iterator());
writer.add(startElement2);
StartElement codeSE = xmlEventFactory.createStartElement("", "", "code");
writer.add(codeSE);
Characters codeChars = xmlEventFactory.createCharacters("I001");
writer.add(codeChars);
EndElement codeEE = xmlEventFactory.createEndElement("", "", "code");
writer.add(codeEE);
StartElement nameSE = xmlEventFactory.createStartElement(" ", " ", "name");
writer.add(nameSE);
Characters nameChars = xmlEventFactory.createCharacters("a name");
writer.add(nameChars);
EndElement nameEE = xmlEventFactory.createEndElement("", "", "name");
writer.add(nameEE);
StartElement contactSE = xmlEventFactory.createStartElement("", "", "contact");
writer.add(contactSE);
Characters contactChars = xmlEventFactory.createCharacters("another name");
writer.add(contactChars);
EndElement contactEE = xmlEventFactory.createEndElement("", "", "contact");
writer.add(contactEE);
EndDocument ed = xmlEventFactory.createEndDocument();
writer.add(ed);
writer.flush();
writer.close();
}
}
</source>



== Using XMLStreamWriter to create XML file ==



<source lang="java">

import java.io.FileWriter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamWriter;
import java.util.Date;
import javax.xml.namespace.QName;
public class CursorWriter {
public static void main(String[] args) throws Exception {
String fileName = "yourXML.xml";
XMLOutputFactory xof = XMLOutputFactory.newInstance();
XMLStreamWriter xtw = null;
xtw = xof.createXMLStreamWriter(new FileWriter(fileName));
xtw.writeComment("all elements here are explicitly in the HTML namespace");
xtw.writeStartDocument("utf-8", "1.0");
xtw.setPrefix("html", "http://www.w3.org/TR/REC-html40");
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "html");
xtw.writeNamespace("html", "http://www.w3.org/TR/REC-html40");
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "head");
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "title");
xtw.writeCharacters("character");
xtw.writeEndElement();
xtw.writeEndElement();
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "body");
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "p");
xtw.writeCharacters("another character");
xtw.writeStartElement("http://www.w3.org/TR/REC-html40", "a");
xtw.writeAttribute("href", "http://www.jexp.ru");
xtw.writeCharacters("here");
xtw.writeEndElement();
xtw.writeEndElement();
xtw.writeEndElement();
xtw.writeEndElement();
xtw.writeEndDocument();
xtw.flush();
xtw.close();
System.out.println("Done");
}
}
</source>



== XMLEventReader and XMLEventWriter for Stax XML parser ==



<source lang="java">

import java.util.Calendar;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.XMLEvent;

class StaxEvent {
XMLEventFactory m_eventFactory = XMLEventFactory.newInstance();
public static void main(String[] args) throws Exception {
StaxEvent ms = new StaxEvent();
XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(new java.io.FileInputStream("yourXML.xml"));
XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(System.out);
while (reader.hasNext()) {
XMLEvent event = (XMLEvent) reader.next();
if (event.getEventType() == event.CHARACTERS) {
writer.add(ms.getNewCharactersEvent(event.asCharacters()));
} else {
writer.add(event);
}
}
writer.flush();
}
private Characters getNewCharactersEvent(Characters event) {
if (event.getData().equalsIgnoreCase("Name1")) {
return m_eventFactory.createCharacters(Calendar.getInstance().getTime().toString());
} else {
return event;
}
}
}
</source>



== XMLEventReader Demo ==



<source lang="java">

import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class XMLEventReaderDemo {
public static void main(String[] args) throws Exception {
XMLInputFactory factory = XMLInputFactory.newInstance();
Reader fileReader = new FileReader("Source.xml");
XMLEventReader reader = factory.createXMLEventReader(fileReader);
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
if (event.isStartElement()) {
StartElement element = (StartElement) event;
System.out.println("Start Element: " + element.getName());
Iterator iterator = element.getAttributes();
while (iterator.hasNext()) {
Attribute attribute = (Attribute) iterator.next();
QName name = attribute.getName();
String value = attribute.getValue();
System.out.println("Attribute name/value: " + name + "/" + value);
}
}
if (event.isEndElement()) {
EndElement element = (EndElement) event;
System.out.println("End element:" + element.getName());
}
if (event.isCharacters()) {
Characters characters = (Characters) event;
System.out.println("Text: " + characters.getData());
}
}
}
}
</source>



== XMLStreamWriter Demo ==



<source lang="java">

import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamWriter;
public class XMLStreamWriterDemo {
public static void main(String[] args) throws Exception {
XMLOutputFactory factory = XMLOutputFactory.newInstance();
XMLStreamWriter writer = factory.createXMLStreamWriter(System.out);
writer.writeStartDocument("1.0");
writer.writeStartElement("catalog");
writer.writeStartElement("book");
writer.writeAttribute("id", "1");
writer.writeStartElement("code");
writer.writeCharacters("I01");
writer.writeEndElement();
writer.writeStartElement("title");
writer.writeCharacters("This is the title");
writer.writeEndElement();
writer.writeStartElement("price");
writer.writeCharacters("$2.95");
writer.writeEndElement();
writer.writeEndDocument();
writer.flush();
writer.close();
}
}
</source>

Java/JDK 6/Streaming XML Parser - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010

← Предыдущая	Версия 06:12, 1 июня 2010
(нет различий)