HTTP अनुरोधों को आग और संभालने के लिए java.net.URL कनेक्शन का उपयोग कैसे करें

अद्यतन करें

जावा 9 के साथ भेजा गया नया HTTP क्लाइंट लेकिन jdk.incubator.httpclient नामक इनक्यूबेटर मॉड्यूल के हिस्से के रूप में। इनक्यूबेटर मॉड्यूल डेवलपर्स के हाथों में गैर-अंतिम एपीआई डालने का माध्यम है जबकि एपीआई भविष्य में रिलीज में अंतिम रूप देने या हटाने की दिशा में प्रगति करता है।

जावा 9 में, आप एक GET अनुरोध भेज सकते हैं जैसे:

// GET
HttpResponse response = HttpRequest
    .create(new URI("http://www..com"))
    .headers("Foo", "foovalue", "Bar", "barvalue")
    .GET()
    .response();

फिर आप लौटे HttpResponse जांच कर सकते हैं:

int statusCode = response.statusCode();
String responseBody = response.body(HttpResponse.asString());

चूंकि यह नया HTTP क्लाइंट अंदर है java.httpclient jdk.incubator.httpclient मॉड्यूल, आपको इस module-info.java फ़ाइल में इस निर्भरता की घोषणा करनी चाहिए:

module com.foo.bar {
    requires jdk.incubator.httpclient;
}

मेरा सुझाव है कि आप kevinsawicki/http-request पर कोड को kevinsawicki/http-request , मूल रूप से HttpUrlConnection शीर्ष पर एक रैपर यह एक बहुत ही सरल API प्रदान करता है यदि आप अभी अनुरोध करना चाहते हैं या आप स्रोतों को देख सकते हैं (यह बहुत बड़ा नहीं है) यह देखने के लिए कि कनेक्शन कैसे प्रबंधित किए जाते हैं।

उदाहरण: सामग्री प्रकार application/json और कुछ क्वेरी पैरामीटर के साथ एक GET अनुरोध GET :

// 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);

एसओ पर इस और अन्य प्रश्नों से प्रेरित, मैंने एक न्यूनतम ओपन सोर्स basic-http-client जो यहां पाए गए अधिकांश तकनीकों का प्रतीक है।

google-http-java-client भी एक महान ओपन सोर्स संसाधन है।

मैं भी इस प्रतिक्रिया से बहुत प्रेरित था।

मैं अक्सर उन परियोजनाओं पर हूं जहां मुझे कुछ HTTP करने की ज़रूरत है, और मैं कई तृतीय पक्ष निर्भरताओं को नहीं लेना चाहता हूं (जो दूसरों को लाता है और इसी तरह आदि)

मैंने इस बातचीत में से कुछ के आधार पर अपनी खुद की उपयोगिताएं लिखना शुरू कर दिया (कहीं भी नहीं किया गया):

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 {

फिर केवल एक गुच्छा या स्थिर तरीके हैं।

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;
    }
}

फिर पोस्ट करें ...

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;
}

खैर, आप विचार समझ गए....

यहां परीक्षण हैं:

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);


}

आप बाकी को यहां पा सकते हैं:

https://github.com/RichardHightower/boon

मेरा लक्ष्य उन सामान्य चीजों को प्रदान करना है जो एक और अधिक आसान तरीके से करना चाहते हैं ....

शुरुआत में मुझे इस article गुमराह किया गया था जो HttpClient पक्ष HttpClient ।

बाद में मुझे एहसास हुआ कि HttpURLConnection इस article से बने रहने जा रहा है

Google ब्लॉग के अनुसार :

अपाचे HTTP क्लाइंट में एक्लेयर और फियोयो पर कम कीड़े हैं। इन रिलीज के लिए यह सबसे अच्छा विकल्प है। जिंजरब्रेड के लिए, HttpURLConnection सबसे अच्छा विकल्प है। इसका सरल एपीआई और छोटा आकार एंड्रॉइड के लिए यह बहुत अच्छा बनाता है।

