Programación de red de Android (5) Uso de Volley Framework

1 Introducción

Por lo general, desarrollamos solicitudes de red en pruebas de programas de Android, y el propio Android también proporciona HttpURLConnection y HttpClient para realizar la comunicación de solicitud de red. Pero HttpURLConnection y HttpClient inevitablemente serán un poco complicados de usar. El marco de comunicación de red Volley se introdujo en la conferencia Google I / O 2013. La característica de Volley es que es fácil de usar y es adecuado para operaciones de solicitud de red con un volumen de datos pequeño y comunicación frecuente y gran volumen.

2 Descargar

La dirección del sitio web oficial de Volly es: https://developer.android.com/training/volley/index.html , el código fuente es: https://github.com/google/volley . Después de descargar el código fuente, podemos compilarlo en un paquete jar o un archivo aar. Use Android Studio para abrir el proyecto y haga clic directamente en "Crear" - "Crear proyecto" en la barra de menú para generar el archivo aar directamente en \ build \ salidas \ aar \. No hay recursos en el archivo aar, solo un classes.jar y dos AndroidManifest.xml. Por lo tanto, puede elegir importar el archivo aar directamente desde su propio proyecto o extraer el archivo jar e importarlo para usarlo.

Si no desea descargar el código fuente y compilar, puede confiar directamente en Gradle:

dependencies {
    ...
    compile 'com.android.volley:volley:1.1.1'
}

3 uso

El uso de Volley es muy simple, de hecho, consta de cuatro pasos:

1. Agregue permiso de red de acceso en AndroidManifest.xml <uses-permissionandroid: name = "android.permission.INTERNET" />

2. Crear un objeto RequestQueue

3. Crear un objeto de solicitud

4. Agregue el objeto Request al objeto RequestQueue

Nota:

Cuando presentamos Volley anteriormente, mencionamos que Volley es adecuado para operaciones de solicitud de red de alta concurrencia, por lo que no tenemos que crear múltiples objetos RequestQueue para solicitar operaciones de red, porque esto es un desperdicio de recursos. En general, usamos un singleton para usar RequestQueue en todo el proyecto.

3.1 Uso de StringRequest

StringRequest hereda de Request. El paso 3 de los cuatro pasos que acabamos de mencionar crea un objeto Request. Ahora use StringRequest para implementar una solicitud de URL y luego devolver el resultado de acceso:

RequestQueue requestQueue = Volley.newRequestQueue(getApplicationContext());
StringRequest stringRequest = new StringRequest(Request.Method.GET, "http://www.xxx.com",
        new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                // 请求成功
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                // 请求失败
            }
        });
requestQueue.add(stringRequest);

En el ejemplo, primero se crea un objeto RequestQueue a través del método Volley.newRequestQueue; luego se crea un objeto StringRequest de solicitud. El constructor de la clase StringRequest recibe cuatro parámetros, a saber, el tipo de solicitud (GET o POST), la URL de solicitud, la solicitud de devolución de llamada exitosa y Solicitar devolución de llamada de falla; finalmente, agregue este objeto StringRequest a la cola RequestQueue y listo.

No sé si los lectores han descubierto que la clase StringRequest tiene un gran defecto, es decir, no admite parámetros entrantes, pero sabemos que StringRequest hereda de Request, y del código fuente, podemos ver que la clase Request tiene un método getParams, este método devuelve El valor es el parámetro solicitado por la solicitud final. Así que modificamos ligeramente el código anterior:

RequestQueue requestQueue = Volley.newRequestQueue(getApplicationContext());
StringRequest stringRequest = new StringRequest(Request.Method.GET, "http://www.xxx.com",
        new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {
                // 请求成功
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                // 请求失败
            }
        }) {
    @Override
    protected Map<String, String> getParams() throws AuthFailureError {
        Map<String, String> map = new HashMap();
        map.put("params1", "value1");
        map.put("params2", "value2");
        // ...
        return map;
    }
};
requestQueue.add(stringRequest);

De esta forma, es posible admitir perfectamente las solicitudes de red con parámetros, ya que generalmente incluimos parámetros en las solicitudes POST. Si no es compatible, es realmente un desperdicio.

3.2 Uso de JsonRequest

JsonRequest también se hereda de Request. El uso de JsonRequest es similar al de StringRequest, excepto que el tipo de devolución de llamada es un objeto Json, no una cadena String. JsonRequest en sí es una clase abstracta, y su implementación se completa con JsonObjectRequest y JsonArrayRequest. Debería ser posible adivinar por el nombre que una de sus solicitudes devuelve los datos Json recibidos y la otra devuelve la matriz Json recibida. Echemos un vistazo a su implementación:

RequestQueue requestQueue = Volley.newRequestQueue(getApplicationContext());

// 带参数的JsonObjectRequest请求
Map<String, String> params = new HashMap();
params.put("params1", "value1");
params.put("params2", "value2");
JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.POST, "http://www.xxx.com", new JSONObject(params),
        new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                // 请求成功
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                // 请求失败
            }
        });
