Android使用http协议与服务器通讯

Android使用http协议与服务器通讯

网上介绍Android上http通讯的文章不少，不过大部分只给出了实现代码的片断，一些注意事项和如何设计一个合理的类用来处理全部的http请求以及返回结果，通常都不会说起。所以，本身对此作了些总结，给出了个人一个解决方案。

首先，须要明确一下http通讯流程，Android目前提供两种http通讯方式，HttpURLConnection和HttpClient，HttpURLConnection多用于发送或接收流式数据，所以比较适合上传/下载文件，HttpClient相对来说更大更全能，可是速度相对也要慢一点。在此只介绍HttpClient的通讯流程：

1.建立HttpClient对象，改对象能够用来屡次发送不一样的http请求

2.建立HttpPost或HttpGet对象，设置参数，每发送一次http请求，都须要这样一个对象

3.利用HttpClient的execute方法发送请求并等待结果，该方法会一直阻塞当前线程，直到返回结果或抛出异常。

4.针对结果和异常作相应处理

 

根据上述流程，发如今设计类的时候，有几点须要考虑到：

1.HttpClient对象能够重复使用，所以能够做为类的静态变量

2.HttpPost/HttpGet对象通常没法重复使用（若是你每次请求的参数都差很少，也能够重复使用），所以能够建立一个方法用来初始化，同时设置一些须要上传到服务器的资源

3.目前Android再也不支持在UI线程中发起Http请求，实际上也不应这么作，由于这样会阻塞UI线程。所以还须要一个子线程，用来发起Http请求，即执行execute方法

4.不一样的请求对应不一样的返回结果，对于如何处理返回结果（通常来讲都是解析json&更新UI），须要有必定的自由度。

5.最简单的方法是，每次须要发送http请求时，开一个子线程用于发送请求，子线程中接收到结果或抛出异常时，根据状况给UI线程发送message，最后在UI线程的handler的handleMessage方法中作结果解析和UI更新。这么写虽然简单，可是UI线程和Http请求的耦合度很高，并且代码比较散乱、丑陋。

 

基于上述几点缘由，我设计了一个PostRequest类，用于知足个人http通讯需求。我只用到了Post请求，若是你须要Get请求，也能够改写成GetRequest

package com.handspeaker.network;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.json.JSONObject;

import android.app.Activity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.os.Handler;
import android.util.Log;

/**
 * 
 * 用于封装&简化http通讯
 * 
 */
public class PostRequest implements Runnable {
    
    private static final int NO_SERVER_ERROR=1000;
    //服务器地址
    public static final String URL = "fill your own url";
    //一些请求类型
    public final static String ADD = "/add";
    public final static String UPDATE = "/update";
    public final static String PING = "/ping";
    //一些参数
    private static int connectionTimeout = 60000;
    private static int socketTimeout = 60000;
    //类静态变量
    private static HttpClient httpClient=new DefaultHttpClient();
    private static ExecutorService executorService=Executors.newCachedThreadPool();
    private static Handler handler = new Handler();
    //变量
    private String strResult;
    private HttpPost httpPost;
    private HttpResponse httpResponse;
    private OnReceiveDataListener onReceiveDataListener;
    private int statusCode;

    /**
     * 构造函数，初始化一些能够重复使用的变量
     */
    public PostRequest() {
        strResult = null;
        httpResponse = null;
        httpPost = new HttpPost();
    }
    
    /**
     * 注册接收数据监听器
     * @param listener
     */
    public void setOnReceiveDataListener(OnReceiveDataListener listener) {
        onReceiveDataListener = listener;
    }

    /**
     * 根据不一样的请求类型来初始化httppost
     * 
     * @param requestType
     *            请求类型
     * @param nameValuePairs
     *            须要传递的参数
     */
    public void iniRequest(String requestType, JSONObject jsonObject) {
        httpPost.addHeader("Content-Type", "text/json");
        httpPost.addHeader("charset", "UTF-8");

        httpPost.addHeader("Cache-Control", "no-cache");
        HttpParams httpParameters = httpPost.getParams();
        HttpConnectionParams.setConnectionTimeout(httpParameters,
                connectionTimeout);
        HttpConnectionParams.setSoTimeout(httpParameters, socketTimeout);
        httpPost.setParams(httpParameters);
        try {
            httpPost.setURI(new URI(URL + requestType));
            httpPost.setEntity(new StringEntity(jsonObject.toString(),
                    HTTP.UTF_8));
        } catch (URISyntaxException e1) {
            e1.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    /**
     * 新开一个线程发送http请求
     */
    public void execute() {
        executorService.execute(this);
    }

    /**
     * 检测网络情况
     * 
     * @return true is available else false
     */
    public static boolean checkNetState(Activity activity) {
        ConnectivityManager connManager = (ConnectivityManager) activity
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connManager.getActiveNetworkInfo() != null) {
            return connManager.getActiveNetworkInfo().isAvailable();
        }
        return false;
    }

    /**
     * 发送http请求的具体执行代码
     */
    @Override
    public void run() {
        httpResponse = null;
        try {
            httpResponse = httpClient.execute(httpPost);
            strResult = EntityUtils.toString(httpResponse.getEntity());
        } catch (ClientProtocolException e1) {
            strResult = null;
            e1.printStackTrace();
        } catch (IOException e1) {
            strResult = null;
            e1.printStackTrace();
        } finally {
            if (httpResponse != null) {
                statusCode = httpResponse.getStatusLine().getStatusCode();
            }
            else
            {
                statusCode=NO_SERVER_ERROR;
            }
            if(onReceiveDataListener!=null)
            {
                //将注册的监听器的onReceiveData方法加入到消息队列中去执行
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        onReceiveDataListener.onReceiveData(strResult, statusCode);
                    }
                });
            }
        }
    }

    /**
     * 用于接收并处理http请求结果的监听器
     *
     */
    public interface OnReceiveDataListener {
        /**
         * the callback function for receiving the result data
         * from post request, and further processing will be done here
         * @param strResult the result in string style.
         * @param StatusCode the status of the post
         */
        public abstract void onReceiveData(String strResult,int StatusCode);
    }

}

代码使用了观察者模式，任何须要接收http请求结果的类，都要实现OnReceiveDataListener接口的抽象方法，同时PostRequest实例调用setOnReceiveDataListener方法，注册该监听器。完整调用步骤以下：

1.建立PostRequest对象，实现onReceiveData接口，编写本身的onReceiveData方法

2.注册监听器

3.调用PostRequest的iniRequest方法，初始化本次request

4.调用PostRequest的execute方法

 

可能的改进：

1.若是须要多个观察者，能够把只能注册单个监听器改成能够注册多个监听器，维护一个监听器List。

2.若是需求比较简单，并但愿调用流程更简洁，iniRequest和execute能够合并