jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/message/jaxb/JAXBMessage.java@9c07ef4934dd

     1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package com.sun.xml.internal.ws.message.jaxb;

    28 import com.sun.istack.internal.FragmentContentHandler;

    29 import com.sun.xml.internal.stream.buffer.MutableXMLStreamBuffer;

    30 import com.sun.xml.internal.stream.buffer.XMLStreamBuffer;

    31 import com.sun.xml.internal.stream.buffer.XMLStreamBufferResult;

    32 import com.sun.xml.internal.ws.api.SOAPVersion;

    33 import com.sun.xml.internal.ws.api.message.AttachmentSet;

    34 import com.sun.xml.internal.ws.api.message.Header;

    35 import com.sun.xml.internal.ws.api.message.HeaderList;

    36 import com.sun.xml.internal.ws.api.message.Message;

    37 import com.sun.xml.internal.ws.api.message.MessageHeaders;

    38 import com.sun.xml.internal.ws.api.message.StreamingSOAP;

    39 import com.sun.xml.internal.ws.encoding.SOAPBindingCodec;

    40 import com.sun.xml.internal.ws.message.AbstractMessageImpl;

    41 import com.sun.xml.internal.ws.message.AttachmentSetImpl;

    42 import com.sun.xml.internal.ws.message.RootElementSniffer;

    43 import com.sun.xml.internal.ws.message.stream.StreamMessage;

    44 import com.sun.xml.internal.ws.spi.db.BindingContext;

    45 import com.sun.xml.internal.ws.spi.db.BindingContextFactory;

    46 import com.sun.xml.internal.ws.spi.db.XMLBridge;

    47 import com.sun.xml.internal.ws.streaming.XMLStreamWriterUtil;

    48 import com.sun.xml.internal.ws.streaming.XMLStreamReaderUtil;

    49 import com.sun.xml.internal.ws.streaming.MtomStreamWriter;

    50 import com.sun.xml.internal.ws.util.xml.XMLReaderComposite;

    51 import com.sun.xml.internal.ws.util.xml.XMLReaderComposite.ElemInfo;

    53 import org.xml.sax.ContentHandler;

    54 import org.xml.sax.ErrorHandler;

    55 import org.xml.sax.SAXException;

    57 import javax.xml.bind.JAXBContext;

    58 import javax.xml.bind.JAXBElement;

    59 import javax.xml.bind.JAXBException;

    60 import javax.xml.bind.Marshaller;

    61 import javax.xml.bind.Unmarshaller;

    62 import javax.xml.bind.attachment.AttachmentMarshaller;

    63 import javax.xml.bind.annotation.XmlRootElement;

    64 import javax.xml.bind.util.JAXBResult;

    65 import javax.xml.namespace.QName;

    66 import javax.xml.stream.XMLStreamException;

    67 import javax.xml.stream.XMLStreamReader;

    68 import javax.xml.stream.XMLStreamWriter;

    69 import static javax.xml.stream.XMLStreamConstants.START_DOCUMENT;

    70 import javax.xml.transform.Source;

    71 import javax.xml.ws.WebServiceException;

    72 import java.io.OutputStream;

    73 import java.util.List;

    75 /**

    76  * {@link Message} backed by a JAXB bean.

    77  *

    78  * @author Kohsuke Kawaguchi

    79  */

    80 public final class JAXBMessage extends AbstractMessageImpl implements StreamingSOAP {

    81     private MessageHeaders headers;

    83     /**

    84      * The JAXB object that represents the payload.

    85      */

    86     private final Object jaxbObject;

    88     private final XMLBridge bridge;

    90     /**

    91      * For the use case of a user-supplied JAXB context that is not

    92      * a known JAXB type, as when creating a Disaptch object with a

    93      * JAXB object parameter, we will marshal and unmarshal directly with

    94      * the context object, as there is no Bond available.  In this case,

    95      * swaRef is not supported.

    96      */

    97     private final JAXBContext rawContext;

    99     /**

   100      * Lazily sniffed payload element name

   101      */

   102     private String nsUri,localName;

   104     /**

   105      * If we have the infoset representation for the payload, this field is non-null.

   106      */

   107     private XMLStreamBuffer infoset;

   109     public static Message create(BindingContext context, Object jaxbObject, SOAPVersion soapVersion, MessageHeaders headers, AttachmentSet attachments) {

   110         if(!context.hasSwaRef()) {

   111             return new JAXBMessage(context,jaxbObject,soapVersion,headers,attachments);

   112         }

   114         // If we have swaRef, then that means we might have attachments.

   115         // to comply with the packet API, we need to eagerly turn the JAXB object into infoset

   116         // to correctly find out about attachments.

   118         try {

   119             MutableXMLStreamBuffer xsb = new MutableXMLStreamBuffer();

   121             Marshaller m = context.createMarshaller();

   122             AttachmentMarshallerImpl am = new AttachmentMarshallerImpl(attachments);

   123             m.setAttachmentMarshaller(am);

   124             am.cleanup();

   125             m.marshal(jaxbObject,xsb.createFromXMLStreamWriter());

   127             // any way to reuse this XMLStreamBuffer in StreamMessage?

   128             return new StreamMessage(headers,attachments,xsb.readAsXMLStreamReader(),soapVersion);

   129         } catch (JAXBException e) {

   130             throw new WebServiceException(e);

   131         } catch (XMLStreamException e) {

   132             throw new WebServiceException(e);

   133         }

   134     }

   135     /**

   136      * Creates a {@link Message} backed by a JAXB bean.

   137      *

   138      * @param context

   139      *      The JAXBContext to be used for marshalling.

   140      * @param jaxbObject

   141      *      The JAXB object that represents the payload. must not be null. This object

   142      *      must be bound to an element (which means it either is a {@link JAXBElement} or

   143      *      an instanceof a class with {@link XmlRootElement}).

   144      * @param soapVersion

   145      *      The SOAP version of the message. Must not be null.

   146      */

   147     public static Message create(BindingContext context, Object jaxbObject, SOAPVersion soapVersion) {

   148         return create(context,jaxbObject,soapVersion,null,null);

   149     }

   150     /** @deprecated */

   151     public static Message create(JAXBContext context, Object jaxbObject, SOAPVersion soapVersion) {

   152         return create(BindingContextFactory.create(context),jaxbObject,soapVersion,null,null);

   153     }

   155     /**

   156      * @deprecated

   157      * For use when creating a Dispatch object with an unknown JAXB implementation

   158      * for he JAXBContext parameter.

   159      *

   160      */

   161     public static Message createRaw(JAXBContext context, Object jaxbObject, SOAPVersion soapVersion) {

   162         return new JAXBMessage(context,jaxbObject,soapVersion,null,null);

   163     }

   165     private JAXBMessage( BindingContext context, Object jaxbObject, SOAPVersion soapVer, MessageHeaders headers, AttachmentSet attachments ) {

   166         super(soapVer);

   167 //        this.bridge = new MarshallerBridge(context);

   168         this.bridge = context.createFragmentBridge();

   169         this.rawContext = null;

   170         this.jaxbObject = jaxbObject;

   171         this.headers = headers;

   172         this.attachmentSet = attachments;

   173     }

   175     private JAXBMessage( JAXBContext rawContext, Object jaxbObject, SOAPVersion soapVer, MessageHeaders headers, AttachmentSet attachments ) {

   176         super(soapVer);

   177 //        this.bridge = new MarshallerBridge(context);

   178         this.rawContext = rawContext;

   179         this.bridge = null;

   180         this.jaxbObject = jaxbObject;

   181         this.headers = headers;

   182         this.attachmentSet = attachments;

   183     }

   185     /**

   186      * Creates a {@link Message} backed by a JAXB bean.

   187      *

   188      * @param bridge

   189      *      Specify the payload tag name and how <tt>jaxbObject</tt> is bound.

   190      * @param jaxbObject

   191      */

   192     public static Message create(XMLBridge bridge, Object jaxbObject, SOAPVersion soapVer) {

   193         if(!bridge.context().hasSwaRef()) {

   194             return new JAXBMessage(bridge,jaxbObject,soapVer);

   195         }

   197         // If we have swaRef, then that means we might have attachments.

   198         // to comply with the packet API, we need to eagerly turn the JAXB object into infoset

   199         // to correctly find out about attachments.

   201         try {

   202             MutableXMLStreamBuffer xsb = new MutableXMLStreamBuffer();

   204             AttachmentSetImpl attachments = new AttachmentSetImpl();

   205             AttachmentMarshallerImpl am = new AttachmentMarshallerImpl(attachments);

   206             bridge.marshal(jaxbObject,xsb.createFromXMLStreamWriter(), am);

   207             am.cleanup();

   209             // any way to reuse this XMLStreamBuffer in StreamMessage?

   210             return new StreamMessage(null,attachments,xsb.readAsXMLStreamReader(),soapVer);

   211         } catch (JAXBException e) {

   212             throw new WebServiceException(e);

   213         } catch (XMLStreamException e) {

   214             throw new WebServiceException(e);

   215         }

   216     }

   218     private JAXBMessage(XMLBridge bridge, Object jaxbObject, SOAPVersion soapVer) {

   219         super(soapVer);

   220         // TODO: think about a better way to handle BridgeContext

   221         this.bridge = bridge;

   222         this.rawContext = null;

   223         this.jaxbObject = jaxbObject;

   224         QName tagName = bridge.getTypeInfo().tagName;

   225         this.nsUri = tagName.getNamespaceURI();

   226         this.localName = tagName.getLocalPart();

   227         this.attachmentSet = new AttachmentSetImpl();

   228     }

   230     /**

   231      * Copy constructor.

   232      */

   233     public JAXBMessage(JAXBMessage that) {

   234         super(that);

   235         this.headers = that.headers;

   236         if(this.headers!=null)

   237             this.headers = new HeaderList(this.headers);

   238         this.attachmentSet = that.attachmentSet;

   240         this.jaxbObject = that.jaxbObject;

   241         this.bridge = that.bridge;

   242         this.rawContext = that.rawContext;

   243     }

   245     @Override

   246     public boolean hasHeaders() {

   247         return headers!=null && headers.hasHeaders();

   248     }

   250     @Override

   251     public MessageHeaders getHeaders() {

   252         if(headers==null)

   253             headers = new HeaderList(getSOAPVersion());

   254         return headers;

   255     }

   257     @Override

   258     public String getPayloadLocalPart() {

   259         if(localName==null)

   260             sniff();

   261         return localName;

   262     }

   264     @Override

   265     public String getPayloadNamespaceURI() {

   266         if(nsUri==null)

   267             sniff();

   268         return nsUri;

   269     }

   271     @Override

   272     public boolean hasPayload() {

   273         return true;

   274     }

   276     /**

   277      * Obtains the tag name of the root element.

   278      */

   279     private void sniff() {

   280         RootElementSniffer sniffer = new RootElementSniffer(false);

   281         try {

   282                 if (rawContext != null) {

   283                         Marshaller m = rawContext.createMarshaller();

   284                         m.setProperty("jaxb.fragment", Boolean.TRUE);

   285                         m.marshal(jaxbObject,sniffer);

   286                 } else

   287                         bridge.marshal(jaxbObject,sniffer,null);

   288         } catch (JAXBException e) {

   289             // if it's due to us aborting the processing after the first element,

   290             // we can safely ignore this exception.

   291             //

   292             // if it's due to error in the object, the same error will be reported

   293             // when the readHeader() method is used, so we don't have to report

   294             // an error right now.

   295             nsUri = sniffer.getNsUri();

   296             localName = sniffer.getLocalName();

   297         }

   298     }

   300     @Override

   301     public Source readPayloadAsSource() {

   302         return new JAXBBridgeSource(bridge,jaxbObject);

   303     }

   305     @Override

   306     public <T> T readPayloadAsJAXB(Unmarshaller unmarshaller) throws JAXBException {

   307         JAXBResult out = new JAXBResult(unmarshaller);

   308         // since the bridge only produces fragments, we need to fire start/end document.

   309         try {

   310             out.getHandler().startDocument();

   311             if (rawContext != null) {

   312                 Marshaller m = rawContext.createMarshaller();

   313                 m.setProperty("jaxb.fragment", Boolean.TRUE);

   314                 m.marshal(jaxbObject,out);

   315             } else

   316                 bridge.marshal(jaxbObject,out);

   317             out.getHandler().endDocument();

   318         } catch (SAXException e) {

   319             throw new JAXBException(e);

   320         }

   321         return (T)out.getResult();

   322     }

   324     @Override

   325     public XMLStreamReader readPayload() throws XMLStreamException {

   326        try {

   327             if(infoset==null) {

   328                                 if (rawContext != null) {

   329                         XMLStreamBufferResult sbr = new XMLStreamBufferResult();

   330                                         Marshaller m = rawContext.createMarshaller();

   331                                         m.setProperty("jaxb.fragment", Boolean.TRUE);

   332                                         m.marshal(jaxbObject, sbr);

   333                         infoset = sbr.getXMLStreamBuffer();

   334                                 } else {

   335                                     MutableXMLStreamBuffer buffer = new MutableXMLStreamBuffer();

   336                                     writePayloadTo(buffer.createFromXMLStreamWriter());

   337                                     infoset = buffer;

   338                                 }

   339             }

   340             XMLStreamReader reader = infoset.readAsXMLStreamReader();

   341             if(reader.getEventType()== START_DOCUMENT)

   342                 XMLStreamReaderUtil.nextElementContent(reader);

   343             return reader;

   344         } catch (JAXBException e) {

   345            // bug 6449684, spec 4.3.4

   346            throw new WebServiceException(e);

   347         }

   348     }

   350     /**

   351      * Writes the payload as SAX events.

   352      */

   353     @Override

   354     protected void writePayloadTo(ContentHandler contentHandler, ErrorHandler errorHandler, boolean fragment) throws SAXException {

   355         try {

   356             if(fragment)

   357                 contentHandler = new FragmentContentHandler(contentHandler);

   358             AttachmentMarshallerImpl am = new AttachmentMarshallerImpl(attachmentSet);

   359             if (rawContext != null) {

   360                 Marshaller m = rawContext.createMarshaller();

   361                 m.setProperty("jaxb.fragment", Boolean.TRUE);

   362                 m.setAttachmentMarshaller(am);

   363                 m.marshal(jaxbObject,contentHandler);

   364             } else

   365                 bridge.marshal(jaxbObject,contentHandler, am);

   366             am.cleanup();

   367         } catch (JAXBException e) {

   368             // this is really more helpful but spec compliance

   369             // errorHandler.fatalError(new SAXParseException(e.getMessage(),NULL_LOCATOR,e));

   370             // bug 6449684, spec 4.3.4

   371             throw new WebServiceException(e.getMessage(),e);

   372         }

   373     }

   375     @Override

   376     public void writePayloadTo(XMLStreamWriter sw) throws XMLStreamException {

   377         try {

   378             // MtomCodec sets its own AttachmentMarshaller

   379             AttachmentMarshaller am = (sw instanceof MtomStreamWriter)

   380                     ? ((MtomStreamWriter)sw).getAttachmentMarshaller()

   381                     : new AttachmentMarshallerImpl(attachmentSet);

   383             // Get the encoding of the writer

   384             String encoding = XMLStreamWriterUtil.getEncoding(sw);

   386             // Get output stream and use JAXB UTF-8 writer

   387             OutputStream os = bridge.supportOutputStream() ? XMLStreamWriterUtil.getOutputStream(sw) : null;

   388             if (rawContext != null) {

   389                 Marshaller m = rawContext.createMarshaller();

   390                 m.setProperty("jaxb.fragment", Boolean.TRUE);

   391                 m.setAttachmentMarshaller(am);

   392                 if (os != null) {

   393                     m.marshal(jaxbObject, os);

   394                 } else {

   395                     m.marshal(jaxbObject, sw);

   396                 }

   397             } else {

   398                 if (os != null && encoding != null && encoding.equalsIgnoreCase(SOAPBindingCodec.UTF8_ENCODING)) {

   399                     bridge.marshal(jaxbObject, os, sw.getNamespaceContext(), am);

   400                 } else {

   401                     bridge.marshal(jaxbObject, sw, am);

   402                 }

   403             }

   404             //cleanup() is not needed since JAXB doesn't keep ref to AttachmentMarshaller

   405             //am.cleanup();

   406         } catch (JAXBException e) {

   407             // bug 6449684, spec 4.3.4

   408             throw new WebServiceException(e);

   409         }

   410     }

   412     @Override

   413     public Message copy() {

   414         return new JAXBMessage(this);

   415     }

   417     public XMLStreamReader readEnvelope() {

   418         int base = soapVersion.ordinal()*3;

   419         this.envelopeTag = DEFAULT_TAGS.get(base);

   420         this.bodyTag = DEFAULT_TAGS.get(base+2);

   421         List<XMLStreamReader> hReaders = new java.util.ArrayList<XMLStreamReader>();

   422         ElemInfo envElem =  new ElemInfo(envelopeTag, null);

   423         ElemInfo bdyElem =  new ElemInfo(bodyTag, envElem);

   424         for (Header h : getHeaders().asList()) {

   425             try {

   426                 hReaders.add(h.readHeader());

   427             } catch (XMLStreamException e) {

   428                 throw new RuntimeException(e);

   429             }

   430         }

   431         XMLStreamReader soapHeader = null;

   432         if(hReaders.size()>0) {

   433             headerTag = DEFAULT_TAGS.get(base+1);

   434             ElemInfo hdrElem = new ElemInfo(headerTag, envElem);

   435             soapHeader = new XMLReaderComposite(hdrElem, hReaders.toArray(new XMLStreamReader[hReaders.size()]));

   436         }

   437         try {

   438             XMLStreamReader payload= readPayload();

   439             XMLStreamReader soapBody = new XMLReaderComposite(bdyElem, new XMLStreamReader[]{payload});

   440             XMLStreamReader[] soapContent = (soapHeader != null) ? new XMLStreamReader[]{soapHeader, soapBody} : new XMLStreamReader[]{soapBody};

   441             return new XMLReaderComposite(envElem, soapContent);

   442         } catch (XMLStreamException e) {

   443             throw new RuntimeException(e);

   444         }

   445     }

   446 }

Mercurial > jdk8-mips64-public > jaxws / file revision

src/share/jaxws_classes/com/sun/xml/internal/ws/message/jaxb/JAXBMessage.java@9c07ef4934dd

src/share/jaxws_classes/com/sun/xml/internal/ws/message/jaxb/JAXBMessage.java