Android http访问简单封装

简介

以下是我对Android端http请求的简单封装，方便使用。分为以下四个部分MyRequest、MyResponse、RequestCallback、HttpClient。

MyRequest

请求类，包含请求的url、参数、回调等；

public class MyRequest {

    public static final String POST = "POST";
    public static final String GET = "GET";

    private String url;
    private String method;//请求方法
    private Map<String,String> parameters;//参数
    private RequestCallback callback;//回调

    public MyRequest(String url,String method,Map<String,String> parameters,RequestCallback callback){
        this.url = url;
        this.method = method;
        this.parameters = parameters;
        this.callback = callback;
    }

    public MyRequest(){

    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getMethod() {
        if(method == null){
            return GET;
        }
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public Map<String, String> getParameters() {
        return parameters;
    }

    public void setParameters(Map<String, String> parameters) {
        this.parameters = parameters;
    }

    public void addParameter(String name,String value){
        if(parameters == null){
            parameters = new HashMap<>();
        }
        parameters.put(name,value);
    }

    public void deleteParameter(String name){
        if(parameters != null){
            parameters.remove(name);
        }
    }

    public RequestCallback getCallback() {
        return callback;
    }

    public void setCallback(RequestCallback callback) {
        this.callback = callback;
    }

    //生成请求的url
    public String generateUrl(){
        if(this.parameters == null || this.url == null){
            return url;
        }else {
            StringBuilder builder = new StringBuilder();
            builder.append(url);
            builder.append("?");
            Iterator<String> iterator = parameters.keySet().iterator();
            while(true){
                String name = iterator.next();
                String value = parameters.get(name);
                builder.append(name);
                builder.append("=");
                builder.append(value);
                if(iterator.hasNext()){
                    builder.append("&");
                }else{
                    break;
                }
            }
            return builder.toString();
        }
    }
}

RequestCallback

请求的回调

public interface RequestCallback {

    public void onSuccess(MyResponse response);
    public void onFailed(int code,String message);
    public void onError(Exception e);
}

MyResponse

请求的返回

public class MyResponse {
    private int responseCode;//返回码
    private String responseMessage;//返回消息
    private InputStream inputStream;//返回的输入流

    public MyResponse(){

    }

    public MyResponse(int responseCode,String responseMessage,InputStream inputStream){
        this.responseCode = responseCode;
        this.responseMessage = responseMessage;
        this.inputStream = inputStream;
    }

    public int getResponseCode() {
        return responseCode;
    }

    public void setResponseCode(int responseCode) {
        this.responseCode = responseCode;
    }

    public String getResponseMessage() {
        return responseMessage;
    }

    public void setResponseMessage(String responseMessage) {
        this.responseMessage = responseMessage;
    }

    public InputStream getInputStream() {
        return inputStream;
    }

    public void setInputStream(InputStream inputStream) {
        this.inputStream = inputStream;
    }


    public void closeInputStream(){
        try{
            if(inputStream!=null) {
                inputStream.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

HttpClient

发送请求。采用单例模式，内部有一个请求队列和一个发送请求的线程，每个请求会被添加到请求队列当中，请求线程从队列当中取出请求。当请求队列为空时，请求线程会被阻塞。

public class HttpClient {

    private int connectionTimeout = 5000;
    private int readTimeout = 5000;

    private boolean isRunning ;

    private LinkedBlockingDeque<MyRequest> requestQueue;//请求队列

    private static HttpClient client = new HttpClient();

    private HttpClient(){
        requestQueue = new LinkedBlockingDeque<>();
        isRunning = true;
        ThreadFactory.getNormalPool().execute(sender);//开启发送线程
    }

    public static HttpClient getInstance(){
        return client;
    }

    public void setConnectionTimeout(int connectionTimeout){
        this.connectionTimeout = connectionTimeout;
    }

    public void setReadTimeout(int readTimeout){
        this.readTimeout = readTimeout;
    }

    public void sendRequest(final MyRequest request){
        requestQueue.offer(request);
    }

    private Runnable sender = new Runnable() {//请求的线程
        @Override
        public void run() {
            while(isRunning){
                try {
                    MyRequest request = requestQueue.take();
                    actualySendRequest(request);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    public void actualySendRequest(MyRequest request){
        try {
            URL newUrl = new URL(request.generateUrl());
            HttpURLConnection conn = (HttpURLConnection) newUrl.openConnection();
            conn.setConnectTimeout(connectionTimeout);
            conn.setReadTimeout(readTimeout);
            conn.setRequestMethod(request.getMethod());
            conn.setDoInput(true);
            conn.setDoOutput(true);

            int responseCode = conn.getResponseCode();
            String message = conn.getResponseMessage();

            if(responseCode>=400){
                request.getCallback().onFailed(responseCode,message);
                return;
            }

            MyResponse response = new MyResponse(responseCode,message,conn.getInputStream());
            request.getCallback().onSuccess(response);
        }catch(Exception e){
            e.printStackTrace();
            request.getCallback().onError(e);
        }
    }

    public void close(){
        isRunning = false;
    }

}

demo

MyRequest[] requests = new MyRequest[10];
for(int i=0;i<requests.length;i++){
    requests[i] = new MyRequest();
    requests[i].setUrl("http://www.baidu.com");
    requests[i].setCallback(new RequestCallback() {
        @Override
        public void onSuccess(MyResponse response) {
            Log.i("网络","访问成功"+response.getResponseCode());
            Log.i("网络","访问成功"+response.getResponseMessage());
        }

        @Override
        public void onFailed(int code, String message) {
            Log.i("网络","访问失败"+code);
        }

        @Override
        public void onError(Exception e) {
            Log.i("网络","出现异常"+e);
        }
    });
}
for(int i=0;i<requests.length;i++) {
    HttpClient.getInstance().sendRequest(requests[i]);
}