赠送 HttpClient 和HttpURLConnection 的轻型网络 --》线程池介绍和网络请求流程

标签：android   interface   线程池   框架   

转载注明出处 ：http://blog.csdn.net/codingandroid/article/details/41748743

作为一个框架，肯定要去处理一些比较复杂的情况，正常情况下当然不会阻塞，当情况比较复杂的时候，会出现前多个网络请求的情况，那对于这种情况我们规范去管理当然是最好的了，于是我们需要一个线程池。

首先解释一下，什么叫线程池  ：

每当启动一个线程的时候，我们通常代码是   new Thead(){}.start();  new 一个对象 里面又要new一个runnable 这个是相对比较耗时的，资源我们能省就省，这个线程池就相当与说：我维护一个池子，例如里面放5个现成的线程，请求来了也不用重新去new 直接就能使用，超过5个的时候需要等待一下    对android的开发的来说  就类似于 soundpool吧

理解这个就好，代码没几行，放上来哦

package com.clxu.netframe.abstractinterface;

import java.util.concurrent.AbstractExecutorService;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


/***
 * @function  线程池
 * @author CLXU
 *
 * 2014-11-25
 */
public class DefaultThreadPool {
    /**
     * 用于保存等待执行的任务的阻塞队列。(有序的先进先出阻塞队列)
     */
    private static ArrayBlockingQueue<Runnable> mBlockingQueue = new ArrayBlockingQueue<Runnable>(15, true);

    /**
     * 线程池
     */
    private static AbstractExecutorService mThreadPoolExecutor
                                                        = new ThreadPoolExecutor(5, 7, 25, TimeUnit.SECONDS, mBlockingQueue, 
                                                                new ThreadPoolExecutor.DiscardOldestPolicy());

    private static DefaultThreadPool instance = null;

    public static DefaultThreadPool getInstance() {
        if (instance == null) {
            instance = new DefaultThreadPool();
        }
        return instance;
    }

    /**
     * 执行任务
     * @param r
     */
    public void execute(Runnable r) {
        mThreadPoolExecutor.execute(r);
    }

    /**
     * 关闭，并等待任务执行完成，不接受新任务
     */
    public static void shutdown() {
        if (mThreadPoolExecutor != null) {
            mThreadPoolExecutor.shutdown();
        }
    }

