Utilizarea java.net.URLConnection
este întrebat despre destul de des aici, iar Oracle tutorial este de asemenea concise despre asta.
Acel tutorial practic doar arată cum să tragă o cerere și citește răspunsul. Nu't explica oriunde cum să-l folosească, printre altele, de a efectua o cerere POST, set de antete cerere, citiți anteturile de răspuns, treaba cu cookie-urile, să prezinte un formular HTML, încărcați un fișier, etc.
Deci, cum pot folosi java.net.URLConnection` la foc și se ocupe de "avansat" cereri HTTP?
IOException e și
RuntimeException ca NullPointerException,
ArrayIndexOutOfBoundsException și lipește-te. Avem nevoie în primul rând să știi cel puțin URL-ul și setul de caractere. Parametrii sunt opționale și depind de cerințele funcționale.
String url = "http://example.com";
String charset = "UTF-8"; // Or in Java 7 and later, use the constant: java.nio.charset.StandardCharsets.UTF_8.name()
String param1 = "value1";
String param2 = "value2";
// ...
String query = String.format("param1=%s¶m2=%s",
URLEncoder.encode(param1, charset),
URLEncoder.encode(param2, charset));
nume=valoare
format și de a fi concatenate de &
. În mod normal, de asemenea, URL encode parametrii de interogare cu cel specificat de caractere folosind URLEncoder#encode()
.
String#format()
este doar pentru comoditate. Prefer atunci când am nevoie de Șirul operatorul de concatenare +
mai mult decât de două ori. L's o sarcină trivială. L's implicit metoda cerere.
URLConnection connection = new URL(url + "?" + query).openConnection();
connection.setRequestProperty("Accept-Charset", charset);
InputStream response = connection.getInputStream();
// ...
Orice șir de interogare ar trebui să fie concatenate pentru a URL-ul cu ajutorul"?". A Accept-Charset
antet poate sugestie server ce codare parametrii sunt în. Dacă tu nu't trimite orice șir de interogare, atunci puteți lăsa Accept-Charset
antet departe. Dacă tu nu't nevoie pentru a seta orice antete, atunci puteți folosi chiar URL#openStream()
metoda rapidă.
InputStream response = new URL(url).openStream();
// ...
Oricum, dacă cealaltă parte este o HttpServlet
, apoi doGet()
va fi apelată metoda și parametrii vor fi disponibile prin HttpServletRequest#getParameter()
.
Pentru scopuri de testare, puteți imprima răspunsul organismului la stdout ca mai jos:
try (Scanner scanner = new Scanner(response)) {
String responseBody = scanner.useDelimiter("\\A").next();
System.out.println(responseBody);
}
Setarea URLConnection#setDoOutput()
pentru "adevărat" implicit seturi cererea metoda de a POSTA. Standardul HTTP POST ca formularele de pe web nu este de tip application/x-www-form-urlencoded
în care șirul de interogare este scris la cererea organismului.
URLConnection connection = new URL(url).openConnection();
connection.setDoOutput(true); // Triggers POST.
connection.setRequestProperty("Accept-Charset", charset);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=" + charset);
try (OutputStream output = connection.getOutputStream()) {
output.write(query.getBytes(charset));
}
InputStream response = connection.getInputStream();
// ...
Notă: ori de câte ori te'd dori să prezinte un formular HTML programatic, don't uitați să luați nume=valoare
perechi de orice <input type="ascunse">
elemente în șir de interogare și, desigur, de asemenea, nume=valoare
pereche de <input type="trimiteți"> element care'd ca sa "apăsați" programatic (pentru că's, de obicei, a fost folosit în partea de server pentru a distinge dacă un buton a fost apăsat și dacă da, care anume). Puteți, de asemenea, exprimate obținute [
URLConnection][11] la [
HttpURLConnection][12] și de a folosi [
HttpURLConnection#setRequestMethod()][13] în loc. Dar dacă te're încercarea de a utiliza conexiunea de ieșire tu încă mai trebuie să setați [
URLConnection#setDoOutput()`]14 pentru "adevărat".
HttpURLConnection httpConnection = (HttpURLConnection) new URL(url).openConnection();
httpConnection.setRequestMethod("POST");
// ...
HttpServlet
, apoi doPost()
va fi apelată metoda și parametrii vor fi disponibile prin HttpServletRequest#getParameter()
. URLConnection#connect()
, dar cererea va fi automat tras la cerere, atunci când doriți pentru a obține orice informații cu privire la răspuns HTTP, cum ar fi raspunsul organismului folosind URLConnection#getInputStream()
și așa mai departe. Exemplele de mai sus exact asta face, deci, connect()
apelul este în fapt de prisos. HttpURLConnection
aici. Aruncă-l în primul rând, dacă este necesar.
int status = httpConnection.getResponseCode(); Partea de server sesiune este, de obicei, susținute de un cookie. Unele formulare web necesită pe care le're logat și/sau sunt urmărite de o sesiune. Puteți utiliza CookieHandler
API pentru a menține cookie-uri. Aveți nevoie pentru a pregăti o CookieManager
o CookiePolicy
de ACCEPT_ALL
înainte de a trimite toate cererile HTTP.
// First set the default cookie manager.
CookieHandler.setDefault(new CookieManager(null, CookiePolicy.ACCEPT_ALL));
// All the following subsequent URLConnections will use the same cookie manager.
URLConnection connection = new URL(url).openConnection();
// ...
connection = new URL(url).openConnection();
// ...
connection = new URL(url).openConnection();
// ...
Rețineți că acest lucru este cunoscut pentru a nu funcționează întotdeauna corect în toate împrejurările. Dacă nu pentru tine, atunci cel mai bine este să adune manual și seta cookie antete. Practic, aveți nevoie pentru a apuca toate Set-Cookie` anteturile de răspuns de autentificare sau primul "OBȚINE" cerere și apoi trece asta prin cereri ulterioare.
// Gather all cookies on the first request.
URLConnection connection = new URL(url).openConnection();
List<String> cookies = connection.getHeaderFields().get("Set-Cookie");
// ...
// Then use the same cookies on all subsequent requests.
connection = new URL(url).openConnection();
for (String cookie : cookies) {
connection.addRequestProperty("Cookie", cookie.split(";", 2)[0]);
}
// ...
split(";", 2)[0]
este acolo pentru a scăpa de cookie atribute care sunt irelevante pentru partea de server ca expira
, calea
, etc. Alternativ, ai putea folosi, de asemenea, cookie'.substring(0, cookie.indexOf(';'))
în loc de split()
. A HttpURLConnection
va implicit tampon întreg cerere organismului de fapt, înainte de a-l trimite, indiferent dacă'am stabilit un conținut fix lungime-te folosind conexiunea.setRequestProperty("Content-Length", contentLength);. Acest lucru poate cauza OutOfMemoryException lui ori de câte ori concomitent trimite POST de mare de cereri (de exemplu, încărcarea de fișiere). Pentru a evita acest lucru, veți dori să setați [
HttpURLConnection#setFixedLengthStreamingMode()`]29.
httpConnection.setFixedLengthStreamingMode(contentLength);
Dar dacă lungimea de conținut nu este cunoscut în prealabil, atunci puteți face uz de chunked modul de streaming prin setarea HttpURLConnection#setChunkedStreamingMode()
în mod corespunzător. Acest lucru va seta HTTP Transfer-Encoding
antet a căzut
care va forța corpul cerere de a fi trimis în bucăți. Exemplul de mai jos va trimite corpul în bucăți de 1KB.
httpConnection.setChunkedStreamingMode(1024);
Se poate întâmpla ca o cerere returnează un răspuns neașteptat, în timp ce acesta funcționează bine cu un browser web reală. Partea de server este, probabil, blocarea cererilor în baza User-Agent
cerere antet. Anii URLConnection
va în mod implicit setat la Java/1.6.0_19
în cazul în care ultima parte este evident pe versiunea JRE. Aceasta se poate înlocui după cum urmează:
connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36"); // Do as if you're using Chrome 41 on Windows 7.
Dacă răspunsul HTTP cod este 4nn
(Eroare de Client) sau 5nn
(Eroare de Server), atunci este posibil să doriți să citiți HttpURLConnection#getErrorStream()
pentru a vedea dacă serverul a trimis nici util de informații de eroare.
InputStream error = ((HttpURLConnection) connection).getErrorStream();
Dacă răspunsul HTTP cod este -1, atunci ceva a mers prost cu conexiune de răspuns și de manipulare. Anii HttpURLConnection punerea în aplicare este în vârstă JREs oarecum buggy cu păstrarea conexiuni în viață. Poate doriți să-l opriți prin setarea
http.keepAlive sistem de proprietate de la "false". Puteți face acest lucru în mod programatic la începutul cererea dumneavoastră prin:
System.setProperty("http.keepAlive", "false");
Te'd utilizați în mod normal multipart/form-data
codare pentru amestecat POSTA conținut (binar și date de tip caracter). Codificarea este mai în detaliu descris în RFC2388.
String param = "value";
File textFile = new File("/path/to/file.txt");
File binaryFile = new File("/path/to/file.bin");
String boundary = Long.toHexString(System.currentTimeMillis()); // Just generate some unique random value.
String CRLF = "\r\n"; // Line separator required by multipart/form-data.
URLConnection connection = new URL(url).openConnection();
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
try (
OutputStream output = connection.getOutputStream();
PrintWriter writer = new PrintWriter(new OutputStreamWriter(output, charset), true);
) {
// Send normal param.
writer.append("--" + boundary).append(CRLF);
writer.append("Content-Disposition: form-data; name=\"param\"").append(CRLF);
writer.append("Content-Type: text/plain; charset=" + charset).append(CRLF);
writer.append(CRLF).append(param).append(CRLF).flush();
// Send text file.
writer.append("--" + boundary).append(CRLF);
writer.append("Content-Disposition: form-data; name=\"textFile\"; filename=\"" + textFile.getName() + "\"").append(CRLF);
writer.append("Content-Type: text/plain; charset=" + charset).append(CRLF); // Text file itself must be saved in this charset!
writer.append(CRLF).flush();
Files.copy(textFile.toPath(), output);
output.flush(); // Important before continuing with writer!
writer.append(CRLF).flush(); // CRLF is important! It indicates end of boundary.
// Send binary file.
writer.append("--" + boundary).append(CRLF);
writer.append("Content-Disposition: form-data; name=\"binaryFile\"; filename=\"" + binaryFile.getName() + "\"").append(CRLF);
writer.append("Content-Type: " + URLConnection.guessContentTypeFromName(binaryFile.getName())).append(CRLF);
writer.append("Content-Transfer-Encoding: binary").append(CRLF);
writer.append(CRLF).flush();
Files.copy(binaryFile.toPath(), output);
output.flush(); // Important before continuing with writer!
writer.append(CRLF).flush(); // CRLF is important! It indicates end of boundary.
// End of multipart/form-data.
writer.append("--" + boundary + "--").append(CRLF).flush();
}
HttpServlet
, apoi doPost()
metoda va fi numit și piese vor fi disponibile prin HttpServletRequest#getPart()
(notă, astfel nu getParameter()
și așa mai departe!). Anii getPart()
metoda este, totuși, relativ nou, l's-a introdus în Servlet 3.0 (Glassfish 3, Tomcat 7, etc). Înainte de a Servlet 3.0, cea mai buna alegere este folosind Apache Commons FileUpload pentru a analiza o `multipart/form-data cererea. Vedea, de asemenea, acest răspuns pentru exemple de ambele FileUpload și Servelt 3.0 abordări. Uneori ai nevoie pentru a conecta un HTTPS URL-ul, poate pentru că're scris un web scraper. În acest caz, tu ar putea confrunta probabil cu o javax.net.ssl.SSLException: Nu a avut încredere certificat de server pe unele site-uri HTTPS, care nu't păstreze SSL certificate până la data de, sau un java.de securitate.cert.CertificateException: Nu pot alternative DNS nume de potrivire [hostname] găsit " sau " javax.net.ssl.SSLProtocolException: strângere de mână de alertă: unrecognized_name pe unele greșit site-uri HTTPS. Următoarele one-time-run "statice" inițializare în web scraper clasă ar trebui să facă
HttpsURLConnection` mai indulgent ca la aceste site-uri HTTPS și, astfel, nu arunca aceste excepții mai.
static {
TrustManager[] trustAllCertificates = new TrustManager[] {
new X509TrustManager() {
@Override
public X509Certificate[] getAcceptedIssuers() {
return null; // Not relevant.
}
@Override
public void checkClientTrusted(X509Certificate[] certs, String authType) {
// Do nothing. Just allow them all.
}
@Override
public void checkServerTrusted(X509Certificate[] certs, String authType) {
// Do nothing. Just allow them all.
}
}
};
HostnameVerifier trustAllHostnames = new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true; // Just allow them all.
}
};
try {
System.setProperty("jsse.enableSNIExtension", "false");
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCertificates, new SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HttpsURLConnection.setDefaultHostnameVerifier(trustAllHostnames);
}
catch (GeneralSecurityException e) {
throw new ExceptionInInitializerError(e);
}
}
De Apache HttpComponents HttpClient este mult mai convenabil din toate astea :)
Dacă tot ce vrei este analiza și extragerea datelor din HTML, atunci mai bine folosesti un parser HTML, cum ar fi Jsoup
Atunci când se lucrează cu HTTP it's aproape întotdeauna mai util să se refere la HttpURLConnection
mai degrabă decât de la clasa de baza URLConnection
(din URLConnection
este o clasă abstractă atunci când vă întreb pentru URLConnection.openConnection()` pe un URL HTTP care's ceea ce ai'll a obține înapoi, oricum).
Apoi, puteți în loc de bazându-se pe URLConnection#setDoOutput(adevărat) să implicit setați metoda cerere de a POST în loc să faci httpURLConnection.setRequestMethod("POST")` care unii s-ar putea găsi mai natural (și care, de asemenea, vă permite să specificați alte metode cerere, cum ar fi PUNE, ȘTERGERE, ...).
Acesta oferă, de asemenea, util HTTP constante astfel încât să puteți face:
int responseCode = httpURLConnection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
Inspirat de acest lucru și alte întrebări pe ATÂT, am'am creat un minim open source de bază-http-client, care întruchipează cele mai multe dintre tehnicile de găsit aici.
google-http-java-client este, de asemenea, o mare sursă deschisă de resurse.
Există 2 opțiuni puteți merge cu URL HTTP Afisari : GET / POST
IA Cerere :-
HttpURLConnection.setFollowRedirects(true); // defaults to true
String url = "https://name_of_the_url";
URL request_url = new URL(url);
HttpURLConnection http_conn = (HttpURLConnection)request_url.openConnection();
http_conn.setConnectTimeout(100000);
http_conn.setReadTimeout(100000);
http_conn.setInstanceFollowRedirects(true);
System.out.println(String.valueOf(http_conn.getResponseCode()));
Cerere POST :-
HttpURLConnection.setFollowRedirects(true); // defaults to true
String url = "https://name_of_the_url"
URL request_url = new URL(url);
HttpURLConnection http_conn = (HttpURLConnection)request_url.openConnection();
http_conn.setConnectTimeout(100000);
http_conn.setReadTimeout(100000);
http_conn.setInstanceFollowRedirects(true);
http_conn.setDoOutput(true);
PrintWriter out = new PrintWriter(http_conn.getOutputStream());
if (urlparameter != null) {
out.println(urlparameter);
}
out.close();
out = null;
System.out.println(String.valueOf(http_conn.getResponseCode()));
Vă sugerez să luați o privire la codul cu privire la kevinsawicki/http-cerere, sa practic un înveliș deasupra HttpUrlConnection` acesta oferă un API mult mai simplu în cazul în care doriți doar pentru a face cereri de acum sau puteți lua o privire la surse (it's nu prea mare), să ia o privire la modul în care conexiunile sunt manipulate.
Exemplu: a Face o "OBȚINE" cerere tip de conținut `application/json și unii parametri de interogare:
// GET http://google.com?q=baseball%20gloves&size=100
String response = HttpRequest.get("http://google.com", true, "q", "baseball gloves", "size", 100)
.accept("application/json")
.body();
System.out.println("Response was: " + response);
De asemenea, am fost foarte inspirat de acest răspuns.
Eu sunt de multe ori pe proiectele în care am nevoie pentru a face unele HTTP, și poate că nu vreau să aduc o mulțime de 3rd party dependențe (care aduce în altele și așa mai departe și așa mai departe, etc.)
Am început să-mi scriu propria utilitati bazate pe unele dintre această conversație (nu orice în cazul în care a făcut):
package org.boon.utils;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Map;
import static org.boon.utils.IO.read;
public class HTTP {
Apoi, există doar o grămadă de metode statice.
public static String get(
final String url) {
Exceptions.tryIt(() -> {
URLConnection connection;
connection = doGet(url, null, null, null);
return extractResponseString(connection);
});
return null;
}
public static String getWithHeaders(
final String url,
final Map<String, ? extends Object> headers) {
URLConnection connection;
try {
connection = doGet(url, headers, null, null);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
public static String getWithContentType(
final String url,
final Map<String, ? extends Object> headers,
String contentType) {
URLConnection connection;
try {
connection = doGet(url, headers, contentType, null);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
public static String getWithCharSet(
final String url,
final Map<String, ? extends Object> headers,
String contentType,
String charSet) {
URLConnection connection;
try {
connection = doGet(url, headers, contentType, charSet);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
Apoi posta...
public static String postBody(
final String url,
final String body) {
URLConnection connection;
try {
connection = doPost(url, null, "text/plain", null, body);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
public static String postBodyWithHeaders(
final String url,
final Map<String, ? extends Object> headers,
final String body) {
URLConnection connection;
try {
connection = doPost(url, headers, "text/plain", null, body);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
public static String postBodyWithContentType(
final String url,
final Map<String, ? extends Object> headers,
final String contentType,
final String body) {
URLConnection connection;
try {
connection = doPost(url, headers, contentType, null, body);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
public static String postBodyWithCharset(
final String url,
final Map<String, ? extends Object> headers,
final String contentType,
final String charSet,
final String body) {
URLConnection connection;
try {
connection = doPost(url, headers, contentType, charSet, body);
return extractResponseString(connection);
} catch (Exception ex) {
Exceptions.handle(ex);
return null;
}
}
private static URLConnection doPost(String url, Map<String, ? extends Object> headers,
String contentType, String charset, String body
) throws IOException {
URLConnection connection;/* Handle output. */
connection = new URL(url).openConnection();
connection.setDoOutput(true);
manageContentTypeHeaders(contentType, charset, connection);
manageHeaders(headers, connection);
IO.write(connection.getOutputStream(), body, IO.CHARSET);
return connection;
}
private static void manageHeaders(Map<String, ? extends Object> headers, URLConnection connection) {
if (headers != null) {
for (Map.Entry<String, ? extends Object> entry : headers.entrySet()) {
connection.setRequestProperty(entry.getKey(), entry.getValue().toString());
}
}
}
private static void manageContentTypeHeaders(String contentType, String charset, URLConnection connection) {
connection.setRequestProperty("Accept-Charset", charset == null ? IO.CHARSET : charset);
if (contentType!=null && !contentType.isEmpty()) {
connection.setRequestProperty("Content-Type", contentType);
}
}
private static URLConnection doGet(String url, Map<String, ? extends Object> headers,
String contentType, String charset) throws IOException {
URLConnection connection;/* Handle output. */
connection = new URL(url).openConnection();
manageContentTypeHeaders(contentType, charset, connection);
manageHeaders(headers, connection);
return connection;
}
private static String extractResponseString(URLConnection connection) throws IOException {
/* Handle input. */
HttpURLConnection http = (HttpURLConnection)connection;
int status = http.getResponseCode();
String charset = getCharset(connection.getHeaderField("Content-Type"));
if (status==200) {
return readResponseBody(http, charset);
} else {
return readErrorResponseBody(http, status, charset);
}
}
private static String readErrorResponseBody(HttpURLConnection http, int status, String charset) {
InputStream errorStream = http.getErrorStream();
if ( errorStream!=null ) {
String error = charset== null ? read( errorStream ) :
read( errorStream, charset );
throw new RuntimeException("STATUS CODE =" + status + "\n\n" + error);
} else {
throw new RuntimeException("STATUS CODE =" + status);
}
}
private static String readResponseBody(HttpURLConnection http, String charset) throws IOException {
if (charset != null) {
return read(http.getInputStream(), charset);
} else {
return read(http.getInputStream());
}
}
private static String getCharset(String contentType) {
if (contentType==null) {
return null;
}
String charset = null;
for (String param : contentType.replace(" ", "").split(";")) {
if (param.startsWith("charset=")) {
charset = param.split("=", 2)[1];
break;
}
}
charset = charset == null ? IO.CHARSET : charset;
return charset;
}
Ei bine, ai prins ideea....
Aici sunt testele:
static class MyHandler implements HttpHandler {
public void handle(HttpExchange t) throws IOException {
InputStream requestBody = t.getRequestBody();
String body = IO.read(requestBody);
Headers requestHeaders = t.getRequestHeaders();
body = body + "\n" + copy(requestHeaders).toString();
t.sendResponseHeaders(200, body.length());
OutputStream os = t.getResponseBody();
os.write(body.getBytes());
os.close();
}
}
@Test
public void testHappy() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9212), 0);
server.createContext("/test", new MyHandler());
server.setExecutor(null); // creates a default executor
server.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBodyWithContentType("http://localhost:9212/test", headers, "text/plain", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.postBodyWithCharset("http://localhost:9212/test", headers, "text/plain", "UTF-8", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.postBodyWithHeaders("http://localhost:9212/test", headers, "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.get("http://localhost:9212/test");
System.out.println(response);
response = HTTP.getWithHeaders("http://localhost:9212/test", headers);
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.getWithContentType("http://localhost:9212/test", headers, "text/plain");
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.getWithCharSet("http://localhost:9212/test", headers, "text/plain", "UTF-8");
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
Thread.sleep(10);
server.stop(0);
}
@Test
public void testPostBody() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9220), 0);
server.createContext("/test", new MyHandler());
server.setExecutor(null); // creates a default executor
server.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBody("http://localhost:9220/test", "hi mom");
assertTrue(response.contains("hi mom"));
Thread.sleep(10);
server.stop(0);
}
@Test(expected = RuntimeException.class)
public void testSad() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9213), 0);
server.createContext("/test", new MyHandler());
server.setExecutor(null); // creates a default executor
server.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBodyWithContentType("http://localhost:9213/foo", headers, "text/plain", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
Thread.sleep(10);
server.stop(0);
}
Puteți găsi restul aici:
https://github.com/RichardHightower/boon
Scopul meu este de a oferi cele mai comune lucruri pe care ar dori să facă într-un pic mai ușor mod de apoi....
noul Client HTTP livrat cu Java 9 dar ca parte a unui Incubator modulul numit
jdk.incubator.httpclient
. Incubator module sunt un mijloc de a pune non-finală APIs în mâinile de dezvoltatori în timp ce APIs progres față de finalizare sau eliminarea într-un viitor versiune.
În Java 9, puteți trimite un "OBȚINE" cerere de genul:
// GET
HttpResponse response = HttpRequest
.create(new URI("http://www.stackoverflow.com"))
.headers("Foo", "foovalue", "Bar", "barvalue")
.GET()
.response();
Apoi, puteți examina revenit HttpResponse
:
int statusCode = response.statusCode();
String responseBody = response.body(HttpResponse.asString());
Începând cu acest nou Client HTTP este în java.httpclient</del>
jdk.incubator.httpclientmodul, ar trebui să declare această dependență în module-info.java
fișier:
module com.foo.bar {
requires jdk.incubator.httpclient;
}
Inițial am fost induși în eroare de acest articolul, care favorizează HttpClient`.
Mai târziu am dat seama că HttpURLConnection
este de gând să stați la acest articolul
Ca pe Google blog:
HTTP Apache clientul are mai putine bug-uri de pe Eclair si Froyo. Este cea mai buna alegere pentru aceste versiuni. Pentru turtă dulce , HttpURLConnection este cea mai buna alegere. Sale API simplu și de dimensiuni mici face o potrivire mare pentru Android.
Transparent de compresie și de răspuns în cache reduce utilizarea rețelei, pentru a îmbunătăți viteza și de a salva bateria. Noi aplicații ar trebui să utilizeze HttpURLConnection; acesta este locul unde vom petrece energia noastră merge înainte.
După ce a citit acest articol și alte câteva stack de peste fluxul de întrebări, sunt convins că HttpURLConnection` este de gând să rămână pentru durate mai lungi.
Unele dintre întrebări SE favorizând HttpURLConnections
:
https://stackoverflow.com/questions/4221420/httppost-works-in-java-project-not-in-android
Există, de asemenea, OkHttp, care este un client HTTP, care este eficientă în mod implicit:
- HTTP/2 suport permite toate cererile de la aceeași gazdă pentru a partaja un soclu.
- gruparea de Conexiuni reduce cererea latenta (dacă HTTP/2 nu este disponibil).
- Transparent GZIP micsoreaza dimensiunile de descărcare.
- Răspuns în cache evită rețea complet pentru cereri repetate.
Creați mai întâi un exemplu de OkHttpClient
:
OkHttpClient client = new OkHttpClient();
Apoi, pregătește-ți "OBȚINE" cerere:
Request request = new Request.Builder()
.url(url)
.build();
în cele din urmă, utilizați OkHttpClient
pentru a trimite pregătit "Cerere":
Response response = client.newCall(request).execute();
Pentru mai multe detalii, puteți consulta OkHttp's documentație
Puteți folosi, de asemenea, JdkRequest
din jcabi-http (I'm un dezvoltator), care face toată munca pentru tine, decorarea HttpURLConnection, trăgând cereri HTTP și analiză a răspunsurilor, de exemplu:
String html = new JdkRequest("http://www.google.com").fetch().body();
Verificați acest blog pentru mai multe informatii: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html
dacă utilizați http get vă rugăm să eliminați această linie
urlConnection.setDoOutput(true);