Android
HttpURLConnection

वाक्य - विन्यास

• अमूर्त शून्य डिस्कनेक्ट ()
• अमूर्त बूलियन
• स्थिर बूलियन getFollowRedirects ()
• स्थिर शून्य सेटफ्लोरर अप्रत्यक्ष (बूलियन सेट)
• स्ट्रिंग getHeaderField (int n)
• स्ट्रिंग getHeaderFieldKey (int n)
• स्ट्रिंग getRequestMethod ()
• स्ट्रिंग getResponseMessage ()
• int getResponseCode ()
• लंबे getHeaderFieldDate (स्ट्रिंग नाम, लंबे डिफ़ॉल्ट)
• बूलियन getInstanceFollowRedirects ()
• अनुमति getPermission ()
• InputStream getErrorStream ()
• शून्य सेटहंकडस्ट्रीमिंगमोड (int chunklen)
• शून्य सेट
• शून्य सेटफ़िल्डलिफ्टिंगस्ट्रीमिंगमोड
• शून्य सेट
• शून्य setRequestMethod (स्ट्रिंग विधि)

टिप्पणियों

एक HttpURLConnection बनाना

एक नया Android HTTP क्लाइंट HttpURLConnection , URL उदाहरण पर openConnection() कॉल करें। चूंकि openConnection() एक URLConnection देता है, तो आपको दिए गए मान को स्पष्ट रूप से डालना होगा।

URL url = new URL("http://example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// do something with the connection

यदि आप एक नया URL बना रहे हैं, तो आपको URL पार्सिंग से जुड़े अपवादों को भी संभालना होगा।

try {
    URL url = new URL("http://example.com");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    // do something with the connection
} catch (MalformedURLException e) {
    e.printStackTrace();
}

एक बार जब प्रतिक्रिया बॉडी को पढ़ लिया गया है और कनेक्शन की आवश्यकता नहीं है, तो disconnect() को कॉल करके कनेक्शन को बंद कर दिया जाना चाहिए।

यहाँ एक उदाहरण है:

URL url = new URL("http://example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
try {
    // do something with the connection
} finally {
    connection.disconnect();
}

HTTP GET अनुरोध भेजना

URL url = new URL("http://example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();

try {
    BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));

    // read the input stream
    // in this case, I simply read the first line of the stream
    String line = br.readLine();
    Log.d("HTTP-GET", line);

} finally {
    connection.disconnect();
}

कृपया ध्यान दें कि अपवाद ऊपर दिए गए उदाहरण में नियंत्रित नहीं किए गए हैं। एक पूर्ण उदाहरण, (एक तुच्छ) अपवाद हैंडलिंग सहित, होगा:

URL url;
HttpURLConnection connection = null;

try {
    url = new URL("http://example.com");
    connection = (HttpURLConnection) url.openConnection();
    BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));

    // read the input stream
    // in this case, I simply read the first line of the stream
    String line = br.readLine();
    Log.d("HTTP-GET", line);

} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (connection != null) {
        connection.disconnect();
    }
}

HTTP GET अनुरोध के मुख्य भाग को पढ़ना

URL url = new URL("http://example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();

try {
    BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));

    // use a string builder to bufferize the response body
    // read from the input strea.
    StringBuilder sb = new StringBuilder();
    String line;
    while ((line = br.readLine()) != null) {
        sb.append(line).append('\n');
    }

    // use the string builder directly,
    // or convert it into a String
    String body = sb.toString();

    Log.d("HTTP-GET", body);

} finally {
    connection.disconnect();
}

कृपया ध्यान दें कि अपवाद ऊपर दिए गए उदाहरण में नियंत्रित नहीं किए गए हैं।

मल्टीपार्ट / फॉर्म-डेटा के लिए HttpURLConnection का उपयोग करें

मल्टीपार्ट / फॉर्म-डेटा HttpURLConnection अनुरोध के लिए कस्टम वर्ग बनाएं

MultipartUtility.java

public class MultipartUtility {
        private final String boundary;
        private static final String LINE_FEED = "\r\n";
        private HttpURLConnection httpConn;
        private String charset;
        private OutputStream outputStream;
        private PrintWriter writer;
    
