Dio encapsulated by the flutter network request (cookie management, adding interceptors, downloading files, exception handling, canceling requests, etc.)

The reason is that , Thousands of words make up a sentence ： Easy to use .

Dio relevant

dio Is a powerful Dart Http Request Library , Support Restful API、FormData、 Interceptor 、 Request cancellation 、Cookie management 、 Upload files / download 、 Overtime 、 Custom adapter, etc ...

• Add dependency , Be careful 3.0.+ Is an incompatible upgrade

dependencies:
 dio: ^3.0.9


• A minimalist example

import 'package:dio/dio.dart';
void getHttp() async {
 try {
 Response response = await Dio().get("http://www.baidu.com");
 print(response);
 } catch (e) {
 print(e);
 }
}


<br>

Packaging begins

• Network requests are often used , So let's take a simple example , Create a new one called httpUtil The file of

class HttpUtil {
 static HttpUtil instance;
 Dio dio;
 BaseOptions options;

 CancelToken cancelToken = new CancelToken();

 static HttpUtil getInstance() {
 if (null == instance) instance = new HttpUtil();
 return instance;
 }
}


• Configure and initialize Dio

 /*
 * config it and create
 */
 HttpUtil() {
 //BaseOptions、Options、RequestOptions  Parameters can be configured , The priority level increases in turn , And the parameters can be overridden according to the priority
 options = new BaseOptions(
 // Request base address , Can contain sub paths
 baseUrl: "http://www.google.com",
 // Connection server timeout , In milliseconds .
 connectTimeout: 10000,
 // The interval between the two received data on the response stream , The unit is millisecond .
 receiveTimeout: 5000,
 //Http Request header .
 headers: {
 //do something
 "version": "1.0.0"
 },
 // Requested Content-Type, The default value is "application/json; charset=utf-8",Headers.formUrlEncodedContentType The request body is automatically encoded .
 contentType: Headers.formUrlEncodedContentType,
 // Indicates that you expect to ( The way ) Accept response data . Accept 4 Types  `json`, `stream`, `plain`, `bytes`.  The default value is  `json`,
 responseType: ResponseType.json,
 );

 dio = new Dio(options);
 }


Configuration at a glance , But there is a potential problem , Careful students may find that ,baseUrl The parameters are fixed , It is very possible to request two or more domain names in the actual development , So how do we dynamically change baseUrl Well ？

The configuration here is BaseOptions, Actually there are Options、RequestOptions,  Parameters can be configured , The priority level increases in turn , And the parameters can be overridden according to the priority

BaseOptions  Base class requests configuration Options Single request configuration RequestOptions Actual request configuration

therefore , We can create where we need to RequestOptions, Then replace or cover BaseOptions  Add to the request parameter

such as ：

RequestOptions requestOptions=new RequestOptions(
 baseUrl: "http://www.google.com/aa/bb/cc/"
 );


<br>

get request

 /*
 * get request
 */
 get(url, {data, options, cancelToken}) async {
 Response response;
 try {
 response = await dio.get(url, queryParameters: data, options: options, cancelToken: cancelToken);
 print('get success---------${response.statusCode}');
 print('get success---------${response.data}');

// response.data;  Response body
// response.headers;  Response head
// response.request;  Request body
// response.statusCode;  Status code

 } on DioError catch (e) {
 print('get error---------$e');
 formatError(e);
 }
 return response.data;
 }


url： Request address data： Request parameters options： Request configuration cancelToken： Unmark

<br>

post request

 /*
 * post request
 */
 post(url, {data, options, cancelToken}) async {
 Response response;
 try {
 response = await dio.post(url, queryParameters: data, options: options, cancelToken: cancelToken);
 print('post success---------${response.data}');
 } on DioError catch (e) {
 print('post error---------$e');
 formatError(e);
 }
 return response.data;
 }


post Form Forms

As usual post Requests are similar , It's just data It's just a change

FormData formData = FormData.from({
 "name": "wendux",
 "age": 25,
 });
response = await dio.post("/info", data: formData);


establish FormData, Then replace the original data that will do

<br>

exception handling

