twitter4j.http.HttpClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of twitter4j-core Show documentation
Show all versions of twitter4j-core Show documentation
A Java library for the Twitter API
The newest version!
/*
Copyright (c) 2007-2009, Yusuke Yamamoto
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Yusuke Yamamoto nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY Yusuke Yamamoto ``AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL Yusuke Yamamoto BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package twitter4j.http;
import twitter4j.TwitterException;
import twitter4j.logging.Logger;
import java.io.BufferedInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Authenticator;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.Proxy.Type;
import java.net.URL;
import java.net.URLEncoder;
import java.security.AccessControlException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static twitter4j.http.RequestMethod.*;
/**
* A utility class to handle HTTP request/response.
*
* @author Yusuke Yamamoto - yusuke at mac.com
*/
public class HttpClient implements java.io.Serializable {
private static final Logger logger = Logger.getLogger();
private static final int OK = 200;// OK: Success!
private static final int NOT_MODIFIED = 304;// Not Modified: There was no new data to return.
private static final int BAD_REQUEST = 400;// Bad Request: The request was invalid. An accompanying error message will explain why. This is the status code will be returned during rate limiting.
private static final int NOT_AUTHORIZED = 401;// Not Authorized: Authentication credentials were missing or incorrect.
private static final int FORBIDDEN = 403;// Forbidden: The request is understood, but it has been refused. An accompanying error message will explain why.
private static final int NOT_FOUND = 404;// Not Found: The URI requested is invalid or the resource requested, such as a user, does not exists.
private static final int NOT_ACCEPTABLE = 406;// Not Acceptable: Returned by the Search API when an invalid format is specified in the request.
/**
* @see Search API: new HTTP response code 420 for rate limiting starting 1/18/2010
*/
public static final int EXCEEDED_RATE_LIMIT_QUOTA = 420;// Not registered in RFC.
private static final int INTERNAL_SERVER_ERROR = 500;// Internal Server Error: Something is broken. Please post to the group so the Twitter team can investigate.
private static final int BAD_GATEWAY = 502;// Bad Gateway: Twitter is down or being upgraded.
public static final int SERVICE_UNAVAILABLE = 503;// Service Unavailable: The Twitter servers are up, but overloaded with requests. Try again later. The search and trend methods use this to indicate when you are being rate limited.
private String proxyHost = null;
private int proxyPort = -1;
private String proxyAuthUser = null;
private String proxyAuthPassword = null;
private int connectionTimeout = 20000;
private int readTimeout = 120000;
private int retryCount = 0;
private int retryIntervalSeconds = 5 * 1000;
private static boolean isJDK14orEarlier = false;
private static final long serialVersionUID = -8819171414069621503L;
static {
try {
String versionStr = System.getProperty("java.specification.version");
if (null != versionStr) {
isJDK14orEarlier = 1.5d > Double.parseDouble(versionStr);
}
} catch (AccessControlException ace) {
isJDK14orEarlier = true;
}
}
public HttpClient() {
}
public HttpClient(HttpClientConfiguration conf) {
setProxyHost(conf.getHttpProxyHost());
setProxyPort(conf.getHttpProxyPort());
setProxyAuthUser(conf.getHttpProxyUser());
setProxyAuthPassword(conf.getHttpProxyPassword());
setConnectionTimeout(conf.getHttpConnectionTimeout());
setReadTimeout(conf.getHttpReadTimeout());
setRetryCount(conf.getHttpRetryCount());
setRetryIntervalSeconds(conf.getHttpRetryIntervalSeconds());
}
private static final Map instanceMap = new HashMap(1);
public static HttpClient getInstance(HttpClientConfiguration conf) {
HttpClient client = instanceMap.get(conf);
if (null == client) {
client = new HttpClient(conf);
instanceMap.put(conf, client);
}
return client;
}
public String getProxyHost() {
return proxyHost;
}
/**
* Sets proxy host.
*
* @param proxyHost
*/
public void setProxyHost(String proxyHost) {
this.proxyHost = proxyHost;
}
public int getProxyPort() {
return proxyPort;
}
/**
* Sets proxy port.
*
* @param proxyPort
*/
public void setProxyPort(int proxyPort) {
this.proxyPort = proxyPort;
}
public String getProxyAuthUser() {
return proxyAuthUser;
}
/**
* Sets proxy authentication user.
* System property -Dtwitter4j.http.proxyUser overrides this attribute.
*
* @param proxyAuthUser
*/
public void setProxyAuthUser(String proxyAuthUser) {
this.proxyAuthUser = proxyAuthUser;
}
public String getProxyAuthPassword() {
return proxyAuthPassword;
}
/**
* Sets proxy authentication password.
* System property -Dtwitter4j.http.proxyPassword overrides this attribute.
*
* @param proxyAuthPassword
*/
public void setProxyAuthPassword(String proxyAuthPassword) {
this.proxyAuthPassword = proxyAuthPassword;
}
public int getConnectionTimeout() {
return connectionTimeout;
}
/**
* Sets a specified timeout value, in milliseconds, to be used when opening a communications link to the resource referenced by this URLConnection.
*
* @param connectionTimeout - an int that specifies the connect timeout value in milliseconds
*/
public void setConnectionTimeout(int connectionTimeout) {
this.connectionTimeout = connectionTimeout;
}
public int getReadTimeout() {
return readTimeout;
}
/**
* Sets the read timeout to a specified timeout, in milliseconds.
*
* @param readTimeout - an int that specifies the timeout value to be used in milliseconds
*/
public void setReadTimeout(int readTimeout) {
this.readTimeout = readTimeout;
}
public void setRetryCount(int retryCount) {
if (retryCount >= 0) {
this.retryCount = retryCount;
} else {
throw new IllegalArgumentException("RetryCount cannot be negative.");
}
}
public void setRetryIntervalSeconds(int retryIntervalSeconds) {
if (retryIntervalSeconds >= 0) {
this.retryIntervalSeconds = retryIntervalSeconds;
} else {
throw new IllegalArgumentException(
"RetryInterval cannot be negative.");
}
}
public HttpResponse get(String url) throws TwitterException {
return request(new HttpRequest(RequestMethod.GET, url, null, null, null));
}
public HttpResponse post(String url, HttpParameter[] params) throws TwitterException {
return request(new HttpRequest(RequestMethod.POST, url, params, null, null));
}
public HttpResponse request(HttpRequest req) throws TwitterException {
int retriedCount;
int retry = retryCount + 1;
HttpResponse res = null;
for (retriedCount = 0; retriedCount < retry; retriedCount++) {
int responseCode = -1;
try {
HttpURLConnection con = null;
OutputStream os = null;
try {
con = getConnection(req.getURL());
con.setDoInput(true);
setHeaders(req, con);
con.setRequestMethod(req.requestMethod.name());
if (req.requestMethod == POST) {
if (HttpParameter.containsFile(req.httpParams)) {
String boundary = "----Twitter4J-upload" + System.currentTimeMillis();
con.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
boundary = "--" + boundary;
con.setDoOutput(true);
os = con.getOutputStream();
DataOutputStream out = new DataOutputStream(os);
for (HttpParameter param : req.httpParams) {
if (param.isFile()) {
write(out, boundary + "\r\n");
write(out, "Content-Disposition: form-data; name=\"" + param.getName() + "\"; filename=\"" + param.file.getName() + "\"\r\n");
write(out, "Content-Type: " + param.getContentType() + "\r\n\r\n");
BufferedInputStream in = new BufferedInputStream(new FileInputStream(param.file));
int buff = 0;
while ((buff = in.read()) != -1) {
out.write(buff);
}
write(out, "\r\n");
in.close();
} else {
write(out, boundary + "\r\n");
write(out, "Content-Disposition: form-data; name=\"" + param.name + "\"\r\n");
write(out, "Content-Type: text/plain; charset=UTF-8\r\n\r\n");
logger.debug(param.value);
out.write(encode(param.value).getBytes("UTF-8"));
write(out, "\r\n");
}
}
write(out, boundary + "--\r\n");
write(out, "\r\n");
} else {
con.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded");
String postParam = HttpParameter.encodeParameters(req.httpParams);
logger.debug("Post Params: ", postParam);
byte[] bytes = postParam.getBytes("UTF-8");
con.setRequestProperty("Content-Length",
Integer.toString(bytes.length));
con.setDoOutput(true);
os = con.getOutputStream();
os.write(bytes);
}
os.flush();
os.close();
}
res = new HttpResponse(con);
responseCode = con.getResponseCode();
if (logger.isDebugEnabled()) {
logger.debug("Response: ");
Map> responseHeaders = con.getHeaderFields();
for (String key : responseHeaders.keySet()) {
List values = responseHeaders.get(key);
for (String value : values) {
if (null != key) {
logger.debug(key + ": " + value);
} else {
logger.debug(value);
}
}
}
}
if (responseCode != OK) {
if (responseCode == SERVICE_UNAVAILABLE || responseCode == EXCEEDED_RATE_LIMIT_QUOTA){
// application exceeded the rate limitation
// Search API returns Retry-After header that instructs the application when it is safe to continue.
// @see Rate limiting
int retryAfter = -1;
try {
retryAfter = Integer.valueOf(con.getHeaderField("Retry-After"));
} catch (NumberFormatException ignore) {
}
throw TwitterException.createRateLimitedTwitterException(getCause(responseCode)
, responseCode, retryAfter);
}
if (responseCode < INTERNAL_SERVER_ERROR || retriedCount == retryCount) {
throw new TwitterException(getCause(responseCode) + "\n" + res.asString(), responseCode);
}
// will retry if the status code is INTERNAL_SERVER_ERROR
} else {
break;
}
} finally {
try {
os.close();
} catch (Exception ignore) {
}
}
} catch (IOException ioe) {
// connection timeout or read timeout
if (retriedCount == retryCount) {
throw new TwitterException(ioe.getMessage(), ioe, responseCode);
}
}
try {
if (logger.isDebugEnabled() && null != res) {
res.asString();
}
logger.debug("Sleeping " + retryIntervalSeconds + " seconds until the next retry.");
Thread.sleep(retryIntervalSeconds * 1000);
} catch (InterruptedException ignore) {
//nothing to do
}
}
return res;
}
private void write(DataOutputStream out, String outStr) throws IOException {
out.writeBytes(outStr);
logger.debug(outStr);
}
public static String encode(String str) {
try {
return URLEncoder.encode(str, "UTF-8");
} catch (java.io.UnsupportedEncodingException neverHappen) {
throw new AssertionError("will never happen");
}
}
/**
* sets HTTP headers
* @param req The request
* @param connection HttpURLConnection
*/
private void setHeaders(HttpRequest req, HttpURLConnection connection) {
logger.debug("Request: ");
logger.debug(req.requestMethod.name() + " ", req.getURL());
if (null != req.authorization) {
req.authorization.setAuthorizationHeader(req.requestMethod.name(), req.getURL(), req.httpParams, connection);
}
if (null != req.requestHeaders) {
for (String key : req.requestHeaders.keySet()) {
connection.addRequestProperty(key, req.requestHeaders.get(key));
logger.debug(key + ": " + req.requestHeaders.get(key));
}
}
}
private HttpURLConnection getConnection(String url) throws IOException {
HttpURLConnection con = null;
if (proxyHost != null && !proxyHost.equals("")) {
if (proxyAuthUser != null && !proxyAuthUser.equals("")) {
logger.debug("Proxy AuthUser: " + proxyAuthUser);
logger.debug("Proxy AuthPassword: " + proxyAuthPassword);
Authenticator.setDefault(new Authenticator() {
@Override
protected PasswordAuthentication
getPasswordAuthentication() {
//respond only to proxy auth requests
if (getRequestorType().equals(RequestorType.PROXY)) {
return new PasswordAuthentication(proxyAuthUser,
proxyAuthPassword
.toCharArray());
} else {
return null;
}
}
});
}
final Proxy proxy = new Proxy(Type.HTTP, InetSocketAddress
.createUnresolved(proxyHost, proxyPort));
if (logger.isDebugEnabled()) {
logger.debug("Opening proxied connection(" + proxyHost + ":" + proxyPort + ")");
}
con = (HttpURLConnection) new URL(url).openConnection(proxy);
} else {
con = (HttpURLConnection) new URL(url).openConnection();
}
if (connectionTimeout > 0 && !isJDK14orEarlier) {
con.setConnectTimeout(connectionTimeout);
}
if (readTimeout > 0 && !isJDK14orEarlier) {
con.setReadTimeout(readTimeout);
}
return con;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof HttpClient)) return false;
HttpClient that = (HttpClient) o;
if (connectionTimeout != that.connectionTimeout) return false;
if (proxyPort != that.proxyPort) return false;
if (readTimeout != that.readTimeout) return false;
if (retryCount != that.retryCount) return false;
if (retryIntervalSeconds != that.retryIntervalSeconds) return false;
if (proxyAuthPassword != null ? !proxyAuthPassword.equals(that.proxyAuthPassword) : that.proxyAuthPassword != null)
return false;
if (proxyAuthUser != null ? !proxyAuthUser.equals(that.proxyAuthUser) : that.proxyAuthUser != null)
return false;
if (proxyHost != null ? !proxyHost.equals(that.proxyHost) : that.proxyHost != null)
return false;
return true;
}
@Override
public int hashCode() {
int result = proxyHost != null ? proxyHost.hashCode() : 0;
result = 31 * result + proxyPort;
result = 31 * result + (proxyAuthUser != null ? proxyAuthUser.hashCode() : 0);
result = 31 * result + (proxyAuthPassword != null ? proxyAuthPassword.hashCode() : 0);
result = 31 * result + connectionTimeout;
result = 31 * result + readTimeout;
result = 31 * result + retryCount;
result = 31 * result + retryIntervalSeconds;
return result;
}
private static String getCause(int statusCode) {
String cause = null;
// http://apiwiki.twitter.com/HTTP-Response-Codes-and-Errors
switch (statusCode) {
case NOT_MODIFIED:
break;
case BAD_REQUEST:
cause = "The request was invalid. An accompanying error message will explain why. This is the status code will be returned during rate limiting.";
break;
case NOT_AUTHORIZED:
cause = "Authentication credentials were missing or incorrect.";
break;
case FORBIDDEN:
cause = "The request is understood, but it has been refused. An accompanying error message will explain why.";
break;
case NOT_FOUND:
cause = "The URI requested is invalid or the resource requested, such as a user, does not exists.";
break;
case NOT_ACCEPTABLE:
cause = "Returned by the Search API when an invalid format is specified in the request.";
break;
case EXCEEDED_RATE_LIMIT_QUOTA:
cause = "The number of requests you have made exceeds the quota afforded by your assigned rate limit.";
break;
case INTERNAL_SERVER_ERROR:
cause = "Something is broken. Please post to the group so the Twitter team can investigate.";
break;
case BAD_GATEWAY:
cause = "Twitter is down or being upgraded.";
break;
case SERVICE_UNAVAILABLE:
cause = "Service Unavailable: The Twitter servers are up, but overloaded with requests. Try again later. The search and trend methods use this to indicate when you are being rate limited.";
break;
default:
cause = "";
}
return statusCode + ":" + cause;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy