Q:

I found an https client to consume webservice; is this client is using 2-way or 1-way SSL?

package demo.hw_https.client;

import java.io.File; import java.io.FileInputStream; import
java.io.FileNotFoundException; import java.io.IOException; import
java.net.URL; import java.security.GeneralSecurityException; import
java.security.KeyStore; import java.security.KeyStoreException; import
java.security.NoSuchAlgorithmException;

import javax.net.ssl.KeyManager; import
javax.net.ssl.KeyManagerFactory; import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory; import
javax.xml.namespace.QName;

import org.apache.cxf.configuration.jsse.TLSClientParameters; import
org.apache.cxf.frontend.ClientProxy; import
org.apache.cxf.transport.http.HTTPConduit; import
org.apache.hello_world_soap_http.Greeter; import
org.apache.hello_world_soap_http.SOAPService;

public final class ClientNonSpring {

    private static final QName SERVICE_NAME
        = new QName("http://apache.org/hello_world_soap_http", "SOAPService");

    private static final QName PORT_NAME =
        new QName("http://apache.org/hello_world_soap_http", "SoapPort");

    private ClientNonSpring() {
    }

    public static void main(String args[]) throws Exception {

        if (args.length == 0) {
            System.out.println("please specify wsdl");
            System.exit(1);
        }

        URL wsdlURL;
        File wsdlFile = new File(args[0]);
        if (wsdlFile.exists()) {
            wsdlURL = wsdlFile.toURI().toURL();
        } else {
            wsdlURL = new URL(args[0]);
        }

        System.out.println(wsdlURL);
        SOAPService ss = new SOAPService(wsdlURL, SERVICE_NAME);
        Greeter port = ss.getPort(PORT_NAME, Greeter.class);        
        if ("secure".equals(args[1])) {
            setupTLS(port);
        } else if ("insecure".equals(args[1])) {
            //do nothing
        } else {
            System.out.println("arg1 needs to be either secure or insecure");
            System.exit(1);
        }

        System.out.println("Invoking greetMe...");
        try {
            String resp = port.greetMe(System.getProperty("user.name"));
            System.out.println("Server responded with: " + resp);
            System.out.println();

        } catch (Exception e) {
            System.out.println("Invocation failed with the following: " + e.getCause());
            System.out.println();
        }

        System.exit(0);
    }

    private static void setupTLS(Greeter port) 
        throws FileNotFoundException, IOException, GeneralSecurityException {
        String keyStoreLoc = "src/main/config/clientKeystore.jks";
        HTTPConduit httpConduit = (HTTPConduit) ClientProxy.getClient(port).getConduit();

        TLSClientParameters tlsCP = new TLSClientParameters();
        String keyPassword = "ckpass";
        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(new FileInputStream(keyStoreLoc), "cspass".toCharArray());
        KeyManager[] myKeyManagers = getKeyManagers(keyStore, keyPassword);
        tlsCP.setKeyManagers(myKeyManagers);

        KeyStore trustStore = KeyStore.getInstance("JKS");
        trustStore.load(new FileInputStream(keyStoreLoc), "cspass".toCharArray());
        TrustManager[] myTrustStoreKeyManagers = getTrustManagers(trustStore);
        tlsCP.setTrustManagers(myTrustStoreKeyManagers);

        httpConduit.setTlsClientParameters(tlsCP);
    }

    private static TrustManager[] getTrustManagers(KeyStore trustStore) 
        throws NoSuchAlgorithmException, KeyStoreException {
        String alg = KeyManagerFactory.getDefaultAlgorithm();
        TrustManagerFactory fac = TrustManagerFactory.getInstance(alg);
        fac.init(trustStore);
        return fac.getTrustManagers();
    }

    private static KeyManager[] getKeyManagers(KeyStore keyStore, String keyPassword) 
        throws GeneralSecurityException, IOException {
        String alg = KeyManagerFactory.getDefaultAlgorithm();
        char[] keyPass = keyPassword != null
                     ? keyPassword.toCharArray()
                     : null;
        KeyManagerFactory fac = KeyManagerFactory.getInstance(alg);
        fac.init(keyStore, keyPass);
        return fac.getKeyManagers();
    }

}

A:

Not sure what you meant by one way or two way... If a SSL network connection is established it will be encrypted in both ways (request and response).
But if your question is targeted to the direction, if only server is authenticated or client is also athenticated, it looks like your code is doing both. You would not need a client keyStore configuration if only the servers certificate would be used. The servers public key must be contained within the trust-store. Client Authentication is usually not required (for example when you request a web-page via https from a server).