पारदर्शी संपीड़न और प्रतिक्रिया कैशिंग नेटवर्क उपयोग को कम करने, गति में सुधार और बैटरी बचाने के लिए। नए अनुप्रयोगों को HttpURLConnection का उपयोग करना चाहिए; यह वह जगह है जहां हम अपनी ऊर्जा आगे बढ़ेंगे।

प्रवाह rapidvaluesolutions.com/tech_blog/… और कुछ अन्य ढेर को पढ़ने के बाद, मुझे आश्वस्त है कि HttpURLConnection लंबे समय तक रहने के लिए जा रहा है।

HttpURLConnections के पक्ष में कुछ एसई प्रश्न:

एंड्रॉइड पर, UrlEncodedFormEntity का उपयोग किए बिना यूआरएल एनकोडेड फॉर्म डेटा के साथ एक POST अनुरोध करें

एचटीपीपोस्ट जावा प्रोजेक्ट में काम करता है, एंड्रॉइड में नहीं

HTTP यूआरएल हिट्स के साथ 2 विकल्प हैं: जीईटी / पोस्ट करें

अनुरोध प्राप्त करें: -

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()));

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()));

I recomend http-request built on apache http api. (I'm a developer)

Perform HTTP GET request

static final HttpRequest<String> httpRequest =
     HttpRequestBuilder.createGet(someUri, String.class)
     .responseDeserializer(ResponseDeserializer.ignorableDeserializer()).build();

ResponseHandler<String> responseHandler = httpRequest.execute(requestParameters);

int statusCode = responseHandler.getStatusCode();
String responseBody = responseHandler.get(); // see javadoc of get method

या

 ResponseHandler<String> responseHandler = 
      httpRequest.executeWithQuery(queryString); //queryString example "param1=param1&param2=param2"

Perform HTTP POST request

Replace HttpRequestBuilder.createGet to HttpRequestBuilder.createPost

Add headers

static final HttpRequest<String> httpRequest =
      HttpRequestBuilder.createGet(someUri, String.class)
           .responseDeserializer(ResponseDeserializer.ignorableDeserializer())
           .addDefaultHeader("Accept", "application/json")
           .build();

Convert response to type

let's say response is JSON and you know it

{"name":"myname","lastname":"mylastname","age":25}

You must create class User:

public User{
    private String Name;
    private String Lastname;
    private int Age;

   // getters and setters
}

static final HttpRequest<User> httpRequest =
     HttpRequestBuilder.createGet(someUri, User.class).build();

ResponseHandler<User> responseHandler = httpRequest.execute(requestParameters);
User userFromResponse = responseHandler.orElse(null); //returns null if content isn't present
System.out.print(user.getName()); //myname

Note: You don't need to worry about Exceptions. All exceptions is wrapped.

if you are using http get please remove this line

urlConnection.setDoOutput(true);

OkHttp भी है, जो एक HTTP क्लाइंट है जो डिफ़ॉल्ट रूप से कुशल है:

• HTTP / 2 समर्थन एक ही मेजबान को सॉकेट साझा करने के लिए सभी अनुरोधों की अनुमति देता है।
• कनेक्शन पूलिंग अनुरोध विलंबता को कम कर देता है (यदि HTTP / 2 उपलब्ध नहीं है)।
• पारदर्शी जीजेआईपी डाउनलोड आकार को कम करता है।
• प्रतिक्रिया कैशिंग दोहराए गए अनुरोधों के लिए पूरी तरह से नेटवर्क से बचाती है।

पहले OkHttpClient का एक उदाहरण OkHttpClient :

OkHttpClient client = new OkHttpClient();

फिर, अपना GET अनुरोध तैयार करें:

Request request = new Request.Builder()
      .url(url)
      .build();

अंत में, तैयार Request भेजने के लिए OkHttpClient का उपयोग करें:

Response response = client.newCall(request).execute();

अधिक जानकारी के लिए, आप ओकेएचटीपी के दस्तावेज़ीकरण से परामर्श ले सकते हैं