| Methods Summary |
|---|
| private synchronized void | cacheMessage()
if(!readMessage){
message = codec.decode(reader);
readMessage = true;
}
|
| public com.sun.xml.ws.api.message.Message | copy()Creates a copy of a {@link Message}.
This method creates a new {@link Message} whose header/payload/attachments/properties
are identical to this {@link Message}. Once created, the created {@link Message}
and the original {@link Message} behaves independently --- adding header/
attachment to one {@link Message} doesn't affect another {@link Message}
at all.
This method does NOT consume a message.
To enable efficient copy operations, there's a few restrictions on
how copied message can be used.
- The original and the copy may not be
used concurrently by two threads (this allows two {@link Message}s
to share some internal resources, such as JAXB marshallers.)
Note that it's OK for the original and the copy to be processed
by two threads, as long as they are not concurrent.
- The copy has the same 'life scope'
as the original (this allows shallower copy, such as
JAXB beans wrapped in {@link JAXBMessage}.)
A 'life scope' of a message created during a message processing
in a pipeline is until a pipeline processes the next message.
A message cannot be kept beyond its life scope.
(This experimental design is to allow message objects to be reused
--- feedback appreciated.)
Design Rationale
Since a {@link Message} body is read-once, sometimes
(such as when you do fail-over, or WS-RM) you need to
create an idential copy of a {@link Message}.
The actual copy operation depends on the layout
of the data in memory, hence it's best to be done by
the {@link Message} implementation itself.
The restrictions placed on the use of copied {@link Message} can be
relaxed if necessary, but it will make the copy method more expensive.
if(!readMessage){
cacheMessage();
}
return message.copy();
|
| public com.sun.xml.ws.api.message.AttachmentSet | getAttachments()Gets the attachments of this message
(attachments live outside a message.)
if(!readMessage){
cacheMessage();
}
return message.getAttachments();
|
| public com.sun.xml.ws.api.pipe.StreamSOAPCodec | getCodec()
return codec;
|
| public com.sun.xml.ws.api.message.HeaderList | getHeaders()Gets all the headers of this message.
Implementation Note
{@link Message} implementation is allowed to defer
the construction of {@link HeaderList} object. So
if you only want to check for the existence of any header
element, use {@link #hasHeaders()}.
if(!readMessage){
cacheMessage();
}
return message.getHeaders();
|
| public java.lang.String | getPayloadLocalPart()Gets the local name of the payload element.
if(!readMessage){
cacheMessage();
}
return message.getPayloadLocalPart();
|
| public java.lang.String | getPayloadNamespaceURI()Gets the namespace URI of the payload element.
if(!readMessage){
cacheMessage();
}
return message.getPayloadNamespaceURI();
|
| public boolean | hasHeaders()Returns true if headers are present in the message.
if(!readMessage){
cacheMessage();
}
return message.hasHeaders();
|
| public boolean | hasPayload()Returns true if a {@link Message} has a payload.
A message without a payload is a SOAP message that looks like:
<![CDATA[
<S:Envelope>
<S:Header>
...
</S:Header>
<S:Body />
</S:Envelope>
]]>
if(!readMessage){
cacheMessage();
}
return message.hasPayload();
|
| public boolean | isFault()Returns true if this message is a fault.
Just a convenience method built on {@link #getPayloadNamespaceURI()}
and {@link #getPayloadLocalPart()}.
return false;
// if(!readMessage){
// cacheMessage();
// }
// return message.isFault();
|
| public boolean | isOneWay(com.sun.xml.ws.api.model.wsdl.WSDLPort port)Returns true if this message is a request message for a
one way operation according to the given WSDL. False otherwise.
This method is functionally equivalent as doing
{@code getOperation(port).getOperation().isOneWay()}
(with proper null check and all.) But this method
can sometimes work faster than that (for example,
on the client side when used with SEI.)
if(!readMessage){
cacheMessage();
}
return message.isOneWay(port);
|
| public void | print()
if(readMessage){
try {
message.readAsSOAPMessage().writeTo(java.lang.System.out);
return;
} catch (SOAPException ex) {
logger.log(java.util.logging.Level.SEVERE,
LogStringsMessages.WSSMSG_0003_ERROR_PRINT(),ex);
} catch (IOException ex) {
logger.log(java.util.logging.Level.SEVERE,
LogStringsMessages.WSSMSG_0003_ERROR_PRINT(),ex);
}
}
if(buffer == null){
buffer = new MutableXMLStreamBuffer();
buffer.createFromXMLStreamReader(reader);
reader = buffer.readAsXMLStreamReader();
}
XMLOutputFactory xof = XMLOutputFactory.newInstance();
buffer.writeToXMLStreamWriter(xof.createXMLStreamWriter(System.out));
|
| public javax.xml.soap.SOAPMessage | readAsSOAPMessage()Creates the equivalent {@link SOAPMessage} from this message.
This consumes the message.
if(!readMessage){
cacheMessage();
}
return message.readAsSOAPMessage();
|
| public javax.xml.transform.Source | readEnvelopeAsSource()Consumes this message including the envelope.
returns it as a {@link Source} object.
if(!readMessage){
cacheMessage();
}
return message.readEnvelopeAsSource();
|
| public javax.xml.stream.XMLStreamReader | readMessage()
if (!readMessage) {
return reader;
}
if (buffer == null) {
try {
buffer = new com.sun.xml.stream.buffer.MutableXMLStreamBuffer();
javax.xml.stream.XMLStreamWriter writer = buffer.createFromXMLStreamWriter();
message.writeTo(writer);
} catch (javax.xml.stream.XMLStreamException ex) {
logger.log(java.util.logging.Level.SEVERE,LogStringsMessages.WSSMSG_0001_PROBLEM_CACHING(),ex);
}
}
try {
reader = buffer.readAsXMLStreamReader();
return reader;
} catch (XMLStreamException ex) {
logger.log(java.util.logging.Level.SEVERE,LogStringsMessages.WSSMSG_0002_ERROR_READING_BUFFER(),ex);
}
return null;
|
| public javax.xml.stream.XMLStreamReader | readPayload()Reads the payload as a {@link XMLStreamReader}
This consumes the message.
if(!readMessage){
cacheMessage();
}
return message.readPayload();
|
| public T | readPayloadAsJAXB(javax.xml.bind.Unmarshaller unmarshaller)Reads the payload as a JAXB object by using the given unmarshaller.
This consumes the message.
if(!readMessage){
cacheMessage();
}
throw new UnsupportedOperationException();
|
| public T | readPayloadAsJAXB(com.sun.xml.bind.api.Bridge bridge)Reads the payload as a JAXB object according to the given {@link Bridge}.
This consumes the message.
if(!readMessage){
cacheMessage();
}
return message.readPayloadAsJAXB(bridge);
|
| public javax.xml.transform.Source | readPayloadAsSource()Returns the payload as a {@link Source} object.
This consumes the message.
if(!readMessage){
cacheMessage();
}
return message.readPayloadAsSource();
|
| public void | writePayloadTo(javax.xml.stream.XMLStreamWriter sw)Writes the payload to StAX.
This method writes just the payload of the message to the writer.
This consumes the message.
The implementation will not write
{@link XMLStreamWriter#writeStartDocument()}
nor
{@link XMLStreamWriter#writeEndDocument()}
If there's no payload, this method is no-op.
if(!readMessage){
cacheMessage();
}
message.writePayloadTo(sw);
|
| public void | writeTo(javax.xml.stream.XMLStreamWriter sw)Writes the whole SOAP message (but not attachments)
to the given writer.
This consumes the message.
if(!readMessage){
cacheMessage();
}
message.writeTo(sw);
|
| public void | writeTo(org.xml.sax.ContentHandler contentHandler, org.xml.sax.ErrorHandler errorHandler)Writes the whole SOAP envelope as SAX events.
This consumes the message.
if(!readMessage){
cacheMessage();
}
message.writeTo(contentHandler,errorHandler);
|
