1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
41
42
43
44
45
46
47
48
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
63
64
65
66
67
68 protected XMLEventFactory createXmlEventFactory() {
69 return XMLEventFactory.newInstance();
70 }
71
72
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
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
131 }
132 }
133 return eventWriter;
134 }
135
136
137
138
139
140
141
142
143
144 protected abstract void invokeInternal(XMLEventReader eventReader,
145 XMLEventConsumer eventWriter,
146 XMLEventFactory eventFactory) throws Exception;
147
148
149
150
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
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
231 os = new ByteArrayOutputStream();
232 eventWriter = getOutputFactory().createXMLEventWriter(os);
233 }
234 }
235 }
236 }
237 }