Android Volley使用介绍(三)，量身定做自己的Request

最新推荐文章于 2021-11-04 18:04:42 发布
最新推荐文章于 2021-11-04 18:04:42 发布
阅读量422 收藏
点赞数
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PrettyDie/article/details/51728798
版权

Volley提供了特别强的扩展机制，我们可以很轻松地定制出任意类型的Request。目前市场的Android客户端与服务端进行数据通信用到的数据类型90%以上都是json。而搭配Google的Gson会让json数据解析变得更加的简单。

  • 自定义GsonRequest
import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.toolbox.HttpHeaderParser;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;

import java.io.UnsupportedEncodingException;
import java.util.Hashtable;
import java.util.Map;

/**
 * volley请求json数据的封装
 *  * Created by changj on 16/6/14.
 */
public class GsonRequest<T> extends Request<T>{
    /**
     * gson实例用于解析请求回调的json数据
     */
    private final Gson gson = new Gson();
    /**
     * 解析json对应的泛型对象
     */
    private final Class<T> clazz;
    /**
     * 请求成功的回调
     */
    private final Response.Listener<T> listener;
    /**
     * 请求服务器时必须携带的请求头参数，密钥、token等
     */
    private static Map<String,String> mHeader = new Hashtable<String,String>();

    /**
     * 设置请求头参数
     */
    static {
        mHeader.put("token","Suso56");
        //mHeader.put("APP-Secret","afafaffgrgth4");
    }

    /**
     * 定制请求参数
     *
     * @param method 请求方式，GET、POST等
     * @param url 请求地址
     * @param appendHeader 请求头参数
     * @param clazz 最终json数据转化对应的对象
     * @param listener 成功回调
     * @param errorlistener 失败回调
     */
    public GsonRequest(int method, String url, Map<String, String> appendHeader,Class<T> clazz, Response.Listener<T> listener,Response.ErrorListener errorlistener) {
        super(method, url, errorlistener);
        this.clazz = clazz;
        this.listener = listener;
        if (appendHeader != null){
            mHeader.putAll(appendHeader);
        }

    }

