How can I avoid reinstalling the client? Run when (JAX-WS) webservice moves elsewhere?

If you are using Spring, you can create a helper bean to configure your client (this is what I did in a recent project):

<bean name="exampleClient" class="com.lingoswap.ws.util.JaxWsClientFactoryBean">
    <property name="wsdlDocumentLocation" value="${exampleClient.wsdlDocumentLocation}" />
    <property name="namespaceURI" value="http://com.example/exampleClient" />
    <property name="localPart" value="ExampleService" />
    <property name="serviceEndpointInterface" value="com.example.ExampleServicePortType" />
</bean>

      

        
        
        
      

    

The parts between $ {...} are property placeholders, which means that this value is viewed from a properties file that is set by PropertyPlaceholderConfigurer. An example of specifying a value looks like this:

## Web Service WSDL locations
exampleClient.wsdlDocumentLocation=http://www.example.com/exampleService?wsdl

      

        
        
        
      

    

Then you can modify the properties file (probably "myapplication.properties") to change the location of the WSDL as needed (even at runtime if you are using a custom TargetSource with a ProxyFactoryBean). For what it's worth, here is my implementation of a simple JaxWsClientFactoryBean (no automatic property modification support):

package com.lingoswap.ws.util;

import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;

public class JaxWsClientFactoryBean implements FactoryBean, InitializingBean {

    private URL wsdlDocumentLocation;
    private Class<?> serviceEndpointInterface;
    private String namespaceURI;
    private String localPart;

    // derived from namespaceURI and localPart
    private QName serviceName;

    public void afterPropertiesSet() {    
        serviceName = new QName(namespaceURI, localPart);
    }

    public Object getObject() {
        Service service = Service.create(wsdlDocumentLocation, serviceName);
        Object port = service.getPort(serviceEndpointInterface);
        return port;
    }
    public Class<?> getObjectType() {
        return serviceEndpointInterface;
    }
    public boolean isSingleton() {
        return false;
    }
    public URL getWsdlDocumentLocation() {
        return wsdlDocumentLocation;
    }
    public void setWsdlDocumentLocation(final URL wsdlDocumentLocation) {
        this.wsdlDocumentLocation = wsdlDocumentLocation;
    }
    public Class<?> getServiceEndpointInterface() {
        return serviceEndpointInterface;
    }
    public void setServiceEndpointInterface(
        final Class<?> serviceEndpointInterface) {
        this.serviceEndpointInterface = serviceEndpointInterface;
    }
    public String getNamespaceURI() {
        return namespaceURI;
    }
    public void setNamespaceURI(final String namespaceURI) {
        this.namespaceURI = namespaceURI;
    }
    public String getLocalPart() {
        return localPart;
    }
    public void setLocalPart(final String localPart) {
        this.localPart = localPart;
    }
}

      

        
        
        
      

    

I decided to offer an answer even though you already answered your own question. You may find this advice helpful. The good thing about using a FactoryBean-like implementation is that it can be reused for all of your web service clients and encapsulate the creation of web services from its consumers. Objects of the web tier or business tier will only depend on the SEI (Service Endpoint Interface).