Android volley request queue

Sending a Simple Request

This lesson teaches you to

Video

Volley: Easy, Fast Networking for Android

At a high level, you use Volley by creating a RequestQueue and passing it Request objects. The RequestQueue manages worker threads for running the network operations, reading from and writing to the cache, and parsing responses. Requests do the parsing of raw responses and Volley takes care of dispatching the parsed response back to the main thread for delivery.

This lesson describes how to send a request using the Volley.newRequestQueue convenience method, which sets up a RequestQueue for you. See the next lesson, Setting Up a RequestQueue, for information on how to set up a RequestQueue yourself.

This lesson also describes how to add a request to a RequestQueue and cancel a request.

Add the INTERNET Permission

To use Volley, you must add the android.permission.INTERNET permission to your app’s manifest. Without this, your app won’t be able to connect to the network.

Use newRequestQueue

Volley provides a convenience method Volley.newRequestQueue that sets up a RequestQueue for you, using default values, and starts the queue. For example:

Volley always delivers parsed responses on the main thread. Running on the main thread is convenient for populating UI controls with received data, as you can freely modify UI controls directly from your response handler, but it’s especially critical to many of the important semantics provided by the library, particularly related to canceling requests.

See Setting Up a RequestQueue for a description of how to set up a RequestQueue yourself, instead of using the Volley.newRequestQueue convenience method.

Send a Request

To send a request, you simply construct one and add it to the RequestQueue with add() , as shown above. Once you add the request it moves through the pipeline, gets serviced, and has its raw response parsed and delivered.

When you call add() , Volley runs one cache processing thread and a pool of network dispatch threads. When you add a request to the queue, it is picked up by the cache thread and triaged: if the request can be serviced from cache, the cached response is parsed on the cache thread and the parsed response is delivered on the main thread. If the request cannot be serviced from cache, it is placed on the network queue. The first available network thread takes the request from the queue, performs the HTTP transaction, parsse the response on the worker thread, writes the response to cache, and posts the parsed response back to the main thread for delivery.

Note that expensive operations like blocking I/O and parsing/decoding are done on worker threads. You can add a request from any thread, but responses are always delivered on the main thread.

Figure 1 illustrates the life of a request:

Figure 1. Life of a request.

Cancel a Request

To cancel a request, call cancel() on your Request object. Once cancelled, Volley guarantees that your response handler will never be called. What this means in practice is that you can cancel all of your pending requests in your activity’s onStop() method and you don’t have to litter your response handlers with checks for getActivity() == null , whether onSaveInstanceState() has been called already, or other defensive boilerplate.

To take advantage of this behavior, you would typically have to track all in-flight requests in order to be able to cancel them at the appropriate time. There is an easier way: you can associate a tag object with each request. You can then use this tag to provide a scope of requests to cancel. For example, you can tag all of your requests with the Activity they are being made on behalf of, and call requestQueue.cancelAll(this) from onStop() . Similarly, you could tag all thumbnail image requests in a ViewPager tab with their respective tabs and cancel on swipe to make sure that the new tab isn’t being held up by requests from another one.

Here is an example that uses a string value for the tag:

1. Define your tag and add it to your requests.
2. In your activity’s onStop() method, cancel all requests that have this tag.

Take care when canceling requests. If you are depending on your response handler to advance a state or kick off another process, you need to account for this. Again, the response handler will not be called.

Источник

Простой пример использования библиотеки Volley

Я уверен вы, еще не слышали слово «Volley», это библиотека, представленная на Google I/O 2013 Ficus Kirkpatrick.

Для чего библиотека Volley?

Volley это библиотека, которая делает сетевые приложения для Android проще и, самое главное, быстрее.

Она управляет обработкой и кэшированием сетевых запросов, и это экономит драгоценное время разработчиков от написания одного и того же кода сетевого запроса/считывания из кэша снова и снова. И еще одно преимущество, меньше кода, меньше количество ошибок 🙂

Обычно мы пишем один и тот же код сетевого запроса в AsyncTask, логику обработки ответа от Web API и отображения его в View. Мы должны заботиться об отображении ProgressBar/ProgressDialog внутри OnsourceExecute() и OnPostExecute(). Я знаю, что это не трудная задача, но все же рутинная. Иногда бывает скучно, даже когда определен базовый класс для управления ProgressBar/ProgressDialog и многими другими вещами. Так что теперь можно сказать, Volley может быть мощной альтернативой AsyncTask.