    /**
     * 重载getHeaders()方法，重构请求头参数
     *
     * @return
     * @throws AuthFailureError
     */
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return mHeader;
    }

    /**
     * 解析服务器响应的数据
     *
     * @param networkResponse
     * @return
     */
    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse networkResponse) {
        try {
            /**
             * 得到返回的数据
             */
            String jsonStr = new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers));
            Log.d("VOLLEY",jsonStr);
            /**
             * 将数据转化对象
             */
            return Response.success(gson.fromJson(jsonStr,clazz), HttpHeaderParser.parseCacheHeaders(networkResponse));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e) {
            return Response.error(new ParseError(e));
        }
    }

    /**
     * 解析成功响应的数据的最终回调
     *
     * @param response
     */
    @Override
    protected void deliverResponse(T response) {
        try {
            if (listener != null) {
                listener.onResponse(response);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
  • 封装RequestQueue
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.Volley;
import com.changj.pearl.application.MyApplication;

/**
 * volley请求队列的封装
 * ：
 *
 * Created by admin on 16/6/14.
 */
public class VolleyRequestQueue {

    /**
     * 单例
     */
    private static VolleyRequestQueue instance;
    /**
     * 请求队列
     */
    private RequestQueue mRequestQueue;
    /**
     * 图片加载ImageLoader
     */
    private ImageLoader mImageLoader;

    private VolleyRequestQueue(){
        mRequestQueue = getRequestQueue();
        mImageLoader = getImageLoader();
    }

    /**
     * 异步获取单利
     *
     * @return
     */
    public static synchronized VolleyRequestQueue getInstance(){
        if (instance == null){
            instance = new VolleyRequestQueue();
        }
        return instance;
    }

    /**
     * 获取volley请求队列
     *
     * @return
     */
    public RequestQueue getRequestQueue(){
        if (mRequestQueue == null){
            /**
             * MyApplication.getInstance()返回当前进程的全局应用上下文
             * 使用场景：生命周期独立于当前上下文的全局上下文，即它的存活时间绑定在整个程序进程而不是当前某个组件。
             */
            mRequestQueue = Volley.newRequestQueue(MyApplication.getInstance());
        }
        return  mRequestQueue;
    }

    /**
     * 获取ImageLoader
     * 
     * @return
     */
    public ImageLoader getImageLoader(){
        mImageLoader = new ImageLoader(getRequestQueue(),new BitmapCache());
        return mImageLoader;
    }

    /**
     * add to queue
     *
     * @param request
     * @param <T>
     */
    public <T> void addToReuestQueue(Request<T> request){
        getRequestQueue().add(request);
    }

    /**
     * remove from queue
     *
     * @param tag
     */
    public void cancelRequestFromQueue(Object tag){
        getRequestQueue().cancelAll(tag);
    }

}

其中需要Application的全局变量（注意，别忘了在AndroidManifest.xml中声明）和封装图片缓存的BitmapCache()类，分别如下：

public class MyApplication extends Application{

    private static MyApplication instance;

    public static MyApplication getInstance(){
        if (instance == null){
            synchronized (MyApplication.class){
                if (instance == null){
                    instance = new MyApplication();
                }
            }
        }
        return instance;
    }

    @Override
    public void onCreate() {
        instance = this;
        super.onCreate();
    }
}
import android.graphics.Bitmap;
import android.util.LruCache;

import com.android.volley.toolbox.ImageLoader;

/**
 * 借助Android提供的LruCache功能实现图片缓存
 * Created by admin on 16/6/21.
 */
public class BitmapCache implements ImageLoader.ImageCache{

    private LruCache<String, Bitmap> mCache;

    public BitmapCache() {
        //缓存图片的大小设置为10M
        int maxSize = 10 * 1024 * 1024;
        mCache = new LruCache<String, Bitmap>(maxSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight();
            }
        };
    }
    @Override
    public Bitmap getBitmap(String url) {
       return mCache.get(url);
    }

    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        mCache.put(url, bitmap);
    }
}
  • 封装HttpUtil工具类
public class HttpUtil {

    /**
     * GET请求
     *
     * @param url
     * @param appendHeader
     * @param clazz
     * @param listener
     * @param errorlistener
     * @param <T>
     */
    public static <T>void getJsonRequest(String url, Map<String, String> appendHeader, Class<T> clazz, Response.Listener<T> listener, Response.ErrorListener errorlistener){
        GsonRequest<T> request = new GsonRequest<>(Request.Method.GET, url, appendHeader, clazz, listener, errorlistener);
        request.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));
        VolleyRequestQueue.getInstance().addToReuestQueue(request);
    }

    /**
     * POST请求
     *
     * @param url
     * @param appendHeader
     * @param clazz
     * @param listener
     * @param errorlistener
     * @param <T>
     */
    public static <T>void postJsonRequest(String url, Map<String, String> appendHeader, Class<T> clazz, Response.Listener<T> listener, Response.ErrorListener errorlistener){
        GsonRequest<T> request = new GsonRequest<>(Request.Method.POST, url, appendHeader, clazz, listener, errorlistener);
        request.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));
        VolleyRequestQueue.getInstance().addToReuestQueue(request);
    }

    /**
     * 加载网络图片
     *
     * @param imageUrl 图片url
     * @param view 显示图片的view控件
     * @param loadingImageId 加载中显示的图片id
     * @param failImageId 加载失败显示的图片id
     */
    public static void loadImage(String imageUrl, ImageView view, int loadingImageId, int failImageId){
        //获取ImageLoader
        ImageLoader imageLoader = VolleyRequestQueue.getInstance().getImageLoader();
        //获取ImageListener
        ImageLoader.ImageListener imageListener = ImageLoader.getImageListener(view, loadingImageId, failImageId);
        /**
         * 加载图片：如需设置图片大小，imageLoader.get(imageUrl,imageListener，int maxWidth,int maxHeight);
         */
        imageLoader.get(imageUrl,imageListener);
    }
}
  • 使用实例
    请求的json数据如下：
{
    "status":"1",
    "data":"{"phone":"13083060621","name":"changj","pass":"123456"}",
    "msg":"OK"
}

上述json数据对应的model对象如下：

import com.changj.pearl.http.GsonUtils;
import com.google.gson.Gson;

/**
 *  <p>
 * 封装了业务逻辑的JavaBean（服务端返回的数据）<其中data部分不是数组>
 * </p>
 * Created by admin on 16/6/14.
 */
public class BaseServerModel {

    private int status;
    private String data;
    private String msg;

    /**
     * 数据返回成功
     *
     * @return
     */
    public boolean isSuccess() {
        return getStatus() == 1;
    }

