2012-05-02 3 views
12

こんにちは私はファイルをアップロードするために使用するジャージークライアントを持っています。私はそれをローカルで使ってみました。しかし、プロダクション環境では私はプロキシを設定する必要があります。私はいくつかのページを閲覧しましたが、正確な解決策を得ることはできませんでした。誰かがこれで私を助けることができますか?ここジャージークライアント+セットプロキシ

は私のクライアントコードです:

ここ
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); 

答えて

2

あなたが行く:

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/"); 
12

レガシープロジェクトで複数のライブラリーを避けたい場合に簡単なアプローチは、あるとする必要はありませんプロキシ認証:

まず、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); 
    } 
} 

第二には、com.sun.jersey.client.urlconnection.URLConnectionHandler

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

をインスタンス化することであり、第3は、代わりにClient.createClientコンストラクタを使用することです:

もちろん
Client client = new Client(ch); 

あなたはConnectionFactoryでのプロキシの初期化をカスタマイズすることができます。

+1

私のために働いた.......... –

9

luckyluke回答が効くものとする。 ここに私のバージョン:

0

私はuser67871を取って少し変更しました。このアプローチの素晴らしい点は、Windows上のシステムプロキシで動作することです。あなたがWindows上で、IEでプロキシを設定している場合、このコードはそれを選択します。 Fiddlerを実行しているときには、システムプロキシも設定されるので、JerseyとFiddlerを一緒に使用するのは簡単です。

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); 
0

私は

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; 
      } 
     }; 
    } 

} 

このクラスを作成し、すべての最初に、私はまた、その後、作成後にこのクラスは、私はこの

のようにクライアントを呼んでいる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; 
    } 

} 

と呼ばれる別のクラスを作成します

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

proxyProxy.getWeserviceHostをproxyHostで置換し、webProxy.getWebserviceProxyPort()をプロキシポートで置き換えます。

これは私のために働いたし、あなたのためにも動作するはずです。私はJersey 1.8を使用していますが、Jersey 2でも動作するはずです。

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

SDolgy私はJerseyクライアントのインスタンス化で3つの機能を追加しました: SSL TLSv1.1(JVM> = 1.7が必要)を有効にし、conexを設定します。プールする。 conectionsを増やすには、システムプロキシを設定します。

# 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; 
    } 

}