        /**
         * This constructor initializes a new HTTP POST request with content type
         * is set to multipart/form-data
         *
         * @param requestURL
         * @param charset
         * @throws IOException
         */
        public MultipartUtility(String requestURL, String charset)
                throws IOException {
            this.charset = charset;
    
            // creates a unique boundary based on time stamp
            boundary = "===" + System.currentTimeMillis() + "===";
            URL url = new URL(requestURL);
            httpConn = (HttpURLConnection) url.openConnection();
            httpConn.setUseCaches(false);
            httpConn.setDoOutput(true);    // indicates POST method
            httpConn.setDoInput(true);
            httpConn.setRequestProperty("Content-Type",
                    "multipart/form-data; boundary=" + boundary);
            outputStream = httpConn.getOutputStream();
            writer = new PrintWriter(new OutputStreamWriter(outputStream, charset),
                    true);
        }
    
        /**
         * Adds a form field to the request
         *
         * @param name  field name
         * @param value field value
         */
        public void addFormField(String name, String value) {
            writer.append("--" + boundary).append(LINE_FEED);
            writer.append("Content-Disposition: form-data; name=\"" + name + "\"")
                    .append(LINE_FEED);
            writer.append("Content-Type: text/plain; charset=" + charset).append(
                    LINE_FEED);
            writer.append(LINE_FEED);
            writer.append(value).append(LINE_FEED);
            writer.flush();
        }
    
        /**
         * Adds a upload file section to the request
         *
         * @param fieldName  name attribute in <input type="file" name="..." />
         * @param uploadFile a File to be uploaded
         * @throws IOException
         */
        public void addFilePart(String fieldName, File uploadFile)
                throws IOException {
            String fileName = uploadFile.getName();
            writer.append("--" + boundary).append(LINE_FEED);
            writer.append(
                    "Content-Disposition: form-data; name=\"" + fieldName
                            + "\"; filename=\"" + fileName + "\"")
                    .append(LINE_FEED);
            writer.append(
                    "Content-Type: "
                            + URLConnection.guessContentTypeFromName(fileName))
                    .append(LINE_FEED);
            writer.append("Content-Transfer-Encoding: binary").append(LINE_FEED);
            writer.append(LINE_FEED);
            writer.flush();
    
            FileInputStream inputStream = new FileInputStream(uploadFile);
            byte[] buffer = new byte[4096];
            int bytesRead = -1;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            outputStream.flush();
            inputStream.close();
            writer.append(LINE_FEED);
            writer.flush();
        }
    
        /**
         * Adds a header field to the request.
         *
         * @param name  - name of the header field
         * @param value - value of the header field
         */
        public void addHeaderField(String name, String value) {
            writer.append(name + ": " + value).append(LINE_FEED);
            writer.flush();
        }
    
        /**
         * Completes the request and receives response from the server.
         *
         * @return a list of Strings as response in case the server returned
         * status OK, otherwise an exception is thrown.
         * @throws IOException
         */
        public List<String> finish() throws IOException {
            List<String> response = new ArrayList<String>();
            writer.append(LINE_FEED).flush();
            writer.append("--" + boundary + "--").append(LINE_FEED);
            writer.close();
    
            // checks server's status code first
            int status = httpConn.getResponseCode();
            if (status == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(
                        httpConn.getInputStream()));
                String line = null;
                while ((line = reader.readLine()) != null) {
                    response.add(line);
                }
                reader.close();
                httpConn.disconnect();
            } else {
                throw new IOException("Server returned non-OK status: " + status);
            }
            return response;
        }
    }

इसका उपयोग करें (Async way)

    MultipartUtility multipart = new MultipartUtility(requestURL, charset);

    // In your case you are not adding form data so ignore this
                /*This is to add parameter values */
                for (int i = 0; i < myFormDataArray.size(); i++) {
                    multipart.addFormField(myFormDataArray.get(i).getParamName(),
                            myFormDataArray.get(i).getParamValue());
                }


//add your file here.
                /*This is to add file content*/
                for (int i = 0; i < myFileArray.size(); i++) {
                    multipart.addFilePart(myFileArray.getParamName(),
                            new File(myFileArray.getFileName()));
                }

                List<String> response = multipart.finish();
                Debug.e(TAG, "SERVER REPLIED:");
                for (String line : response) {
                    Debug.e(TAG, "Upload Files Response:::" + line);
// get your server response here.
                    responseString = line;
                }

मापदंडों के साथ HTTP POST अनुरोध भेजना

POST मापदंडों के माध्यम से सर्वर को भेजे जाने वाले मापदंडों को संग्रहीत करने के लिए एक HashMap का उपयोग करें:

HashMap<String, String> params;

