网络加载的基类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);
    }
}  






评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值