requestQueue.add(jsonObjectRequest);

// 不带参数的JsonArrayRequest请求
JsonArrayRequest jsonArrayRequest = new JsonArrayRequest(Request.Method.POST, "http://www.xxx.com", null,
        new Response.Listener<JSONArray>() {
            @Override
            public void onResponse(JSONArray jsonArray) {
                // 请求成功
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                // 请求失败
            }
        });
requestQueue.add(jsonArrayRequest);

3.3 Uso de ImageRequest

Por la misma razón, ImageRequest también hereda de Request, echemos un vistazo a su ejemplo de uso directamente:

RequestQueue requestQueue = Volley.newRequestQueue(getApplicationContext());
ImageRequest imageRequest = new ImageRequest(
        "http://xxx.png",                        // 请求图片地址
        new Response.Listener<Bitmap>() {      // 请求成功回调
            @Override
            public void onResponse(Bitmap bitmap) {
                //imageView.setImageBitmap(bitmap);
            }
        },
        0,                                        // 图片最大宽度，如果比原图小，则会进行压缩处理，0表示获取原图大小不会进行压缩
        0,                                        // 图片最大高度，如果比原图小，则会进行压缩处理，0表示获取原图大小不会进行压缩
        ImageView.ScaleType.CENTER_INSIDE,   // 指定图片进行压缩的缩放类型，默认CENTER_INSIDE，表示保持宽高比例缩小图片
        Bitmap.Config.ARGB_8888,              // 指定图片的颜色属性，ARGB_8888可以展示最好的颜色属性，每个图片像素占据4个字节的大小，而RGB_565则表示每个图片像素占据2个字节大小
        new Response.ErrorListener() {       // 请求失败回调
            @Override
            public void onErrorResponse(VolleyError error) {
                //imageView.setImageResource(R.drawable.default_image);
            }
        });
requestQueue.add(imageRequest);

Se puede ver que los parámetros de ImageRequest son ligeramente diferentes de los anteriores StringRequest y JsonRequest. Para ver las descripciones de los parámetros, consulte los comentarios en el código anterior.

3.4 Uso de ImageLoader

ImageLoader no hereda la clase Request como las XXXRequests anteriores. Utiliza ImageRequest para implementarlo internamente. Se puede decir que es una actualización basada en ImageRequest. Puede almacenar en caché las imágenes de solicitud de red para evitar algunas solicitudes de red repetidas. Por lo tanto, es más eficiente que ImageRequest. Echemos un vistazo al siguiente ejemplo:

RequestQueue requestQueue = Volley.newRequestQueue(getApplicationContext());
ImageLoader.ImageListener listener = ImageLoader.getImageListener(imageView, R.drawable.default_image, R.drawable.failed_image);
ImageLoader imageLoader = new ImageLoader(requestQueue, new ImageLoader.ImageCache() {
    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        // TODO 在这里要将bitmap添加入缓存
    }

    @Override
    public Bitmap getBitmap(String url) {
        // TODO 在这里要做返回缓存中的图片
        return null;
    }
});
imageLoader.get("http://xxx.png", listener, 100, 100);

Descripción:

1. El primer paso es definir un objeto RequestQueue;

2. Cree un objeto ImageListener. El método de creación recibe tres parámetros. El primer parámetro especifica el control ImageView utilizado para mostrar la imagen. El segundo parámetro especifica la imagen mostrada durante la carga de la imagen. El tercer parámetro especifica la falla al cargar la imagen. La imagen mostrada bajo las circunstancias;

3. Cree un objeto ImageLoader. Su constructor recibe dos parámetros. El primer parámetro es un objeto RequestQueue, y el segundo parámetro es un objeto de clase ImageCache. La clase ImageCache implementa dos métodos, que son putBitmap y getBitmap. El caché que mencionamos anteriormente se implementa aquí. En el método putBitmap, el objeto de mapa de bits recibido por la solicitud se agrega al caché, y el método getBitmap obtiene la imagen agregada al caché en el método putBitmap a través de la URL solicitada. Para la implementación de la memoria caché , se puede utilizar LruCache. LruCache es una clase genérica. Es una clase de memoria caché proporcionada por Android 3.1. Utiliza un LinkedHashMap para almacenar objetos de memoria caché externa de una manera de referencia sólida. Proporciona métodos get y put. Para completar las operaciones de adquisición y adición de caché. Si desea obtener caché de disco, también puede usar DiskLruCache , que no forma parte del AndroidSDK. Use DiskLruCache para descargarlo por adelantado. Aquí no presentaremos el uso de caché en detalle, porque hoy nos enfocamos en el uso de volley.

4. Finalmente, llame al método get () de ImageLoader para cargar la imagen. Los dos últimos parámetros del método get son establecer la longitud y el ancho máximos de la imagen. De manera predeterminada, 0 significa que no hay compresión, de acuerdo con el tamaño de la imagen original.