android एंड्रॉइड के साथ एक HTTP अनुरोध करें




httpwebrequest androidhttpclient (8)

मैंने हर जगह खोज की है लेकिन मुझे मेरा जवाब नहीं मिला, क्या एक सरल HTTP अनुरोध करने का कोई तरीका है? मैं अपनी वेबसाइट में से किसी एक पर PHP पृष्ठ / स्क्रिप्ट का अनुरोध करना चाहता हूं लेकिन मैं वेबपृष्ठ नहीं दिखाना चाहता हूं।

यदि संभव हो तो मैं इसे पृष्ठभूमि में भी करना चाहता हूं (ब्रॉडकास्ट रिसीवर में)


जब तक आप Apache HttpClient को चुनने का कोई स्पष्ट कारण नहीं रखते हैं, तो आपको java.net.URLConnection को प्राथमिकता देना चाहिए। आप वेब पर इसका उपयोग करने के तरीके के बहुत से उदाहरण पा सकते हैं।

हमने आपकी मूल पोस्ट के बाद एंड्रॉइड दस्तावेज़ों में भी सुधार किया है: HttpUrlConnection

और हमने आधिकारिक ब्लॉग पर ट्रेड-ऑफ के बारे में बात की है: android-developers.blogspot.com/2011/09/…


इस अद्भुत नई लाइब्रेरी को देखें जो gradle के माध्यम से उपलब्ध है :)

build.gradle: compile 'com.apptakk.http_request:http-request:0.1.2'

उपयोग:

new HttpRequestTask(
    new HttpRequest("http://httpbin.org/post", HttpRequest.POST, "{ \"some\": \"data\" }"),
    new HttpRequest.Handler() {
      @Override
      public void response(HttpResponse response) {
        if (response.code == 200) {
          Log.d(this.getClass().toString(), "Request successful!");
        } else {
          Log.e(this.getClass().toString(), "Request unsuccessful: " + response);
        }
      }
    }).execute();

https://github.com/erf/http-request


Android में HTTP Get / POST अनुरोध के लिए यह नया कोड है। HTTPClient को HTTPClient है और यह मेरे मामले में उपलब्ध नहीं हो सकता है।

सबसे पहले build.gradle में दो निर्भरताओं को जोड़ें:

compile 'org.apache.httpcomponents:httpcore:4.4.1'
compile 'org.apache.httpcomponents:httpclient:4.5'

फिर doBackground विधि में ASyncTask में यह कोड लिखें।

 URL url = new URL("http://localhost:8080/web/get?key=value");
 HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
 urlConnection.setRequestMethod("GET");
 int statusCode = urlConnection.getResponseCode();
 if (statusCode ==  200) {
      InputStream it = new BufferedInputStream(urlConnection.getInputStream());
      InputStreamReader read = new InputStreamReader(it);
      BufferedReader buff = new BufferedReader(read);
      StringBuilder dta = new StringBuilder();
      String chunks ;
      while((chunks = buff.readLine()) != null)
      {
         dta.append(chunks);
      }
 }
 else
 {
     //Handle else
 }

मेरे लिए, सबसे आसान तरीका Retrofit2 नामक लाइब्रेरी का उपयोग कर रहा है

हमें बस एक इंटरफ़ेस बनाने की आवश्यकता है जिसमें हमारी अनुरोध विधि, पैरामीटर शामिल हों, और हम प्रत्येक अनुरोध के लिए कस्टम हेडर भी बना सकते हैं:

    public interface MyService {

      @GET("users/{user}/repos")
      Call<List<Repo>> listRepos(@Path("user") String user);

      @GET("user")
      Call<UserDetails> getUserDetails(@Header("Authorization") String   credentials);

      @POST("users/new")
      Call<User> createUser(@Body User user);

      @FormUrlEncoded
      @POST("user/edit")
      Call<User> updateUser(@Field("first_name") String first, 
                            @Field("last_name") String last);

      @Multipart
      @PUT("user/photo")
      Call<User> updateUser(@Part("photo") RequestBody photo, 
                            @Part("description") RequestBody description);

      @Headers({
        "Accept: application/vnd.github.v3.full+json",
        "User-Agent: Retrofit-Sample-App"
      })
      @GET("users/{username}")
      Call<User> getUser(@Path("username") String username);    

    }

और सबसे अच्छा यह है कि हम इसे एन्क्यू विधि का उपयोग करके आसानी से असीमित रूप से कर सकते हैं


नोट: Android के साथ बंडल किए गए अपाचे HTTP क्लाइंट को अब HttpUrlConnection पक्ष में बहिष्कृत किया गया है। अधिक जानकारी के लिए कृपया एंड्रॉइड डेवलपर android-developers.blogspot.com/2011/09/… देखें।

अपने <uses-permission android:name="android.permission.INTERNET" />

फिर आप इस प्रकार एक वेब पेज पुनर्प्राप्त करेंगे:

URL url = new URL("http://www.android.com/");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
try {
     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
}
finally {
     urlConnection.disconnect();
}

मैं इसे एक अलग धागे पर चलाने का भी सुझाव देता हूं:

