Android中基于Http请求获取数据基础

Android中应对基础请求Http数据的结果回调

本文中阐述如何对Http方法获取的数据进行监听获取请求的结果：

• 定义基本Http请求数据及方法
• 定义封装好的网络请求代码示例
• 执行请求结果数据处理

---

定义基本Http请求数据及方法

根据URI获取相应返回的Json数据，等待解析

public class HttpClientDS
{
public static JSONObject get(String uri)
    {
        HttpClient httpclient = HttpClientTemplate.getHttpClient();
        HttpGet httpget = new HttpGet(uri);
        InputStream is = null;
        try
        {
            HttpResponse response = httpclient.execute(httpget);
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
            {
                is = response.getEntity().getContent();
                String result = inStream2String(is);
                Log.d(TAG, "result: " + result);
                return new JSONObject(result);
            } else
            {
                Log.d(TAG, "get uri=" + uri + "   status: " + response.getStatusLine().getStatusCode());
                return null;
            }
        } catch (Exception e)
        {
            Log.e(TAG, "get uri=" + uri, e);
            return null;
        } finally
        {
            if (is != null)
            {
                try
                {
                    is.close();
                } catch (IOException e)
                {
                    Log.e(TAG, "", e);
                }
            }
        }
    }
}

HttpClientTemplate方法定义(创建HttpClient接口)

public class HttpClientTemplate {

    private static HttpClient httpClient;

    /** 
     * 最大连接数 
     */
    public final static int   MAX_TOTAL_CONNECTIONS = 100;
    /** 
     * 获取连接的最大等待时间 
     */
    public final static int   WAIT_TIMEOUT          = 60000;
    /** 
     * 每个路由最大连接数 
     */
    public final static int   MAX_ROUTE_CONNECTIONS = 50;
    /** 
     * 连接超时时间 
     */
    public final static int   CONNECT_TIMEOUT       = 60000;
    /** 
     * 读取超时时间 
     */
    public final static int   READ_TIMEOUT          = 30000;

    //创建HttpClient实例
    private static HttpClient createHttpClient() 
    {
        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
        HttpProtocolParams.setUseExpectContinue(params, true);

        // 设置最大连接数  
        ConnManagerParams.setMaxTotalConnections(params, MAX_TOTAL_CONNECTIONS);
        // 设置获取连接的最大等待时间  
        ConnManagerParams.setTimeout(params, WAIT_TIMEOUT);
        // 设置每个路由最大连接数  
        ConnPerRouteBean connPerRoute = new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS);
        ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
        // 设置连接超时时间  
        HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIMEOUT);
        // 设置读取超时时间  
        HttpConnectionParams.setSoTimeout(params, READ_TIMEOUT);
//协议模式
        SchemeRegistry schReg = new SchemeRegistry();
        schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 8080));
        schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
//管理持久连接和同步访问持久连接来确保同一时间仅有一个线程可以访问一个连接。
        ClientConnectionManager connMgr = new ThreadSafeClientConnManager(params, schReg);

        return new DefaultHttpClient(connMgr, params);
    }

    //关闭连接管理器并释放资源
    public static void shutdownHttpClient() 
    {
        if (httpClient != null && httpClient.getConnectionManager() != null) {
            httpClient.getConnectionManager().shutdown();
        }
    }

    //对外提供HttpClient实例
    public static HttpClient getHttpClient() 
    {
        if (null == httpClient) {
            httpClient = createHttpClient();
        }
        return httpClient;
    }

}

Http的post请求方法实例

执行顺序 onPreExecute–>doInBackground–>onPostExecute
//获取解析的json字符串解析，将获取的数据存储到对应的bean中，获取成功通过CallbackListener回调结果

@Override
    public void getAddPublishInfo(final String postId, final String type, final CallbackListener listener)
    {
        /* 1,判断传入数据时候为空 */
        if (postId != null && listener != null)
        {
            new AsyncTask<String, Void, JSONObject>()
            {
                @Override
                protected JSONObject doInBackground(String... params)
                {
                    Map<String, Object> map = LoginInfoManage.getInstance().getUserInfo();
                    if (map != null)
                    {
                        token = map.get("token").toString();
                    }
                    /* 2,将数据放入param中 */
                    List<NameValuePair> param = new ArrayList<NameValuePair>();
                    BasicNameValuePair value = new BasicNameValuePair(Constants.COMMENT_SEND_ID, postId);
                    BasicNameValuePair Type = new BasicNameValuePair(Constants.COMMENT_SEND_TYPE, type);
                    BasicNameValuePair tokens = new BasicNameValuePair("token", token);
                    param.add(value);
                    param.add(Type);
                    param.add(tokens);
                    param.add(new BasicNameValuePair("uid", uid));
                    /* 3,通过HttpClientDS请求网络并返回数据 */
                    try
                    {
                        JSONObject result = HttpClientDS.post(param, Constants.HOST_ADDRESS + Constants.ADDPUBLISH_ACTION);
                        return result;
                    } catch (Exception e)
                    {
                        Log.e(TAG, "Exception: getAddPublishInfo" + e);
                        e.printStackTrace();
                    }
                    return null;
                }

                protected void onPostExecute(JSONObject result)
                {

                    if (LoginInfoManage.getInstance().isTokenError(result))
                    {
                        listener.onError(Constants.TOKEN_ERROR);
                        return;
                    }
                    /* 4,如果返回数据为空则返回错误数据 */
                    if (result == null)
                    {
                        listener.onError(Constants.REQUEST_FAILED);
                        return;
                    }
                    try
                    {
                        /* 5,解析json数据并set入List<AddPublishInfo>中 */
                        OtherPublishInfo addInfos = null;
                        List<OtherPublishInfo> values = new ArrayList<OtherPublishInfo>();
                        JSONArray value = (JSONArray) result.get(Constants.COMMENT_GET_ADDINFO);
                        int len = value.length();
                        for (int i = 0; i < len; i++)
                        {
                            addInfos = new OtherPublishInfo();
                            JSONObject jsonStr = (JSONObject) value.get(i);
                            String content = jsonStr.getString(Constants.COMMENT_GET_ADDCONTENT);
                            String time = jsonStr.getString(Constants.COMMENT_GET_ADDDATATIME);
                            addInfos.setContent(content);
                            addInfos.setTime(time);
                            values.add(addInfos);
                        }
                        listener.onCallback(values);
                    } catch (JSONException e)
                    {
                        Log.e(TAG, "getAddPublishInfo JSONException:" + e);
                        e.printStackTrace();
                    }
                }
            }.execute();
        }
    }

CallbackListener 方法实例，抽象函数提供调用者实现

public interface CallbackListener {
    public void onCallback(Object result);
    public void onError(String error);
}

获取服务器信息实例，抽象函数实现

// 获取追加信息
    private void appendMessage()
    {
        数据.getAddPublishInfo(postId, "3", new CallbackListener()
        {
            @Override
            public void onError(String error)
            {
                Toast.makeText(DetailActivity.this, error, Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onCallback(Object result)
            {
            //获取数据成功界面赋值
                }
        });
    }

本文阐述的是基于Http的post基本请求方式，同时也定义了接口用于类与类之间的通信，使用了AsyncTask进行数据的异步加载(需要熟悉其中的方法以及实现的顺序)，获取json数据，进行原生态解析赋值。