    public <E> E parseData(Class<E> clazz) {
        E e = null;
        try {
            Log.d("VOLLEY",getData());
            e = new Gson().fromJson(getData(),clazz);
        } catch (Exception e1) {
            try {
                e = clazz.newInstance();
            } catch (Exception e2) {
            }
        }
        return e;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

上述json数据data部分对应的model对象如下：

public class User implements Serializable{

    private String phone;
    private String name;
    private String pass;

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getPass() {
        return pass;
    }

    public void setPass(String pass) {
        this.pass = pass;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

请求代码如下：

HttpUtil.getJsonRequest(url, null, BaseServerModel.class, new        Response.Listener<BaseServerModel>() {
            @Override
            public void onResponse(BaseServerModel baseServerModel) {
                User user = baseServerModel.parseData(User.class);
                Toast.makeText(getActivity(), "姓名："+user.getName()+"|手机："+user.getPhone()+"|密码:"+user.getPass(), Toast.LENGTH_SHORT).show();
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Toast.makeText(getActivity(), "error", Toast.LENGTH_SHORT).show();
            }
        });
Mr.Jason
关注
专栏目录
Volley详解（二）——请求（Request）
howard_90的专栏
08-13 585
概述本篇介绍请求相关的类，主要包括Request<T>和RequestQueue两部分。
Volley#Request（GsonRequest,MultiPartRequest）
11-13
1.自定义带header(包含coockie),Json参数，Gson解析的GsonRequest. 2.自定义支持文件上传的MultiPartRequest. 3.拍照，图库图片，压缩图片一些列功能
Android Volley 之自定义Request
weixin_30740295的博客
04-27 163
转载标明出处：http://blog.csdn.net/lmj623565791/article/details/24589837 今天群里一哥们需要自定义Volley的Request的例子，于是产生了这篇博客。关于Volley的介绍就不多说了，网上例子特别多。 Volley的所有的请求的超类型是Resuest，类结构如下图，所有我们常用的请求都是这个类的子类，那么我们自定义View肯...
Volley自定义一个Request
Chailyn的博客
06-26 518
之前通过源码简单的了解一下Volley. 1.Volley源码学习笔记_RequestQueue和BasicNetWork 2.Volley源码学习笔记_ExecutorDelivery 3.Volley源码学习笔记_CacheDispatcher和NetworkDispatcher 4.Volley源码学习笔记_Request 现在我们可以尝试自定义一个Volley请求。可以适用一般
Volley的Request的添加、移除和取消
wxz的博客
07-14 964
本文系转载，转载于Volley源码分析 1，原文作者写的不错，很赞！我们先来看一下Volley的架构图： 可以看出，Volley至少工作在3个线程当中，其中蓝色部分为主线程：主要的工作是将请求按照优先级的顺序添加到cache的队列当中，当发出去的请求的得到相应的时候，在主线程将结果进行分发。 绿色部分为cache线程：如果cache hit，那么直接将cache中的数据进行解析，并传递给主线程，
Android Volley框架使用方法详解
09-01
Android Volley框架是Google推出的一个轻量级的网络请求库，它被设计为简化Android应用中的网络通信。Volley的主要优势在于其高效的缓存机制、线程管理以及对异步请求的良好支持，使得开发者能够更便捷地处理网络...
Android框架Volley使用之Json请求实现
08-26
在Android开发中，Volley是一个高效且易于使用的网络请求库，尤其适合处理小量的数据交换。本篇文章将深入探讨如何在Android应用中使用Volley框架实现Json数据的请求。 首先，要在项目中引入Volley库，你需要在...
Android中Volley的Request的自定义
火神漫步
03-09 391
1. 自定义XMLRequest 下面我们准备自定义一个XMLRequest，用于请求一条XML格式的数据。那么该从哪里开始入手呢？额，好像是有些无从下手。遇到这种情况，我们应该去参考一下Volley的源码，看一看StringRequest是怎么实现的，然后就可以模仿着写出XMLRequest了。首先看下StringRequest的源码，如下所示： [java] view
Volley以及自定义Request详解
HIMan
05-18 2447
google在2013年I/O大会上发布了volley, 主打频繁的网络通信(小请求)。本身Android就提供了HttpClient和HttpUrlConnection来进行网络请求，可是随着需求不断的提升，比如增加缓存啊，就变得更加复杂了，当然除了volley还有其他很多的优秀的网络请求。比如：OkHttp， Retrofit，xutils等等。当然，今天我们的主题还是volley。
Volley的框架解读七（Request）
Jack_King007的专栏
09-21 407
先看看UML图 Request也是volley的核心类之一，是一个抽象类。volley中所有的请求都是由Request的子类来完成的，它定义了一些公共性的内容，并抽象出来，其子类只需要继承该类并实现其预留的抽象方法即可。比如volley默认实现的请求如StringRequest、JsonRequest、JsonObjectRequest等都是继承自Request。再比如在Google的官方文档中定义
Volley 框架自定义请求（Request）之参数传递
yingaizhu的博客
11-04 927
一、前言     Volley 是 Android 官方的 HTTP 请求框架 ，它是基于 HttpURLConnection 的，OKHttp 是基于 WebSocket 的，它有一些优势，也有一些缺点，更多关于 Volley的使用，可以参考官方文档：使用 Volley 传输网络数据。 二、Volley 自定义请求（Request）     使用过 Volley 的都知道，Volley 已经提供了一些请求（Request）的实
深入了解Volley如何执行一个Request的流程
github_26939093的博客
04-07 3630
Volley主要类构成 Volley: 框架同名类，负责创建RequestQueue对象 Request:代表一个网络请求的抽象类，具体实现子类有(StringRequest,JsonRequest,ImageRequest)，需添加到RequestQueue中操作。包含了url,请求方法，请求Header,请求Body,请求的优先等级信息。 RequestQueue:核心类，负责维护所有的Requ
android Volley自定义request的方法
lqy的android学习专栏
09-17 2326
android推出新的网络访问框架volley，volley在多次少量的网络请求中，效率很高，对于json也有很好的支持。 如果对于volley做一个全面的认识，转到下面的链接： http://blog.csdn.net/t12x3456/article/details/9221611 对于一个简单的volley请求，内容如下。 mQueue = Volley.newRequest
Android高级之Volley框架（一）：StringRequest
FightFightFight的博客
11-08 834
一.重要概念 1.Volley 是 Google 推出的 Android 异步网络请求框架和图片加载框架。在 Google I/O 2013 大会上发布。 2.适用场景：Volley适合处理数据量小、操作频繁的网络操作。 3.分类：Volley大体上分为4种： 3.1.StringRequest：用于请求String字符串 3.2.JsonRequest：用于请求JSON字符串 3.3
SAP 工作台请求和定制请求的区别
逍遥游
03-20 2401
SAP BASIS 工作台请求和定制请求的区别 工作台: workbench相关的对象更改，比如新建一个ABAP程序，一般是跨 client的修改； 工作台请求可以理解成ABAP开发相关的，比如定价例程、替代、COPA这些修改跨client表的请求. 定制：就是对配置的修改，比如 修改公司代码，一般是client相关的修改. 工作台和定制这两种传输类型，必须按照系统事先定义的传输路径进行传输，开发系统 产生的工作台或定制的传输请求的目标系统，只能是生产系统； 副本传输：此类传输请求的目标系统可以是整个传
Android网络框架volley学习(三)底层网络请求分析
ostracod
01-18 897
相关文章 《 Android网络框架volley学习(一)基本用法》 《 Android网络框架volley学习(二)工作流程分析》 前面我们分析了一下volley的基本用法及总体工作流程，由于volley是一个网络请求框架，所以本篇我们分析一下它的底层网络请求。 volley源码说长不长，说短不短，也有几十个类，该从哪里开始分析呢？我们从最基本的开始分析，还记得一开始进行发送请求的代码
Android中第三方框架【网络框架Volley】的使用【Application生命周期】【内存泄漏问题】
风吹草低见牛羊
09-13 1079
工作内容： 1.自定义类继承Application类（全局变量的定义——所有activity都可以使用 2.内存泄漏问题分享 3.第三方框架Volley的使用 学习分享：（这里讲解Volley会涉及到子定义Application子类，就先说说Application的使用） 一、application讲解 1.Application生命周期 2.onCreate 在创建利用程序时创
深入解析与实战：Android Volley 框架
通过以上介绍，我们可以看到Volley为Android开发者提供了高效的网络请求处理能力，特别适合需要频繁、快速交互的移动应用。然而，对于大文件下载或上传等场景，可能需要考虑其他的网络库，如OkHttp或Retrofit，这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值