前言

跟我学flutter系列：
跟我学flutter：我们来举个例子通俗易懂讲解dart 中的 mixin
跟我学flutter：我们来举个例子通俗易懂讲解异步（一）ioslate
跟我学flutter：我们来举个例子通俗易懂讲解异步（二）ioslate循环机制
企业级篇目：
跟我学企业级flutter项目：用bloc手把手教你搭建用户认证系统
跟我学企业级flutter项目：dio网络框架增加公共请求参数&header
跟我学企业级flutter项目：如何用dio封装一套企业级可扩展高效的网络层
跟我学企业级flutter项目：如何封装一套易用，可扩展的Hybrid混合开发webview
跟我学企业级flutter项目：手把手教你制作一款低耦合空页面widget

网上有很多，比如说“Flutter Dio 亲妈级别封装教程”这篇文章，该文章上有几点问题：

1. 
   
2. 重试机制代码错误
   
3. token存取耦合很高
   
4. 网络请求只能针对单一地址进行访问
   
5. 网络请求缓存机制也不是很完美。
   

一旦依照这样的封装去做，那么项目后期的扩展性和易用性会有一定的阻碍，那么如何做到token存取无耦合，而且还能让app多种网络地址一同请求，还可以做到针对不同请求不同超时时长处理，网络缓存还加入可自动清理的lru算法呢？那么今天这篇文章为你揭晓企业级flutter dio网络层封装。

搭建前夕准备

三方库：

dio_cache_interceptor lru缓存库
dio 网络库
retrofit 网络生成库
connectivity_plus 网络情况判断

技能：

单例模式
享元模式
迭代

文章：

持久化：跟我学企业级flutter项目：dio网络框架增加公共请求参数&header

准备好如上技能，我们来封装一套优秀的网络层

一、准备好几个基本拦截器

1、超时拦截器

import 'dart:collection';

import 'package:dio/dio.dart';
import 'package:flutter_base_lib/src/app/contants.dart';
import 'package:flutter_base_lib/src/tools/net/cache_object.dart';

class TimeInterceptor extends Interceptor {

@override
void onRequest(RequestOptions options, RequestInterceptorHandler handler) {

    Map extra = options.extra;

    bool connect = extra.containsKey(SysConfig.connectTimeout);

    bool receive = extra.containsKey(SysConfig.receiveTimeOut);
if(connect||receive){
if(connect){
int connectTimeout = options.extra[SysConfig.connectTimeout];

        options.connectTimeout = connectTimeout;

      }
if(receive){
int receiveTimeOut = options.extra[SysConfig.receiveTimeOut];

        options.receiveTimeout = receiveTimeOut;

      }

    }
super.onRequest(options, handler);


  }


}
,>

作用：单独针对个别接口进行超时时长设定，如（下载，长链接接口）

2、缓存拦截器

dio_cache_interceptor 这个库中有lru算法缓存拦截库，可直接集成

3、持久化拦截器

跟我学企业级flutter项目：dio网络框架增加公共请求参数&header 本篇文章介绍了如何持久化

4、重试拦截器

import 'dart:async';
import 'dart:io';

import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:dio/dio.dart';
import 'package:flutter_base_lib/src/app/application.dart';
import 'package:flutter_base_lib/src/app/contants.dart';
import 'package:flutter_ulog/flutter_ulog.dart';

import '../dio_utli.dart';

/// 重试拦截器
class RetryOnConnectionChangeInterceptor extends Interceptor {

  Dio? dio;


