How to make twilio work with a proxy in java

问题

Our application is java based web application. We cannot access third party api directly in this case https://api.twilio.com This has to be done through a proxy. Can anyone tell me how can I achieve it for TwilioRestClient?

回答1:

You can use the .getHttpClient() method of TwilioRestClient and set your proxy parameters like this:

final TwilioRestClient client = new TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN);
client.getHttpClient().getHostConfiguration().setProxy(PROXY_HOST, PROXY_PORT);

回答2:

I know this is late for you, but I've been working around it because setting connection parameters directly to Apache's HttpClient is now deprecated. It is all done through builders and factories now. This is how I've done it with Apache httpcomponents 4.3.4:

HttpHost proxy = new HttpHost(PROXY_HOST, PROXY_PORT, "http");
DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(
    new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT),
    new UsernamePasswordCredentials(ACCOUNT_SID, ACCOUNT_TOKEN)
    );    
CloseableHttpClient httpClient = HttpClients.custom()
    .setRoutePlanner(routePlanner)
    .setDefaultCredentialsProvider(credentialsProvider)
    .build();
TwilioRestClient client = new TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN);
client.setHttpclient(httpClient);

//do your regular stuff with this client

Hope it helps.

回答3:

If you are using above 7.0.0 or latest jar Twilio has provided its own HttpClient, follow these steps,

1) You need to create your customHttpProxy class that extends com.twilio.http.HttpClient

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.apache.http.Header;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;

import com.google.common.collect.Lists;
import com.twilio.Twilio;
import com.twilio.exception.ApiException;
import com.twilio.http.HttpClient;
import com.twilio.http.HttpMethod;
import com.twilio.http.Request;
import com.twilio.http.Response;

import XXXX.XXX.twilio.util.TwilioUtil;

public class CustomNetworkClient extends HttpClient {

    private static final int CONNECTION_TIMEOUT = 5000;
    private static final int SOCKET_TIMEOUT = 5000;
    private static final int CONNECTIONS_PER_ROUTE = 10;

    private org.apache.http.client.HttpClient client;

    private String twilioRequestId;

    private Float twilioResponseDuration;


    /**
     * Create a new HTTP Client.
     * @throws Exception 
     */
    public CustomNetworkClient() throws Exception {
        this.invokeHttpProxy();
    }

    /**
     * Make a request.
     *
     * @param request request to make
     * @return Response of the HTTP request
     */
    public Response makeRequest(final Request request) {
        twilioResponseDuration = null;
        twilioRequestId = null;

        RequestBuilder builder = RequestBuilder.create(request.getMethod().toString())
            .setUri(request.constructURL().toString())
            .setVersion(HttpVersion.HTTP_1_1)
            .setCharset(StandardCharsets.UTF_8);

        if (request.requiresAuthentication()) {
            builder.addHeader(HttpHeaders.AUTHORIZATION, request.getAuthString());
        }

        HttpMethod method = request.getMethod();
        if (method == HttpMethod.POST) {
            builder.addHeader(HttpHeaders.CONTENT_TYPE, "application/x-www-form-urlencoded");

            for (Map.Entry<String, List<String>> entry : request.getPostParams().entrySet()) {
                for (String value : entry.getValue()) {
                    builder.addParameter(entry.getKey(), value);
                }
            }
        }

        try {
            HttpResponse response = client.execute(builder.build());

            if (response.containsHeader("Twilio-Request-Id"))
                twilioRequestId = response.getFirstHeader("Twilio-Request-Id").getValue();

            if (response.containsHeader("Twilio-Request-Duration"))
                twilioResponseDuration = new Float(response.getFirstHeader("Twilio-Request-Duration").getValue());

            return new Response(
                response.getEntity() == null ? null : response.getEntity().getContent(),
                response.getStatusLine().getStatusCode()
            );            
        } catch (IOException e) {
            throw new ApiException(e.getMessage());
        }
    }

    public String getTwilioRequestId() {
        return twilioRequestId;
    }

    public Float getTwilioResponseDuration() {
        return twilioResponseDuration;
    }