When something goes wrong , Of course, the clearer and more careful you know, the better , The easier it is to deal with

 /*
 * error Unified treatment
 */
 void formatError(DioError e) {
 if (e.type == DioErrorType.CONNECT_TIMEOUT) {
 // It occurs when url is opened timeout.
 print(" Connection timeout ");
 } else if (e.type == DioErrorType.SEND_TIMEOUT) {
 // It occurs when url is sent timeout.
 print(" request timeout ");
 } else if (e.type == DioErrorType.RECEIVE_TIMEOUT) {
 //It occurs when receiving timeout
 print(" Response timeout ");
 } else if (e.type == DioErrorType.RESPONSE) {
 // When the server response, but with a incorrect status, such as 404, 503...
 print(" Something unusual happened ");
 } else if (e.type == DioErrorType.CANCEL) {
 // When the request is cancelled, dio will throw a error with this type.
 print(" Request cancellation ");
 } else {
 //DEFAULT Default error type, Some other Error. In this case, you can read the DioError.error if it is not null.
 print(" Unknown error ");
 }
 }


<br>

Cookie management

Cookie Management is http An inextricable topic in , Keep the reply lasting , Will be cookie Persistence

• rely on

dependencies:
 dio_cookie_manager: ^1.0.0


• introduce

import 'package:cookie_jar/cookie_jar.dart';
import 'package:dio/dio.dart';
import 'package:dio_cookie_manager/dio_cookie_manager.dart';


• Use

//Cookie management
dio.interceptors.add(CookieManager(CookieJar()));


<br>

Add interceptor

The interceptor can before the request 、 Before responding 、error Do some pretreatment before


 dio = new Dio(options);
 
 // Add interceptor
 dio.interceptors.add(InterceptorsWrapper(onRequest: (RequestOptions options) {
 print(" Request before ");
 // Do something before request is sent
 return options; //continue
 }, onResponse: (Response response) {
 print(" Before responding ");
 // Do something with response data
 return response; // continue
 }, onError: (DioError e) {
 print(" Before the mistake ");
 // Do something with response error
 return e; //continue
 }));


<br>

Download the file

Downloading files is often used , Like downloading pictures , Or update

 /*
 *  Download the file
 */
 downloadFile(urlPath, savePath) async {
 Response response;
 try {
 response = await dio.download(urlPath, savePath,onReceiveProgress: (int count, int total){
 // speed of progress
 print("$count $total");
 });
 print('downloadFile success---------${response.data}');
 } on DioError catch (e) {
 print('downloadFile error---------$e');
 formatError(e);
 }
 return response.data;
 }


<br>

Cancel the request

 /*
 *  Cancel the request
 *
 *  The same cancel token  Can be used for multiple requests , When one cancel token On cancellation , All uses should be cancel token All requests will be cancelled .
 *  So the parameters are optional
 */
 void cancelRequests(CancelToken token) {
 token.cancel("cancelled");
 }


<br>

Https Certificate verification

There are two ways to verify https certificate , Suppose our background service uses a self signed certificate , The certificate format is PEM Format , We save the contents of the certificate in the local string , Then our verification logic is as follows ：

String PEM="XXXXX"; // certificate content
(dio.httpClientAdapter as DefaultHttpClientAdapter).onHttpClientCreate = (client) {
 client.badCertificateCallback=(X509Certificate cert, String host, int port){
 if(cert.pem==PEM){ // Verify the certificate
 return true;
 }
 return false;
 };
};


X509Certificate Is the standard format of the certificate , Contains all the information of the certificate except the private key , Readers can consult the documents themselves . in addition , The above example does not verify host, Because as long as the certificate returned by the server is consistent with the local storage, it can be proved to be our server （ Not a middleman ）,host Verification is usually to prevent the certificate and domain name from mismatching .

For self signed certificates , We can also add it to the local certificate trust chain , In this way, the certificate will automatically pass , Instead of going to badCertificateCallback Calling back ：

(dio.httpClientAdapter as DefaultHttpClientAdapter).onHttpClientCreate = (client) {
 SecurityContext sc = new SecurityContext();
 //file is the path of certificate
 sc.setTrustedCertificates(file);
 HttpClient httpClient = new HttpClient(context: sc);
 return httpClient;
};


Be careful , adopt setTrustedCertificates() The set certificate format must be PEM or PKCS12, If the certificate format is PKCS12, You need to pass the certificate password into , This will expose the certificate password in the code , Therefore, client certificate verification is not recommended PKCS12 Certificate in format .

<br>

Invoke the sample

 var response = await HttpUtil().get("http://www.baidu.com");
 print(response.toString());


json Parse view ：

Flutter Json Auto resolve FlutterJsonBeanFactory

<br>

Complete code

github：

https://github.com/yechaoa/wanandroid_flutter

<br>

Think it's useful. Give it a compliment  ^ _ ^

<br><br>