Set SSL et délai d'attente pour WS appeler au printemps (HttpsUrlConnectionMessageSender, HttpsUrlConnectionMessageSender)

Question

Je suis en train de définir le délai et le protocole SSL (https) pour l'appel WS:

PS: Pas besoin de marquer ce reproduite, le seul similaire question n'a jamais été répondu.

1. J'ai essayé HttpsUrlConnectionMessageSender qui ajoute le support des certificats (auto-signé) HTTPS, mais il ne délai d'attente de soutien.
2. lorsque je passe à HttpComponentsMessageSender qui prend en charge le délai d'expiration (connexion et délais de lecture), il prend en charge SSL.

Je veux combile délai d'attente et ssl lorsque vous appelez WS:

webServiceTemplate.setDefaultUri(uri); 
    response = webServiceTemplate.marshalSendAndReceive(inputs, new SoapHandler(createCredentials(), soapAction)); 

Answer 1

Enfin, l'a fait en utilisant HttpComponentsMessageSender. Voici mon code:

HttpComponentsMessageSender messageSender = new HttpComponentsMessageSender(); 
HttpClient httpClient = HttpClientFactory.getHttpsClient(sslUtils, timeout); 
messageSender.setHttpClient(httpClient); 
webServiceTemplate.setMessageSender(messageSender); 

J'ai aussi créé une nouvelle classe d'usine HttpClientFactory qui définit le protocole SSL et délai d'attente:

import java.io.IOException; 
import java.security.KeyManagementException; 
import java.security.KeyStore; 
import java.security.KeyStoreException; 
import java.security.NoSuchAlgorithmException; 
import java.security.UnrecoverableKeyException; 
import java.security.cert.CertificateException; 

import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.SSLSession; 

import org.apache.http.HttpException; 
import org.apache.http.HttpRequest; 
import org.apache.http.HttpRequestInterceptor; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.config.RequestConfig; 
import org.apache.http.conn.ssl.SSLConnectionSocketFactory; 
import org.apache.http.conn.ssl.SSLContextBuilder; 
import org.apache.http.conn.ssl.SSLContexts; 
import org.apache.http.conn.ssl.TrustSelfSignedStrategy; 
import org.apache.http.impl.client.CloseableHttpClient; 
import org.apache.http.impl.client.HttpClientBuilder; 
import org.apache.http.impl.client.HttpClients; 
import org.apache.http.protocol.HTTP; 
import org.apache.http.protocol.HttpContext; 

public class HttpClientFactory { 

    private static CloseableHttpClient client; 

    private HttpClientFactory() { 
    } 

    public static HttpClient getHttpsClient(SslUtils sslUtils, int timeout) throws Exception { 

     if (client != null) { 
      return client; 
     } 

     SSLContext sslcontext = getSSLContext(sslUtils); 
     SSLConnectionSocketFactory factory = new SSLConnectionSocketFactory(sslcontext, new HostnameVerifier() { 
      @Override 
      public boolean verify(String hostname, SSLSession session) { 
       return true; 
      } 
     }); 
     HttpClientBuilder httpClientBuilder = HttpClients.custom(); 
     httpClientBuilder.addInterceptorFirst(new ContentLengthHeaderRemover()); 
     RequestConfig config = RequestConfig.custom() 
            .setConnectTimeout(timeout) 
            .setConnectionRequestTimeout(timeout) 
            .setSocketTimeout(timeout) 
            .build(); 

     return httpClientBuilder.setSSLSocketFactory(factory) 
        .setDefaultRequestConfig(config) 
        .build(); 
    } 

    private static class ContentLengthHeaderRemover implements HttpRequestInterceptor { 
     @Override 
     public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { 
      request.removeHeaders(HTTP.CONTENT_LEN); 
     } 
    } 

    public static void releaseInstance() { 
     client = null; 
    } 

    private static SSLContext getSSLContext(SslUtils sslUtils) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException, KeyManagementException { 

     KeyStore ks = KeyStore.getInstance("JKS"); 
     ks.load(sslUtils.getKeystore().getInputStream(), sslUtils.getKeyPwd().toCharArray()); 
     sslUtils.getKeystore().getInputStream().close(); 

     KeyStore ts = KeyStore.getInstance("JKS"); 
     ts.load(sslUtils.getTrustStore().getInputStream(), sslUtils.getTrustPwd().toCharArray()); 
     sslUtils.getTrustStore().getInputStream().close(); 

     SSLContextBuilder sslContextBuilder = SSLContexts.custom(); 
     try { 
      sslContextBuilder = SSLContexts.custom().loadKeyMaterial(ks, ssl.getKeyPwd().toCharArray()); 
     } catch (UnrecoverableKeyException e) { 
      e.printStack(); 
     } 
     sslContextBuilder.loadTrustMaterial(ts, new TrustSelfSignedStrategy()); 
     return sslContextBuilder.build(); 
    } 
} 

Pour plus d'informations les SslUtils est juste une classe de haricot qui contient les informations keystore et trustStore ':

public class SslUtils { 

    private Resource keystore; 
    private String keyPwd; 
    private Resource trustStore; 
    private String trustPwd; 

    // Getters and Setters 
} 

Ceci fonctionne pour moi et permettez-moi d'utiliser à la fois SSL et timeout. J'espère que cela aidera les autres.