Jersey Client + set proxy

Question

Hola, tengo un jersey client que utilizo para subir un archivo. Intenté usarlo localmente y todo funciona bien. Pero en el entorno de producción, tengo que establecer el proxy. Busqué en algunas páginas, pero no pude encontrar la solución exacta. ¿Alguien puede ayudarme con esto?

aquí es mi código de cliente:

File file = new File("e:\\test.zip"); 
FormDataMultiPart part = new FormDataMultiPart(); 

    part.bodyPart(new FileDataBodyPart("file", file, MediaType.APPLICATION_OCTET_STREAM_TYPE)); 

    WebResource resource = null; 

    if(proxy.equals("yes")){ 
    //How do i configure client in this case? 

    }else{ 
      //this uses system proxy i guess 
     resource = Client.create().resource(url); 
    } 

    String response = (String)resource.type(MediaType.MULTIPART_FORM_DATA_TYPE).post(String.class, part); 

    System.out.println(response); 

Answer 1

Aquí van:

DefaultApacheHttpClient4Config config = new DefaultApacheHttpClient4Config(); 
     config.getProperties().put(
     ApacheHttpClient4Config.PROPERTY_PROXY_URI, 
     "PROXY_URL" 
); 

config.getProperties().put(
     ApacheHttpClient4Config.PROPERTY_PROXY_USERNAME, 
     "PROXY_USER" 
); 

config.getProperties().put(
     ApacheHttpClient4Config.PROPERTY_PROXY_PASSWORD, 
     "PROXY_PASS" 
);  

Client c = ApacheHttpClient4.create(config); 
WebResource r = c.resource("https://www.google.com/"); 

Answer 2

hay un acercamiento más fácil, si se quiere evitar más bibliotecas en proyectos heredados y no hay necesidad de Autentificación de poder:

en primer lugar se necesita una clase que implementa HttpURLConnectionFactory:

import java.io.IOException; 
import java.net.HttpURLConnection; 
import java.net.InetSocketAddress; 
import java.net.Proxy; 
import java.net.URL; 

import com.sun.jersey.client.urlconnection.HttpURLConnectionFactory; 


public class ConnectionFactory implements HttpURLConnectionFactory { 

    Proxy proxy; 

    private void initializeProxy() { 
     proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("myproxy.com", 3128)); 
    } 

    public HttpURLConnection getHttpURLConnection(URL url) throws IOException { 
     initializeProxy(); 
     return (HttpURLConnection) url.openConnection(proxy); 
    } 
} 

segundo es crear una instancia de un com.sun.jersey.client.urlconnection.URLConnectionHandler

URLConnectionClientHandler ch = new URLConnectionClientHandler(new ConnectionFactory()); 

y la tercera es utilizar el Client Constructor en lugar de Client.create:

Client client = new Client(ch); 

Por supuesto, se puede personalizar la inicialización del proxy en el ConnectionFactory .

Answer 3

luckyluke answer shall work. Aquí mi versión:

ClientConfig config = new DefaultClientConfig(); 
Client client = new Client(new URLConnectionClientHandler(
     new HttpURLConnectionFactory() { 
    Proxy p = null; 
    @Override 
    public HttpURLConnection getHttpURLConnection(URL url) 
      throws IOException { 
     if (p == null) { 
      if (System.getProperties().containsKey("http.proxyHost")) { 
       p = new Proxy(Proxy.Type.HTTP, 
         new InetSocketAddress(
         System.getProperty("http.proxyHost"), 
         Integer.getInteger("http.proxyPort", 80))); 
      } else { 
       p = Proxy.NO_PROXY; 
      } 
     } 
     return (HttpURLConnection) url.openConnection(p); 
    } 
}), config); 

Answer 4

Tomé user67871 y cambió un poco. Lo bueno de este enfoque es que funciona con el proxy del sistema en Windows. Si está en Windows y configura un proxy en IE, este código lo detectará. Cuando está ejecutando Fiddler, también establece el proxy del sistema, por lo que es muy fácil usar Jersey y Fiddler juntos.