    public  void invokeHttpProxy()throws Exception {
        HttpHost proxy = new HttpHost("YOUR_PROXY_HOST", YOUR_PROXY_PORT, "http");
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);

        //Set up Twilio user credentials
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
                    new AuthScope("api.twilio.com", 443), 
                    new UsernamePasswordCredentials(TwilioUtil.ACCOUNT_SID, TwilioUtil.AUTH_TOKEN));

        RequestConfig config = RequestConfig.custom()
            .setConnectTimeout(CONNECTION_TIMEOUT)
            .setSocketTimeout(SOCKET_TIMEOUT)
            .build();

            Collection<Header> headers = Lists.<Header>newArrayList(
                new BasicHeader("X-Twilio-Client", "java-" + Twilio.VERSION),
                new BasicHeader(HttpHeaders.USER_AGENT, "twilio-java/" + Twilio.VERSION + " (" + Twilio.JAVA_VERSION + ")"),
                new BasicHeader(HttpHeaders.ACCEPT, "application/json"),
                new BasicHeader(HttpHeaders.ACCEPT_ENCODING, "utf-8")
            );


        client = HttpClientBuilder.create().setRoutePlanner(routePlanner)
                 .setDefaultCredentialsProvider(credsProvider) 
            .setConnectionManager(new PoolingHttpClientConnectionManager())
            .setDefaultRequestConfig(config)
           .setDefaultHeaders(headers)
            .setMaxConnPerRoute(CONNECTIONS_PER_ROUTE)
            .build();
    }
}

2) Inject the custom class into Twilio and TwilioRestClient respectively.

 CustomNetworkClient newHttpClient = new CustomNetworkClient();
 Twilio.init(TwilioUtil.ACCOUNT_SID, TwilioUtil.AUTH_TOKEN);
 TwilioRestClient client = new TwilioRestClient.Builder(TwilioUtil.ACCOUNT_SID, TwilioUtil.AUTH_TOKEN).httpClient(newHttpClient)
                .build();`enter code here`
                Twilio.setRestClient(client);

Hope this is helpful to your guys.

回答4:

Thanks a lot for the preceding. I write a much elegant class than ustomNetworkClient

import com.twilio.http.NetworkHttpClient;
import lombok.RequiredArgsConstructor;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;

public class ProxyAuthenticateHttpClient extends NetworkHttpClient {

    private ProxyAuthenticateHttpClient(HttpClientBuilder clientBuilder) {
        super(clientBuilder);
    }

    @RequiredArgsConstructor
    public static class Builder {
        public ProxyAuthenticateHttpClient build() {
            HttpClientBuilder clientBuilder = HttpClientBuilder.create();
            clientBuilder.useSystemProperties();

            RequestConfig config = RequestConfig.custom()
                .setConnectTimeout(CONNECTION_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT)
                .build();

            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(new AuthScope(proxyHost, proxyPort),
                new UsernamePasswordCredentials(proxyUser, proxyPassword));

            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
            connectionManager.setDefaultMaxPerRoute(10);
            connectionManager.setMaxTotal(10*2);

            clientBuilder
                .setConnectionManager(connectionManager)
                .setDefaultCredentialsProvider(credsProvider)
                .setDefaultRequestConfig(config);

            return new ProxyAuthenticateHttpClient(clientBuilder);
        }

        private final String proxyHost;
        private final int proxyPort;
        private final String proxyUser;
        private final String proxyPassword;

        private static final int CONNECTION_TIMEOUT = 10000;
        private static final int SOCKET_TIMEOUT = 30500;
    }
}

Then use the following code to init Twilio and everything is OK

Twilio.init(username, password);
TwilioRestClient.Builder builder = new TwilioRestClient.Builder(username, password);
builder.httpClient(new ProxyAuthenticateHttpClient.Builder(proxyUser, proxyPort, proxyUser, proxyPassword).build());
Twilio.setRestClient(builder.build());

来源：https://stackoverflow.com/questions/22230722/how-to-make-twilio-work-with-a-proxy-in-java