If you are working with the Twilio Java Helper Library, and you need to be able to modify the HTTP requests that the library makes to the Twilio servers, you’re in the right place. The most common need to alter the HTTP request is to connect and authenticate with an enterprise’s proxy server. We’ll provide sample code that you can drop right into your app to handle this use case.
To connect and provide credentials to a proxy server that may be between your app and Twilio, you need a way to modify the HTTP requests that the Twilio helper library makes on your behalf to invoke the Twilio REST API.
The Twilio Java helper library uses the HttpClient interface (in the
org.apache.http.client package) under the hood to make the HTTP requests. With this in mind, the following two facts should help us arrive at the solution:
- Connecting to a proxy server with
HttpClientis a solved problem.
- The Twilio Helper Library allows you to provide your own
HttpClientfor making API requests.
So the question becomes: how do we apply this to a typical Twilio REST API example?
Twilio.init(ACCOUNT_SID, AUTH_TOKEN); Message message = Message.creator(new PhoneNumber("+15558675310"), new PhoneNumber("+15017122661"), "Hey there!").create();
TwilioRestClient created and used? Out of the box, the helper library creates a default
TwilioRestClient for you, using the Twilio credentials you pass to the
init method. However, nothing is stopping you from creating your own and using that.
Once you have your own
TwilioRestClient, you can pass it to any Twilio REST API resource action you want. Here’s an example of sending an SMS message with a custom client:
When you take a closer look at the constructor for
TwilioRestClient, you see that the
httpClient parameter is actually of type
HttpClient is an abstraction that allows plugging in any implementation of an HTTP client you want (or even creating a mocking layer for unit testing).
However, within the helper library, there is an implementation of
NetworkHttpClient. This class wraps the
org.apache.http.client.HttpClient and provides it to the Twilio helper library to make the necessary HTTP requests.
Now that we understand how all the components fit together, we can create our own
TwilioRestClient that can connect through a proxy server. To make this reusable, here’s a class that you can use to create this
TwilioRestClient whenever you need one:
In this example, we use some environmental variables loaded at the program startup to retrieve various configuration settings:
- Your Twilio Account Sid and Auth Token (found here, in the Twilio console)
- Your proxy server host
- Your proxy port
These settings are located in a file named
.env like so:
ACCOUNT_SID=ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx AUTH_TOKEN= your_auth_token PROXY_HOST=127.0.0.1 PROXY_PORT=8888
Here’s a console program that sends a text message and shows how it all can work together. It loads the
.env file for us.
Now that you know how to inject your own
HttpClient into the Twilio API request pipeline, you could use this technique to add custom HTTP headers and authorization to the requests, perhaps as required by an upstream proxy server.
You could also implement your own
HttpClient to mock the Twilio API responses so your unit and integration tests can run quickly without needing to make a connection to Twilio.
We can’t wait to see what you build!