Using Two different JAX-WS client implementations

javax.xml.ws.spi.Provider

com.snaphop.jaxws.ThreadLocalProvider

ThreadLocalProvider.java

package com.snaphop.jaxws;

import static java.util.Arrays.asList;

import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ServiceLoader;

import javax.xml.namespace.QName;
import javax.xml.transform.Source;
import javax.xml.ws.Endpoint;
import javax.xml.ws.EndpointReference;
import javax.xml.ws.WebServiceFeature;
import javax.xml.ws.spi.Provider;
import javax.xml.ws.spi.ServiceDelegate;
import javax.xml.ws.wsaddressing.W3CEndpointReference;

import org.w3c.dom.Element;


public class ThreadLocalProvider extends Provider {
	
	private static final ThreadLocal<Provider> providerContext = new ThreadLocal<Provider>();
	
	public static Collection<String> JAXWS_RI_PROVIDER = Collections.unmodifiableList(asList("com.sun.xml.ws.spi.ProviderImpl"));
	public static Collection<String> CXF_PROVIDER = Collections.unmodifiableList(asList("org.apache.cxf.jaxws.spi.ProviderImpl", "org.apache.cxf.jaxws22.spi.ProviderImpl"));

	Provider _getProvider() {
		Provider p = providerContext.get();
		if (p == null) {
			//Should synchronize here?
			p = _findProviderWithServiceLoader(null);
			setProviderForCurrentThread(p);
		}
		return p;
	}
	
	static Provider _findProviderWithServiceLoader(Collection<String> names) {
		ServiceLoader<Provider> loader = ServiceLoader.load(Provider.class);
		Iterator<Provider> pit = loader.iterator();
		while (pit.hasNext()) {
			Provider p = pit.next();
			final String cn = p.getClass().getName();
			if (! "com.snaphop.jaxws.ThreadLocalProvider".equals(cn)) {
				if (names != null && names.contains(cn)) {
					return p;
				}
				else if(names == null || names.isEmpty()) {
					return p;
				}
			}
		}
		return null;
	}
	
	static void setProviderForCurrentThread(Provider provider) {
		//if (providerContext.get() == null) //Ignore if its already set.
		providerContext.set(provider);
	}
	
	public static void setProvider(Collection<String> className) {
		Provider p = _findProviderWithServiceLoader(className);
		setProviderForCurrentThread(p);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public ServiceDelegate createServiceDelegate(URL wsdlDocumentLocation, QName serviceName, Class serviceClass) {
		return _getProvider().createServiceDelegate(wsdlDocumentLocation, serviceName, serviceClass);
	}

	@Override
	public Endpoint createEndpoint(String bindingId, Object implementor) {
		return _getProvider().createEndpoint(bindingId, implementor);
	}

	@Override
	public Endpoint createAndPublishEndpoint(String address, Object implementor) {
		return _getProvider().createAndPublishEndpoint(address, implementor);
	}

	@Override
	public EndpointReference readEndpointReference(Source eprInfoset) {
		return _getProvider().readEndpointReference(eprInfoset);
	}

	@Override
	public <T> T getPort(EndpointReference endpointReference, Class<T> serviceEndpointInterface,
			WebServiceFeature... features) {
		return _getProvider().getPort(endpointReference, serviceEndpointInterface, features);
	}

	@Override
	public W3CEndpointReference createW3CEndpointReference(String address, QName serviceName, QName portName,
			List<Element> metadata, String wsdlDocumentLocation, List<Element> referenceParameters) {
		return _getProvider().createW3CEndpointReference(address, serviceName, portName, metadata, wsdlDocumentLocation, referenceParameters);
	}

}

To force a provider

   ThreadLocalProvider.setProvider(ThreadLocalProvider.JAXWS_RI_PROVIDER);

OR

   ThreadLocalProvider.setProvider(ThreadLocalProvider.CXF_PROVIDER);