All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.springframework.http.codec.xml.XmlEventDecoder Maven / Gradle / Ivy

Go to download

Spring Web

There is a newer version: 6.1.6
Show newest version
/*
 * Copyright 2002-2019 the original author or authors.
 *
 * 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.
 */

package org.springframework.http.codec.xml;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.XMLEvent;
import javax.xml.stream.util.XMLEventAllocator;

import com.fasterxml.aalto.AsyncByteBufferFeeder;
import com.fasterxml.aalto.AsyncXMLInputFactory;
import com.fasterxml.aalto.AsyncXMLStreamReader;
import com.fasterxml.aalto.evt.EventAllocatorImpl;
import com.fasterxml.aalto.stax.InputFactoryImpl;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import org.springframework.core.ResolvableType;
import org.springframework.core.codec.AbstractDecoder;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.ClassUtils;
import org.springframework.util.MimeType;
import org.springframework.util.MimeTypeUtils;
import org.springframework.util.xml.StaxUtils;

/**
 * Decodes a {@link DataBuffer} stream into a stream of {@link XMLEvent XMLEvents}.
 *
 * 
Given the following XML:
 *
 * 
 * <root>
 *     <child>foo</child>
 *     <child>bar</child>
 * </root>
 * 

 *
 * this decoder will produce a {@link Flux} with the following events:
 *
 * 
    
 * 
  1. {@link javax.xml.stream.events.StartDocument}
    2. 
 * 
  2. {@link javax.xml.stream.events.StartElement} {@code root}
    3. 
 * 
  3. {@link javax.xml.stream.events.StartElement} {@code child}
    4. 
 * 
  4. {@link javax.xml.stream.events.Characters} {@code foo}
    5. 
 * 
  5. {@link javax.xml.stream.events.EndElement} {@code child}
    6. 
 * 
  6. {@link javax.xml.stream.events.StartElement} {@code child}
    7. 
 * 
  7. {@link javax.xml.stream.events.Characters} {@code bar}
    8. 
 * 
  8. {@link javax.xml.stream.events.EndElement} {@code child}
    9. 
 * 
  9. {@link javax.xml.stream.events.EndElement} {@code root}
    10. 
 * 

 *
 * 
Note that this decoder is not registered by default but is used internally
 * by other decoders which are registered by default.
 *
 * @author Arjen Poutsma
 * @since 5.0
 */
public class XmlEventDecoder extends AbstractDecoder {

	private static final XMLInputFactory inputFactory = StaxUtils.createDefensiveInputFactory();

	private static final boolean aaltoPresent = ClassUtils.isPresent(
			"com.fasterxml.aalto.AsyncXMLStreamReader", XmlEventDecoder.class.getClassLoader());

	boolean useAalto = aaltoPresent;


	public XmlEventDecoder() {
		super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
	}


	@Override
	@SuppressWarnings({"rawtypes", "unchecked"})  // on JDK 9 where XMLEventReader is Iterator
	public Flux decode(Publisher inputStream, ResolvableType elementType,
			@Nullable MimeType mimeType, @Nullable Map hints) {

		Flux flux = Flux.from(inputStream);
		if (this.useAalto) {
			AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent();
			return flux.flatMap(aaltoMapper)
					.doFinally(signalType -> aaltoMapper.endOfInput());
		}
		else {
			Mono singleBuffer = DataBufferUtils.join(flux);
			return singleBuffer.
					flatMapMany(dataBuffer -> {
						try {
							InputStream is = dataBuffer.asInputStream();
							Iterator eventReader = inputFactory.createXMLEventReader(is);
							return Flux.fromIterable((Iterable) () -> eventReader)
									.doFinally(t -> DataBufferUtils.release(dataBuffer));
						}
						catch (XMLStreamException ex) {
							return Mono.error(ex);
						}
					});
		}
	}


	/*
	 * Separate static class to isolate Aalto dependency.
	 */
	private static class AaltoDataBufferToXmlEvent implements Function> {

		private static final AsyncXMLInputFactory inputFactory =
				StaxUtils.createDefensiveInputFactory(InputFactoryImpl::new);

		private final AsyncXMLStreamReader streamReader =
				inputFactory.createAsyncForByteBuffer();

		private final XMLEventAllocator eventAllocator = EventAllocatorImpl.getDefaultInstance();


		@Override
		public Publisher apply(DataBuffer dataBuffer) {
			try {
				this.streamReader.getInputFeeder().feedInput(dataBuffer.asByteBuffer());
				List events = new ArrayList<>();
				while (true) {
					if (this.streamReader.next() == AsyncXMLStreamReader.EVENT_INCOMPLETE) {
						// no more events with what currently has been fed to the reader
						break;
					}
					else {
						XMLEvent event = this.eventAllocator.allocate(this.streamReader);
						events.add(event);
						if (event.isEndDocument()) {
							break;
						}
					}
				}
				return Flux.fromIterable(events);
			}
			catch (XMLStreamException ex) {
				return Mono.error(ex);
			}
			finally {
				DataBufferUtils.release(dataBuffer);
			}
		}

		public void endOfInput() {
			this.streamReader.getInputFeeder().endOfInput();
		}
	}

}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy