网络加载的基类http_get请求

创建一个网络加载的基类,使用xutil工具,Get请求,默认的参数index=0,可增加参数通过复写getParaqm方法

   http的get请求的请求行为:http:xxxx/key/?index=xx?key=value?.....

   如果做一个该基类,且能进行三级缓存需要暴露的方法是

     *文件缓存时效

    *index的value-----默认为0

    *使用map集合提交参数

    *关键模块的interfacekey;

    *baseUrl__-有默认值

网络访问使用的是xutil

1.使用的实例,首先继承BaseProtocl,

public class AppDetailProtocol extends BaseProtocol<AppInfoBean>

{

    private String    mPackageName;

    public AppDetailProtocol(String packageName) {

        this.mPackageName = packageName;

    }

    @Override

    protected String getInterfaceKey()

    {

        return "detail";

    }

    @Override

    protected Map<String, String> getParams()

    {

        Map<String, String> map = new HashMap<String, String>();

        map.put("packageName", mPackageName);

        return map;

    }

    @Override

    protected AppInfoBean parseJson(String json)

    {

        return new Gson().fromJson(json, AppInfoBean.class);

    }

    @Override

    protected int setIndex()

    {

        return 0;

    }

    @Override

    protected String setBaseurl()

    {

        return "http://10.0.2.2:8080/GooglePlayServer/";;

    }

    @Override

    protected long setFreshdeley_time_ms()

    {

        return 1000*60*5;

    }

}  

2.使用实例:

        String packageName = getIntent().getStringExtra("packagerName");

        mProtocol = new SexDetailProtocol(packageName);

        try

        {

              //这一步就是网络请求数据

            T mData = mProtocol.loadData(0);

            System.out.println("应用页面网络加载的数据" + mData);

            LoadedResult checkData = BaseProtocol.checkData(mData);

            return checkData;

        }

        catch (Exception e)

        {

            e.printStackTrace();

            return  LoadedResult .ERROR;

                  }

以下是BaseProtocol

public abstract class BaseProtocol<T>

{

    protected abstract String getInterfaceKey();

    protected abstract T parseJson(String json);

    /**

     * 如果孩子有自己定义的参数，复写此方法,因为缓存策略的原因,所以,文件名使用识别该参数

     * 

     * 

     * @return

     */

    protected Map<String, String> getParams()

    {

        return null;

    }

    public T loadData(int index) throws Exception

    {

        // 1. 到本地中去缓存数据

        T data = getDataFromLocal(index);

        if (data != null)

        {

            System.out.println("使用本地缓存");

            return data;

        }

        // 2. 到网络中取数据

        return getDataFromNet(index);

    }

    /**

     * 去本地获取缓存

     * 

     * @param index

     * @return

     * @throws Exception

     */

    private T getDataFromLocal(int index) throws Exception

    {

        File file = getCahceFile(index);

        if (!file.exists())

        {

            // 如果不存在

            return null;

        }

        // 读取file，拿到json字符

        BufferedReader reader = null;

        try

        {

            reader = new BufferedReader(new FileReader(file));

            String timeString = reader.readLine();// 第一行： 时间戳

            long time = Long.valueOf(timeString);

            if (System.currentTimeMillis() > (time + Constans.REFRESH_DELAY))

            {

                // 数据过期，无效

                return null;

            }

            // 将json解析返回

            String json = reader.readLine();// 第二行:json

            return parseJson(json);

        }

        finally

        {

            IOUtils.close(reader);

        }

    }

    private T getDataFromNet(int index) throws Exception

    {

        HttpUtils utils = new HttpUtils();

        // method,url,header,params

        String url = Constans.SERVER_URL + getInterfaceKey();

        RequestParams params = new RequestParams();

        Map<String, String> parameters = getParams();

        if (parameters == null)

        {

            params.addQueryStringParameter("index", index + "");

        }

        else

        {

            for (Map.Entry<String, String> me : parameters.entrySet())

            {

                params.addQueryStringParameter(me.getKey(), me.getValue());

            }

        }

        ResponseStream stream = utils.sendSync(HttpMethod.GET, url, params);

        // 响应码

        int statusCode = stream.getStatusCode();

        if (200 == statusCode)

        {

            // ##### 1. 数据 json ##########

            // 访问接口成功

            // 获取json字符

            String json = stream.readString();

            // ##########################

            System.out.println("存储到本地");

            // 存储到本地

            write2Local(index, json);

            // ##### 2. 解析 json ##########

            // 解析json字符

            return parseJson(json);

            // ###########################

        }

        return null;

    }

    public static LoadedResult checkData(Object data)

    {

        if (data == null) { return LoadedResult.EMPTY; }

        if (data instanceof List)

        {

            if (((List) data).size() == 0) { return LoadedResult.EMPTY; }

        }

        if (data instanceof Map)

        {

            if (((Map) data).size() == 0) { return LoadedResult.EMPTY; }

        }

        return LoadedResult.SUCCESS;

    }

    

    private void write2Local(int index, String json) throws Exception

    {

        File file = getCahceFile(index);

        // 将json字符写入文件中

        BufferedWriter writer = null;

        try

        {

            writer = new BufferedWriter(new FileWriter(file));

            // 第一行：存储时间戳-->保存缓存的时间

            // 第二行：存储json字符

            writer.write("" + System.currentTimeMillis());// 第一行：存储时间戳

            writer.write("\r\n");// 换行

            writer.write(json);

        }

        finally

        {

            IOUtils.close(writer);

        }

    }

    private File getCahceFile(int index)

    {

        // 到文件当中读取缓存

        // 文件存储的路径，以及格式

        // 1. 缓存数据的时效性

        // //通过文件内容格式来确定时效性

        // // 第一行：存储时间戳-->保存缓存的时间

        // // 第二行：存储json字符

        // 2. 文件地址的存放和命名

        // // 存储的路径 sd---> Android/data/包名/json/

        // // 文件名称 : InterfaceKey + "." + index

        String dir = FileUtils.getDir("json");

        String name = null;

        Map<String, String> params = getParams();

        if (params != null)

        {

            StringBuffer sb = new StringBuffer();

            for (Map.Entry<String, String> me : params.entrySet())

            {

                sb.append("_" + me.getValue());

            }

            name = getInterfaceKey() + sb.toString();

        }

        else

        {

            name = getInterfaceKey() + "." + index;

        }

        // 获取缓存文件

        return new File(dir, name);

    }

}