private synchronized XMLEventReader createXmlEventReader(InputStream xmlStream) throws XMLStreamException { return XML_INPUT_FACTORY.createXMLEventReader( xmlStream ); }
private List<XMLEvent> readEvents(String xml) throws XMLStreamException { XMLEventReader reader = this.inputFactory.createXMLEventReader(new StringReader(xml)); List<XMLEvent> events = new ArrayList<>(); while (reader.hasNext()) { events.add(reader.nextEvent()); } return events; }
@Override protected AbstractStaxXMLReader createStaxXmlReader(InputStream inputStream) throws XMLStreamException { return new StaxEventXMLReader(inputFactory.createXMLEventReader(inputStream)); }
@Before public void createStreamReader() throws Exception { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML)); streamReader = new XMLEventStreamReader(eventReader); }
private static StaxUnmarshallerContext payloadUnmarshaller(Message message) throws XMLStreamException { InputStream payloadStream = new ByteArrayInputStream(message.getPayload()); XMLEventReader xmlEventReader = XmlUtils.getXmlInputFactory().createXMLEventReader(payloadStream); return new StaxUnmarshallerContext(xmlEventReader); } }
@Test public void partial() throws Exception { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(CONTENT)); eventReader.nextTag(); // skip to root StaxEventXMLReader xmlReader = new StaxEventXMLReader(eventReader); ContentHandler contentHandler = mock(ContentHandler.class); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource()); verify(contentHandler).startDocument(); verify(contentHandler).startElement(eq("http://springframework.org/spring-ws"), eq("child"), eq("child"), any(Attributes.class)); verify(contentHandler).endElement("http://springframework.org/spring-ws", "child", "child"); verify(contentHandler).endDocument(); }
protected XMLEventReader createReader(InputStream stream, Origin origin) { try { // create a standard StAX reader final XMLEventReader staxReader = staxFactory().createXMLEventReader( stream ); // and wrap it in a buffered reader (keeping 100 element sized buffer) return new BufferedXMLEventReader( staxReader, 100 ); } catch ( XMLStreamException e ) { throw new MappingException( "Unable to create stax reader", e, origin ); } }
protected XMLEventReader createReader(Source source, Origin origin) { try { // create a standard StAX reader final XMLEventReader staxReader = staxFactory().createXMLEventReader( source ); // and wrap it in a buffered reader (keeping 100 element sized buffer) return new BufferedXMLEventReader( staxReader, 100 ); } catch ( XMLStreamException e ) { throw new MappingException( "Unable to create stax reader", e, origin ); } }
XMLEventFactory eventFactory = XMLEventFactory.newInstance(); XMLEvent dtd = eventFactory .createDTD("<!DOCTYPE Employee SYSTEM \"xmlValidate.dtd\">"); XMLInputFactory inFactory = XMLInputFactory.newInstance(); XMLOutputFactory outFactory = XMLOutputFactory.newInstance(); XMLEventReader reader = inFactory .createXMLEventReader(new StreamSource( "xmlValidate.xml")); reader = new DTDReplacer(reader, dtd); XMLEventWriter writer = outFactory.createXMLEventWriter(System.out); writer.add(reader); writer.flush(); // TODO error and proper stream handling
@Test public void eventReaderSourceToDOMResult() throws Exception { XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML)); StaxSource source = new StaxSource(eventReader); assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader()); assertNull("StreamReader returned", source.getXMLStreamReader()); Document expected = documentBuilder.parse(new InputSource(new StringReader(XML))); Document result = documentBuilder.newDocument(); transformer.transform(source, new DOMResult(result)); assertThat("Invalid result", result, isSimilarTo(expected)); } }
@Test public void unmarshalStaxSourceXmlEventReader() throws Exception { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(INPUT_STRING)); Source source = StaxUtils.createStaxSource(eventReader); Object flights = unmarshaller.unmarshal(source); testFlights(flights); }
@Test public void unmarshalJaxp14StaxSourceXmlEventReader() throws Exception { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(INPUT_STRING)); StAXSource source = new StAXSource(eventReader); Object flights = unmarshaller.unmarshal(source); testFlights(flights); }
@Test public void eventReaderSourceToStreamResult() throws Exception { XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML)); StaxSource source = new StaxSource(eventReader); assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader()); assertNull("StreamReader returned", source.getXMLStreamReader()); StringWriter writer = new StringWriter(); transformer.transform(source, new StreamResult(writer)); assertThat("Invalid result", writer.toString(), isSimilarTo(XML)); }
public JaxbCfgHibernateConfiguration unmarshal(InputStream stream, Origin origin) { try { XMLEventReader staxReader = staxFactory().createXMLEventReader( stream ); try { return unmarshal( staxReader, origin ); } finally { try { staxReader.close(); } catch ( Exception ignore ) { } } } catch ( XMLStreamException e ) { throw new HibernateException( "Unable to create stax reader", e ); } }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // on JDK 9 where XMLEventReader is Iterator<Object> public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<DataBuffer> flux = Flux.from(inputStream); if (this.useAalto) { AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent(); return flux.flatMap(aaltoMapper) .doFinally(signalType -> aaltoMapper.endOfInput()); } else { Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux); return singleBuffer. flatMapMany(dataBuffer -> { try { InputStream is = dataBuffer.asInputStream(); Iterator eventReader = inputFactory.createXMLEventReader(is); return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader) .doFinally(t -> DataBufferUtils.release(dataBuffer)); } catch (XMLStreamException ex) { return Mono.error(ex); } }); } }
/** * Setup the fragmentReader to read the test input. */ @Override protected void setUp() throws Exception { Resource input = new ByteArrayResource(xml.getBytes()); eventReader = StaxUtils.createXmlInputFactory().createXMLEventReader( input.getInputStream()); fragmentReader = new DefaultFragmentEventReader(eventReader); }
/** * Document with no fragments works OK. */ @Test public void testMoveCursorToNextFragmentOnMissing() throws XMLStreamException, FactoryConfigurationError, IOException { Resource resource = new ByteArrayResource(missingXml.getBytes()); XMLEventReader reader = StaxUtils.createXmlInputFactory().createXMLEventReader(resource.getInputStream()); assertFalse(source.moveCursorToNextFragment(reader)); }
/** * Empty document works OK. */ @Test public void testMoveCursorToNextFragmentOnEmpty() throws XMLStreamException, FactoryConfigurationError, IOException { Resource resource = new ByteArrayResource(emptyXml.getBytes()); XMLEventReader reader = StaxUtils.createXmlInputFactory().createXMLEventReader(resource.getInputStream()); assertFalse(source.moveCursorToNextFragment(reader)); }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // on JDK 9 where XMLEventReader is Iterator<Object> public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<DataBuffer> flux = Flux.from(inputStream); if (this.useAalto) { AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent(); return flux.flatMap(aaltoMapper) .doFinally(signalType -> aaltoMapper.endOfInput()); } else { Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux); return singleBuffer. flatMapMany(dataBuffer -> { try { InputStream is = dataBuffer.asInputStream(); Iterator eventReader = inputFactory.createXMLEventReader(is); return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader) .doFinally(t -> DataBufferUtils.release(dataBuffer)); } catch (XMLStreamException ex) { return Mono.error(ex); } }); } }
/** * Cursor is moved before beginning of next fragment. */ @Test public void testMoveCursorToNextFragment() throws XMLStreamException, FactoryConfigurationError, IOException { Resource resource = new ByteArrayResource(xml.getBytes()); XMLEventReader reader = StaxUtils.createXmlInputFactory().createXMLEventReader(resource.getInputStream()); final int EXPECTED_NUMBER_OF_FRAGMENTS = 2; for (int i = 0; i < EXPECTED_NUMBER_OF_FRAGMENTS; i++) { assertTrue(source.moveCursorToNextFragment(reader)); assertTrue(EventHelper.startElementName(reader.peek()).equals("fragment")); reader.nextEvent(); // move away from beginning of fragment } assertFalse(source.moveCursorToNextFragment(reader)); }