jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java

Tue, 09 Apr 2013 14:51:13 +0100

author: alanb
date: Tue, 09 Apr 2013 14:51:13 +0100
changeset 368: 0989ad8c0860
parent 286: f50545b5e2f1
child 637: 9c07ef4934dd
permissions: -rw-r--r--

8010393: Update JAX-WS RI to 2.2.9-b12941
Reviewed-by: alanb, erikj
Contributed-by: miroslav.kos@oracle.com, martin.grebac@oracle.com

 /*
  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.xml.internal.ws.api.server;
 import com.sun.istack.internal.NotNull;
 import com.sun.istack.internal.Nullable;
 import com.sun.xml.internal.ws.api.BindingID;
 import com.sun.xml.internal.ws.api.Component;
 import com.sun.xml.internal.ws.api.ComponentRegistry;
 import com.sun.xml.internal.ws.api.SOAPVersion;
 import com.sun.xml.internal.ws.api.WSBinding;
 import com.sun.xml.internal.ws.api.config.management.EndpointCreationAttributes;
 import com.sun.xml.internal.ws.api.config.management.ManagedEndpointFactory;
 import com.sun.xml.internal.ws.api.databinding.MetadataReader;
 import com.sun.xml.internal.ws.api.message.Message;
 import com.sun.xml.internal.ws.api.message.Packet;
 import com.sun.xml.internal.ws.api.model.SEIModel;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;
 import com.sun.xml.internal.ws.api.pipe.Codec;
 import com.sun.xml.internal.ws.api.pipe.Engine;
 import com.sun.xml.internal.ws.api.pipe.FiberContextSwitchInterceptor;
 import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext;
 import com.sun.xml.internal.ws.api.pipe.ThrowableContainerPropertySet;
 import com.sun.xml.internal.ws.api.pipe.Tube;
 import com.sun.xml.internal.ws.policy.PolicyMap;
 import com.sun.xml.internal.ws.server.EndpointAwareTube;
 import com.sun.xml.internal.ws.server.EndpointFactory;
 import com.sun.xml.internal.ws.util.ServiceFinder;
 import com.sun.xml.internal.ws.util.xml.XmlUtil;
 import com.sun.xml.internal.ws.wsdl.OperationDispatcher;
 import com.sun.org.glassfish.gmbal.ManagedObjectManager;
 import org.xml.sax.EntityResolver;
 import org.w3c.dom.Element;
 import javax.xml.namespace.QName;
 import javax.xml.ws.Binding;
 import javax.xml.ws.EndpointReference;
 import javax.xml.ws.WebServiceContext;
 import javax.xml.ws.WebServiceException;
 import java.net.URL;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Executor;
 /**
  * Root object that hosts the {@link Packet} processing code
  * at the server.
  *
  * <p>
  * One instance of {@link WSEndpoint} is created for each deployed service
  * endpoint. A hosted service usually handles multiple concurrent
  * requests. To do this efficiently, an endpoint handles incoming
  * {@link Packet} through {@link PipeHead}s, where many copies can be created
  * for each endpoint.
  *
  * <p>
  * Each {@link PipeHead} is thread-unsafe, and request needs to be
  * serialized. A {@link PipeHead} represents a sizable resource
  * (in particular a whole pipeline), so the caller is expected to
  * reuse them and avoid excessive allocations as much as possible.
  * Making {@link PipeHead}s thread-unsafe allow the JAX-WS RI internal to
  * tie thread-local resources to {@link PipeHead}, and reduce the total
  * resource management overhead.
  *
  * <p>
  * To abbreviate this resource management (and for a few other reasons),
  * JAX-WS RI provides {@link Adapter} class. If you are hosting a JAX-WS
  * service, you'll most likely want to send requests to {@link WSEndpoint}
  * through {@link Adapter}.
  *
  * <p>
  * {@link WSEndpoint} is ready to handle {@link Packet}s as soon as
  * it's created. No separate post-initialization step is necessary.
  * However, to comply with the JAX-WS spec requirement, the caller
  * is expected to call the {@link #dispose()} method to allow an
  * orderly shut-down of a hosted service.
  *
  *
  *
  * <h3>Objects Exposed From Endpoint</h3>
  * <p>
  * {@link WSEndpoint} exposes a series of information that represents
  * how an endpoint is configured to host a service. See the getXXX methods
  * for more details.
  *
  *
  *
  * <h3>Implementation Notes</h3>
  * <p>
  * {@link WSEndpoint} owns a {@link WSWebServiceContext} implementation.
  * But a bulk of the work is delegated to {@link WebServiceContextDelegate},
  * which is passed in as a parameter to {@link PipeHead#process(Packet, WebServiceContextDelegate, TransportBackChannel)}.
  *
  * @author Kohsuke Kawaguchi
  */
 public abstract class WSEndpoint<T> implements ComponentRegistry {
     /**
      * Gets the Endpoint's codec that is used to encode/decode {@link Message}s. This is a
      * copy of the master codec and it shouldn't be shared across two requests running
      * concurrently(unless it is stateless).
      *
      * @return codec to encode/decode
      */
     public abstract @NotNull Codec createCodec();
     /**
      * Gets the application endpoint's serviceName. It could be got from DD or annotations
      *
      * @return same as wsdl:service QName if WSDL exists or generated
      */
     public abstract @NotNull QName getServiceName();
     /**
      * Gets the application endpoint's portName. It could be got from DD or annotations
      *
      * @return same as wsdl:port QName if WSDL exists or generated
      */
     public abstract @NotNull QName getPortName();
     /**
      * Gets the application endpoint {@link Class} that eventually serves the request.
      *
      * <p>
      * This is the same value given to the {@link #create} method.
      */
     public abstract @NotNull Class<T> getImplementationClass();
     /**
      * Represents the binding for which this {@link WSEndpoint}
      * is created for.
      *
      * @return
      *      always same object.
      */
     public abstract @NotNull WSBinding getBinding();
     /**
      * Gets the {@link Container} object.
      *
      * <p>
      * The components inside {@link WSEndpoint} uses this reference
      * to communicate with the hosting environment.
      *
      * @return
      *      always same object. If no "real" {@link Container} instance
      *      is given, {@link Container#NONE} will be returned.
      */
     public abstract @NotNull Container getContainer();
     /**
      * Gets the port that this endpoint is serving.
      *
      * <p>
      * A service is not required to have a WSDL, and when it doesn't,
      * this method returns null. Otherwise it returns an object that
      * describes the port that this {@link WSEndpoint} is serving.
      *
      * @return
      *      Possibly null, but always the same value.
      */
     public abstract @Nullable WSDLPort getPort();
     /**
      * Set this {@link Executor} to run asynchronous requests using this executor.
      * This executor is set on {@link Engine} and must be set before
      * calling {@link #schedule(Packet,CompletionCallback) } and
      * {@link #schedule(Packet,CompletionCallback,FiberContextSwitchInterceptor)} methods.
      *
      * @param exec Executor to run async requests
      */
     public abstract void setExecutor(@NotNull Executor exec);
     /**
      * This method takes a {@link Packet} that represents
      * a request, run it through a {@link Tube}line, eventually
      * pass it to the user implementation code, which produces
      * a reply, then run that through the tubeline again,
      * and eventually return it as a return value through {@link CompletionCallback}.
      *
      * <p>
      * This takes care of pooling of {@link Tube}lines and reuses
      * tubeline for requests. Same instance of tubeline is not used concurrently
      * for two requests.
      *
      * <p>
      * If the transport is capable of asynchronous execution, use this
      * instead of using {@link PipeHead#process}.
      *
      * <p>
      * Before calling this method, set the executor using {@link #setExecutor}. The
      * executor may used multiple times to run this request in a asynchronous fashion.
      * The calling thread will be returned immediately, and the callback will be
      * called in a different a thread.
      *
      * <p>
      * {@link Packet#transportBackChannel} should have the correct value, so that
      * one-way message processing happens correctly. {@link Packet#webServiceContextDelegate}
      * should have the correct value, so that some {@link WebServiceContext} methods correctly.
      *
      * @see Packet#transportBackChannel
      * @see Packet#webServiceContextDelegate
      *
      * @param request web service request
      * @param callback callback to get response packet
      */
     public final void schedule(@NotNull Packet request, @NotNull CompletionCallback callback ) {
         schedule(request,callback,null);
     }
     /**
      * Schedule invocation of web service asynchronously.
      *
      * @see #schedule(Packet, CompletionCallback)
      *
      * @param request web service request
      * @param callback callback to get response packet(exception if there is one)
      * @param interceptor caller's interceptor to impose a context of execution
      */
     public abstract void schedule(@NotNull Packet request, @NotNull CompletionCallback callback, @Nullable FiberContextSwitchInterceptor interceptor );
     public void process(@NotNull Packet request, @NotNull CompletionCallback callback, @Nullable FiberContextSwitchInterceptor interceptor ) {
        schedule(request,callback,interceptor);
     }
     /**
      * Returns {@link Engine} for this endpoint
      * @return Engine
      */
     public Engine getEngine() {
         throw new UnsupportedOperationException();
     }
     /**
      * Callback to notify that jax-ws runtime has finished execution of a request
      * submitted via schedule().
      */
     public interface CompletionCallback {
         /**
          * Indicates that the jax-ws runtime has finished execution of a request
          * submitted via schedule().
          *
          * <p>
          * Since the JAX-WS RI runs asynchronously,
          * this method maybe invoked by a different thread
          * than any of the threads that started it or run a part of tubeline.
          *
          * @param response {@link Packet}
          */
         void onCompletion(@NotNull Packet response);
     }
     /**
      * Creates a new {@link PipeHead} to process
      * incoming requests.
      *
      * <p>
      * This is not a cheap operation. The caller is expected
      * to reuse the returned {@link PipeHead}. See
      * {@link WSEndpoint class javadoc} for details.
      *
      * @return
      *      A newly created {@link PipeHead} that's ready to serve.
      */
     public abstract @NotNull PipeHead createPipeHead();
     /**
      * Represents a resource local to a thread.
      *
      * See {@link WSEndpoint} class javadoc for more discussion about
      * this.
      */
     public interface PipeHead {
         /**
          * Processes a request and produces a reply.
          *
          * <p>
          * This method takes a {@link Packet} that represents
          * a request, run it through a {@link Tube}line, eventually
          * pass it to the user implementation code, which produces
          * a reply, then run that through the pipeline again,
          * and eventually return it as a return value.
          *
          * @param request
          *      Unconsumed {@link Packet} that represents
          *      a request.
          * @param wscd
          *      {@link WebServiceContextDelegate} to be set to {@link Packet}.
          *      (we didn't have to take this and instead just ask the caller to
          *      set to {@link Packet#webServiceContextDelegate}, but that felt
          *      too error prone.)
          * @param tbc
          *      {@link TransportBackChannel} to be set to {@link Packet}.
          *      See the {@code wscd} parameter javadoc for why this is a parameter.
          *      Can be null.
          * @return
          *      Unconsumed {@link Packet} that represents
          *      a reply to the request.
          *
          * @throws WebServiceException
          *      This method <b>does not</b> throw a {@link WebServiceException}.
          *      The {@link WSEndpoint} must always produce a fault {@link Message}
          *      for it.
          *
          * @throws RuntimeException
          *      A {@link RuntimeException} thrown from this method, including
          *      {@link WebServiceException}, must be treated as a bug in the
          *      code (including JAX-WS and all the pipe implementations), not
          *      an operator error by the user.
          *
          *      <p>
          *      Therefore, it should be recorded by the caller in a way that
          *      allows developers to fix a bug.
          */
         @NotNull Packet process(
             @NotNull Packet request, @Nullable WebServiceContextDelegate wscd, @Nullable TransportBackChannel tbc);
     }
     /**
      * Indicates that the {@link WSEndpoint} is about to be turned off,
      * and will no longer serve any packet anymore.
      *
      * <p>
      * This method needs to be invoked for the JAX-WS RI to correctly
      * implement some of the spec semantics (TODO: pointer.)
      * It's the responsibility of the code that hosts a {@link WSEndpoint}
      * to invoke this method.
      *
      * <p>
      * Once this method is called, the behavior is undefed for
      * all in-progress {@link PipeHead#process} methods (by other threads)
      * and future {@link PipeHead#process} method invocations.
      */
     public abstract void dispose();
     /**
      * Gets the description of the service.
      *
      * <p>
      * A description is a set of WSDL/schema and other documents that together
      * describes a service.
      * A service is not required to have a description, and when it doesn't,
      * this method returns null.
      *
      * @return
      *      Possibly null, always the same value under ordinary circumstances but
      *      may change if the endpoint is managed.
      */
     public abstract @Nullable ServiceDefinition getServiceDefinition();
     /**
      * Gets the list of {@link BoundEndpoint} that are associated
      * with this endpoint.
      *
      * @return
      *      always return the same set.
      */
     public List<BoundEndpoint> getBoundEndpoints() {
         Module m = getContainer().getSPI(Module.class);
         return m != null ? m.getBoundEndpoints() : null;
     }
     /**
      * Gets the list of {@link EndpointComponent} that are associated
      * with this endpoint.
      *
      * <p>
      * Components (such as codec, tube, handler, etc) who wish to provide
      * some service to other components in the endpoint can iterate the
      * registry and call its {@link EndpointComponent#getSPI(Class)} to
      * establish a private contract between components.
      * <p>
      * Components who wish to subscribe to such a service can add itself
      * to this set.
      *
      * @return
      *      always return the same set.
      * @deprecated
      */
     public abstract @NotNull Set<EndpointComponent> getComponentRegistry();
         public @NotNull Set<Component> getComponents() {
         return Collections.emptySet();
     }
         public @Nullable <S> S getSPI(@NotNull Class<S> spiType) {
                 Set<Component> componentRegistry = getComponents();
                 if (componentRegistry != null) {
                         for (Component c : componentRegistry) {
                                 S s = c.getSPI(spiType);
                                 if (s != null)
                                         return s;
                         }
                 }
                 return getContainer().getSPI(spiType);
         }
     /**
      * Gets the {@link com.sun.xml.internal.ws.api.model.SEIModel} that represents the relationship
      * between WSDL and Java SEI.
      *
      * <p>
      * This method returns a non-null value if and only if this
      * endpoint is ultimately serving an application through an SEI.
      *
      * @return
      *      maybe null. See above for more discussion.
      *      Always the same value.
      */
     public abstract @Nullable SEIModel getSEIModel();
     /**
      * Gives the PolicMap that captures the Policy for the endpoint
      *
      * @return PolicyMap
      *
      * @deprecated
      * Do not use this method as the PolicyMap API is not final yet and might change in next few months.
      */
     public abstract PolicyMap getPolicyMap();
     /**
      * Get the ManagedObjectManager for this endpoint.
      */
     public abstract @NotNull ManagedObjectManager getManagedObjectManager();
     /**
      * Close the ManagedObjectManager for this endpoint.
      * This is used by the Web Service Configuration Management system so that it
      * closes the MOM before it creates a new WSEndpoint.  Then it calls dispose
      * on the existing endpoint and then installs the new endpoint.
      * The call to dispose also calls closeManagedObjectManager, but is a noop
      * if that method has already been called.
      */
     public abstract void closeManagedObjectManager();
     /**
      * This is only needed to expose info for monitoring.
      */
     public abstract @NotNull ServerTubeAssemblerContext getAssemblerContext();
     /**
      * Creates an endpoint from deployment or programmatic configuration
      *
      * <p>
      * This method works like the following:
      * <ol>
      * <li>{@link ServiceDefinition} is modeleed from the given SEI type.
      * <li>{@link Invoker} that always serves <tt>implementationObject</tt> will be used.
      * </ol>
      * @param implType
      *      Endpoint class(not SEI). Enpoint class must have @WebService or @WebServiceProvider
      *      annotation.
      * @param processHandlerAnnotation
      *      Flag to control processing of @HandlerChain on Impl class
      *      if true, processes @HandlerChain on Impl
      *      if false, DD might have set HandlerChain no need to parse.
      * @param invoker
      *      Pass an object to invoke the actual endpoint object. If it is null, a default
      *      invoker is created using {@link InstanceResolver#createDefault}. Appservers
      *      could create its own invoker to do additional functions like transactions,
      *      invoking the endpoint through proxy etc.
      * @param serviceName
      *      Optional service name(may be from DD) to override the one given by the
      *      implementation class. If it is null, it will be derived from annotations.
      * @param portName
      *      Optional port name(may be from DD) to override the one given by the
      *      implementation class. If it is null, it will be derived from annotations.
      * @param container
      *      Allows technologies that are built on top of JAX-WS(such as WSIT) needs to
      *      negotiate private contracts between them and the container
      * @param binding
      *      JAX-WS implementation of {@link Binding}. This object can be created by
      *      {@link BindingID#createBinding()}. Usually the binding can be got from
      *      DD, {@link javax.xml.ws.BindingType}.
      *
      *
      * TODO: DD has a configuration for MTOM threshold.
      * Maybe we need something more generic so that other technologies
      * like Tango can get information from DD.
      *
      * TODO: does it really make sense for this to take EntityResolver?
      * Given that all metadata has to be given as a list anyway.
      *
      * @param primaryWsdl
      *      The {@link ServiceDefinition#getPrimary() primary} WSDL.
      *      If null, it'll be generated based on the SEI (if this is an SEI)
      *      or no WSDL is associated (if it's a provider.)
      *      TODO: shouldn't the implementation find this from the metadata list?
      * @param metadata
      *      Other documents that become {@link SDDocument}s. Can be null.
      * @param resolver
      *      Optional resolver used to de-reference resources referenced from
      *      WSDL. Must be null if the {@code url} is null.
      * @param isTransportSynchronous
      *      If the caller knows that the returned {@link WSEndpoint} is going to be
      *      used by a synchronous-only transport, then it may pass in <tt>true</tt>
      *      to allow the callee to perform an optimization based on that knowledge
      *      (since often synchronous version is cheaper than an asynchronous version.)
      *      This value is visible from {@link ServerTubeAssemblerContext#isSynchronous()}.
      *
      * @return newly constructed {@link WSEndpoint}.
      * @throws WebServiceException
      *      if the endpoint set up fails.
      */
     public static <T> WSEndpoint<T> create(
             @NotNull Class<T> implType,
             boolean processHandlerAnnotation,
             @Nullable Invoker invoker,
             @Nullable QName serviceName,
             @Nullable QName portName,
             @Nullable Container container,
             @Nullable WSBinding binding,
             @Nullable SDDocumentSource primaryWsdl,
             @Nullable Collection<? extends SDDocumentSource> metadata,
             @Nullable EntityResolver resolver,
             boolean isTransportSynchronous) {
         return create(implType, processHandlerAnnotation, invoker, serviceName, portName, container, binding, primaryWsdl, metadata, resolver, isTransportSynchronous, true);
     }
     public static <T> WSEndpoint<T> create(
         @NotNull Class<T> implType,
         boolean processHandlerAnnotation,
         @Nullable Invoker invoker,
         @Nullable QName serviceName,
         @Nullable QName portName,
         @Nullable Container container,
         @Nullable WSBinding binding,
         @Nullable SDDocumentSource primaryWsdl,
         @Nullable Collection<? extends SDDocumentSource> metadata,
         @Nullable EntityResolver resolver,
         boolean isTransportSynchronous,
         boolean isStandard)
     {
         final WSEndpoint<T> endpoint =
             EndpointFactory.createEndpoint(
                 implType,processHandlerAnnotation, invoker,serviceName,portName,container,binding,primaryWsdl,metadata,resolver,isTransportSynchronous,isStandard);
         final Iterator<ManagedEndpointFactory> managementFactories = ServiceFinder.find(ManagedEndpointFactory.class).iterator();
         if (managementFactories.hasNext()) {
             final ManagedEndpointFactory managementFactory = managementFactories.next();
             final EndpointCreationAttributes attributes = new EndpointCreationAttributes(
                     processHandlerAnnotation, invoker, resolver, isTransportSynchronous);
             WSEndpoint<T> managedEndpoint = managementFactory.createEndpoint(endpoint, attributes);
             if (endpoint.getAssemblerContext().getTerminalTube() instanceof EndpointAwareTube) {
                 ((EndpointAwareTube)endpoint.getAssemblerContext().getTerminalTube()).setEndpoint(managedEndpoint);
             }
             return managedEndpoint;
         }
         return endpoint;
     }
     /**
      * Deprecated version that assumes <tt>isTransportSynchronous==false</tt>
      */
     @Deprecated
     public static <T> WSEndpoint<T> create(
         @NotNull Class<T> implType,
         boolean processHandlerAnnotation,
         @Nullable Invoker invoker,
         @Nullable QName serviceName,
         @Nullable QName portName,
         @Nullable Container container,
         @Nullable WSBinding binding,
         @Nullable SDDocumentSource primaryWsdl,
         @Nullable Collection<? extends SDDocumentSource> metadata,
         @Nullable EntityResolver resolver) {
         return create(implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata,resolver,false);
     }
     /**
      * The same as
      * {@link #create(Class, boolean, Invoker, QName, QName, Container, WSBinding, SDDocumentSource, Collection, EntityResolver)}
      * except that this version takes an url of the <tt>jax-ws-catalog.xml</tt>.
      *
      * @param catalogUrl
      *      if not null, an {@link EntityResolver} is created from it and used.
      *      otherwise no resolution will be performed.
      */
     public static <T> WSEndpoint<T> create(
         @NotNull Class<T> implType,
         boolean processHandlerAnnotation,
         @Nullable Invoker invoker,
         @Nullable QName serviceName,
         @Nullable QName portName,
         @Nullable Container container,
         @Nullable WSBinding binding,
         @Nullable SDDocumentSource primaryWsdl,
         @Nullable Collection<? extends SDDocumentSource> metadata,
         @Nullable URL catalogUrl) {
         return create(
             implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata,
             XmlUtil.createEntityResolver(catalogUrl),false);
     }
     /**
      * Gives the wsdl:service default name computed from the endpoint implementaiton class
      */
     public static @NotNull QName getDefaultServiceName(Class endpointClass){
         return getDefaultServiceName(endpointClass, true, null);
     }
     public static @NotNull QName getDefaultServiceName(Class endpointClass, MetadataReader metadataReader){
         return getDefaultServiceName(endpointClass, true, metadataReader);
     }
     public static @NotNull QName getDefaultServiceName(Class endpointClass, boolean isStandard){
         return getDefaultServiceName(endpointClass, isStandard, null);
     }
     public static @NotNull QName getDefaultServiceName(Class endpointClass, boolean isStandard, MetadataReader metadataReader){
         return EndpointFactory.getDefaultServiceName(endpointClass, isStandard, metadataReader);
     }
     /**
      * Gives the wsdl:service/wsdl:port default name computed from the endpoint implementaiton class
      */
     public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass) {
         return getDefaultPortName(serviceName, endpointClass, null);
     }
     public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, MetadataReader metadataReader) {
         return getDefaultPortName(serviceName, endpointClass, true, metadataReader);
     }
     public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, boolean isStandard) {
         return getDefaultPortName(serviceName, endpointClass, isStandard, null);
     }
     public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, boolean isStandard, MetadataReader metadataReader){
         return EndpointFactory.getDefaultPortName(serviceName, endpointClass, isStandard, metadataReader);
     }
     /**
      * Return EndpointReference instance, based on passed parameters and spec version represented by clazz
      * @param <T>
      * @param clazz represents spec version
      * @param address   endpoint address
      * @param wsdlAddress   wsdl address
      * @param referenceParameters   any reference parameters to be added to the instance
      * @return EndpointReference instance based on passed parameters and values obtained from current instance
      */
     public abstract <T extends EndpointReference> T getEndpointReference(Class<T> clazz, String address, String wsdlAddress, Element... referenceParameters);
     /**
      *
      * @param <T>
      * @param clazz
      * @param address
      * @param wsdlAddress
      * @param metadata
      * @param referenceParameters
      * @return EndpointReference instance based on passed parameters and values obtained from current instance
      */
     public abstract <T extends EndpointReference> T getEndpointReference(Class<T> clazz,
             String address, String wsdlAddress, List<Element> metadata,
             List<Element> referenceParameters);
     /**
      * Used for managed endpoints infrastructure to compare equality of proxies vs proxied endpoints.
      * @param endpoint
      * @return true if the proxied endpoint instance held by this instance equals to 'endpoint', otherwise return false.
      */
     public boolean equalsProxiedInstance(WSEndpoint endpoint) {
         if (endpoint == null) return false;
         return this.equals(endpoint);
     }
     /**
      * Nullable when there is no associated WSDL Model
      * @return
      */
     public abstract @Nullable OperationDispatcher getOperationDispatcher();
     /**
      * This is used by WsaServerTube and WSEndpointImpl to create a Packet with SOAPFault message from a Java exception.
      */
     public abstract Packet createServiceResponseForException(final ThrowableContainerPropertySet tc,
                                                              final Packet      responsePacket,
                                                              final SOAPVersion soapVersion,
                                                              final WSDLPort    wsdlPort,
                                                              final SEIModel    seiModel,
                                                              final WSBinding   binding);
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java