एक बार जब params HashMap आबाद हो जाता है, तो StringBuilder बनाएँ जो उन्हें सर्वर पर भेजने के लिए उपयोग किया जाएगा:

    StringBuilder sbParams = new StringBuilder();
    int i = 0;
    for (String key : params.keySet()) {
        try {
            if (i != 0){
                sbParams.append("&");
            }
            sbParams.append(key).append("=")
                    .append(URLEncoder.encode(params.get(key), "UTF-8"));

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        i++;
    }

फिर, HttpURLConnection बनाएँ, कनेक्शन खोलें, और POST पैरामीटर भेजें:

try{
    String url = "http://www.example.com/test.php";
    URL urlObj = new URL(url);
    HttpURLConnection conn = (HttpURLConnection) urlObj.openConnection();
    conn.setDoOutput(true);
    conn.setRequestMethod("POST");
    conn.setRequestProperty("Accept-Charset", "UTF-8");
    
    conn.setReadTimeout(10000);
    conn.setConnectTimeout(15000);
    
    conn.connect();
    
    String paramsString = sbParams.toString();
    
    DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
    wr.writeBytes(paramsString);
    wr.flush();
    wr.close();
} catch (IOException e) {
  e.printStackTrace();
}

फिर वह परिणाम प्राप्त करें जो सर्वर वापस भेजता है:

try {
  InputStream in = new BufferedInputStream(conn.getInputStream());
  BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  StringBuilder result = new StringBuilder();
  String line;
  while ((line = reader.readLine()) != null) {
    result.append(line);
  }

  Log.d("test", "result from server: " + result.toString());

} catch (IOException e) {
  e.printStackTrace();
} finally {
    if (conn != null) {
        conn.disconnect();
    }
}

HttpURLConnection का उपयोग करके अपलोड (POST) फ़ाइल

एक दूरस्थ सर्वर पर फ़ाइल भेजने / अपलोड करने के लिए अक्सर यह आवश्यक होता है, उदाहरण के लिए, रिमोट प्राइवेट सर्वर के लिए इमेज, वीडियो, ऑडियो या एप्लिकेशन डेटाबेस का बैकअप। यह मानते हुए कि सर्वर सामग्री के साथ एक POST अनुरोध की अपेक्षा कर रहा है, यहां एक सरल उदाहरण है कि एंड्रॉइड में इस कार्य को कैसे पूरा किया जाए।

फ़ाइल अपलोड multipart/form-data POST अनुरोधों का उपयोग करके भेजे जाते हैं। इसे लागू करना बहुत आसान है:

URL url = new URL(postTarget);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();

String auth = "Bearer " + oauthToken;
connection.setRequestProperty("Authorization", basicAuth);

String boundary = UUID.randomUUID().toString();
connection.setRequestMethod("POST");
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);

DataOutputStream request = new DataOutputStream(uc.getOutputStream());

request.writeBytes("--" + boundary + "\r\n");
request.writeBytes("Content-Disposition: form-data; name=\"description\"\r\n\r\n");
request.writeBytes(fileDescription + "\r\n");

request.writeBytes("--" + boundary + "\r\n");
request.writeBytes("Content-Disposition: form-data; name=\"file\"; filename=\"" + file.fileName + "\"\r\n\r\n");
request.write(FileUtils.readFileToByteArray(file));
request.writeBytes("\r\n");

request.writeBytes("--" + boundary + "--\r\n");
request.flush();
int respCode = connection.getResponseCode();

switch(respCode) {
    case 200:
        //all went ok - read response
        ...
        break;
    case 301:
    case 302:
    case 307:
        //handle redirect - for example, re-post to the new location
        ...
        break;
    ...
    default:
        //do something sensible
}

बेशक, अपवादों को पकड़ने या घोषित किए जाने की आवश्यकता होगी। इस कोड के बारे में ध्यान देने के लिए कुछ बिंदु:

1. postTarget POST का गंतव्य URL है; oauthToken प्रमाणीकरण टोकन है; fileDescription फाइल का विवरण है, जिसे फ़ील्ड description के मान के रूप में भेजा जाता है; file भेजी जाने वाली फ़ाइल है - यह java.io.File प्रकार की है - यदि आपके पास फ़ाइल पथ है, तो आप इसके स्थान पर new File(filePath) उपयोग कर सकते हैं।
2. यह ऑथोरिटी ऑडर के लिए Authorization हैडर सेट करता है
3. यह फ़ाइल को बाइट सरणी में पढ़ने के लिए Apache Common FileUtil का उपयोग करता है - यदि आपके पास फ़ाइल की सामग्री पहले से ही बाइट सरणी में या किसी अन्य तरीके से मेमोरी में है, तो इसे पढ़ने की कोई आवश्यकता नहीं है।

सभी प्रकार के HTTP अनुरोधों को संभालने के लिए एक बहुउद्देश्यीय HttpURLConnection वर्ग

