View Javadoc
1   /*
2    * Copyright (c) 2005, 2010, 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   */
25  
26  package javax.xml.ws;
27  
28  import javax.xml.namespace.QName;
29  import java.util.Iterator;
30  import javax.xml.ws.handler.HandlerResolver;
31  import javax.xml.bind.JAXBContext;
32  import javax.xml.ws.spi.ServiceDelegate;
33  import javax.xml.ws.spi.Provider;
34  
35  /**
36   * <code>Service</code> objects provide the client view of a Web service.
37   * <p><code>Service</code> acts as a factory of the following:
38   * <ul>
39   * <li>Proxies for a target service endpoint.</li>
40   * <li>Instances of {@link javax.xml.ws.Dispatch} for
41   *     dynamic message-oriented invocation of a remote
42   *     operation.
43   * </li>
44   * </ul>
45   *
46   * <p>The ports available on a service can be enumerated using the
47   * <code>getPorts</code> method. Alternatively, you can pass a
48   * service endpoint interface to the unary <code>getPort</code> method
49   * and let the runtime select a compatible port.
50   *
51   * <p>Handler chains for all the objects created by a <code>Service</code>
52   * can be set by means of a <code>HandlerResolver</code>.
53   *
54   * <p>An <code>Executor</code> may be set on the service in order
55   * to gain better control over the threads used to dispatch asynchronous
56   * callbacks. For instance, thread pooling with certain parameters
57   * can be enabled by creating a <code>ThreadPoolExecutor</code> and
58   * registering it with the service.
59   *
60   * @since JAX-WS 2.0
61   *
62   * @see javax.xml.ws.spi.Provider
63   * @see javax.xml.ws.handler.HandlerResolver
64   * @see java.util.concurrent.Executor
65   **/
66  public class Service {
67  
68      private ServiceDelegate delegate;
69      /**
70       * The orientation of a dynamic client or service. <code>MESSAGE</code> provides
71       * access to entire protocol message, <code>PAYLOAD</code> to protocol message
72       * payload only.
73       **/
74      public enum Mode { MESSAGE, PAYLOAD }
75  
76      protected Service(java.net.URL wsdlDocumentLocation, QName serviceName) {
77          delegate = Provider.provider().createServiceDelegate(wsdlDocumentLocation,
78                  serviceName,
79                  this.getClass());
80      }
81  
82      protected Service(java.net.URL wsdlDocumentLocation, QName serviceName, WebServiceFeature ... features) {
83          delegate = Provider.provider().createServiceDelegate(wsdlDocumentLocation,
84                  serviceName,
85                  this.getClass(), features);
86      }
87  
88  
89      /**
90       * The <code>getPort</code> method returns a proxy. A service client
91       * uses this proxy to invoke operations on the target
92       * service endpoint. The <code>serviceEndpointInterface</code>
93       * specifies the service endpoint interface that is supported by
94       * the created dynamic proxy instance.
95       *
96       * @param portName  Qualified name of the service endpoint in
97       *                  the WSDL service description.
98       * @param serviceEndpointInterface Service endpoint interface
99       *                  supported by the dynamic proxy instance.
100      * @return Object Proxy instance that
101      *                supports the specified service endpoint
102      *                interface.
103      * @throws WebServiceException This exception is thrown in the
104      *                  following cases:
105      *                  <UL>
106      *                  <LI>If there is an error in creation of
107      *                      the proxy.
108      *                  <LI>If there is any missing WSDL metadata
109      *                      as required by this method.
110      *                  <LI>If an illegal
111      *                      <code>serviceEndpointInterface</code>
112      *                      or <code>portName</code> is specified.
113      *                  </UL>
114      * @see java.lang.reflect.Proxy
115      * @see java.lang.reflect.InvocationHandler
116      **/
117     public <T> T getPort(QName portName,
118             Class<T> serviceEndpointInterface) {
119         return delegate.getPort(portName, serviceEndpointInterface);
120     }
121 
122     /**
123      * The <code>getPort</code> method returns a proxy. A service client
124      * uses this proxy to invoke operations on the target
125      * service endpoint. The <code>serviceEndpointInterface</code>
126      * specifies the service endpoint interface that is supported by
127      * the created dynamic proxy instance.
128      *
129      * @param portName  Qualified name of the service endpoint in
130      *                  the WSDL service description.
131      * @param serviceEndpointInterface Service endpoint interface
132      *                  supported by the dynamic proxy instance.
133      * @param features  A list of WebServiceFeatures to configure on the
134      *                proxy.  Supported features not in the <code>features
135      *                </code> parameter will have their default values.
136      * @return Object Proxy instance that
137      *                supports the specified service endpoint
138      *                interface.
139      * @throws WebServiceException This exception is thrown in the
140      *                  following cases:
141      *                  <UL>
142      *                  <LI>If there is an error in creation of
143      *                      the proxy.
144      *                  <LI>If there is any missing WSDL metadata
145      *                      as required by this method.
146      *                  <LI>If an illegal
147      *                      <code>serviceEndpointInterface</code>
148      *                      or <code>portName</code> is specified.
149      *                  <LI>If a feature is enabled that is not compatible
150      *                      with this port or is unsupported.
151      *                  </UL>
152      * @see java.lang.reflect.Proxy
153      * @see java.lang.reflect.InvocationHandler
154      * @see WebServiceFeature
155      *
156      * @since JAX-WS 2.1
157      **/
158     public <T> T getPort(QName portName,
159             Class<T> serviceEndpointInterface, WebServiceFeature... features) {
160         return delegate.getPort(portName, serviceEndpointInterface, features);
161     }
162 
163 
164     /**
165      * The <code>getPort</code> method returns a proxy. The parameter
166      * <code>serviceEndpointInterface</code> specifies the service
167      * endpoint interface that is supported by the returned proxy.
168      * In the implementation of this method, the JAX-WS
169      * runtime system takes the responsibility of selecting a protocol
170      * binding (and a port) and configuring the proxy accordingly.
171      * The returned proxy should not be reconfigured by the client.
172      *
173      * @param serviceEndpointInterface Service endpoint interface.
174      * @return Object instance that supports the
175      *                  specified service endpoint interface.
176      * @throws WebServiceException
177      *                  <UL>
178      *                  <LI>If there is an error during creation
179      *                      of the proxy.
180      *                  <LI>If there is any missing WSDL metadata
181      *                      as required by this method.
182      *                  <LI>If an illegal
183      *                      <code>serviceEndpointInterface</code>
184      *                      is specified.
185      *                  </UL>
186      **/
187     public <T> T getPort(Class<T> serviceEndpointInterface) {
188         return delegate.getPort(serviceEndpointInterface);
189     }
190 
191 
192     /**
193      * The <code>getPort</code> method returns a proxy. The parameter
194      * <code>serviceEndpointInterface</code> specifies the service
195      * endpoint interface that is supported by the returned proxy.
196      * In the implementation of this method, the JAX-WS
197      * runtime system takes the responsibility of selecting a protocol
198      * binding (and a port) and configuring the proxy accordingly.
199      * The returned proxy should not be reconfigured by the client.
200      *
201      * @param serviceEndpointInterface Service endpoint interface.
202      * @param features  A list of WebServiceFeatures to configure on the
203      *                proxy.  Supported features not in the <code>features
204      *                </code> parameter will have their default values.
205      * @return Object instance that supports the
206      *                  specified service endpoint interface.
207      * @throws WebServiceException
208      *                  <UL>
209      *                  <LI>If there is an error during creation
210      *                      of the proxy.
211      *                  <LI>If there is any missing WSDL metadata
212      *                      as required by this method.
213      *                  <LI>If an illegal
214      *                      <code>serviceEndpointInterface</code>
215      *                      is specified.
216      *                  <LI>If a feature is enabled that is not compatible
217      *                      with this port or is unsupported.
218      *                  </UL>
219      *
220      * @see WebServiceFeature
221      *
222      * @since JAX-WS 2.1
223      **/
224     public <T> T getPort(Class<T> serviceEndpointInterface,
225             WebServiceFeature... features) {
226         return delegate.getPort(serviceEndpointInterface, features);
227     }
228 
229 
230     /**
231      * The <code>getPort</code> method returns a proxy.
232      * The parameter <code>endpointReference</code> specifies the
233      * endpoint that will be invoked by the returned proxy.  If there
234      * are any reference parameters in the
235      * <code>endpointReference</code>, then those reference
236      * parameters MUST appear as SOAP headers, indicating them to be
237      * reference parameters, on all messages sent to the endpoint.
238      * The <code>endpointReference's</code> address MUST be used
239      * for invocations on the endpoint.
240      * The parameter <code>serviceEndpointInterface</code> specifies
241      * the service endpoint interface that is supported by the
242      * returned proxy.
243      * In the implementation of this method, the JAX-WS
244      * runtime system takes the responsibility of selecting a protocol
245      * binding (and a port) and configuring the proxy accordingly from
246      * the WSDL associated with this <code>Service</code> instance or
247      * from the metadata from the <code>endpointReference</code>.
248      * If this <code>Service</code> instance has a WSDL and
249      * the <code>endpointReference</code> metadata
250      * also has a WSDL, then the WSDL from this instance MUST be used.
251      * If this <code>Service</code> instance does not have a WSDL and
252      * the <code>endpointReference</code> does have a WSDL, then the
253      * WSDL from the <code>endpointReference</code> MAY be used.
254      * The returned proxy should not be reconfigured by the client.
255      * If this <code>Service</code> instance has a known proxy
256      * port that matches the information contained in
257      * the WSDL,
258      * then that proxy is returned, otherwise a WebServiceException
259      * is thrown.
260      * <p>
261      * Calling this method has the same behavior as the following
262      * <pre>
263      * <code>port = service.getPort(portName, serviceEndpointInterface);</code>
264      * </pre>
265      * where the <code>portName</code> is retrieved from the
266      * metadata of the <code>endpointReference</code> or from the
267      * <code>serviceEndpointInterface</code> and the WSDL
268      * associated with this <code>Service</code> instance.
269      *
270      * @param endpointReference  The <code>EndpointReference</code>
271      * for the target service endpoint that will be invoked by the
272      * returned proxy.
273      * @param serviceEndpointInterface Service endpoint interface.
274      * @param features  A list of <code>WebServiceFeatures</code> to configure on the
275      *                proxy.  Supported features not in the <code>features
276      *                </code> parameter will have their default values.
277      * @return Object Proxy instance that supports the
278      *                  specified service endpoint interface.
279      * @throws WebServiceException
280      *                  <UL>
281      *                  <LI>If there is an error during creation
282      *                      of the proxy.
283      *                  <LI>If there is any missing WSDL metadata
284      *                      as required by this method.
285      *                  <LI>If the <code>endpointReference</code> metadata does
286      *                      not match the <code>serviceName</code> of this
287      *                      <code>Service</code> instance.
288      *                  <LI>If a <code>portName</code> cannot be extracted
289      *                      from the WSDL or <code>endpointReference</code> metadata.
290      *                  <LI>If an invalid
291      *                      <code>endpointReference</code>
292      *                      is specified.
293      *                  <LI>If an invalid
294      *                      <code>serviceEndpointInterface</code>
295      *                      is specified.
296      *                  <LI>If a feature is enabled that is not compatible
297      *                      with this port or is unsupported.
298      *                  </UL>
299      *
300      * @since JAX-WS 2.1
301      **/
302     public <T> T getPort(EndpointReference endpointReference,
303            Class<T> serviceEndpointInterface, WebServiceFeature... features) {
304         return delegate.getPort(endpointReference, serviceEndpointInterface, features);
305     }
306 
307     /**
308      * Creates a new port for the service. Ports created in this way contain
309      * no WSDL port type information and can only be used for creating
310      * <code>Dispatch</code>instances.
311      *
312      * @param portName  Qualified name for the target service endpoint.
313      * @param bindingId A String identifier of a binding.
314      * @param endpointAddress Address of the target service endpoint as a URI.
315      * @throws WebServiceException If any error in the creation of
316      * the port.
317      *
318      * @see javax.xml.ws.soap.SOAPBinding#SOAP11HTTP_BINDING
319      * @see javax.xml.ws.soap.SOAPBinding#SOAP12HTTP_BINDING
320      * @see javax.xml.ws.http.HTTPBinding#HTTP_BINDING
321      **/
322     public void addPort(QName portName, String bindingId, String endpointAddress) {
323         delegate.addPort(portName, bindingId, endpointAddress);
324     }
325 
326 
327     /**
328      * Creates a <code>Dispatch</code> instance for use with objects of
329      * the client's choosing.
330      *
331      * @param portName  Qualified name for the target service endpoint
332      * @param type The class of object used for messages or message
333      * payloads. Implementations are required to support
334      * <code>javax.xml.transform.Source</code>, <code>javax.xml.soap.SOAPMessage</code>
335      * and <code>javax.activation.DataSource</code>, depending on
336      * the binding in use.
337      * @param mode Controls whether the created dispatch instance is message
338      * or payload oriented, i.e. whether the client will work with complete
339      * protocol messages or message payloads. E.g. when using the SOAP
340      * protocol, this parameter controls whether the client will work with
341      * SOAP messages or the contents of a SOAP body. Mode MUST be MESSAGE
342      * when type is SOAPMessage.
343      *
344      * @return Dispatch instance.
345      * @throws WebServiceException If any error in the creation of
346      *                  the <code>Dispatch</code> object.
347      *
348      * @see javax.xml.transform.Source
349      * @see javax.xml.soap.SOAPMessage
350      **/
351     public <T> Dispatch<T> createDispatch(QName portName, Class<T> type, Mode mode) {
352         return delegate.createDispatch(portName, type, mode);
353     }
354 
355 
356     /**
357      * Creates a <code>Dispatch</code> instance for use with objects of
358      * the client's choosing.
359      *
360      * @param portName  Qualified name for the target service endpoint
361      * @param type The class of object used for messages or message
362      * payloads. Implementations are required to support
363      * <code>javax.xml.transform.Source</code> and <code>javax.xml.soap.SOAPMessage</code>.
364      * @param mode Controls whether the created dispatch instance is message
365      * or payload oriented, i.e. whether the client will work with complete
366      * protocol messages or message payloads. E.g. when using the SOAP
367      * protocol, this parameter controls whether the client will work with
368      * SOAP messages or the contents of a SOAP body. Mode MUST be <code>MESSAGE</code>
369      * when type is <code>SOAPMessage</code>.
370      * @param features  A list of <code>WebServiceFeatures</code> to configure on the
371      *                proxy.  Supported features not in the <code>features
372      *                </code> parameter will have their default values.
373      *
374      * @return Dispatch instance.
375      * @throws WebServiceException If any error in the creation of
376      *                  the <code>Dispatch</code> object or if a
377      *                  feature is enabled that is not compatible with
378      *                  this port or is unsupported.
379      *
380      * @see javax.xml.transform.Source
381      * @see javax.xml.soap.SOAPMessage
382      * @see WebServiceFeature
383      *
384      * @since JAX-WS 2.1
385      **/
386     public <T> Dispatch<T> createDispatch(QName portName, Class<T> type,
387             Service.Mode mode, WebServiceFeature... features) {
388         return delegate.createDispatch(portName, type, mode, features);
389     }
390 
391 
392     /**
393      * Creates a <code>Dispatch</code> instance for use with objects of
394      * the client's choosing. If there
395      * are any reference parameters in the
396      * <code>endpointReference</code>, then those reference
397      * parameters MUST appear as SOAP headers, indicating them to be
398      * reference parameters, on all messages sent to the endpoint.
399      * The <code>endpointReference's</code> address MUST be used
400      * for invocations on the endpoint.
401      * In the implementation of this method, the JAX-WS
402      * runtime system takes the responsibility of selecting a protocol
403      * binding (and a port) and configuring the dispatch accordingly from
404      * the WSDL associated with this <code>Service</code> instance or
405      * from the metadata from the <code>endpointReference</code>.
406      * If this <code>Service</code> instance has a WSDL and
407      * the <code>endpointReference</code>
408      * also has a WSDL in its metadata, then the WSDL from this instance MUST be used.
409      * If this <code>Service</code> instance does not have a WSDL and
410      * the <code>endpointReference</code> does have a WSDL, then the
411      * WSDL from the <code>endpointReference</code> MAY be used.
412      * An implementation MUST be able to retrieve the <code>portName</code> from the
413      * <code>endpointReference</code> metadata.
414      * <p>
415      * This method behaves the same as calling
416      * <pre>
417      * <code>dispatch = service.createDispatch(portName, type, mode, features);</code>
418      * </pre>
419      * where the <code>portName</code> is retrieved from the
420      * WSDL or <code>EndpointReference</code> metadata.
421      *
422      * @param endpointReference  The <code>EndpointReference</code>
423      * for the target service endpoint that will be invoked by the
424      * returned <code>Dispatch</code> object.
425      * @param type The class of object used to messages or message
426      * payloads. Implementations are required to support
427      * <code>javax.xml.transform.Source</code> and <code>javax.xml.soap.SOAPMessage</code>.
428      * @param mode Controls whether the created dispatch instance is message
429      * or payload oriented, i.e. whether the client will work with complete
430      * protocol messages or message payloads. E.g. when using the SOAP
431      * protocol, this parameter controls whether the client will work with
432      * SOAP messages or the contents of a SOAP body. Mode MUST be <code>MESSAGE</code>
433      * when type is <code>SOAPMessage</code>.
434      * @param features  An array of <code>WebServiceFeatures</code> to configure on the
435      *                proxy.  Supported features not in the <code>features
436      *                </code> parameter will have their default values.
437      *
438      * @return Dispatch instance
439      * @throws WebServiceException
440      *                  <UL>
441      *                    <LI>If there is any missing WSDL metadata
442      *                      as required by this method.
443      *                    <li>If the <code>endpointReference</code> metadata does
444      *                      not match the <code>serviceName</code> or <code>portName</code>
445      *                      of a WSDL associated
446      *                      with this <code>Service</code> instance.
447      *                    <li>If the <code>portName</code> cannot be determined
448      *                    from the <code>EndpointReference</code> metadata.
449      *                    <li>If any error in the creation of
450      *                     the <code>Dispatch</code> object.
451      *                    <li>If a feature is enabled that is not
452      *                    compatible with this port or is unsupported.
453      *                  </UL>
454      *
455      * @see javax.xml.transform.Source
456      * @see javax.xml.soap.SOAPMessage
457      * @see WebServiceFeature
458      *
459      * @since JAX-WS 2.1
460      **/
461     public <T> Dispatch<T> createDispatch(EndpointReference endpointReference,
462             Class<T> type, Service.Mode mode,
463             WebServiceFeature... features) {
464         return delegate.createDispatch(endpointReference, type, mode, features);
465     }
466 
467     /**
468      * Creates a <code>Dispatch</code> instance for use with JAXB
469      * generated objects.
470      *
471      * @param portName  Qualified name for the target service endpoint
472      * @param context The JAXB context used to marshall and unmarshall
473      * messages or message payloads.
474      * @param mode Controls whether the created dispatch instance is message
475      * or payload oriented, i.e. whether the client will work with complete
476      * protocol messages or message payloads. E.g. when using the SOAP
477      * protocol, this parameter controls whether the client will work with
478      * SOAP messages or the contents of a SOAP body.
479      *
480      * @return Dispatch instance.
481      * @throws WebServiceException If any error in the creation of
482      *                  the <code>Dispatch</code> object.
483      *
484      * @see javax.xml.bind.JAXBContext
485      **/
486     public Dispatch<Object> createDispatch(QName portName, JAXBContext context,
487             Mode mode) {
488         return delegate.createDispatch(portName, context,  mode);
489     }
490 
491 
492     /**
493      * Creates a <code>Dispatch</code> instance for use with JAXB
494      * generated objects.
495      *
496      * @param portName  Qualified name for the target service endpoint
497      * @param context The JAXB context used to marshall and unmarshall
498      * messages or message payloads.
499      * @param mode Controls whether the created dispatch instance is message
500      * or payload oriented, i.e. whether the client will work with complete
501      * protocol messages or message payloads. E.g. when using the SOAP
502      * protocol, this parameter controls whether the client will work with
503      * SOAP messages or the contents of a SOAP body.
504      * @param features  A list of <code>WebServiceFeatures</code> to configure on the
505      *                proxy.  Supported features not in the <code>features
506      *                </code> parameter will have their default values.
507      *
508      * @return Dispatch instance.
509      * @throws WebServiceException If any error in the creation of
510      *                  the <code>Dispatch</code> object or if a
511      *                  feature is enabled that is not compatible with
512      *                  this port or is unsupported.
513      *
514      * @see javax.xml.bind.JAXBContext
515      * @see WebServiceFeature
516      *
517      * @since JAX-WS 2.1
518      **/
519     public Dispatch<Object> createDispatch(QName portName,
520             JAXBContext context, Service.Mode mode, WebServiceFeature... features) {
521         return delegate.createDispatch(portName, context, mode, features);
522     }
523 
524 
525     /**
526      * Creates a <code>Dispatch</code> instance for use with JAXB
527      * generated objects. If there
528      * are any reference parameters in the
529      * <code>endpointReference</code>, then those reference
530      * parameters MUST appear as SOAP headers, indicating them to be
531      * reference parameters, on all messages sent to the endpoint.
532      * The <code>endpointReference's</code> address MUST be used
533      * for invocations on the endpoint.
534      * In the implementation of this method, the JAX-WS
535      * runtime system takes the responsibility of selecting a protocol
536      * binding (and a port) and configuring the dispatch accordingly from
537      * the WSDL associated with this <code>Service</code> instance or
538      * from the metadata from the <code>endpointReference</code>.
539      * If this <code>Service</code> instance has a WSDL and
540      * the <code>endpointReference</code>
541      * also has a WSDL in its metadata, then the WSDL from this instance
542      * MUST be used.
543      * If this <code>Service</code> instance does not have a WSDL and
544      * the <code>endpointReference</code> does have a WSDL, then the
545      * WSDL from the <code>endpointReference</code> MAY be used.
546      * An implementation MUST be able to retrieve the <code>portName</code> from the
547      * <code>endpointReference</code> metadata.
548      * <p>
549      * This method behavies the same as calling
550      * <pre>
551      * <code>dispatch = service.createDispatch(portName, context, mode, features);</code>
552      * </pre>
553      * where the <code>portName</code> is retrieved from the
554      * WSDL or <code>endpointReference</code> metadata.
555      *
556      * @param endpointReference  The <code>EndpointReference</code>
557      * for the target service endpoint that will be invoked by the
558      * returned <code>Dispatch</code> object.
559      * @param context The JAXB context used to marshall and unmarshall
560      * messages or message payloads.
561      * @param mode Controls whether the created dispatch instance is message
562      * or payload oriented, i.e. whether the client will work with complete
563      * protocol messages or message payloads. E.g. when using the SOAP
564      * protocol, this parameter controls whether the client will work with
565      * SOAP messages or the contents of a SOAP body.
566      * @param features  An array of <code>WebServiceFeatures</code> to configure on the
567      *                proxy.  Supported features not in the <code>features
568      *                </code> parameter will have their default values.
569      *
570      * @return Dispatch instance
571      * @throws WebServiceException
572      *                  <UL>
573      *                    <li>If there is any missing WSDL metadata
574      *                      as required by this method.
575      *                    <li>If the <code>endpointReference</code> metadata does
576      *                    not match the <code>serviceName</code> or <code>portName</code>
577      *                    of a WSDL associated
578      *                    with this <code>Service</code> instance.
579      *                    <li>If the <code>portName</code> cannot be determined
580      *                    from the <code>EndpointReference</code> metadata.
581      *                    <li>If any error in the creation of
582      *                    the <code>Dispatch</code> object.
583      *                    <li>if a feature is enabled that is not
584      *                    compatible with this port or is unsupported.
585      *                  </UL>
586      *
587      * @see javax.xml.bind.JAXBContext
588      * @see WebServiceFeature
589      *
590      * @since JAX-WS 2.1
591     **/
592     public Dispatch<Object> createDispatch(EndpointReference endpointReference,
593             JAXBContext context, Service.Mode mode,
594             WebServiceFeature... features) {
595         return delegate.createDispatch(endpointReference, context, mode, features);
596     }
597 
598     /**
599      * Gets the name of this service.
600      * @return Qualified name of this service
601      **/
602     public QName getServiceName() {
603         return delegate.getServiceName();
604     }
605 
606     /**
607      * Returns an <code>Iterator</code> for the list of
608      * <code>QName</code>s of service endpoints grouped by this
609      * service
610      *
611      * @return Returns <code>java.util.Iterator</code> with elements
612      *         of type <code>javax.xml.namespace.QName</code>.
613      * @throws WebServiceException If this Service class does not
614      *         have access to the required WSDL metadata.
615      **/
616     public Iterator<javax.xml.namespace.QName> getPorts() {
617         return delegate.getPorts();
618     }
619 
620     /**
621      * Gets the location of the WSDL document for this Service.
622      *
623      * @return URL for the location of the WSDL document for
624      *         this service.
625      **/
626     public java.net.URL getWSDLDocumentLocation() {
627         return delegate.getWSDLDocumentLocation();
628     }
629 
630     /**
631      * Returns the configured handler resolver.
632      *
633      * @return HandlerResolver The <code>HandlerResolver</code> being
634      *         used by this <code>Service</code> instance, or <code>null</code>
635      *         if there isn't one.
636      **/
637     public HandlerResolver getHandlerResolver() {
638         return delegate.getHandlerResolver();
639     }
640 
641     /**
642      * Sets the <code>HandlerResolver</code> for this <code>Service</code>
643      * instance.
644      * <p>
645      * The handler resolver, if present, will be called once for each
646      * proxy or dispatch instance that is created, and the handler chain
647      * returned by the resolver will be set on the instance.
648      *
649      * @param handlerResolver The <code>HandlerResolver</code> to use
650      *        for all subsequently created proxy/dispatch objects.
651      *
652      * @see javax.xml.ws.handler.HandlerResolver
653      **/
654     public void setHandlerResolver(HandlerResolver handlerResolver) {
655         delegate.setHandlerResolver(handlerResolver);
656     }
657 
658     /**
659      * Returns the executor for this <code>Service</code>instance.
660      *
661      * The executor is used for all asynchronous invocations that
662      * require callbacks.
663      *
664      * @return The <code>java.util.concurrent.Executor</code> to be
665      *         used to invoke a callback.
666      *
667      * @see java.util.concurrent.Executor
668      **/
669     public java.util.concurrent.Executor getExecutor() {
670         return delegate.getExecutor();
671     }
672 
673     /**
674      * Sets the executor for this <code>Service</code> instance.
675      *
676      * The executor is used for all asynchronous invocations that
677      * require callbacks.
678      *
679      * @param executor The <code>java.util.concurrent.Executor</code>
680      *        to be used to invoke a callback.
681      *
682      * @throws SecurityException If the instance does not support
683      *         setting an executor for security reasons (e.g. the
684      *         necessary permissions are missing).
685      *
686      * @see java.util.concurrent.Executor
687      **/
688     public void setExecutor(java.util.concurrent.Executor executor) {
689         delegate.setExecutor(executor);
690     }
691 
692     /**
693      * Creates a <code>Service</code> instance.
694      *
695      * The specified WSDL document location and service qualified name MUST
696      * uniquely identify a <code>wsdl:service</code> element.
697      *
698      * @param wsdlDocumentLocation <code>URL</code> for the WSDL document location
699      *                             for the service
700      * @param serviceName <code>QName</code> for the service
701      * @throws WebServiceException If any error in creation of the
702      *                    specified service.
703      **/
704     public static Service create(
705             java.net.URL wsdlDocumentLocation,
706             QName serviceName) {
707         return new Service(wsdlDocumentLocation, serviceName);
708     }
709 
710     /**
711      * Creates a <code>Service</code> instance. The created instance is
712      * configured with the web service features.
713      *
714      * The specified WSDL document location and service qualified name MUST
715      * uniquely identify a <code>wsdl:service</code> element.
716      *
717      * @param wsdlDocumentLocation <code>URL</code> for the WSDL document location
718      *                             for the service
719      * @param serviceName <code>QName</code> for the service
720      * @param features Web Service features that must be configured on
721      *        the service. If the provider doesn't understand a feature,
722      *        it must throw a WebServiceException.
723      * @throws WebServiceException If any error in creation of the
724      *                    specified service.
725      * @since JAX-WS 2.2
726      **/
727     public static Service create(
728             java.net.URL wsdlDocumentLocation,
729             QName serviceName, WebServiceFeature ... features) {
730         return new Service(wsdlDocumentLocation, serviceName, features);
731     }
732 
733     /**
734      * Creates a <code>Service</code> instance.
735      *
736      * @param serviceName <code>QName</code> for the service
737      * @throws WebServiceException If any error in creation of the
738      *                    specified service
739      */
740     public static Service create(QName serviceName) {
741         return new Service(null, serviceName);
742     }
743 
744     /**
745      * Creates a <code>Service</code> instance. The created instance is
746      * configured with the web service features.
747      *
748      * @param serviceName <code>QName</code> for the service
749      * @param features Web Service features that must be configured on
750      *        the service. If the provider doesn't understand a feature,
751      *        it must throw a WebServiceException.
752      * @throws WebServiceException If any error in creation of the
753      *                    specified service
754      *
755      * @since JAX-WS 2.2
756      */
757     public static Service create(QName serviceName, WebServiceFeature ... features) {
758         return new Service(null, serviceName, features);
759     }
760 }