Asynchttpurlconnection 网络框架 (HttpURLConnection+newCachedThreadPool)

看过git上volley和asynchttpclient网络框架的源码好长时间了，打算自己弄个网络框架是基于HttpURLConnection+newCachedThreadPool，目前httpclient已经被淘汰了，盛行的是HttpURLConnection，像volley和okhttp都主打HttpURLConnection，所以我弄了这个框架。

框架结构相对来说比较简单：Request、Response、ResponseListener、NewWorkManager、NewWorkRunnable、RequestParams、Erro等主要的类；
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。基于这个优点所以我选择它。Request封装了请求参数和响应体，初始化线程池，完成整个请求过程。

Request主要用来初始化请求的参数和返回体等。首先要在Application里初始化initRequest(）创建线程池。防止context内存泄漏采用了WeakReference引用；

public class Request {    private static NetWorkThreadManager newtWorkInstance;    //在application里初始化    public static void initRequest(){        newtWorkInstance = NetWorkThreadManager.getNetWorkThreadPoolInstance();    }    private WeakReference weakReference;    private Activity activity;    private Response<?> response;    private RequestParams requestParams;    private int tag;    public Request(Response<?> response,Activity activity,RequestParams requestParams,int tag){        weakReference = new WeakReference<Activity>(activity);        this.response = response;        this.requestParams = requestParams;        this.tag = tag;        this.activity = activity;    }    public Request(Response response,Fragment fragment,RequestParams requestParams,int tag){        weakReference = new WeakReference<Fragment>(fragment);        this.response = response;        this.requestParams = requestParams;        this.tag = tag;        activity = fragment.getActivity();    }    private int requestType = 0;    public void setRequestType(int requestType){        this.requestType = requestType;    }    public int getRequestType(){        return requestType;    }    public void requestStart(){        if(!Utils.isNetworkAvailable(activity)){            ((ResponseListener)weakReference.get()).onError(new Error("当前无网络"),tag);            return;        }        response.getResponseListener().onBefore(tag);        netWorkRunnable = new NetWorkRunnable(this);        newtWorkInstance.cachedThreadPool.execute(netWorkRunnable);    }    private NetWorkRunnable netWorkRunnable;    public RequestParams getRequestParams() {        return requestParams;    }    public void setRequestParams(RequestParams requestParams) {        this.requestParams = requestParams;    }    public int getTag() {        return tag;    }    public void setTag(int tag) {        this.tag = tag;    }    public Response<?> getResponse() {        return response;    }    public void setResponse(Response<?> response) {        this.response = response;    }    //在退出程序的时候调用    public void cancleAll(){        newtWorkInstance.cancleAll();    }    //只是试图去结束掉线程    public void cancle(boolean isCancle){        netWorkRunnable.stop(isCancle);        netWorkRunnable = null;    }

在activity或者fragment里这样调用函数，要实现ResponseListener接口，接口可以指定实体类或者String类型的数据。通过泛型更方便的拿到返回的数据。设置tag可以区分不同的请求。

RequestParams requestParams = new RequestParams();        String url = "";//地址不能给，是公司的。        requestParams.setUrl(url);        LinkedHashMap<String,Object> linkedHashMap = new LinkedHashMap<String,Object>();        linkedHashMap.put("pageNum", "1");        linkedHashMap.put("numPerPage", "10");        linkedHashMap.put("sign",sign);        requestParams.setMapParams(linkedHashMap);        Request requset = new Request(new Response<String>(this,String.class),this,requestParams,0);        requset.setRequestType(RequestType.STRING_TYPE);        requset.requestStart();

再来说说RequestParams这个类，他里边实际上就是一个map，存放请求的参数，可以直接addParams（map）或者addParams(“”).addParams(“”).

public class RequestParams {    public RequestParams(){    }    public LinkedHashMap<String, Object> getMapParams() {        return mapParams;    }    public void setMapParams(LinkedHashMap<String, Object> mapParams) {        this.mapParams = mapParams;    }    private LinkedHashMap<String,Object> mapParams;    public RequestParams addParams(LinkedHashMap<String,Object> params){        mapParams = params;        return this;    }    public RequestParams addParams(String key,Object value){        if(mapParams == null){            mapParams = new LinkedHashMap<>();            mapParams.put(key,value);        }        return this;    }    private String url;    public void setUrl(String url){        this.url = url;    }    public String getUrl(){        return  url;    }    private String userAgent;    public void setUserAgent(String userAgent){        this.userAgent = userAgent;    }    public String getUserAgent(){        return userAgent;    }

NetWorkThreadManager 是一个单例的创建一个线程池newCachedThreadPool对象，cancleAll用来在退出程序的时候试图来结束所的线程

public class NetWorkThreadManager{    public static ExecutorService cachedThreadPool;    private NetWorkRunnable netWorkRunnable;    private NetWorkThreadManager(){        cachedThreadPool = Executors.newCachedThreadPool();    }    private static NetWorkThreadManager netWorkThreadPool;    public static NetWorkThreadManager getNetWorkThreadPoolInstance(){        synchronized (NetWorkThreadManager.class){            if(netWorkThreadPool == null){                netWorkThreadPool = new NetWorkThreadManager();            }        }        return netWorkThreadPool;    }    public void cancleAll(){        cachedThreadPool.shutdown();        try {            if (!cachedThreadPool.awaitTermination(60, TimeUnit.SECONDS)) {                cachedThreadPool.shutdownNow();            }        } catch (InterruptedException ie) {            cachedThreadPool.shutdownNow();            Thread.currentThread().interrupt();        }        cachedThreadPool = null;    }}

NetWorkRunnable 子线程加载网络请求，创建了一个静态内部类handler来处理子线程和主线程的信息传递。

public class NetWorkRunnable implements Runnable{    private Request request;    private MyHandler myHandler;    public NetWorkRunnable(Request request){        this.request = request;        myHandler = new MyHandler(Looper.myLooper());        myHandler.put(request);    }    @Override    public void run() {        if(isCancle){            return;        }        String res = HttpUrlConnectionUtils.httpUtils(request);        if(isCancle){            return;        }        Looper.prepare();        Message message = Message.obtain();        message.obj = res;        myHandler.sendMessage(message);        Looper.loop();    }    private boolean isCancle = false;    public void stop(boolean isCancle){        this.isCancle = isCancle;    }    public  static class MyHandler extends Handler{        public MyHandler(Looper looper){            super(looper);        }        private Request request;        public void put(Request request){           this.request = request;        }        @Override        public void handleMessage(Message msg) {            super.handleMessage(msg);            int tag = request.getTag();            String res = (String)msg.obj;            ResponseListener listener = request.getResponse().getResponseListener();            listener.onFinish(tag);            Response response = request.getResponse();            if(res.equals("error")){                listener.onError(request.getResponse().getError(),tag);                return;            }            switch (request.getRequestType()){                case 1:                    listener.onSuccess(res,tag);                    break;                case 2:                    Gson gson = new Gson();                    Object o = gson.fromJson(res, request.getResponse().getC());                    listener.onSuccess(o,tag);                    break;            }        }    }}

Error封装了错误的信息；

public class Error extends Exception implements Serializable{    public Exception getE() {        return e;    }    public void setE(Exception e) {        this.e = e;    }    private Exception e;    public Error(Exception e){        this.e = e;    }    public Error(String message){        super(message);    }    public Error(){        super();        e.printStackTrace();    }    public void printStackTrace(){        this.printStackTrace();    }    public String getMessage(){        return this.getMessage();    }}

ResponseListener 响应的接口。Response

public class Response<T> {    public ResponseListener<T> getResponseListener() {        return responseListener;    }    public void setResponseListener(ResponseListener<T> responseListener) {        this.responseListener = responseListener;    }    private ResponseListener<T> responseListener;    public Response(ResponseListener<T> responseListener,Class<T> c){        this.responseListener = responseListener;        this.c = c;    }    private Error error;    public void setError(Error error){        this.error = error;    }    public Error getError(){        return error;    }    public Class<T> getC() {        return c;    }    public void setC(Class<T> c) {        this.c = c;    }    private Class<T> c;}public interface ResponseListener<T>{    public void onBefore(int tag);    public void onSuccess(T res,int tag);    public void onError(Error error,int tag);    public void onFinish(int tag);}

源码地址