Client client = new Client(new URLConnectionClientHandler(
      new HttpURLConnectionFactory() { 
     Proxy p = null; 

     @Override 
     public HttpURLConnection getHttpURLConnection(URL url) 
       throws IOException { 
      try { 
       if (p == null) { 
        List<Proxy> proxies = ProxySelector.getDefault().select(url.toURI()); 
        if (proxies != null) { 
         // just use the first one, I don't know if we should sometimes use a different one 
         p = proxies.get(0); 
        } 
        if (p == null) { 
         p = Proxy.NO_PROXY; 
        } 
       } 
       return (HttpURLConnection) url.openConnection(p); 
      } catch (URISyntaxException ex) { 
       throw new IOException(ex); 
      } 
     } 
    }), config); 

Answer 5

Primero de todo lo creado esta clase

import com.sun.jersey.client.urlconnection.HttpURLConnectionFactory; 
    import java.io.IOException; 
    import java.net.HttpURLConnection; 
    import java.net.InetSocketAddress; 
    import java.net.Proxy; 
    import java.net.URL; 
    import java.security.KeyManagementException; 
import java.security.NoSuchAlgorithmException; 
import java.security.SecureRandom; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.HttpsURLConnection; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.TrustManager; 

/** 
* 
* @author Aimable 
*/ 
public class ConnectionFactory implements HttpURLConnectionFactory { 

    Proxy proxy; 

    String proxyHost; 

    Integer proxyPort; 

    SSLContext sslContext; 

    public ConnectionFactory() { 
    } 

    public ConnectionFactory(String proxyHost, Integer proxyPort) { 
     this.proxyHost = proxyHost; 
     this.proxyPort = proxyPort; 
    } 

