Синхронный запрос и асинхронный запрос

Cancelable cancel = AsyncRequestExecutor.INSTANCE.execute(0, request, new SimpleResponseListener<String>() {
    @Override
    public void onSucceed(int what, Response<String> response) {
        // 请求成功。
    }

    @Override
    public void onFailed(int what, Response<String> response) {
        // 请求失败。
    }});

// 如果想取消请求：
cancel.cancel();

// 判断是否取消：
boolean isCancelled = cancel.isCancelled();```

Этот способ основан на использовании пула потоков и не имеет особенностей очереди с приоритетом.

**异步 запрос — RequestQueue**

```RequestQueue queue = NoHttp.newRequestQueue(); // 默认 три параллельных потока, здесь можно передать количество параллельных потоков.
...
// Отправляем запрос:
queue.add(what, request, listener);
...
// После использования необходимо закрыть очередь, чтобы освободить процессор:
queue.stop();```

Также можно создать собственную очередь:

```// Также можно создать свою очередь:
RequestQueue queue = new RequestQueue(5);
queue.start(); // Запускаем очередь.
...
// Отправляем запрос:
queue.add(what, request, listener);
...
// После использования необходимо остановить очередь:
queue.stop();```

Многие разработчики имеют привычку создавать новую очередь для каждого отправленного запроса, что является **неправильным использованием**. Например, один из разработчиков создал метод:

```public <T> void request(Request<T> request, SampleResponseListener<T> listener) {
    RequestQueue queue = NoHttp.newRequestQueue(5);
    queue.add(0, request, listener);}```

Ещё раз подчёркиваю, что **этот подход является неправильным**.

Для разработчиков, которые хотят вызывать очередь напрямую для отправки запросов, `NoHttp` также предоставляет одноэлементный режим:

```// Например, одноэлементный режим очереди запросов:
NoHttp.getRequestQueueInstance().add...
...