    /**
     * 关闭，立即关闭，并挂起所有正在执行的线程，不接受新任务
     */
    public static void shutdownRightnow() {
        if (mThreadPoolExecutor != null) {
            mThreadPoolExecutor.shutdownNow();
            try {
                // 设置超时极短，强制关闭所有任务
                mThreadPoolExecutor.awaitTermination(1, TimeUnit.MICROSECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

上一篇中使用的时候有一句代码   mDefaultThreadPool.execute(asyncBaseRequest);那就是线程池了，不过下面那个是什么呢？

mAsyncRequests.add(asyncBaseRequest);这行的代码的作用是 维护当前的 activity的所有的请求，当前页面关闭的时候，方便结束掉所有的请求

package com.clxu.netframe.abstractinterface;

import java.io.IOException;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.util.Map;
import java.util.concurrent.TimeoutException;

import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.HttpHostConnectException;

import com.clxu.netframe.R;
import com.clxu.netframe.constant.Constant;
import com.clxu.netframe.exception.MyException;
import com.clxu.netframe.net.callback.ParseCallback;
import com.clxu.netframe.net.callback.ResultCallback;
import com.clxu.netframe.util.LogUtil;

/**
 * 功能描述：网络请求线程基类
 * @author clxu
 * 创建日期：2014-12-4
 */
public abstract class AsyncBaseRequest implements Runnable, Serializable {
    private static final long serialVersionUID = 1L;
    /** LOG打印标签*/
    private static final String TAG = "AsyncBaseRequest";
    /** 网络连接超时，默认值为10秒*/
    protected int connectTimeout = 10 * 1000;
    /** 网络数据读取超时，默认值为10秒*/
    protected int readTimeout = 10* 1000;
    private boolean interrupted;
    public boolean isInterrupted() {
        return interrupted;
    }

    public void setInterrupted(boolean interrupted) {
        this.interrupted = interrupted;
    }

    protected void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

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

    protected String requestUrl;
    protected Map<String, String> parameter;
    private ParseCallback parseHandler;
    private ResultCallback requestCallback;
    protected HttpURLConnection mHttpURLConn;
    protected String mInStream;
    private MyException ex;

    public AsyncBaseRequest(String url, Map<String, String> parameter, ParseCallback handler, ResultCallback requestCallback) {
        this.parseHandler = handler;
        this.requestUrl = url;
        this.parameter = parameter;
        this.requestCallback = requestCallback;
    }

    /**
     * 发送网络请求
     * @return 网络请求返回的InputStream数据流
     * @throws Exception
     */
    protected abstract String getRequestResult() throws Exception;

    @Override
    public void run() {
        if (interrupted) {
            LogUtil.i(TAG, "访问网络前中断业务处理线程(终止)");
            return;
        }
        
        try {
        	//访问网络，获取到返回数据
            mInStream = getRequestResult();
            if (mInStream != null) {
                Object obj = null;
                if(parseHandler != null){
                	//回调 数据解析接口
                    obj = parseHandler.parse(mInStream);
                }
                if(requestCallback!=null){
                    requestCallback.onSuccess(obj);          	
                }
 

            } else {
                LogUtil.e(TAG, "get InputStream By HttpURLConnection return result is NULL.");
                ex = new MyException(R.string.network_request_fail, Constant.NETWORK_REQUEST_RETUN_NULL, R.string.network_request_return_null);
                requestCallback.onFail(ex); // 网络请求返回NULL
            }
        }catch(SocketTimeoutException e){
        	//SocketTimeoutException 这个超时异常是说明请求已经到达服务器，返回数据过程中超时了，如果是订单类的请求要注意了，需要防止重复提交
            ex = new MyException(e);
            requestCallback.onFail(ex);					
		}catch(ConnectTimeoutException e){
			//ConnectTimeoutException 这个是连接异常（例如根本没有打开网络等情况下），数据还没有到达服务器，所以就算是订单类的也没有关系，可以再次提交
            ex = new MyException(e);
            requestCallback.onFail(ex);		
		}catch (TimeoutException e) {
			//TimeoutException 这个是总的超时异常，这里还是捕捉一下
            ex = new MyException(e);
            requestCallback.onFail(ex); // IO异常标识	
		}catch (HttpHostConnectException e) {
			//HttpHostConnectException 出现这个异常，检查程序是否添加网络权限
            ex = new MyException(e);
            requestCallback.onFail(ex);
		}catch (IOException e) {
            ex = new MyException(e);
            requestCallback.onFail(ex); // IO异常标识
        } catch (Exception e) {
            ex = new MyException(e);
            requestCallback.onFail(ex); // 未知异常标识
        }
        
    }

    public HttpURLConnection getRequestConn() {
        return mHttpURLConn;
    }

}

package com.clxu.netframe.net.callback;

import org.json.JSONException;

/***
 * @function 网络请求返回的数据解析接口 
 * @author CLXU
 * 2014-11-25
 */
public interface ParseCallback {
    /**
     * 对网络请求返回的数据进行解析
     * @param json  要解析的字符串，JSON格式
     * @return 解析的结果
     * @throws JSONException JSON异常（普通字符串转换成JSON字符串时，格式出错会抛此异常）
     */
	public Object parse(String json) throws JSONException;
	
}

package com.clxu.netframe.net.callback;

import com.clxu.netframe.exception.MyException;

/**
 * 功能描述：网络请求返回的结果回调接口
 * <span style="font-family: Arial, Helvetica, sans-serif;">@author CLXU</span>
 * 创建日期：2014-11-19
 */
public interface ResultCallback {
    public void onSuccess(Object obj);

    public void onFail(MyException e);

}

框架源码下载地址：http://download.csdn.net/detail/brightshadow11111/8228287

赠送 HttpClient 和HttpURLConnection 的轻型网络 --》线程池介绍和网络请求流程

标签：android   interface   线程池   框架   

原文地址：http://blog.csdn.net/codingandroid/article/details/41748743