    private void initializeProxy() { 
     proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort)); 
    } 

    @Override 
    public HttpURLConnection getHttpURLConnection(URL url) throws IOException { 
     initializeProxy(); 
     HttpURLConnection con = (HttpURLConnection) url.openConnection(proxy); 
     if (con instanceof HttpsURLConnection) { 
      System.out.println("The valus is...."); 
      HttpsURLConnection httpsCon = (HttpsURLConnection) url.openConnection(proxy); 
      httpsCon.setHostnameVerifier(getHostnameVerifier()); 
      httpsCon.setSSLSocketFactory(getSslContext().getSocketFactory()); 
      return httpsCon; 
     } else { 
      return con; 
     } 

    } 

    public SSLContext getSslContext() { 
     try { 
      sslContext = SSLContext.getInstance("SSL"); 
      sslContext.init(null, new TrustManager[]{new SecureTrustManager()}, new SecureRandom()); 
     } catch (NoSuchAlgorithmException ex) { 
      Logger.getLogger(ConnectionFactory.class.getName()).log(Level.SEVERE, null, ex); 
     } catch (KeyManagementException ex) { 
      Logger.getLogger(ConnectionFactory.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     return sslContext; 
    } 

    private HostnameVerifier getHostnameVerifier() { 
     return new HostnameVerifier() { 
      @Override 
      public boolean verify(String hostname, 
        javax.net.ssl.SSLSession sslSession) { 
       return true; 
      } 
     }; 
    } 

} 

entonces yo también crear otra clase llamada SecureTrustManager

import java.security.cert.CertificateException; 
import java.security.cert.X509Certificate; 
import javax.net.ssl.X509TrustManager; 

/** 
* 
* @author Aimable 
*/ 
public class SecureTrustManager implements X509TrustManager { 

    @Override 
    public void checkClientTrusted(X509Certificate[] arg0, String arg1) 
      throws CertificateException { 
    } 

    @Override 
    public void checkServerTrusted(X509Certificate[] arg0, String arg1) 
      throws CertificateException { 
    } 

    @Override 
    public X509Certificate[] getAcceptedIssuers() { 
     return new X509Certificate[0]; 
    } 

    public boolean isClientTrusted(X509Certificate[] arg0) { 
     return true; 
    } 

    public boolean isServerTrusted(X509Certificate[] arg0) { 
     return true; 
    } 

} 

continuación, después de la creación de esta clase Voy a llamar al cliente como éste

URLConnectionClientHandler cc = new URLConnectionClientHandler(new ConnectionFactory(webProxy.getWebserviceProxyHost(), webProxy.getWebserviceProxyPort())); 
    client = new Client(cc); 
    client.setConnectTimeout(2000000); 

reemplace webProxy.getWeserviceHost por su proxyHost y webProxy.getWebserviceProxyPort() por el puerto proxy.

Esto funcionó para mí y debería funcionar también para usted. Tenga en cuenta que estoy usando Jersey 1.8 pero también debería funcionar para Jersey 2

Answer 6

System.setProperty("http.proxyHost","your proxy url"); 
System.setProperty("http.proxyPort", "your proxy port"); 

Answer 7

SDolgy. Hice esto, agregué 3 funciones en la creación de instancias del cliente Jersey: Habilita SSL TLSv1.1 (se necesita JVM> = 1.7), configure conex. agrupando. para aumentar las conexiones, configure un proxy del sistema.

# My props file  
# CONFIGURAR EL CLIENTE 
#PROXY_URI=http://5.5.5.5:8080 
#SECURITY_PROTOCOL=TLSv1.2 
#POOLING_HTTP_CLIENT_CONNECTION_MANAGER.MAXTOTAL=200 
#POOLING_HTTP_CLIENT_CONNECTION_MANAGER.DEFAULTMAXPERROUTE=20 

import java.util.Properties; 
import javax.net.ssl.SSLContext; 
import javax.ws.rs.client.Client; 
import javax.ws.rs.client.ClientBuilder; 

import org.apache.http.config.Registry; 
import org.apache.http.config.RegistryBuilder; 
import org.apache.http.conn.socket.ConnectionSocketFactory; 
import org.apache.http.conn.socket.PlainConnectionSocketFactory; 
import org.apache.http.conn.ssl.SSLConnectionSocketFactory; 
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager; 

import org.glassfish.jersey.SslConfigurator; 
import org.glassfish.jersey.apache.connector.ApacheClientProperties; 
import org.glassfish.jersey.apache.connector.ApacheConnectorProvider; 
import org.glassfish.jersey.client.ClientConfig; 
import org.glassfish.jersey.client.ClientProperties; 
import org.glassfish.jersey.jackson.JacksonFeature; 

public class JerseyClientHelper { 
    private static Client cliente; 
    private static final Properties configuracion = SForceConfiguration.getInstance(); 

    public static synchronized Client getInstance() { 
     if (cliente == null) {    
      SSLContext sslContext = SslConfigurator.newInstance().securityProtocol(configuracion.getProperty("SECURITY_PROTOCOL")).createSSLContext(); // Usar TLSv1.2 

      SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext); 
      Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create() 
      .register("http", PlainConnectionSocketFactory.getSocketFactory()) 
      .register("https", socketFactory) 
      .build(); 

      // Para configurar las conexiones simultaneas al servidor 
      int maxTotal = Integer.parseInt(configuracion.getProperty("POOLING_HTTP_CLIENT_CONNECTION_MANAGER.MAXTOTAL")); 
      int defaultMaxPerRoute = Integer.parseInt(configuracion.getProperty("POOLING_HTTP_CLIENT_CONNECTION_MANAGER.DEFAULTMAXPERROUTE")); 
      PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry); 
      connectionManager.setMaxTotal(maxTotal); 
      connectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute); 

      ClientConfig config = new ClientConfig(); 
      config.property(ApacheClientProperties.CONNECTION_MANAGER, connectionManager); 
      config.connectorProvider(new ApacheConnectorProvider()); 
      config.property(ClientProperties.PROXY_URI, configuracion.getProperty("PROXY_URI")); // Debemos poner el PROXY del sistema 


      cliente = ClientBuilder.newBuilder().sslContext(sslContext).withConfig(config).build(); 

     }   
     return cliente; 
    } 

}