Преимущества использования Volley:

Как начать?

2 главных класса Volley

Есть 2 основных класса:

1. Request queue
2. Request

Request queue: используется для отправки сетевых запросов, можете создавать класс request queue, где хотите, но, как правило его создают во время запуска и используют как Singleton.

Request: он содержит все необходимые детали для создания вызова Web API. Например: какой метод использовать (GET или POST), данные запроса, response listener, error listener.

Взгляните на метод JSONObjectRequest:

Простой пример использования Volley:

Я надеюсь вы уже клонировали/скачали библиотеку Volley из Git репозитория. Теперь следуйте инструкциям, что бы создать простой пример извлечения JSON ответа.

Шаг 1: Убедитесь что вы импортировали проект Volley в Eclipse. Теперь после импорта мы должны сделать проект библиотекой (Library project), правой кнопкой мыши => Properties => Android (левая панель).

Шаг 2: Создайте новый проект VolleyExample.

Шаг 3: Правый клик на VolleyExample и включите библиотеку Volley в ваш проект.

Шаг 4: Включите разрешение на использование интернета в файле AndroidManifest.xml

Шаг 5:
5.1 Создайте объект класса RequestQueue

5.2 Создайте JSONObjectRequest с response и error listener.

Источник

Setting Up a RequestQueue

This lesson teaches you to

Video

Volley: Easy, Fast Networking for Android

The previous lesson showed you how to use the convenience method Volley.newRequestQueue to set up a RequestQueue , taking advantage of Volley’s default behaviors. This lesson walks you through the explicit steps of creating a RequestQueue , to allow you to supply your own custom behavior.

This lesson also describes the recommended practice of creating a RequestQueue as a singleton, which makes the RequestQueue last the lifetime of your app.

Set Up a Network and Cache

A RequestQueue needs two things to do its job: a network to perform transport of the requests, and a cache to handle caching. There are standard implementations of these available in the Volley toolbox: DiskBasedCache provides a one-file-per-response cache with an in-memory index, and BasicNetwork provides a network transport based on your choice of the Apache HTTP client android.net.http.AndroidHttpClient or HttpURLConnection .

BasicNetwork is Volley’s default network implementation. A BasicNetwork must be initialized with the HTTP client your app is using to connect to the network. Typically this is a HttpURLConnection :

• Use android.net.http.AndroidHttpClient for apps targeting Android API levels lower than API Level 9 (Gingerbread). Prior to Gingerbread, HttpURLConnection was unreliable. For more discussion of this topic, see Android’s HTTP Clients.
• Use HttpURLConnection for apps targeting Android API Level 9 (Gingerbread) and higher.

To create an app that runs on all versions of Android, you can check the version of Android the device is running and choose the appropriate HTTP client, for example:

This snippet shows you the steps involved in setting up a RequestQueue :

If you just need to make a one-time request and don’t want to leave the thread pool around, you can create the RequestQueue wherever you need it and call stop() on the RequestQueue once your response or error has come back, using the Volley.newRequestQueue() method described in Sending a Simple Request. But the more common use case is to create the RequestQueue as a singleton to keep it running for the lifetime of your app, as described in the next section.

Use a Singleton Pattern

If your application makes constant use of the network, it’s probably most efficient to set up a single instance of RequestQueue that will last the lifetime of your app. You can achieve this in various ways. The recommended approach is to implement a singleton class that encapsulates RequestQueue and other Volley functionality. Another approach is to subclass Application and set up the RequestQueue in Application.onCreate() . But this approach is discouraged; a static singleton can provide the same functionality in a more modular way.

A key concept is that the RequestQueue must be instantiated with the Application context, not an Activity context. This ensures that the RequestQueue will last for the lifetime of your app, instead of being recreated every time the activity is recreated (for example, when the user rotates the device).

Here is an example of a singleton class that provides RequestQueue and ImageLoader functionality:

Here are some examples of performing RequestQueue operations using the singleton class:

Источник

Настройка RequestQueue

Этот урок научит вас

Видео

Volley: простой и быстрый сетевой обмен для Android

