public Connection data(String... keyvals) {
Validate.notNull(keyvals, "Data key value pairs must not be null");
Validate.isTrue(keyvals.length % 2 == 0, "Must supply an even number of key value pairs");
for (int i = 0; i < keyvals.length; i += 2) {
String key = keyvals[i];
String value = keyvals[i + 1];
Validate.notEmpty(key, "Data key must not be empty");
Validate.notNull(value, "Data value must not be null");
req.data(KeyVal.create(key, value));
}
return this;
}
public String body() {
Validate.isTrue(
executed,
"Request must be executed (with .execute(), .get(), or .post() before getting response body");
// charset gets set from header on execute, and from meta-equiv on parse. parse may not have
// happened yet
String body;
if (charset == null)
body = Charset.forName(DataUtil.defaultCharset).decode(byteData).toString();
else body = Charset.forName(charset).decode(byteData).toString();
byteData.rewind();
return body;
}
public Document parse() throws IOException {
Validate.isTrue(
executed,
"Request must be executed (with .execute(), .get(), or .post() before parsing response");
if (!req.ignoreContentType()
&& (contentType == null
|| !(contentType.startsWith("text/")
|| contentType.startsWith("application/xml")
|| contentType.startsWith("application/xhtml+xml"))))
throw new IOException(
String.format(
"Unhandled content type \"%s\" on URL %s. Must be text/*, application/xml, or application/xhtml+xml",
contentType, url.toString()));
Document doc = DataUtil.parseByteData(byteData, charset, url.toExternalForm());
byteData.rewind();
charset = doc.outputSettings().charset().name(); // update charset from meta-equiv, possibly
return doc;
}
public byte[] bodyAsBytes() {
Validate.isTrue(
executed,
"Request must be executed (with .execute(), .get(), or .post() before getting response body");
return byteData.array();
}
static Response execute(Connection.Request req, Response previousResponse) throws IOException {
Validate.notNull(req, "Request must not be null");
String protocol = req.url().getProtocol();
Validate.isTrue(
protocol.equals("http") || protocol.equals("https"),
"Only http & https protocols supported");
// set up the request for execution
if (req.method() == Connection.Method.GET && req.data().size() > 0)
serialiseRequestUrl(req); // appends query string
HttpURLConnection conn = createConnection(req);
conn.connect();
if (req.method() == Connection.Method.POST) writePost(req.data(), conn.getOutputStream());
int status = conn.getResponseCode();
boolean needsRedirect = false;
if (status != HttpURLConnection.HTTP_OK) {
if (status == HttpURLConnection.HTTP_MOVED_TEMP
|| status == HttpURLConnection.HTTP_MOVED_PERM
|| status == HttpURLConnection.HTTP_SEE_OTHER) needsRedirect = true;
else if (!req.ignoreHttpErrors())
throw new IOException(status + " error loading URL " + req.url().toString());
}
Response res = new Response(previousResponse);
res.setupFromConnection(conn, previousResponse);
if (needsRedirect && req.followRedirects()) {
req.method(
Method
.GET); // always redirect with a get. any data param from original req are dropped.
req.data().clear();
req.url(new URL(req.url(), res.header("Location")));
for (Map.Entry<String, String> cookie :
res.cookies.entrySet()) { // add response cookies to request (for e.g. login posts)
req.cookie(cookie.getKey(), cookie.getValue());
}
return execute(req, res);
}
res.req = req;
InputStream bodyStream = null;
InputStream dataStream = null;
try {
dataStream = conn.getErrorStream() != null ? conn.getErrorStream() : conn.getInputStream();
bodyStream =
res.hasHeader("Content-Encoding")
&& res.header("Content-Encoding").equalsIgnoreCase("gzip")
? new BufferedInputStream(new GZIPInputStream(dataStream))
: new BufferedInputStream(dataStream);
res.byteData = DataUtil.readToByteBuffer(bodyStream);
res.charset =
DataUtil.getCharsetFromContentType(
res.contentType); // may be null, readInputStream deals with it
} finally {
if (bodyStream != null) bodyStream.close();
if (dataStream != null) dataStream.close();
}
res.executed = true;
return res;
}
public Request timeout(int millis) {
Validate.isTrue(millis >= 0, "Timeout milliseconds must be 0 (infinite) or greater");
timeoutMilliseconds = millis;
return this;
}
