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