निम्न वर्ग को एकल वर्ग के रूप में इस्तेमाल किया जा सकता है जो GET , POST , PUT , PATCH , और अन्य अनुरोधों को संभाल सकता है:

class APIResponseObject{
    int responseCode;
    String response;

    APIResponseObject(int responseCode,String response)
    {
         this.responseCode = responseCode;
         this.response = response;
    }
}

public class APIAccessTask extends AsyncTask<String,Void,APIResponseObject> {
    URL requestUrl;
    Context context;
    HttpURLConnection urlConnection;
    List<Pair<String,String>> postData, headerData;
    String method;
    int responseCode = HttpURLConnection.HTTP_OK;

    interface OnCompleteListener{
        void onComplete(APIResponseObject result);
    }

    public OnCompleteListener delegate = null;

    APIAccessTask(Context context, String requestUrl, String method, OnCompleteListener delegate){
        this.context = context;
        this.delegate = delegate;
        this.method = method;
        try {
            this.requestUrl = new URL(requestUrl);
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }

    APIAccessTask(Context context, String requestUrl, String method, List<Pair<String,String>> postData, OnCompleteListener delegate){
        this(context, requestUrl, method, delegate);
        this.postData = postData;
    }

    APIAccessTask(Context context, String requestUrl, String method, List<Pair<String,String>> postData,
            List<Pair<String,String>> headerData, OnCompleteListener delegate ){
        this(context, requestUrl,method,postData,delegate);
        this.headerData = headerData;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected APIResponseObject doInBackground(String... params) {
        Log.d("debug", "url = "+ requestUrl);
        try {
            urlConnection = (HttpURLConnection) requestUrl.openConnection();

            if(headerData != null) {
                for (Pair pair : headerData) {
                    urlConnection.setRequestProperty(pair.first.toString(),pair.second.toString());
                }
            }

            urlConnection.setDoInput(true);
            urlConnection.setChunkedStreamingMode(0);
            urlConnection.setRequestMethod(method);
            urlConnection.connect();

            StringBuilder sb = new StringBuilder();

            if(!(method.equals("GET"))) {
                OutputStream out = new BufferedOutputStream(urlConnection.getOutputStream());
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, "UTF-8"));
                writer.write(getPostDataString(postData));
                writer.flush();
                writer.close();
                out.close();
            }

            urlConnection.connect();
            responseCode = urlConnection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                InputStream in = new BufferedInputStream(urlConnection.getInputStream());
                BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
                String line;

                while ((line = reader.readLine()) != null) {
                    sb.append(line);
                }
            }

            return new APIResponseObject(responseCode, sb.toString());
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
        return null;
    }

    @Override
    protected void onPostExecute(APIResponseObject result) {
        delegate.onComplete(result);
        super.onPostExecute(result);
    }

    private String getPostDataString(List<Pair<String, String>> params) throws UnsupportedEncodingException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for(Pair<String,String> pair : params){
            if (first)
                first = false;
            else
                result.append("&");

            result.append(URLEncoder.encode(pair.first,"UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(pair.second, "UTF-8"));
        }
        return result.toString();
    }
} 

प्रयोग

कक्षा के दिए गए किसी भी निर्माणकर्ता का उपयोग इस बात पर निर्भर करता है कि आपको POST डेटा या कोई अतिरिक्त हेडर भेजने की आवश्यकता है।

डेटा लाने पर onComplete() विधि को कहा जाएगा। डेटा को APIResponseObject क्लास के ऑब्जेक्ट के रूप में लौटाया गया है, जिसमें स्टेटस कोड है जो अनुरोध के HTTP स्टेटस कोड और रिस्पॉन्स वाले स्ट्रिंग को APIResponseObject । आप अपनी कक्षा में इस प्रतिक्रिया को XML या JSON से पार्स कर सकते हैं।

अनुरोध निष्पादित करने के लिए कक्षा के ऑब्जेक्ट पर कॉल execute() , जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

class MainClass {
    String url = "https://example.com./api/v1/ex";
    String method = "POST";    
    List<Pair<String,String>> postData = new ArrayList<>();

    postData.add(new Pair<>("email","whatever");
    postData.add(new Pair<>("password", "whatever");

    new APIAccessTask(MainActivity.this, url, method, postData,
            new APIAccessTask.OnCompleteListener() {
        @Override
        public void onComplete(APIResponseObject result) {
            if (result.responseCode == HttpURLConnection.HTTP_OK) {
                String str = result.response;
                // Do your XML/JSON parsing here
            }
        }
    }).execute();
}