HttpEntity를 사용하지 않고 Volley로 멀티파트 POST 요청을 만드는 방법은 무엇입니까?

HttpEntity 없이 Volley를 사용하여 멀티파트 POST 요청을 수행하는 방법

Volley는 HTTP 요청을 생성하는 데 널리 사용되는 Android 라이브러리입니다. 이전 API 버전에서는 다중 부분 양식 데이터 제출을 위해 HttpEntity가 Volley와 함께 사용되었습니다. 그러나 API 22에서 HttpEntity가 더 이상 사용되지 않고 API 23에서 완전히 제거됨에 따라 개발자는 문제에 직면하게 됩니다.

이 기사에서는 HttpEntity를 사용하지 않고 멀티파트 POST 요청을 수행하기 위한 작동하는 솔루션을 시연합니다. HttpEntity. 제공된 코드를 사용하면 텍스트 데이터와 함께 여러 파일을 업로드할 수 있습니다.

코드 개요

여기에 제시된 구현은 MultipartActivity 및 MultipartRequest라는 두 가지 클래스로 구성됩니다. MultipartActivity는 멀티파트 양식 데이터 준비를 처리하는 반면 MultipartRequest는 Volley의 Request 클래스를 확장하고 멀티파트 본문을 처리하고 서버 응답을 처리하는 데 필요한 메서드를 재정의합니다.

사용법

이 솔루션을 활용하려면 다음 단계를 따르세요. :

1. URL, mimeType, 멀티파트 본문 및 응답 리스너.
2. getParams()를 사용하여 추가 텍스트 매개변수를 추가합니다.
3. 관련 파일 또는 데이터가 포함된 DataPart 객체를 생성하고 이를 getByteData() 메서드에 추가합니다.
4. addToRequestQueue()를 사용하여 Volley의 요청 대기열에 대한 MultipartRequest.

예 코드

MultipartActivity.java:

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.widget.Toast;

import com.android.volley.NetworkResponse;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.example.multipartvolley.MultipartRequest;
import com.example.multipartvolley.VolleySingleton;

import java.util.HashMap;
import java.util.Map;

public class MultipartActivity extends Activity {

    private Context context = this;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Assuming you have prepared file data in fileData1 and fileData2
        String url = "http://192.168.1.100/api/postfile";
        MultipartRequest multipartRequest = new MultipartRequest(url, null, "multipart/form-data", multipartBody, new Response.Listener<NetworkResponse>() {
            @Override
            public void onResponse(NetworkResponse response) {
                Toast.makeText(context, "Upload successfully!", Toast.LENGTH_SHORT).show();
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Toast.makeText(context, "Upload failed!\r\n" + error.toString(), Toast.LENGTH_SHORT).show();
            }
        }) {
            @Override
            protected Map<String, String> getParams() {
                Map<String, String> params = new HashMap<>();
                params.put("text_field1", "Value for text field 1");
                params.put("text_field2", "Value for text field 2");
                return params;
            }

            @Override
            protected Map<String, DataPart> getByteData() {
                Map<String, DataPart> params = new HashMap<>();
                params.put("file_name1", new DataPart("file_name1.txt", "file content 1".getBytes(), "text/plain"));
                params.put("file_name2", new DataPart("file_name2.png", fileData1, "image/png"));
                return params;
            }
        };

        VolleySingleton.getInstance(context).addToRequestQueue(multipartRequest);
    }
}

MultipartRequest.java:

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;

import java.util.HashMap;
import java.util.Map;

class MultipartRequest extends Request<NetworkResponse> {

    private final Response.Listener<NetworkResponse> mListener;
    private final Response.ErrorListener mErrorListener;
    private Map<String, String> mHeaders;
    private Map<String, DataPart> mByteData;

    MultipartRequest(String url,
                     Map<String, String> headers,
                     String contentType,
                     Map<String, DataPart> byteData,
                     Response.Listener<NetworkResponse> listener,
                     Response.ErrorListener errorListener) {
        super(Method.POST, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
        this.mHeaders = headers;
        this.mByteData = byteData;
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return mHeaders != null ? mHeaders : super.getHeaders();
    }

    @Override
    public String getBodyContentType() {
        return "multipart/form-data; boundary=" + getBoundary();
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        return encodeMultipartData(mByteData, getBoundary());
    }

    private String getBoundary() {
        return Long.toHexString(System.currentTimeMillis());
    }

    @Override
    protected Response<NetworkResponse> parseNetworkResponse(NetworkResponse response) {
        try {
            return Response.success(
                    response,
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(NetworkResponse response) {
        mListener.onResponse(response);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }

    protected static byte[] encodeMultipartData(Map<String, DataPart> dataParts,
                                                String boundary) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);

        try {
            for (Map.Entry<String, DataPart> entry : dataParts.entrySet()) {
                dos.writeBytes(twoHyphens + boundary + lineEnd);
                dos.writeBytes("Content-Disposition: form-data; name=\"" +
                        entry.getKey() + "\"" +
                        "; filename=\"" +
                        entry.getValue().getFileName() + "\"" +
                        lineEnd);
                dos.writeBytes(String.format("Content-Type: %s%s", entry.getValue().getType(), lineEnd));
                dos.writeBytes(lineEnd);

                dos.write(entry.getValue().getContent());
                dos.writeBytes(lineEnd);
            }
            dos.writeBytes(lineEnd);
            dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);

            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    class DataPart {
        private String fileName;
        private byte[] content;
        private String type;

        DataPart(String fileName, byte[] content, String type) {
            this.fileName = fileName;
            this.content = content;
            this.type = type;
        }

        String getFileName() {
            return fileName;
        }

        byte[] getContent() {
            return content;
        }

        String getType() {
            return type;
        }
    }
}

이 코드는 멀티파트 형식을 처리합니다. 파일 및 텍스트 매개변수를 모두 서버에 안전하게 전달할 수 있는 데이터 요청입니다. 최종 코드는 프로덕션용이 아니며 특정 요구 사항에 따라 수정되어야 한다는 점을 기억하는 것이 중요합니다.

위 내용은 HttpEntity를 사용하지 않고 Volley로 멀티파트 POST 요청을 만드는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!