Предыдущий урок показал вам, как использовать удобный метод Volley.newRequestQueue для настройки RequestQueue , воспользовавшись поведения Volley по умолчанию. Этот урок проведет вас по шагам создания RequestQueue , чтобы позволить вам предоставить собственное пользовательское поведение.

Этот урок также описывает рекомендуемую практику создания RequestQueue используя шаблон «одиночка», что позволяет RequestQueue оставаться работающей до конца жизненного цикла вашего приложения.

Настройка сети и кэша

RequestQueue нужны две вещи, чтобы выполнять свою работу: сеть для выполнения запросов и кэш для кэширования. Стандартные реализации доступны в панели инструментов Volley: DiskBasedCache кэширует каждый ответ, сохраняя в отдельный файл, храня индекс в памяти, и BasicNetwork обеспечивает сетевой транспорт на основе вашего выбора AndroidHttpClient или HttpURLConnection .

BasicNetwork является реализацией сети по умолчанию в Volley. BasicNetwork должен быть проинициализирован HTTP клиентом, который ваше приложение использует для подключения к сети. Обычно это AndroidHttpClient или HttpURLConnection :

• Используйте AndroidHttpClient для приложений, ориентированных на Android API уровня ниже, чем API Level 9 (Gingerbread). До Gingerbread, HttpURLConnection был ненадежным. Более детального обсуждения этой темы см. HTTP клиенты Android.
• Используйте HttpURLConnection для приложений, ориентированных на Android API Level 9 (Gingerbread) и выше.

Чтобы создать приложение, которое работает на всех версиях Android, вы можете проверить версию Android устройства и выбрать соответствующий HTTP клиент, например:

Этот фрагмент показывает этапы настройки RequestQueue :

Если вам просто нужно сделать одноразовый запрос и вы не хотите оставлять пул потоков, вы можете создать RequestQueue , где это необходимо, и вызвать stop() на RequestQueue как только вы получили ответ или ошибку, использование Volley.newRequestQueue() метода описанно в Отправка простого запроса. Но больше общим случаем использования является создание RequestQueue как «одиночку», чтобы держать в работающем состоянии в течение всего срока жизнедеятельности вашего приложения, как описано в следующем разделе.

Используйте шаблон «Одиночка»

Если ваше приложение постоянно использует сеть, то, вероятно, наиболее эффективным является создание одного экземпляра RequestQueue , который будет жить до окончания работы вашего приложения. Вы можете добиться этого различными способами. Рекомендуемый подход заключается в реализации класса «одиночки», который инкапсулирует RequestQueue и другую Volley функциональность. Другой подход заключается в создании подкласса Application и настройке RequestQueue в Application.onCreate() . Но этот подход лишен смысла; статический объект «одиночка» может обеспечить ту же функциональность более модульным способом.

Ключевая концепция в том, что RequestQueue должен быть проинициализирован в Application контексте, а не Activity контексте. Это гарантирует, что RequestQueue будет жив в течение всего периода работы вашего приложения, вместо того, чтобы пересоздавать каждый раз, когда деятельность воссоздается (например, когда пользователь поворачивает устройство).

Вот пример класса «одиночки», предоставляющего RequestQueue и ImageLoader функциональность:

Вот некоторые примеры выполнения RequestQueue операций с использованием класса «одиночки»:

Источник

Русские Блоги

Использование Volley в сети Android

Концепция и преимущества Volley

Volley — это HTTP-библиотека, которая помогает приложениям Android выполнять сетевые операции более легко, а главное, быстрее и эффективнее. Обычно в Android используются сетевые операции, наиболее знакомыми из которых являются HttpURLConnection и HttpClient (не рекомендуется), но использование этих двух методов все еще немного сложнее, и Volley значительно упрощает сетевые операции, требуя всего несколько строк кода. Может завершить операции, которые может завершить HttpURLConnection.
Его цель разработки очень подходит для сетевых операций с небольшим объемом данных, но частым обменом данными.

Залп не подходит для загрузки больших файлов данных. Потому что залп сохранит все ответы во время анализа. Для загрузки больших объемов данных, пожалуйста, подумайте об использованииDownloadManager。

Залп имеет следующие преимущества:

• Автоматически планировать сетевые запросы.
• Высокое одновременное сетевое соединение.
• Кэшируйте прозрачные ответы на диске и в памяти через стандартную согласованность HTTP-кэша.
• Поддержка, чтобы указать приоритет запроса
• Отзыв API запроса. Мы можем отменить один запрос или указать область в очереди запросов на отмену.
• Фреймворк легко настраивается, например, настраиваемые функции повтора или восстановления.
• Мощное упорядочение (Strong order) может упростить асинхронную загрузку сетевых данных и корректно отображать их в пользовательском интерфейсе
• Содержит средства отладки и трассировки.

Простое использование залпа

Способ использования Volley состоит в создании RequestQueue и последующей передаче ему объекта Request. RequestQueue управляет рабочими потоками, используемыми для выполнения сетевых операций, считывает данные из кэша, записывает данные в кэш и анализирует ответ Http. содержание. Запрашивая для анализа исходных данных ответа, Volley распространит проанализированные данные ответа в основной поток.

Использование StringRequest

Volley предоставляет простой способ: Volley.newRequestQueue используется для создания для вас RequestQueue, использования значения по умолчанию и запуска очереди.
Например:

Кроме того, поскольку Volley хочет получить доступ к сети, не забудьте добавить следующие разрешения в свой файл AndroidManifest.xml:

Таким образом, мы можем получить HTML-код страницы Baidu.

Если мы просто хотим сделать один запрос и не хотим сохранять пул потоков, мы можем отправить простой запрос с помощью метода по умолчанию (Volley.newRequestqueue), создать RequestQueue в любое время и затем Метод stop () выполняется в ответ на обратный вызов для остановки операции.

Но более распространенным подходом является создание RequestQueue и установка его как одиночного. Следующий раздел продемонстрирует этот подход.

Использовать шаблон синглтона

Если нашему приложению необходимо продолжать использовать сеть, более эффективным способом должно быть создание единственного экземпляра RequestQueue, чтобы его можно было поддерживать в течение всего жизненного цикла приложения. Мы можем реализовать этот синглтон разными способами.Рекомендуемый способ — реализовать одноэлементный класс, который инкапсулирует объект RequestQueue и другие функции Volley.Другой метод — расширить класс Application и создать RequestQueue в методе Application.OnCreate (). Но мы не рекомендуем этот метод,Потому что статический синглтон может обеспечить ту же функциональность более модульным способом.

Ключевой концепцией является то, что RequestQueue должен создаваться с использованием контекста приложения, а не контекста Activity.Это гарантирует, что RequestQueue переживет жизненный цикл нашего приложения и не будет воссоздан из-за повторного создания действия (например, когда пользователь поворачивает устройство).

Ниже приведен одноэлементный класс, который предоставляет функции RequestQueue и ImageLoader:

Затем мы можем использовать класс singleton для построения RequestQueue:

Использование JsonRequest

Volley предоставляет следующие классы для запроса данных Json:

JsonArrayRequest-запрос на получение тела ответа массива Json для данного URL.

JsonObjectRequest-запрос на получение тела ответа объекта Json по указанному URL. Разрешить передачу необязательного JSONObject как части тела запроса.

Оба эти класса основаны на общем базовом классе, JsonRequest. Их использование практически идентично StringRequest.

Запросить изображение

Volley предоставляет следующие классы для запроса изображений:

ImageRequest———— Инкапсулированный, используемый для обработки изображения запроса URL и возврата декодированного растрового изображения. Он также предоставляет несколько удобных методов интерфейса, таких как указание размера для повторной резки. Его основное преимущество заключается в том, что Volley обеспечит выполнение трудоемких операций, таких как декодирование и изменение размера, в рабочем потоке.

ImageLoader———— Вспомогательный класс для загрузки и кэширования изображений, полученных из сети. ImageLoader является координатором большого количества ImageRequests. Например, когда в ListView необходимо отобразить большое количество миниатюр. ImageLoader обеспечивает более перспективный кеш памяти для обычного кеша Volley, который очень полезен для предотвращения дрожания изображения. Это также позволяет достигать попаданий в кэш без блокировки или задержки основного потока (это невозможно с дисковым вводом / выводом). ImageLoader также может реализовать объединение ответов, избегая настройки растрового изображения для просмотра почти при каждом ответном обратном вызове. Синдикация ответов позволяет одновременно отправлять несколько ответов, что повышает производительность.

