Loader的简单封装、使用

对于android中的异步操作，有人说：2B青年用handler+thread，屌丝用AsyncTask，普通青年用Loader，而用rxjava的我都没听过Loader，为了做一个普通青年，所以决定学一学loader

网上的资料一大票的抄袭官方文档，全是通讯录的demo，所以我写一个不一样的，对loader进行一下简单封装，同时体会他的精髓。当然，用完之后，还是他妈的rxjava爽。

封装一个用于做get请求的loader，代码如下:

package com.xk.androiddemo;

import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v4.content.AsyncTaskLoader;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Iterator;

/**
 * Created by xuekai on 2017/12/6.
 */

public class NetGetLoader<T> extends AsyncTaskLoader<T> {
    private String url;

    public NetGetLoader(Context context, String baseUrl, Bundle params) {
        super(context);
        this.url = baseUrl;
        Iterator<String> iterator = params.keySet().iterator();
        //拼接参数的操作，具体如何写，随意发挥
        while (iterator.hasNext()) {
            String next = iterator.next();
            url = url + next + "=" + params.getString(next) + "&";
        }
    }


    @Override
    protected void onStartLoading() {
        //在这里可以做缓存处理：例如，对请求url、返回结果、请求时间进行存储，这样就可以实现同意请求，某段时间内不走网络。如果满足条件，直接调用deliverResult(返回结果)即可把结果传给主线程，否则调用forceLoad()走网络。我这里方便起见，直接走网络了。
   
        //调用该方法 走网络
        forceLoad();
    }

    @Override
    public T loadInBackground() {
        //做网络请求，把返回的json串转成T类型，我这里用的是谷歌的gson，网络请求是随便copy的，具体根据情况发挥
        return doGet(url);
    }
    //自由发挥区
    private T doGet(String urlStr) {
        String result = null;
        HttpURLConnection conn = null;
        ByteArrayOutputStream bout = null;
        InputStream in = null;
        try {
            URL url = new URL(urlStr);
            conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(8000 * 2);
            conn.setConnectTimeout(8000 * 2);
            byte[] buffer = new byte[1024];
            bout = new ByteArrayOutputStream();
            in = conn.getInputStream();
            int len = -1;
            while ((len = in.read(buffer)) > 0) {
                bout.write(buffer, 0, len);
            }
            result = new String(bout.toByteArray(), Charset.forName("UTF-8"));
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null)
                    in.close();
                if (bout != null)
                    bout.close();
            } catch (Exception e) {

            }
            if (conn != null)
                conn.disconnect();
        }

        try {
            Gson gson = new Gson();
            Type jsonType = new TypeToken<T>() {
            }.getType();
            return gson.fromJson(result, jsonType);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

这样就封装了一个简单的用于做get请求的loader，使用起来也很简单

        private final int netget = 1;

        authorParams = new Bundle();
        authorParams.putString("id", "571");
        //指明loader类型，参数列表，callback中指明返回结果的类型和baseurl
        getSupportLoaderManager().initLoader(netget, authorParams, new Callback<Author>("http://baobab.kaiyanapp.com/api/v4/pgcs/detail/tab?"));


    class Callback<T> implements LoaderManager.LoaderCallbacks<T> {
        private String baseUrl;

        public Callback(String baseUrl) {
            this.baseUrl = baseUrl;
        }

        @Override
        public Loader<T> onCreateLoader(int id, Bundle args) {
            //根据标记，创建对应的loader，这里id是netget，就创建之前封装好的NetGetLoader
            switch (id) {
                case netget:
                    return new NetGetLoader(MainActivity.this, baseUrl, args);

            }
            return null;
        }

        @Override
        public void onLoadFinished(Loader<T> loader, T data) {
            Log.i("Callback", "onLoadFinished-->" + data);
        }

        @Override
        public void onLoaderReset(Loader<T> loader) {
        }
    }

loadermanager会被activity、fragment关联，所以我们不用考虑生命周期，不用担心内存泄漏，这是他的好处。

个人不太喜欢handler+thread的写法，感觉把请求操作和处理请求结果的操作分离开，看起来很累，而这个loader也是类似的，所以还是觉的rxjava更好一点。