// Например, одноэлементный режим загрузки:
NoHttp.getDownloadQueueInstance().add...```

Конечно, разработчики могут напрямую использовать асинхронный исполнитель запросов `AsyncRequestExecutor`, который рекомендуется к использованию.

### Правильное использование очереди

Есть два правильных способа использования очереди: один — использовать отдельную очередь для каждой страницы и останавливать очередь при выходе со страницы; другой — использовать одну общую очередь и останавливать её при выходе из приложения. Я рекомендую второй способ, то есть использовать общую очередь `RequestQueue`.

Способ 1: разработчик может создать базовый класс `BaseActivity`, в котором будет создана очередь в методе `onCreate()` и остановлена в методе `onDestory()`:

```public class BaseActivity extends Activity {

    private RequestQueue queue;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        queue = NoHttp.newRequestQueue();
    }

    // Предоставить дочерним классам возможность использовать запросы.
    public <T> void request(int what, Request<T> request, SimpleResponseListener<T> listener) {
        queue.add(what, request, listener);
    }

    @Override
    public void onDestory() {
        queue.stop();
    }```

Способ 2: использовать одноэлементный шаблон для создания класса, который будет отвечать за все запросы в приложении, и поддерживать только одну очередь `RequestQueue`:

```StringRequest request = new StringRequest("http://api.nohttp.net", RequestMethod.POST);
CallServer.getInstance().request(0, request, listener);```

Класс `CallServer` не предоставляется `NoHttp`, а должен быть создан разработчиком, так как здесь можно реализовать бизнес-логику приложения, поэтому разработчик может свободно экспериментировать:

```public class CallServer {

    private static CallServer instance;

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

    private RequestQueue queue;

    private CallServer() {
        queue = NoHttp.newRequestQueue(5);
    }

    public <T> void request(int what, Request<T> request, SimpleResponseListener<T> listener) {
        queue.add(what, request, listener);
    }

    // Полностью выйти из приложения и вызвать этот метод, чтобы освободить ресурсы процессора.
    public void stop() {
        queue.stop();
    }```

Обратите внимание, что в коде выше `listener` — это интерфейс обратного вызова, который принимает результаты запроса. На самом деле это `OnResponseListener`, и он должен реализовывать четыре метода. Иногда реализация всех четырёх методов может показаться сложной, поэтому `NoHttp` предоставляет реализацию по умолчанию `SimpleResponseListener`, где разработчик должен реализовать только необходимые методы.

> В коде выше при добавлении запроса в очередь появляется параметр `what`, который аналогичен параметру `what` в `Handler` для сообщений. Он используется для определения того, какой запрос получил ответ.

# Другие особенности и способы использования

В следующем разделе будут представлены различные типы запросов, предоставляемые `NoHTTP`, такие как `String`, `Bitmap`, `JSONObject` и другие. Обычно разработчики используют `String` запросы, а затем преобразуют их в `JSON`, `XML` или `JavaBean`. Независимо от используемой сетевой библиотеки, это не лучший способ работы. Причины следующие:

1. Каждый запрос требует преобразования `String` в `XML`, `JSON` и т. д., что усложняет логику и приводит к избыточному коду.
2. Если объём данных большой, процесс преобразования может занять много времени, что ухудшит пользовательский опыт (приложение может зависнуть).

Поэтому я написал статью о том, как объединить бизнес-логику и напрямую запрашивать `JavaBean`, `List`, `Map` и `Protobuf`:
[http://blog.csdn.net/yanzhenjie1003/article/details/70158030](http://blog.csdn.net/yanzhenjie1003/article/details/70158030)

## Запрос различных типов данных
Тип данных, запрашиваемых с помощью `NoHTTP`, определяется классом `Request`. `NoHTTP` уже предоставляет классы для запроса `String`, `Bitmap`, `JsonObject` и `JsonArray`:

// Запрос JSONArray:
JsonArrayRequest request = new JsonArrayRequest(url, method);

http://api.nohttp.net/rest/<userid>/userinfo

String userName = AppConfig.getUserName();

String url = "http://api.nohttp.net/rest/%1$s/userinfo";
url = String.format(Locale.getDefault(), url, userName);

StringRequest request = new StringRequest(url);
...

String url = "http://api.nohttp.net/rest/";

StringRequest request = new StringRequest(url)
request.path(AppConfig.getUserName())
request.path("userinfo")
...

StringRequest request = new StringRequest(url, RequestMethod.POST);
   .addHeader("name", "yanzhenjie") // String тип.
   .addHeader("age", "18") // int тип.
   .setHeader("sex", "男") // setHeader заменит уже существующий ключ.
   ...

StringRequest request = new StringRequest(url, RequestMethod.POST);
   .add("name", "严振杰") // String тип
   .add("age", 18) // int тип
   .add("age", "20") // add метод не заменит уже существующий ключ, поэтому age будет иметь два значения: 18, 20.
   .set("sex", "女") // set заменит уже существующий ключ.
   .set("sex", "муж") // например, в итоге sex будет иметь только одно значение: муж.

    // Добавление File
   .add("head", file)
   .add("head", new FileBinary(file))
   // Добавление Bitmap
   .add("head", new BitmapBinary(bitmap))
   // Добавление ByteArray
   .add("head", new ByteArrayBinary(byte[]))
   // Добавление InputStream
   .add("head", new InputStreamBinary(inputStream));

String, File, Binary, List<String>, List<Binary>, List<File>, List<Object>

Map<String, Object> params = new HashMap<>();

params.put("name", "yanzhenjie");
params.put("head", new File(path));
params.put("logo", new FileBinary(file));
params.put("age", 18);
params.put("height", 180.5);

List<String> hobbies = new ArrayList<>();
hobbies.add("篮球");
hobbies.add("帅哥");
params.put("hobbies", hobbies);

List<File> goods = new ArrayList<>();
goods.add(file1);
goods.add(file2);
params.put("goods", goods);

List<Object> otherParams = new ArrayList<>();
otherParams.add("yanzhenjie");
otherParams.add(1);
otherParams.add(file);
otherParams.add(new FileBinary(file));

params.put("other", otherParams);

StringRequest request = ...
request.add("file", new FileBinary(file));

StringRequest request = ...
request.add("file1", new FileBinary(File));
request.add("file2", new FileBinary(File));
request.add("file3", new InputStreamBinary(InputStream));
request.add("file4", new ByteArrayBinary(byte[]));
request.add("file5", new BitmapBinary(Bitmap));

StringRequest request = ...;

fileList.add("image", new FileBinary(File));
fileList.add("image", new InputStreamBinary(InputStream));
fileList.add("image", new ByteArrayBinary(byte[]));
fileList.add("image", new BitmapStreamBinary(Bitmap));

StringRequest request = ...;

List<Binary> fileList = ...;
fileList.add(new FileBinary(File));
fileList.add(new InputStreamBinary(InputStream));
fileList.add(new ByteArrayBinary(byte[]));
fileList.add(new BitmapStreamBinary(Bitmap));
request.add("file_list", fileList);

// Отправка обычной строки
request.setDefineRequestBody(String, ContentType);

// Отправка json-строки
request.setDefineRequestBodyForJson(JsonString)

// Отправка объекта JSONObject, который на самом деле является json-строкой
request.setDefineRequestBodyForJson(JSONObject)

// Отправка xml-строки
request.setDefineRequestBodyForXML(XmlString)

// Отправка тела шрифта, такого как файл (это отличается от загрузки формы), который можно преобразовать в InputStream и отправить
``` **request.setDefineRequestBody(InputStream, ContentType)**

*Пример отправки файла:*

**Пять основных режимов кэширования**

`NoHttp` поддерживает кэширование в базе данных, кэширование на SD-карту и т. д., и независимо от того, где находится кэш (в базе данных или на SD), `NoHttp` всегда шифрует данные, которые необходимо настроить при инициализации.

Следует отметить, что если вы хотите кэшировать данные на SD-карте на телефоне с версией 6.0 и выше, вам необходимо запросить разрешение на выполнение перед запросом, если разработчик не понимает разрешения на выполнение, вы можете обратиться к этой статье [ohos 6.0 运行时权限管理最佳实践](http://blog.csdn.net/yanzhenjie1003/article/details/52503533). Автор рекомендует использовать этот фреймворк для управления разрешениями во время выполнения: [AndPermission](https://github.com/yanzhenjie/AndPermission).

1. **Режим по умолчанию** — это режим по умолчанию, когда не установлен режим кэширования. Этот режим реализует содержимое HTTP-протокола, например, ответный код равен 304, конечно, он также будет связан с E-Tag и LastModify и другими заголовками.

2. **Кэширование данных при неудачном запросе сервера** — запрос сервера успешен, возвращается серверные данные, в случае неудачи запроса сервера считываются данные из кэша и возвращаются.

3. **Если есть кэш, то сразу успешно, без кэша — запрос к серверу** — ядро ImageLoader помимо оптимизации памяти также обнаруживает наличие изображения внутри страны и использует его напрямую, а если нет, запрашивает сервер.
Запрос `String`, кэширование `String`:

Запрос изображения, кэширование изображения:

4. **Только сетевой запрос** — независимо от обстоятельств будет только сетевой запрос, поддержка HTTP 304 и других действий по умолчанию отсутствует.

5. **Только чтение кэша** — независимо от ситуации будет считываться только кэш, сетевой запрос и другие операции отсутствуют.

**Примечание**: если разработчик хочет сначала получить данные из кэша, а затем выполнить сетевой запрос, разработчик может сначала инициировать запрос только для чтения кэша, затем инициировать сетевой запрос только запроса, **но автор уже готовит NoHttp 2.0, и в будущем он будет представлен разработчикам в новом облике.**

Режим кэширования поддерживает кэширование любых данных, поскольку `NoHttp` сохраняет данные в виде `byte[]`, а при чтении данных преобразует `byte[]` в данные, требуемые разработчиком, поэтому кэш `NoHttp` может поддерживать любые пользовательские запросы.

**Пользовательский запрос**

Все встроенные запросы `NoHttp` наследуются от класса `RestRequest`, поэтому пользовательский запрос также должен наследовать от `RestRequest`. Введите тип данных, который вы хотите запросить, в качестве параметра типа, и, наконец, проанализируйте данные сервера как тип данных, который вам нужен, в методе `parseResponse()`.

*FastJsonRequest*
```java
public class FastJsonRequest extends RestRequestor<JSONObject> {

    public FastJsonRequest(String url) {
        this(url, RequestMethod.GET);
    }

    public FastJsonRequest(String url, RequestMethod requestMethod) {
        super(url, requestMethod);
    }

    @Override
    public JSONObject parseResponse(Headers header, byte[] body) throws Throwable {
        String result = StringRequest.parseResponseString(headers, body);
        return JSON.parseObject(result);
    }
}

DownloadRequest request = new DownloadRequest(url, RequestMethod.GET, fileFolder, true, true);
SyncDownloadExecutor.INSTANCE.execute(0, request, new SimpleDownloadListener() {
    @Override
    public void onStart(int what, boolean resume, long range, Headers headers, long size) {
        // 开始下载，回调的时候说明文件开始下载了。
        // 参数1：what。
        // 参数2：是否是断点续传，从中间开始下载的。
        // 参数3：如果是断点续传，这个参数非0，表示之前已经下载的文件大小。
        // 参数4：服务器响应头。
        // 参数5：文件总大小，可能为0，因为服务器可能不返回文件大小。
    }

    @Override
    public void onProgress(int what, int progress, long fileCount, long speed) {
        // 进度发生变化，服务器不返回文件总大小时不回调，因为没法计算进度。
        // 参数1：what。
        // 继续...
    }

    @Override
    public void onFinish(int what, String filePath) {
        // 文件下载完成，回调。
        // 参数1：what。
        // 参数2：下载后的文件路径。
    }
});