View Javadoc

1   /*
2    * Copyright 2006 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.springframework.ws.server.endpoint;
18  
19  import java.io.ByteArrayInputStream;
20  import java.io.ByteArrayOutputStream;
21  import javax.xml.namespace.NamespaceContext;
22  import javax.xml.stream.XMLEventFactory;
23  import javax.xml.stream.XMLEventReader;
24  import javax.xml.stream.XMLEventWriter;
25  import javax.xml.stream.XMLStreamException;
26  import javax.xml.stream.XMLStreamReader;
27  import javax.xml.stream.events.XMLEvent;
28  import javax.xml.stream.util.XMLEventConsumer;
29  import javax.xml.transform.Result;
30  import javax.xml.transform.Source;
31  import javax.xml.transform.TransformerException;
32  import javax.xml.transform.stream.StreamResult;
33  import javax.xml.transform.stream.StreamSource;
34  
35  import org.springframework.ws.WebServiceMessage;
36  import org.springframework.ws.context.MessageContext;
37  import org.springframework.xml.transform.TraxUtils;
38  
39  /**
40   * Abstract base class for endpoints that handle the message payload with event-based StAX. Allows subclasses to read
41   * the request with a <code>XMLEventReader</code>, and to create a response using a <code>XMLEventWriter</code>.
42   *
43   * @author Arjen Poutsma
44   * @see #invokeInternal(javax.xml.stream.XMLEventReader,javax.xml.stream.util.XMLEventConsumer,
45   *      javax.xml.stream.XMLEventFactory)
46   * @see XMLEventReader
47   * @see XMLEventWriter
48   * @since 1.0.0
49   */
50  public abstract class AbstractStaxEventPayloadEndpoint extends AbstractStaxPayloadEndpoint implements MessageEndpoint {
51  
52      private XMLEventFactory eventFactory;
53  
54      public final void invoke(MessageContext messageContext) throws Exception {
55          XMLEventReader eventReader = getEventReader(messageContext.getRequest().getPayloadSource());
56          XMLEventWriter streamWriter = new ResponseCreatingEventWriter(messageContext);
57          invokeInternal(eventReader, streamWriter, getEventFactory());
58          streamWriter.flush();
59      }
60  
61      /**
62       * Create a <code>XMLEventFactory</code> that this endpoint will use to create <code>XMLEvent</code>s. Can be
63       * overridden in subclasses, adding further initialization of the factory. The resulting
64       * <code>XMLEventFactory</code> is cached, so this method will only be called once.
65       *
66       * @return the created <code>XMLEventFactory</code>
67       */
68      protected XMLEventFactory createXmlEventFactory() {
69          return XMLEventFactory.newInstance();
70      }
71  
72      /** Returns an <code>XMLEventFactory</code> to read XML from. */
73      private XMLEventFactory getEventFactory() {
74          if (eventFactory == null) {
75              eventFactory = createXmlEventFactory();
76          }
77          return eventFactory;
78      }
79  
80      private XMLEventReader getEventReader(Source source) throws XMLStreamException, TransformerException {
81          if (source == null) {
82              return null;
83          }
84          XMLEventReader eventReader = null;
85          if (TraxUtils.isStaxSource(source)) {
86              eventReader = TraxUtils.getXMLEventReader(source);
87              if (eventReader == null) {
88                  XMLStreamReader streamReader = TraxUtils.getXMLStreamReader(source);
89                  if (streamReader != null) {
90                      try {
91                          eventReader = getInputFactory().createXMLEventReader(streamReader);
92                      }
93                      catch (XMLStreamException ex) {
94                          eventReader = null;
95                      }
96                  }
97              }
98          }
99          if (eventReader == null) {
100             try {
101                 eventReader = getInputFactory().createXMLEventReader(source);
102             }
103             catch (XMLStreamException ex) {
104                 eventReader = null;
105             }
106             catch (UnsupportedOperationException ex) {
107                 eventReader = null;
108             }
109         }
110         if (eventReader == null) {
111             // as a final resort, transform the source to a stream, and read from that
112             ByteArrayOutputStream os = new ByteArrayOutputStream();
113             transform(source, new StreamResult(os));
114             ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
115             eventReader = getInputFactory().createXMLEventReader(is);
116         }
117         return eventReader;
118     }
119 
120     private XMLEventWriter getEventWriter(Result result) {
121         XMLEventWriter eventWriter = null;
122         if (TraxUtils.isStaxResult(result)) {
123             eventWriter = TraxUtils.getXMLEventWriter(result);
124         }
125         if (eventWriter == null) {
126             try {
127                 eventWriter = getOutputFactory().createXMLEventWriter(result);
128             }
129             catch (XMLStreamException ex) {
130                 // ignore
131             }
132         }
133         return eventWriter;
134     }
135 
136     /**
137      * Template method. Subclasses must implement this. Offers the request payload as a <code>XMLEventReader</code>, and
138      * a <code>XMLEventWriter</code> to write the response payload to.
139      *
140      * @param eventReader  the reader to read the payload events from
141      * @param eventWriter  the writer to write payload events to
142      * @param eventFactory an <code>XMLEventFactory</code> that can be used to create events
143      */
144     protected abstract void invokeInternal(XMLEventReader eventReader,
145                                            XMLEventConsumer eventWriter,
146                                            XMLEventFactory eventFactory) throws Exception;
147 
148     /**
149      * Implementation of the <code>XMLEventWriter</code> interface that creates a response
150      * <code>WebServiceMessage</code> as soon as any method is called, thus lazily creating the response.
151      */
152     private class ResponseCreatingEventWriter implements XMLEventWriter {
153 
154         private XMLEventWriter eventWriter;
155 
156         private MessageContext messageContext;
157 
158         private ByteArrayOutputStream os;
159 
160         public ResponseCreatingEventWriter(MessageContext messageContext) {
161             this.messageContext = messageContext;
162         }
163 
164         public NamespaceContext getNamespaceContext() {
165             return eventWriter.getNamespaceContext();
166         }
167 
168         public void setNamespaceContext(NamespaceContext context) throws XMLStreamException {
169             createEventWriter();
170             eventWriter.setNamespaceContext(context);
171         }
172 
173         public void add(XMLEventReader reader) throws XMLStreamException {
174             createEventWriter();
175             while (reader.hasNext()) {
176                 add(reader.nextEvent());
177             }
178         }
179 
180         public void add(XMLEvent event) throws XMLStreamException {
181             createEventWriter();
182             eventWriter.add(event);
183             if (event.isEndDocument()) {
184                 if (os != null) {
185                     eventWriter.flush();
186                     // if we used an output stream cache, we have to transform it to the response again
187                     try {
188                         ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
189                         transform(new StreamSource(is), messageContext.getResponse().getPayloadResult());
190                     }
191                     catch (TransformerException ex) {
192                         throw new XMLStreamException(ex);
193                     }
194                 }
195             }
196         }
197 
198         public void close() throws XMLStreamException {
199             if (eventWriter != null) {
200                 eventWriter.close();
201             }
202         }
203 
204         public void flush() throws XMLStreamException {
205             if (eventWriter != null) {
206                 eventWriter.flush();
207             }
208         }
209 
210         public String getPrefix(String uri) throws XMLStreamException {
211             createEventWriter();
212             return eventWriter.getPrefix(uri);
213         }
214 
215         public void setDefaultNamespace(String uri) throws XMLStreamException {
216             createEventWriter();
217             eventWriter.setDefaultNamespace(uri);
218         }
219 
220         public void setPrefix(String prefix, String uri) throws XMLStreamException {
221             createEventWriter();
222             eventWriter.setPrefix(prefix, uri);
223         }
224 
225         private void createEventWriter() throws XMLStreamException {
226             if (eventWriter == null) {
227                 WebServiceMessage response = messageContext.getResponse();
228                 eventWriter = getEventWriter(response.getPayloadResult());
229                 if (eventWriter == null) {
230                     // as a final resort, use a stream, and transform that at endDocument()
231                     os = new ByteArrayOutputStream();
232                     eventWriter = getOutputFactory().createXMLEventWriter(os);
233                 }
234             }
235         }
236     }
237 }