Android使用自己封装的Http和Thread、Handler实现异步任务

目录结构如下：

Http协议的封装:

使用http协议有request和response这两个主要的域，下边是Http协议封装的结构图

（1）HttpRequestInter.java：作为request域对象，应该可以获得客户端请求的地址和httpRequest对象，这样的话才可以获得客户端请求的参数等信息；另外public HttpResponseInter request() throws Exception; 使用这个方法，是当执行完request请求之后，返回一个response对象（这里用接口表示）

/** * 请求的接口 * @author xuliugen */public interface HttpRequestInter {    //获得httpRequest    public HttpUriRequest getHttpRequest();    //获得http请求的url地址    public String getRequestURL();    //请求服务端：要返回一个response对象    public HttpResponseInter request() throws Exception;}

（2）HttpResponseInter.java作为和（1）中相对应的response对象，应该具有的方法：获取返回的状态码、获取返回的流、获取返回返回的string数据等，下边的方法就是获取相应的数据

/** * 响应的接口 * @author xuliugen */public interface HttpResponseInter {    //返回状态码    public int statusCode();    // 向客户端返回流数    public InputStream getResponseStream() throws IllegalStateException,IOException;    //向客户端返回字节数组    public byte[] getResponseStreamAsByte() throws IOException;    //向客户端返回JSON数据    public String getResponseStreamAsString() throws ParseException, IOException;}

（3）这是HttpRequestImpl.java接口的实现类，我们可以看到我们不但实现了HttpRequestInter接口还实现了ResponseHandler 第二个就是用于当执行完request请求之后需要返回的数据，存放在一个response的Handler中。

public class HttpRequestImpl implements HttpRequestInter,ResponseHandler<HttpResponseInter> {    protected HttpUriRequest httpUriRequest;// 用于获取request的url地址    private AbstractHttpClient abstractHttpClient; // client对象    // 构造犯法    public HttpRequestImpl(AbstractHttpClient httpClient) {        this.abstractHttpClient = httpClient;    }    // get方法    public HttpUriRequest getHttpRequest() {        return httpUriRequest;    }    //获得request的url    public String getRequestURL() {        return httpUriRequest.getURI().toString();    }    //执行request请求，并返回�?个response对象接口    public HttpResponseInter request() throws Exception {        return abstractHttpClient.execute(httpUriRequest, this);//传入的ResponseHandler对象    }    /**     * 继承ResponseHandler接口要实现的方法     * 执行完毕之后对response对象的处理接口     */    public HttpResponseInter handleResponse(HttpResponse response)throws ClientProtocolException, IOException {        //返回实现HttpResponseInter的类：返回给一个response接口        HttpResponseInter httpResponseInter = new HttpResponseImpl(response); //返回的时候需要response        return httpResponseInter;    }}

（4）然后下边就是接口的实现类：HttpResponseImpl.java 可以在构造方法中看到一个HttpResponse response对象，这就是在执行完request之后的handler返回的response对象。

/** * 接口的实现类 * @author xuliugen */public class HttpResponseImpl implements HttpResponseInter {    private HttpResponse response; // HttpResponse对象    private HttpEntity entity; // HttpEntity试题对象    public HttpResponseImpl(HttpResponse response) throws IOException {        this.response = response;        HttpEntity tempEntity = response.getEntity();// 获得服务器端返回的entity        if (null != tempEntity) {            entity = new BufferedHttpEntity(tempEntity);        }    }    // 返回response对象的状态码    public int statusCode() {        return response.getStatusLine().getStatusCode();    }    // 获得结果的stream    public InputStream getResponseStream() throws IllegalStateException,            IOException {        InputStream inputStream = entity.getContent();        return inputStream;    }    // 获得的结果转化为string    public String getResponseStreamAsString() throws ParseException,            IOException {        return EntityUtils.toString(entity);    }    // 获得的结果转化为字符数组    public byte[] getResponseStreamAsByte() throws IOException {        return EntityUtils.toByteArray(entity);    }}

（5）ExecuteHttpPost.java这个类继承了HttpRequestImpl.java在里边主要写了两个构造方法，构造方法就是实际的进行post请求的方法，和参数的设置：

/** * 这里才是真正执行post请求的地�? *  * 继承HttpRequestImpl 实现客户端向服务器端的请�? *  * @author xuliugen *  */public class ExecuteHttpPost extends HttpRequestImpl {    public ExecuteHttpPost(AbstractHttpClient httpClient, String url) {        this(httpClient, url, null);    }    public ExecuteHttpPost(AbstractHttpClient httpClient, String url,HttpEntity entity) {        super(httpClient);//父类中的httpClient        this.httpUriRequest = new org.apache.http.client.methods.HttpPost(url);// 初始化httpUriRequest        if (null != entity) {// 设置参数            ((HttpEntityEnclosingRequestBase) httpUriRequest).setEntity(entity);        }    }}

（6）另外一个重要的类就是客户端的实现了：BaseHttpClient.java在这里边我们设置了一系列的方法，用于实现不同客户端的请求方法，以及如何将客户端请求的参数转化为post请求的参数类型、将返回的数据转化为相应的格式，方法的层叠调用，希望大家静下心慢慢看。

/** * HttpClient客户端的顶层类 */public class BaseHttpClient {    private AbstractHttpClient httpClient;    public static final int DEFAULT_RETIES_COUNT = 5;    protected int retriesCount = DEFAULT_RETIES_COUNT;    // 设置最大连接数    public final static int MAX_TOTAL_CONNECTIONS = 100;    // 设置获取连接的最大等待时间    public final static int WAIT_TIMEOUT = 30000;    // 设置每个路由最大连接数    public final static int MAX_ROUTE_CONNECTIONS = 100;    // 设置连接超时时间    public final static int CONNECT_TIMEOUT = 10000;    // 设置读取超时时间    public final static int READ_TIMEOUT = 10000;    /**     * 构造方法，调用初始化方法     */    public BaseHttpClient() {        initHttpClient();    }    /**     * 初始化客户端参数     */    private void initHttpClient() {        //http的参数        HttpParams httpParams = new BasicHttpParams();        //设置最大连接数        ConnManagerParams.setMaxTotalConnections(httpParams,MAX_TOTAL_CONNECTIONS);        //设置获取连接的最大等待时间        ConnManagerParams.setTimeout(httpParams, WAIT_TIMEOUT);        //设置每个路由最大连接数        ConnPerRouteBean connPerRoute = new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS);        ConnManagerParams.setMaxConnectionsPerRoute(httpParams, connPerRoute);        // 设置连接超时时间        HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT);        // 设置读取超时时间        HttpConnectionParams.setSoTimeout(httpParams, READ_TIMEOUT);        HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);        HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);        SchemeRegistry schemeRegistry = new SchemeRegistry();        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));//设置端口80        schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));//设置端口443        //就是管理SchemeRegistry的        ClientConnectionManager clientConnectionManager = new ThreadSafeClientConnManager(httpParams, schemeRegistry);        httpClient = new DefaultHttpClient(clientConnectionManager, httpParams);        //创建http重新连接的handler        httpClient.setHttpRequestRetryHandler(new BaseHttpRequestRetryHandler(retriesCount));    }    /**     * 将参数转化为 List<BasicNameValuePair> 的集合     */    private List<BasicNameValuePair> parseParams(HashMap<String, Object> params) {        if (params == null || 0 == params.size()){            return null;        }        List<BasicNameValuePair> paramsList = new ArrayList<BasicNameValuePair>(params.size());        for (Entry<String, Object> entry : params.entrySet()) {            paramsList.add(new BasicNameValuePair(entry.getKey(), entry.getValue() + ""));        }        return paramsList;    }    /**     * 向服务器端请求：当请求只有url 没有参数的时候     */    public String post(String url) throws Exception {        return post(url, null); //调用有参数的时候执行的post并将参数设置为null    }    /**     * post请求之后返回T类型的结果     */    public <T> T post(String url, HashMap<String, Object> params, Class<T> clz) throws Exception {        String json = post(url, params);        return JSONUtil.fromJson(json, clz); //转化为具体的类型返回    }    /**     * 当请求有参数的时候，其他函数间接调用该方法     */    public String post(String url, HashMap<String, Object> params) throws Exception {        //将传入的参数转化为参数实体：将params转化为enrity的对象：表单entity        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parseParams(params));        return request(url, entity).getResponseStreamAsString();    }    /**     * 将post执行的结果直接返回     */    public Result postAsResult(String url, HashMap<String, Object> params)throws Exception {        return post(url, params, Result.class);    }    /**     * 将post执行的结果一Stream的形式返回     */    public InputStream postAsStream(String url, HashMap<String, Object> params) throws Exception {        //将传入的参数转化为参数实体        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parseParams(params));        return request(url, entity).getResponseStream();    }    public HttpResponseInter request(String url, HttpEntity entity) throws Exception {        HttpRequestImpl httpRequestImpl = new ExecuteHttpPost(httpClient, url, entity);        return httpRequestImpl.request();    }}

（7）最后一个就是我们在httpClient中使用的一个BaseHttpRequestRetryHandler.java用于实现网络重复请求的次数

/** * http重新尝试连接：主要用于完成尝试重新连接 * @author xuliugen */public class BaseHttpRequestRetryHandler implements HttpRequestRetryHandler {    private int max_retry_count;// 最大尝试连接的次数    public BaseHttpRequestRetryHandler(int maxretryCount) {        this.max_retry_count = maxretryCount;    }    private static HashSet<Class<? extends IOException>> exceptionWhiteList = new HashSet<Class<? extends IOException>>();    private static HashSet<Class<? extends IOException>> exceptionBlackList = new HashSet<Class<? extends IOException>>();    static {        exceptionWhiteList.add(NoHttpResponseException.class);        exceptionWhiteList.add(UnknownHostException.class);        exceptionWhiteList.add(SocketException.class);        exceptionBlackList.add(SSLException.class);        exceptionBlackList.add(InterruptedIOException.class);        exceptionBlackList.add(SocketTimeoutException.class);    }    public boolean retryRequest(IOException exception, int executionCount,HttpContext context) {        if (executionCount > max_retry_count){            return false;        }        if (exceptionBlackList.contains(exception.getClass())){            return false;        }        if (exceptionWhiteList.contains(exception.getClass())){            return true;        }        HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);        boolean idempotent = (request instanceof HttpEntityEnclosingRequest);        if (!idempotent) {            // 濡傛灉璇锋眰琚涓烘槸骞傜瓑鐨勶紝閭ｄ箞灏遍噸璇�            return true;        }        Boolean b = (Boolean) context.getAttribute(ExecutionContext.HTTP_REQ_SENT);        boolean sent = (b != null && b.booleanValue());        if (!sent) {            return true;        }        return false;    }}

Service和AsyncTask的结合使用

大致流程如下：

（1）我们将任务统一的交给Service进行处理，这样的话我们就需要一个Task实体

public class Task {    private int taskId;// 任务ID    private Map<String, Object> taskParams;// 参数    public static final int USER_LOGIN = 1; //自定义的一个任务ID    //构造方法和get、set方法省略}

（2）下边就是统一管理Task的Service，在Service中我们不仅需要统一的管理Task即是异步任务，我们还需要负责管理更新界面的操作，因为更新界面的操作不能再住UI中进行，所以我们需要统一的管理activity，在Service中，我们执行异步任务的操作使用过Thread和Handler实现的。

public class MainService extends Service implements Runnable {    // 任务队列：用于存放任务的队列    private static Queue<Task> tasks = new LinkedList<Task>();    // 将需要更新的UI添加到集合中    private static ArrayList<Activity> appActivities = new ArrayList<Activity>();    private boolean isRun;// 是否运行线程    Handler handler = new Handler() {        public void handleMessage(android.os.Message msg) {            switch (msg.what) {            case Task.USER_LOGIN: {// 用户登录 :更新UI                //根据name找到activity：因为MAinActivity实现了MainActivityInter接口，所以可以强转为MainActivityInter类型                MainActivityInter activity = (MainActivityInter) getActivityByName("MainActivity");                 activity.refresh(msg.obj.toString());                break;            }            default:                break;            }        };    };    /**     * 添加任务到任务队列中     */    public static void newTask(Task t) {        tasks.add(t);    }    @Override    public void onCreate() {        isRun = true;        Thread thread = new Thread(this);        thread.start();        super.onCreate();    }    /**     * 让服务一直遍历执行     */    public void run() {        while (isRun) { // 去监听任务            Task task = null;            if (!tasks.isEmpty()) { // 判断队列中是否有值                task = tasks.poll();// 执行完任务后把改任务从任务队列中移除                if (null != task) {                    doTask(task); // TO DO ：执行任务                }            }            try {                Thread.sleep(1000);            } catch (Exception e) {            }        }    }    // 处理任务    private void doTask(Task task) {        Message msg = handler.obtainMessage();        msg.what = task.getTaskId();        switch (task.getTaskId()) {        case Task.USER_LOGIN: { // 用户登录            HashMap<String, Object> paramsHashMap =  (HashMap<String, Object>) task.getTaskParams();            //访问网络，进行判断用户是否存在            String url = "http://172.23.252.89:8080/igouServ/userlogin.action";            BaseHttpClient httpClient = new  BaseHttpClient();            try {                String result = httpClient.post(url, paramsHashMap);                msg.obj= result; //返回到handler进行处理            } catch (Exception e) {                e.printStackTrace();            }            break;        }        default:            break;        }        handler.sendMessage(msg);    }    @Override    public IBinder onBind(Intent intent) {        return null;    }    /**     * 添加一个Activity对象到集合中     */    public static void addActivity(Activity activity) {        if (!appActivities.isEmpty()) {            for (Activity ac : appActivities) {                if (ac.getClass().getName().equals(ac.getClass().getName())) {                    appActivities.remove(ac);                    break;                }            }        }        appActivities.add(activity);    }    /**     * 根据Activity的Name获取Activity对象     */    private Activity getActivityByName(String name) {        if (!appActivities.isEmpty()) {            for (Activity activity : appActivities) {                if (null != activity) {                    if (activity.getClass().getName().indexOf(name) > 0) {                        return activity;                    }                }            }        }        return null;    }    /**     * 退出系统     */    public static void appExit(Context context) {        // Finish 所有的Activity        for (Activity activity : appActivities) {            if (!activity.isFinishing())                activity.finish();        }        // 结束 Service        Intent service = new Intent("com.xuliugen.frame.task.MainService");        context.stopService(service);    }}

（3）为了可以让Service统一的管理activity的话，我们可以书写一个Interface接口MainActivityInter.java有两个方法，其中一个就是为了刷新界面，以便于我们在service中进行界面的操作

public interface MainActivityInter {    /**     * 初始化操作     */    public void init();    /**     * 刷新UI     */    public void refresh(Object... params);}

测试步骤

（1）创建MainActivity.java 主要是为了模拟一次登录操作，在这里边我们需要开启服务，差UN该就爱弄一个任务，将任务加到Service管理的任务队列中去，然后其他的操作就交给MainService.java（Service）进行操作了。

public class MainActivity extends Activity implements MainActivityInter {    private Button btn_login;    private TextView textView;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        btn_login = (Button) this.findViewById(R.id.btn_login);        textView=  (TextView) this.findViewById(R.id.textView1);        // 启动服务        Intent serviceIntent = new Intent(this, MainService.class);        startService(serviceIntent);        btn_login.setOnClickListener(new OnClickListener() {            public void onClick(View v) {                //构造参数传给Task进行处理                Map<String, Object> paramsHashMap = new HashMap<String, Object>(2);                paramsHashMap.put("userName", "xuliugen");                paramsHashMap.put("password", "123456");                Task task = new Task(Task.USER_LOGIN, paramsHashMap);                MainService.newTask(task);            }        });        // 将activity放入到activity队列集合中        MainService.addActivity(this);    }    /******************** 以下两个方法是MainActivityInter接口中的 ********************/    public void init() {    }    public void refresh(Object... params) {        //根据返回的参数进行更新UI         textView.setText(params[0].toString());    }}

项目下载地址：https://github.com/xuliugen/HttpAndAsyncTaskFrame