  RequestInterceptorHandler? mHandler;
// RetryOnConnectionChangeInterceptor(){
//
// }

@override
void onRequest(RequestOptions options, RequestInterceptorHandler handler) {

    mHandler = handler;
super.onRequest(options, handler);

  }


@override
Future onError(DioError err, ErrorInterceptorHandler handler) async{
if (dio!=null&&Application.config.httpConfig.retry&&await _shouldRetry(err)) {
return await retryLoop(err,handler,1);

    }
return super.onError(err, handler);

  }

Future retryLoop(DioError err, ErrorInterceptorHandler handler,int retry) async {
try {

      ULog.d("${err.requestOptions.uri.toString()} retry : ${retry}",tag: "${SysConfig.libNetTag}Retry");
await retryHttp(err,handler);

    } on DioError catch (err) {
if(await _shouldRetry(err)&&retry _shouldRetry(DioError err) async{
return err.error != null && err.error is SocketException && await isConnected();

  }

Future isConnected() async {
var connectivityResult = await (Connectivity().checkConnectivity());
return connectivityResult != ConnectivityResult.none;

  }

}
){>

该重试拦截器与其他文章封装不同，主要是用重试次数来管理重试机制。

5、日志拦截器

import 'dart:convert';


import 'package:dio/dio.dart';

import 'package:flutter_base_lib/src/app/contants.dart';

import 'package:flutter_ulog/flutter_ulog.dart';
typedef void LibLogPrint(String message);
class LibLogInterceptor extends Interceptor {

  LibLogInterceptor({
this.request = true,
this.requestHeader = true,
this.requestBody = false,
this.responseHeader = true,
this.responseBody = false,
this.error = true

  });

/// Print request [Options]
bool request;

/// Print request header [Options.headers]
bool requestHeader;

/// Print request data [Options.data]
bool requestBody;

/// Print [Response.data]
bool responseBody;

/// Print [Response.headers]
bool responseHeader;

/// Print error message
bool error;


  @override
void onRequest(

      RequestOptions options, RequestInterceptorHandler handler) async {
var builder = StringBuffer('*** Request *** \n');

    builder.write(_printKV('uri', options.uri));
//options.headers;

if (request) {

      builder.write(_printKV('method', options.method));

      builder.write(_printKV('responseType', options.responseType.toString()));

      builder.write(_printKV('followRedirects', options.followRedirects));

      builder.write(_printKV('connectTimeout', options.connectTimeout));

      builder.write(_printKV('sendTimeout', options.sendTimeout));

      builder.write(_printKV('receiveTimeout', options.receiveTimeout));

      builder.write(_printKV(
'receiveDataWhenStatusError', options.receiveDataWhenStatusError));

          builder.write(_printKV('extra', options.extra));

    }
if (requestHeader) {

      builder.write('headers:\n');

      options.headers.forEach((key, v) => builder.write(_printKV(' $key', v)));

    }
if (requestBody) {
var res = options.data;

      builder.write('data:\n');

      builder.write(_message(res));
// try{
//   ULog.json(res.toString(),tag: "${SysConfig.libNetTag}RequestJson");
// } on Exception catch (e) {
//   ULog.d(res,tag: "${SysConfig.libNetTag}RequestJson");
// }

    }

    ULog.d(builder.toString(),tag: "${SysConfig.libNetTag}Request");

    handler.next(options);

  }

// Handles any object that is causing JsonEncoder() problems
Object toEncodableFallback(dynamic object) {
return object.toString();

  }


  String _message(dynamic res) {
if (res is Map || res is Iterable) {
var encoder = JsonEncoder.withIndent('  ', toEncodableFallback);
return encoder.convert(res);

    } else {
return res.toString();

    }

  }


  @override
void onResponse(Response response, ResponseInterceptorHandler handler) async {
var builder = StringBuffer('*** Response *** \n');

    _printResponse(response,builder,(message){

      ULog.d(message,tag: "${SysConfig.libNetTag}Response");

    });

    handler.next(response);

  }


  @override
void onError(DioError err, ErrorInterceptorHandler handler) async {
if (error) {
var builder = StringBuffer('*** DioError *** \n');

      builder.write('uri: ${err.requestOptions.uri}\n');

      builder.write('$err');
if (err.response != null) {

        _printResponse(err.response!,builder,(message){

          ULog.e(message,tag: "${SysConfig.libNetTag}Error");

        });

      }else{

        ULog.e(builder.toString(),tag: "${SysConfig.libNetTag}Error");

      }

    }


    handler.next(err);

  }

void _printResponse(Response response,StringBuffer builder,LibLogPrint pr) {

    builder.write(_printKV('uri', response.requestOptions.uri));
if (responseHeader) {

      builder.write(_printKV('statusCode', response.statusCode));
if (response.isRedirect == true) {

        builder.write(_printKV('redirect', response.realUri));

      }


      builder.write('headers:\n');

      response.headers.forEach((key, v) => builder.write(_printKV(' $key', v.join('\r\n\t'))));

    }
if (responseBody) {
var res = response.toString();

      builder.write('Response Text:\r\n');
var resJ = res.trim();
if (resJ.startsWith("{")) {

        Map decode = JsonCodec().decode(resJ);

        builder.write(_message(decode));

      }else if (resJ.startsWith("[")) {

        List decode = JsonCodec().decode(resJ);

        builder.write(_message(decode));

      }else {

        builder.write(res);

      }

// try{
//   ULog.json(res,tag: "${SysConfig.libNetTag}ResponseJson");
// } on Exception catch (e) {
//   ULog.d(res,tag: "${SysConfig.libNetTag}ResponseJson");
// }

    }

    pr(builder.toString());


  }


  String _printKV(String key, Object? v) {
return '$key: $v \n';

  }


}
,>

主要是日志拦截打印

6、错误拦截器

import 'dart:io';

import 'package:dio/dio.dart';
import 'package:flutter_base_lib/src/app/contants.dart';
import 'package:flutter_base_lib/src/exception/lib_network_exception.dart';
import 'package:flutter_base_lib/src/tools/net/dio_utli.dart';
import 'package:flutter_ulog/flutter_ulog.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter_base_lib/src/lib_localizations.dart';

/// 错误处理拦截器
class ErrorInterceptor extends Interceptor {
// 是否有网
Future isConnected() async {
var connectivityResult = await (Connectivity().checkConnectivity());
return connectivityResult != ConnectivityResult.none;

  }
@override
Future onError(DioError err, ErrorInterceptorHandler handler) async {
if (err.type == DioErrorType.other) {

      bool isConnectNetWork = await isConnected();
if (!isConnectNetWork && err.error is SocketException) {

        err.error = SocketException(LibLocalizations.getLibString().libNetWorkNoConnect!);

      }else if (err.error is SocketException){

        err.error = SocketException(LibLocalizations.getLibString().libNetWorkError!);

      }

    }

    err.error = LibNetWorkException.create(err);

    ULog.d('DioError : ${err.error.toString()}',tag: "${SysConfig.libNetTag}Interceptor");
super.onError(err, handler);

  }


}

与其他人封装不同，服务器请求异常code，我将其抛到业务层自主处理。常规异常则走库文案。

import 'dart:io';

import 'package:dio/dio.dart';
import 'package:flutter_base_lib/src/lib_localizations.dart';

class LibNetWorkException implements Exception{

final String _message;
final int _code;


  int get code{
return _code;

  }


  String get message{
return _message;

  }


  LibNetWorkException( this._code,this._message);

@override

  String toString() {
return "$_code : $_message";

  }




  factory LibNetWorkException.create(DioError error) {

    switch (error.type) {

      case DioErrorType.cancel:{
return LibNetWorkException(-1, LibLocalizations.getLibString().libNetRequestCancel!);

        }

      case DioErrorType.connectTimeout:{
return LibNetWorkException(-1, LibLocalizations.getLibString().libNetFailCheck!);

        }

      case DioErrorType.sendTimeout:{
return LibNetWorkException(-1, LibLocalizations.getLibString().libNetTimeOutCheck!);

        }

      case DioErrorType.receiveTimeout:{
return LibNetWorkException(-1, LibLocalizations.getLibString().libNetResponseTimeOut!);

        }

      case DioErrorType.response:{
try{
return LibNetWorkException(error.response!.statusCode!,"HTTP ${error.response!.statusCode!}:${LibLocalizations.getLibString().libNetServerError!}");

          } on Exception catch (_) {
return LibNetWorkException(-1, error.error.message);

          }

        }
default:

        {
return LibNetWorkException(-1, error.error.message);

        }

    }

  }

}

二、工具类封装

1、主要类

import 'dart:io';

import 'package:dio/adapter.dart';
import 'package:dio/dio.dart';
import 'package:flutter_base_lib/src/tools/net/interceptor/error_interceptor.dart';
import 'package:flutter_base_lib/src/tools/net/interceptor/lib_log_interceptor.dart';

import '../../../flutter_base_lib.dart';
import 'interceptor/presistent_interceptor.dart';
import 'interceptor/retry_on_connection_change_interceptor.dart';
import 'interceptor/time_interceptor.dart';

class DioUtil{


  final String _baseUrl;

  final HttpConfig _config;

  final List _interceptors;


  late Dio _dio;


  Dio get dio{
return _dio;

  }

  DioUtil._internal(this._baseUrl, this._config, this._interceptors){

    BaseOptions options = new BaseOptions(

      baseUrl: _baseUrl,
connectTimeout: _config.connectTimeout,
receiveTimeout: _config.receiveTimeOut,

    );

    _dio = new Dio(options);
var retry = new Dio(options);

    _interceptors.forEach((element) {
if(element is RetryOnConnectionChangeInterceptor){

        element.dio = retry;

      }else{
if(!(element is ErrorInterceptor)){

          retry.interceptors.add(element);

        }

      }

      _dio.interceptors.add(element);

    });

    proxy(_dio);

    proxy(retry);

  }

void proxy(Dio dio){
if (SpSotre.instance.getBool(SysConfig.PROXY_ENABLE)??false) {
String? porxy = SpSotre.instance.getString(SysConfig.PROXY_IP_PROT)??null;
if(porxy!=null){

        (dio.httpClientAdapter as DefaultHttpClientAdapter).onHttpClientCreate =

            (client) {

          client.findProxy = (uri) {
return "PROXY $porxy";

          };
//代理工具会提供一个抓包的自签名证书，会通不过证书校验，所以我们禁用证书校验

          client.badCertificateCallback =
(X509Certificate cert, String host, int port) => true;

        };

      }

    }

  }

static late Map _dioUtils = Map();

static DioUtil instance(String baseUrl,{HttpConfig? config, List? interceptors,List? applyInterceptors}){
if(!_dioUtils.containsKey(baseUrl)){

      List list = [PresistentInterceptor(),TimeInterceptor(),RetryOnConnectionChangeInterceptor(),LibLogInterceptor(requestBody: Application.config.debugState,responseBody: Application.config.debugState),ErrorInterceptor()];
// List list = [ErrorInterceptor(),PresistentInterceptor()];
var inter = interceptors??list;
if(applyInterceptors!=null){

        inter.addAll(applyInterceptors);

      }

      _dioUtils[baseUrl] = DioUtil._internal(baseUrl,config??Application.config.httpConfig,inter);

    }
return _dioUtils[baseUrl]!;

  }

// CancelToken _cancelToken = new CancelToken();



}
,dioutil>

工具类封装，主要运用享元模式，可以支持多种url进行访问，不同的url有不同的配置。（灵活可用）

2、辅助类：

class HttpConfig{
final int _connectTimeout ;
final int _receiveTimeOut ;
final bool _retry;
final int _retryCount;


  get connectTimeout{
return _connectTimeout;

  }


  get receiveTimeOut{
return _receiveTimeOut;

  }


  get retry{
return _retry;

  }

  get retryCount{
return _retryCount;

  }


  HttpConfig(HttpConfigBuilder builder): _connectTimeout = builder._connectTimeout,_receiveTimeOut = builder._receiveTimeOut,_retry = builder._retry,_retryCount = builder._retryCount;

}

class HttpConfigBuilder {
int _connectTimeout = 10000;//连接超时时间
int _receiveTimeOut = 30000;//接收超时时间
bool _retry = false;
int _retryCount = 3;

// var maxRetry = 1 重试次数

HttpConfigBuilder setConnectTimeout(int connectTimeout){

    _connectTimeout = connectTimeout;
return this;

  }

HttpConfigBuilder setReceiveTimeOut(int receiveTimeOut){

    _receiveTimeOut = receiveTimeOut;
return this;

  }

HttpConfigBuilder setRetry(bool retry){

    _retry = retry;
return this;

  }

HttpConfigBuilder setRetryCount(int retryCount){

    _retryCount = _retryCount;
return this;

  }

HttpConfig build() => HttpConfig(this);

}

三、使用

import 'package:flutter_app_me/data/model/api_result.dart';
import 'package:flutter_app_me/data/model/user.dart';
import 'package:flutter_app_me/data/model/user_infos.dart';
import 'package:flutter_base_lib/flutter_base_lib.dart';
import 'package:retrofit/retrofit.dart';
import 'package:dio/dio.dart';

import 'api_methods.dart';


part 'api_service.g.dart';

@RestApi()
abstract class RestClient {

  factory RestClient(Dio dio, {String baseUrl}) = _RestClient;

@GET(ApiMethods.userinfoJson)

  Future> userinfoJson();

// "test123332","123456"
@POST(ApiMethods.login)
@Extra({SysConfig.connectTimeout:100000})

  Future> userLogin(@Queries() User user);

}

网络请求配置

class BusinessErrorException implements Exception {
final int _errorCode;
final String? _errorMsg;


  BusinessErrorException(this._errorCode, this._errorMsg);


  int get errorCode {
return _errorCode;

  }


  String? get errorMsg => _errorMsg;

}


class TokenTimeOutException implements Exception {
final String? _errorMsg;

  TokenTimeOutException(this._errorMsg);

  String? get errorMsg => _errorMsg;


}

class RequestCodeErrorException implements Exception {
final String? _errorMsg;
final int _errorCode;

  RequestCodeErrorException(this._errorCode, this._errorMsg);


  int get errorCode {
return _errorCode;

  }


  String? get errorMsg => _errorMsg;

}

业务基本异常

import 'package:business_package_auth/business_package_auth.dart';
import 'package:flutter_base_lib/flutter_base_lib.dart';
import 'package:flutter_base_ui/flutter_base_ui.dart';
import 'package:dio/dio.dart';
import 'package:wisdomwork_lib/src/model/api_result.dart';

const int httpSuccessCode = 0;
const int httpErrorCode = 1;
const int httpTokenExt = 10001;


extension SuccessExt on Success {

  Success appSuccess() {
var data = this.data;
if (data is ApiResult) {
if (data.code != httpSuccessCode) {

        switch (data.code){

          case httpTokenExt:

            TipToast.instance.tip(data.msg ?? LibLocalizations.getLibString().libBussinessTokenTimeOut!,tipType: TipType.warning);

            BlocProvider.of(LibRouteNavigatorObserver.instance.navigator!.context).add(LogOut());
throw TokenTimeOutException(data.msg);

          case httpErrorCode:

            TipToast.instance.tip(data.msg ?? LibLocalizations.getLibString().libBussinessRequestCodeError!,tipType: TipType.error);
throw RequestCodeErrorException(data.code!,data.msg);
default:
throw BusinessErrorException(data.code!, data.msg);

        }


      }

    }
return this;

  }

}


extension ErrorExt on Error {

  void appError() {
var exception = this.exception;
if (exception is LibNetWorkException) {

      TipToast.instance.tip(exception.message, tipType: TipType.error);

    }

  }

}



typedef ResultF = Future> Function();


mixin RemoteBase {


  Future>> remoteDataResult(ResultF resultF) async {
try {
var data = await resultF.call();
return Success(data).appSuccess();

    } on DioError catch (err, stack) {
var e = err.error;

      ULog.e(e.toString(), error: e, stackTrace: stack);
return Error(e)..appError();

    } on Exception catch (e, stack) {

      ULog.e(e.toString(), error: e, stackTrace: stack);
return Error(e)..appError();

    }

  }


}

业务基本异常处理方式

import 'package:flutter_base_lib/flutter_base_lib.dart';
import 'package:flutter_base_ui/flutter_base_ui.dart';
import 'package:wisdomwork/data/services/api_service.dart';
import 'package:wisdomwork_lib/wisdomwork_lib.dart';

mixin WisdomworkRemoteBase{
var rest = RestClient(DioUtil.instance(

      AppEnvironment.envConfig![AppConfig.apiName]!,

      applyInterceptors: [UiNetInterceptor()]).dio);

}

业务请求接口，实现

     final data = await AppResponsitory.instance.login(state.phoneText, state.codeText);
if (userResult != null) {
if (userResult is Success) {
if (userResult.data!.data!= null) {

                    onGetUser(userResult.data!.data!, context);

                  }

                } else if(userResult is Error){
var exception = (userResult as Error).exception;
if(exception is BusinessErrorException){

                    Fluttertoast.showToast(msg: exception.errorMsg.toString());

                  }

                }

              }

业务请求与异常处理