class RequestTask extends AsyncTask<String, String, String>{

@Override
protected String doInBackground(String... uri) {
    String responseString = null;
    try {
        URL url = new URL(myurl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        if(conn.getResponseCode() == HttpsURLConnection.HTTP_OK){
            // Do normal input or output stream reading
        }
        else {
            response = "FAILED"; // See documentation for more info on response handling
        }
    } catch (ClientProtocolException e) {
        //TODO Handle problems..
    } catch (IOException e) {
        //TODO Handle problems..
    }
    return responseString;
}

@Override
protected void onPostExecute(String result) {
    super.onPostExecute(result);
    //Do anything with response..
}
}

प्रतिक्रिया हैंडलिंग और POST अनुरोधों के बारे में अधिक जानकारी के लिए HttpUrlConnection देखें।


अद्यतन करें

यह एक बहुत पुराना जवाब है। मैं निश्चित रूप से अपाचे के क्लाइंट की सिफारिश नहीं करूंगा। इसके बजाय या तो उपयोग करें:

मूल उत्तर

सबसे पहले, नेटवर्क तक पहुंचने की अनुमति का अनुरोध करें, अपने मैनिफेस्ट में निम्नलिखित जोड़ें:

<uses-permission android:name="android.permission.INTERNET" />

फिर Android के साथ बंडल किए गए अपाचे http क्लाइंट का उपयोग करने का सबसे आसान तरीका है:

    HttpClient httpclient = new DefaultHttpClient();
    HttpResponse response = httpclient.execute(new HttpGet(URL));
    StatusLine statusLine = response.getStatusLine();
    if(statusLine.getStatusCode() == HttpStatus.SC_OK){
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        response.getEntity().writeTo(out);
        String responseString = out.toString();
        out.close();
        //..more logic
    } else{
        //Closes the connection.
        response.getEntity().getContent().close();
        throw new IOException(statusLine.getReasonPhrase());
    }

यदि आप इसे अलग थ्रेड पर चलाना चाहते हैं तो मैं AsyncTask को विस्तारित करने की अनुशंसा करता हूं:

class RequestTask extends AsyncTask<String, String, String>{

    @Override
    protected String doInBackground(String... uri) {
        HttpClient httpclient = new DefaultHttpClient();
        HttpResponse response;
        String responseString = null;
        try {
            response = httpclient.execute(new HttpGet(uri[0]));
            StatusLine statusLine = response.getStatusLine();
            if(statusLine.getStatusCode() == HttpStatus.SC_OK){
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                response.getEntity().writeTo(out);
                responseString = out.toString();
                out.close();
            } else{
                //Closes the connection.
                response.getEntity().getContent().close();
                throw new IOException(statusLine.getReasonPhrase());
            }
        } catch (ClientProtocolException e) {
            //TODO Handle problems..
        } catch (IOException e) {
            //TODO Handle problems..
        }
        return responseString;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        //Do anything with response..
    }
}

फिर आप इसके द्वारा अनुरोध कर सकते हैं:

   new RequestTask().execute("http://.com");

धागे के साथ:

private class LoadingThread extends Thread {
    Handler handler;

    LoadingThread(Handler h) {
        handler = h;
    }
    @Override
    public void run() {
        Message m = handler.obtainMessage();
        try {
            BufferedReader in = 
                new BufferedReader(new InputStreamReader(url.openStream()));
            String page = "";
            String inLine;

            while ((inLine = in.readLine()) != null) {
                page += inLine;
            }

            in.close();
            Bundle b = new Bundle();
            b.putString("result", page);
            m.setData(b);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        handler.sendMessage(m);
    }
}

Volley नामक एंड्रॉइड लिब का उपयोग करने का सबसे आसान तरीका है

वॉली निम्नलिखित लाभ प्रदान करता है:

नेटवर्क अनुरोधों का स्वचालित शेड्यूलिंग। एकाधिक समवर्ती नेटवर्क कनेक्शन । मानक HTTP कैश समेकन के साथ पारदर्शी डिस्क और मेमोरी प्रतिक्रिया कैशिंग। अनुरोध प्राथमिकता के लिए समर्थन। रद्दीकरण अनुरोध API। आप एक ही अनुरोध को रद्द कर सकते हैं, या आप रद्द करने के अनुरोधों के ब्लॉक या स्कोप सेट कर सकते हैं। अनुकूलन की आसानी, उदाहरण के लिए, पुनः प्रयास और बैकऑफ के लिए। मजबूत ऑर्डरिंग जो नेटवर्क से असीमित रूप से प्राप्त डेटा के साथ आपके यूआई को सही ढंग से पॉप्युलेट करना आसान बनाता है। डिबगिंग और ट्रेसिंग टूल्स।

आप एक http / https अनुरोध को इस प्रकार सरल के रूप में भेज सकते हैं:

        // Instantiate the RequestQueue.
        RequestQueue queue = Volley.newRequestQueue(this);
        String url ="http://www.yourapi.com";
        JsonObjectRequest request = new JsonObjectRequest(url, null,
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if (null != response) {
                         try {
                             //handle your response
                         } catch (JSONException e) {
                             e.printStackTrace();
                         }
                    }
                }
            }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {

            }
        });
        queue.add(request);

इस मामले में, आपको "पृष्ठभूमि में चलने" या "कैश का उपयोग करके" पर विचार करने की आवश्यकता नहीं है क्योंकि ये सभी वॉली द्वारा पहले से ही किए जा चुके हैं।





androidhttpclient