jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/WSEndpoint.java

--1:000000000000
+:373ffda63c9a
+/*
+* 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 / file comparison

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

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