public EndpointImpl(BindingID bindingId,
    Object impl) 
{
        binding = BindingImpl.create(bindingId);
        implementor = impl;
}

 public EndpointImpl(WSEndpoint wse,
    Object serverContext) 
{
        actualEndpoint = new HttpEndpoint(wse, executor);
        ((HttpEndpoint) actualEndpoint).publish(serverContext);
        binding = wse.getBinding();
        implementor = null; // this violates the semantics, but hey, this is a backdoor.
}

Wraps an already created WSEndpoint into an EndpointImpl , and immediately publishes it with the given context.

 public Binding getBinding() 
{
        return binding;
}

 public EndpointReference getEndpointReference(Element referenceParameters) 
{
        return getEndpointReference(W3CEndpointReference.class, referenceParameters);
}

 public T getEndpointReference(Class<T> clazz,
    Element referenceParameters) 
{
        if (!isPublished()) {
            throw new WebServiceException("Endpoint is not published yet");
        }
        return ((HttpEndpoint)actualEndpoint).getEndpointReference(clazz,referenceParameters);
}

 public Executor getExecutor() 
{
        return executor;
}

 public Object getImplementor() 
{
        return implementor;
}

 public List<Source> getMetadata() 
{
        return metadata;
}

 public Map<String, Object> getProperties() 
{
        return new HashMap< String, Object >(properties);
}

 public boolean isPublished() 
{
        return actualEndpoint != null;
}

 public  void publish(String address) 
{
        canPublish();
        URL url;
        try {
            url = new URL(address);
        } catch (MalformedURLException ex) {
            throw new IllegalArgumentException("Cannot create URL for this address " + address);
        }
        if (!url.getProtocol().equals("http")) {
            throw new IllegalArgumentException(url.getProtocol() + " protocol based address is not supported");
        }
        if (!url.getPath().startsWith("/")) {
            throw new IllegalArgumentException("Incorrect WebService address=" + address +
                    ". The address's path should start with /");
        }
        createEndpoint();
        ((HttpEndpoint) actualEndpoint).publish(address);
}

 public  void publish(Object serverContext) 
{
        canPublish();
        if (!com.sun.net.httpserver.HttpContext.class.isAssignableFrom(serverContext.getClass())) {
            throw new IllegalArgumentException(serverContext.getClass() + " is not a supported context.");
        }
        createEndpoint();
        ((HttpEndpoint) actualEndpoint).publish(serverContext);
}

 public  void setExecutor(Executor executor) 
{
        this.executor = executor;
}

 public  void setMetadata(List<Source> metadata) 
{
        if (isPublished()) {
            throw new IllegalStateException("Cannot set Metadata. Endpoint is already published");
        }
        this.metadata = metadata;
}

 public  void setProperties(Map<String, Object> map) 
{
        this.properties = new HashMap< String, Object >(map);
}

 public  void stop() 
{
        if (isPublished()) {
            ((HttpEndpoint) actualEndpoint).stop();
            actualEndpoint = null;
            stopped = true;
        }
}