NetworkImageView———— Создан на основе ImageLoader и эффективно заменяет ImageView в случае изображений, полученных через сетевой URL-адрес. Если представление отделено от иерархии, NetworkImageView также может отменить отложенные запросы.

Использование ImageRequest

Ниже приведен пример использования ImageRequest. Он получит картинку, указанную в URL, и отобразит ее в приложении. Обратите внимание, что RequestQueue, продемонстрированный в нем, реализован через одноэлементный класс:

Использование ImageRequest также очень просто: теперь запустите программу и отправьте сетевой запрос, вы увидите, что изображение загружено.

Использование ImageLoader

Мы также можем использовать сам ImageLoader для отображения изображения.

Метод get () получает два параметра: первый параметр — это URL-адрес изображения, а второй параметр — объект ImageListener, инкапсулированный в одноэлементный класс. Первый параметр в методе getImageListener () указывает элемент управления ImageView, используемый для отображения изображения, второй параметр указывает изображение, отображаемое во время загрузки изображения, и третий параметр указывает изображение, отображаемое при сбое загрузки изображения.

Вы также можете получить указанное изображение, запустив программу.

Использование NetworkImageView

Однако, если все, что нам нужно сделать, это установить изображение для ImageView, то мы также можем использовать NetworkImageView для его достижения.

В XML-файле макета мы используем NetworkImageView так же, как ImageView:

Приведенный выше код обращается к RequestQueue и ImageLoader через одноэлементные классы. Такой подход гарантирует, что наше приложение создает синглтоны этих классов, которые будут продолжать существовать в жизненном цикле приложения. Это важно для ImageLoader (вспомогательный класс, используемый для обработки загрузки и кэширования изображений): основная функция кэша памяти — разрешить вращение без дрожания. Использование одноэлементного режима может сделать кэш растрового изображения длиннее, чем активность. Если мы создадим ImageLoader в действии, этот ImageLoader может быть воссоздан при каждом повороте устройства. Это может вызвать дрожание.

Оптимизировать запрос изображения

Панель инструментов Volley предоставляет стандартный кэш, реализованный с помощью класса DiskBasedCache. Этот класс может кэшировать файлы в указанный каталог на диске. Но для того, чтобы использовать ImageLoader, мы должны предоставить пользовательский кэш растрового изображения LRC, который реализует интерфейс ImageLoader.ImageCache. Мы можем захотеть установить кеш как синглтон.

Ниже приведен пример реализации класса памяти LruBitmapCache. Он наследует класс LruCache и реализует интерфейс ImageLoader.ImageCache:

Ниже показано, как создать экземпляр ImageLoader:

Volley + Gson анализирует сложные данные Json:

Я буду использовать плагин Android Studio GsonFormat, который может автоматически генерировать для вас класс Bean, соответствующий данным Json. Это намного быстрее, чем наше собственное создание. Все классы Bean обрабатываются одним щелчком мыши. !

Нажмите Файл–> Настройки–> Плагины–> и затем найдите GsonFormat, нажмите «Загрузить и установить».

Настройте Javabean (то есть создайте новый файл класса с наилучшим именем и содержимым bean-компонента), а затем нажмите -> code–> Generate–> GsonFormat (или непосредственно нажмите клавишу alt + s [Window]), а затем Скопируйте данные JSON в это поле. Нажмите «Формат», чтобы просмотреть отформатированный эффект (пропустить). Просто нажмите ОК.

Ниже приведен пример ветровой погоды, данные Json, которые он возвращает, выглядят следующим образом:

Поскольку данных слишком много, я не буду их публиковать, но вначале это очень отвратительно. Обратившись к методам других людей, вы можете сделать это:

Данные JSON становятся:

Затем добавьте следующее утверждение:

Тогда данные Json становятся тем, что мы хорошо понимаем:

Тогда вы можете начать анализ! !
Класс Bean автоматически генерируется GsonFormat. Полный код приведен ниже. Я только разбираю здесь название города. Если вам интересно, вы можете анализировать его слой за слоем:

Вставьте результат печати:

Вы можете видеть, что название города было полностью распечатано. Если вам интересно, вы можете анализировать его слой за слоем, поэтому я не буду здесь продолжать.

Источник