flutter 单例

最新推荐文章于 2025-03-26 09:19:20 发布
最新推荐文章于 2025-03-26 09:19:20 发布
阅读量164 收藏
点赞数 2
文章标签： flutter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/python4_1/article/details/144615935
版权

蓝牙和WiFi的一直在后台运行的函数

import 'package:clean_ai/preference_message_type/share_preferences.dart';
import 'package:clean_ai/utils/disconnect_device_bluetooth_sheet_utils.dart';
import 'package:clean_ai/void/bluetooth_scan_void.dart';
import 'package:flutter/material.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:flutter_easyloading/flutter_easyloading.dart';
import 'dart:async';
import 'package:clean_ai/getx/wifi_blue_get.dart';
import 'package:clean_ai/rpx/rpx.dart';
import 'package:clean_ai/utils/style_text_utils.dart';
import 'package:get/get.dart';
import 'package:mqtt_client/mqtt_client.dart';

import 'characteristic_connect_device/characteristic_write_notify_device_utils.dart';
import 'communication_protocols/byte_map_utils/int_byte.dart';
import 'communication_protocols/byte_map_utils/string_byte16.dart';
import 'device/device_failure_level/device_failure_sheet_utils.dart';
import 'flutter_blue/bluetooth_notify_message_parse/parse_last_value_SharedPreferences_utils.dart';
import 'flutter_blue/bluetooth_write_device_message/blue_write_utils.dart';
import 'flutter_blue/bluetooth_write_device_message/write_bluetooth_msg_ping.dart';
import 'flutter_wifi/void/wifi_sub.dart';
import 'getx/blue_device_alarm_message_getx.dart';
import 'getx/blue_device_log_getx.dart';
import 'getx/blue_get_battery_message_get.dart';
import 'getx/blue_write_agreement_getx.dart';
import 'getx/device_connect_type_wifi__blue_get.dart';
import 'getx/update_disbale_run_getx.dart';

///   一直在后台运行    单例模式
class ContinuousTaskManager {
  static final ContinuousTaskManager _instance =
      ContinuousTaskManager._internal();

  factory ContinuousTaskManager() => _instance;

  ContinuousTaskManager._internal();

  Timer? deviceConnectTimer; //1000
  Timer? parsingValueTimer; //50
  Timer? wifiConnectToConnectBlue; //5000

  StreamSubscription<List<int>>? _lastValueSubscription;
  StreamSubscription<BluetoothConnectionState>? _connectionStateSubscription;
  StreamSubscription<BluetoothAdapterState>? _adapterStateSubscription;

  GlobalWiFiBluetooth globalWiFiBluetooth = Get.put(GlobalWiFiBluetooth());
  BlueDeviceLogGet blueDeviceLogGet = Get.put(BlueDeviceLogGet());
  BlueWriteAgreement blueWriteAgreement = Get.put(BlueWriteAgreement());
  UpdateDisableRunGetX updateDisableRunGetX = Get.put(UpdateDisableRunGetX());
  BlueDeviceAlarmMessageGetX blueDeviceAlarmMessageGetX =
      Get.put(BlueDeviceAlarmMessageGetX());
  BlueGetBatteryMessageGetX blueGetBatteryMessageGetX =
      Get.put(BlueGetBatteryMessageGetX());
  DeviceConnectTypeWifiBlueGet deviceConnectTypeWifiBlueGet =
      Get.put(DeviceConnectTypeWifiBlueGet());

  // 在这里定义持续执行的任务
  void startContinuousTask() {
    if (deviceConnectTimer != null) {
      deviceConnectTimer!.cancel();
    }
    if (_connectionStateSubscription != null) {
      _connectionStateSubscription!.cancel();
    }
    if (wifiConnectToConnectBlue != null) {
      wifiConnectToConnectBlue!.cancel();
    }
    if (_lastValueSubscription != null) {
      _lastValueSubscription!.cancel();
    }

    if (parsingValueTimer != null) {
      parsingValueTimer!.cancel();
    }

    deviceConnectTimer =
        Timer.periodic(const Duration(milliseconds: 1000), (_) {
      ///识别WiFi链接状态
      if (deviceConnectTypeWifiBlueGet.client != null &&
          deviceConnectTypeWifiBlueGet.client!.connectionStatus!.state ==
              MqttConnectionState.connected) {
        deviceConnectTypeWifiBlueGet.wifiConnectDeviceVoid(true);
        globalWiFiBluetooth.wifiDisconnectVoid(1);
        // EasyLoading.showToast("status  555");
      } else {
        deviceConnectTypeWifiBlueGet.wifiConnectDeviceVoid(false);
        globalWiFiBluetooth.wifiDisconnectVoid(2);
        // EasyLoading.showToast("status6666");
      }
      ///识别蓝牙连接状态
      if (globalWiFiBluetooth.device != null &&
          _connectionStateSubscription == null) {
        _connectionStateSubscription =
            globalWiFiBluetooth.device!.connectionState.listen((state) async {
          if (state == BluetoothConnectionState.connected) {
            deviceConnectTypeWifiBlueGet.blueConnectDeviceVoid(true);
            // EasyLoading.showToast("status  555");
          } else {
            deviceConnectTypeWifiBlueGet.blueConnectDeviceVoid(false);
            // EasyLoading.showToast("status6666");
          }
        });
      }

      ///判断是否打开手机蓝牙
      if (_adapterStateSubscription == null) {
        BluetoothScanVoid.bluetoothScanVoid(callback: () {
          _adapterStateSubscription = FlutterBluePlus.adapterState
              .listen((BluetoothAdapterState state) {
            if (state == BluetoothAdapterState.on) {
              // 蓝牙已开启，可以进行扫描、连接等操作
              deviceConnectTypeWifiBlueGet.flutterBlueStateVoid(true);
              // EasyLoading.showToast("status");
            } else {
              // 蓝牙未开启，可以提示用户打开蓝牙或执行其他操作
              deviceConnectTypeWifiBlueGet.flutterBlueStateVoid(false);
              // EasyLoading.showToast("status111");
            }
          });
        });
      }

      ///连接协议
      if ((globalWiFiBluetooth.device != null &&
              globalWiFiBluetooth.device!.isConnected &&
              globalWiFiBluetooth.characteristicWrite != null &&
              deviceConnectTypeWifiBlueGet.flutterBlueState.value) ||
          deviceConnectTypeWifiBlueGet.wifiConnectDevice.value) {
        // EasyLoading.showToast("status  555 55 33333 6");
        try {
          BlueWriteUtils.blueWriteUtils(
              WriteBluetoothMsgPing.writeBluetoothMsgPing(),
              globalWiFiBluetooth);

          // ///发送禁止协议
          // if (updateDisableRunGetX.getDisableRun.value == 1) {
          //   BlueWriteUtils.blueWriteUtils(
          //       WriteBluetoothDisableRun.writeBluetoothDisableRun(0),
          //       globalWiFiBluetooth);
          // }
        } catch (e) {
          //
        }
      }

      /// 重连
      if ((globalWiFiBluetooth.device != null &&
          globalWiFiBluetooth.device!.isDisconnected &&
          !deviceConnectTypeWifiBlueGet.wifiConnectDevice.value &&
          !globalWiFiBluetooth.timeOutStatus.value &&
          globalWiFiBluetooth.isDevicePage &&
          !blueWriteAgreement.isUpdateFirmwareAFloat.value)) {
        // isUpdateFirmwareAFloat : 判断是否在升级，在升级就不自动连接

        if (!deviceConnectTypeWifiBlueGet.flutterBlueState.value) {
          return;
        }

        //connectNum 重连次数
        if (globalWiFiBluetooth.connectNum.value < 10) {
          if (globalWiFiBluetooth.connectNum.value == 0) {
            globalWiFiBluetooth
                .connectNumVoid(globalWiFiBluetooth.connectNum.value + 1);
            reconnectDeviceUI();
          }
        }
      }

      /// 故障警告
      if (((globalWiFiBluetooth.device != null &&
                  globalWiFiBluetooth.device!.isConnected) ||
              deviceConnectTypeWifiBlueGet.wifiConnectDevice.value) &&
          !globalWiFiBluetooth.timeOutStatus.value &&
          globalWiFiBluetooth.isDevicePage &&
          !blueWriteAgreement.isUpdateFirmwareAFloat.value) {
        // blueDeviceAlarmMessageGetX.alarmStringDate.toString() == []
        if (blueDeviceAlarmMessageGetX.alarmStringDate.isNotEmpty &&
            blueDeviceAlarmMessageGetX.alarmSheet.value == 0) {
          // blueDeviceAlarmMessageGetX.alarmSheetVoid(1);
          DeviceFailureSheetUtils.deviceFailureSheetUtils(
              blueDeviceAlarmMessageGetX);
        }

        if (blueDeviceAlarmMessageGetX.alarmStringDate.isEmpty &&
            blueDeviceAlarmMessageGetX.alarmSheet.value == 1) {
          blueDeviceAlarmMessageGetX.alarmSheetVoid(2);
          Get.back();
        }
      }

      /// 连接状态下，电量的监听  充电状态下不提示
      if (((globalWiFiBluetooth.device != null &&
                  globalWiFiBluetooth.device!.isConnected &&
                  globalWiFiBluetooth.characteristicWrite != null) ||
              deviceConnectTypeWifiBlueGet.wifiConnectDevice.value) &&
          globalWiFiBluetooth.batteryCharging.value == 0) {
        //电量在10% 和 5% 都提醒一次
        if ((blueGetBatteryMessageGetX.batterySoc.value == 10 ||
                blueGetBatteryMessageGetX.batterySoc.value == 5) &&
            blueGetBatteryMessageGetX.batteryNumTips.value == 0) {
          blueGetBatteryMessageGetX.batteryNumTipsVoid(1);
          EasyLoading.dismiss();
          if (blueGetBatteryMessageGetX.batterySoc.value == 5) {
            EasyLoading.showToast("low_battery_5".tr,
                duration: const Duration(milliseconds: 3000),
                dismissOnTap: true);
          }
          if (blueGetBatteryMessageGetX.batterySoc.value == 10) {
            EasyLoading.showToast("low_battery_10".tr,
                duration: const Duration(milliseconds: 3000),
                dismissOnTap: true);
          }
        }

        if (blueGetBatteryMessageGetX.batterySoc.value != 5 &&
            blueGetBatteryMessageGetX.batterySoc.value != 10) {
          blueGetBatteryMessageGetX.batteryNumTipsVoid(0);
        }
      }
    });

    ///解析蓝牙数据
    parsingValueTimer =
        Timer.periodic(const Duration(milliseconds: 50), (callback) async {
      if (globalWiFiBluetooth.device != null &&
          globalWiFiBluetooth.device!.isConnected &&
          globalWiFiBluetooth.characteristicWrite != null) {
        // print("1111  3333event");
        if (globalWiFiBluetooth.isChangeDevice.value) {
          if (_lastValueSubscription != null) {
            _lastValueSubscription!.cancel();
          }
          _lastValueSubscription = globalWiFiBluetooth
              .characteristicNotify!.lastValueStream
              .listen((event) {
            SharePreferences.sharePreferences(
                "genkinno_flutter_blue_value_list",
                value: event);
          });
          globalWiFiBluetooth.isChangeDeviceVoid(false);
        }

        ParsingLastValueSharedPreferencesUtils.parsingLastValueUtils(
            shareKeys: "genkinno_flutter_blue_value_list");
      } else {
        if (deviceConnectTypeWifiBlueGet.wifiConnectDevice.value &&
            !deviceConnectTypeWifiBlueGet.isListenerAdded.value) {
          deviceConnectTypeWifiBlueGet.isListenerAddedVoid(true);
          WiFiSub.wifiSub(deviceConnectTypeWifiBlueGet, globalWiFiBluetooth);
          // globalWiFiBluetooth.isChangeDeviceVoid(false);
        }

        ParsingLastValueSharedPreferencesUtils.parsingLastValueUtils(
            shareKeys: "genkinno_flutter_blue_value_list");
      }
    });

    ///wifi链接成功后，蓝牙连接
    wifiConnectToConnectBlue =
        Timer.periodic(const Duration(milliseconds: 4000), (_) {
      if (!deviceConnectTypeWifiBlueGet.flutterBlueState.value) {
        return;
      }
      if (deviceConnectTypeWifiBlueGet.wifiConnectDevice.value) {
        if ((globalWiFiBluetooth.device != null &&
                globalWiFiBluetooth.device!.isDisconnected) ||
            globalWiFiBluetooth.device == null) {
          List<int> list;
          String snS =
              globalWiFiBluetooth.addNewDeviceSn.value.substring(0, 4) +
                  globalWiFiBluetooth.addNewDeviceSn.value.substring(8);
          for (ScanResult result in globalWiFiBluetooth.scanResults) {
            try {
              list = [
                ...IntByte.intByte16(
                    result.advertisementData.manufacturerData.keys.first,
                    little: false),
                ...result.advertisementData.manufacturerData.values.first
              ];
              if (StringByte16.byteString(list) == snS) {
                WriteNotifyDeviceUtils.writeNotifyUtils(
                    globalWiFiBluetooth, result.device);
              }
            } catch (e) {
              //
            }
          }
        }
      }
    });
  }

  //重连弹窗
  reconnectDeviceUI() {
    EasyLoading.dismiss();
    Timer.periodic(const Duration(milliseconds: 3000), (timer) {
      //退出页面了，关闭重连弹窗    不在Device页面或者通过wifi链接进来的
      if (!globalWiFiBluetooth.isDevicePage ||
          deviceConnectTypeWifiBlueGet.wifiConnectDevice.value ||
          !deviceConnectTypeWifiBlueGet.flutterBlueState.value) {
        globalWiFiBluetooth.connectNumVoid(0);
        timer.cancel();
        Get.back();
        return;
      }
      //连接成功，关闭重连弹窗
      if (globalWiFiBluetooth.device != null &&
          globalWiFiBluetooth.device!.isConnected) {
        timer.cancel();
        globalWiFiBluetooth.connectNumVoid(0);
        Get.back();
        return;
      }

      //重连操作
      if ((globalWiFiBluetooth.device != null &&
              globalWiFiBluetooth.device!.isDisconnected &&
              !deviceConnectTypeWifiBlueGet.wifiConnectDevice.value) &&
          globalWiFiBluetooth.connectNum.value < 10) {
        globalWiFiBluetooth
            .connectNumVoid(globalWiFiBluetooth.connectNum.value + 1);
        if (globalWiFiBluetooth.connectNum.value >= 10) {
          //重连次数够了
          timer.cancel();
          Get.back();
          globalWiFiBluetooth.connectNumVoid(0);
          globalWiFiBluetooth.isDevicePageVoid(false);
          DisconnectDeviceBluetoothSheetUtils.updatedDialogSheetSuccessUI();
        } else {
          try {
            globalWiFiBluetooth.device!
                .connect(timeout: const Duration(milliseconds: 2500))
                .then((onValue) async {
              //重连成功
              if (globalWiFiBluetooth.device != null &&
                  globalWiFiBluetooth.device!.isConnected) {
                timer.cancel();
                Get.back();
                globalWiFiBluetooth.connectNumVoid(0);
                WriteNotifyDeviceUtils.writeNotifyUtils(
                    globalWiFiBluetooth, globalWiFiBluetooth.device!);
              }
            });
          } catch (e) {
            //
          }
        }
      }
    });

    return Get.dialog(
      Column(
        mainAxisAlignment: MainAxisAlignment.center,
        mainAxisSize: MainAxisSize.min,
        children: [
          Container(
            decoration: BoxDecoration(
                color: Colors.white,
                borderRadius: BorderRadius.circular(10.rpx)),
            // width: 125.rpx,
            clipBehavior: Clip.antiAlias,
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.center,
              children: [
                SizedBox(
                  height: 20.rpx,
                ),
                Container(
                  margin: EdgeInsets.only(
                      right: 25.rpx, left: 25.rpx, bottom: 10.rpx),
                  width: 50.rpx,
                  height: 50.rpx,
                  child: Stack(
                    alignment: Alignment.center,
                    children: [
                      SizedBox(
                        width: 50.rpx,
                        height: 50.rpx,
                        child: const CircularProgressIndicator(
                          color: Colors.black,
                        ),
                      ),
                      Obx(() => Text(
                            "${globalWiFiBluetooth.connectNum.value}",
                            style: StyleTextUtils.textStyle262626(
                                fontWeight: FontWeight.w700, fontSize: 20.rpx),
                          ))
                    ],
                  ),
                ),
                Container(
                  margin: EdgeInsets.only(
                      right: 25.rpx, left: 25.rpx, bottom: 10.rpx),
                  child: Text(
                    "device_reconnecting".tr,
                    style: StyleTextUtils.textStyle262626(),
                  ),
                ),
                SizedBox(
                  height: 5.rpx,
                )
              ],
            ),
          )
        ],
      ),
      barrierDismissible: false,
    );
  }

  // 停止持续执行的任务
  void stopContinuousTask() {
    // 在这里停止你的持续执行的任务
    if (deviceConnectTimer != null) {
      deviceConnectTimer!.cancel();
    }
    if (wifiConnectToConnectBlue != null) {
      wifiConnectToConnectBlue!.cancel();
    }
    if (_lastValueSubscription != null) {
      _lastValueSubscription!.cancel();
    }
    if (_connectionStateSubscription != null) {
      _connectionStateSubscription!.cancel();
    }
    if (_adapterStateSubscription != null) {
      _adapterStateSubscription!.cancel();
    }
    if (parsingValueTimer != null) {
      parsingValueTimer!.cancel();
    }
  }
}

///   一直在后台运行    线程模式
// void backgroundTask(SendPort sendPort) {
//   Timer.periodic(const Duration(seconds: 5), (Timer t) {
//     // 这里是后台任务的逻辑，可以是任何你需要执行的任务
//     sendPort.send("Background task is running...");
//   });
// }
万 志 鹏
关注
Flutter开发 - 单例的使用，教你如何玩转单例，全局传参，根据环境传参
CodingFire的博客
07-30 1763
单例在各个开发平台都有使用的场景，可以用于定义一些全局的参数和保存生命周期内的一些数据。那么在Flutter中单例该怎么使用呢？博主百度了下，找到的大多数都是类似这样的写法： class Manager { // 工厂模式 factory Manager() =>_getInstance() static Manager get instance => _getInstance(); static Manager _instance; Manager._internal()
【Flutter】设计模式（更新）
sheng_er_sheng的博客
06-13 536
flutter 设计模式
Flutter： 单例
青蛙不吃草
08-31 1426
单例一般有这几个特征： 隐藏类的构造函数 提供一个方法获取该类的实例 该实例只能被创建一次，内存中独一份，任何地方通过调用特征2中所述方法获取到的实例都应该是同一个 实现单例 class BluetoothWidgetIos { //通过私有的具造方法_internal()隐藏了构造方法 BluetoothWidgetIos._internal() { init(); } // static final修饰了_singleton，_singleton会在编译期被初始化，保证
Flutter-单例模式
Abner_leader的博客
03-31 5122
Flutter-单例模式什么是单例模式？Flutter-单例identical 和 == 的区别identical== 什么是单例模式？ 单例模式(Singleton pattern)是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。 Flutter-单例 void main() { var one =
Flutter单例对象的使用
最新发布
2302_76222359的博客
03-26 363
检查本地缓存：通过单例类GlobalUser来存储Person对象。减少重复请求：在调用时，先检查单例类中是否已经存在用户数据，只有在数据为空的情况下，才向后端请求，避免重复加载。这样可以有效避免重复请求后端数据，提升应用的性能。
flutter 单例模式
weixin_44911775的博客
03-25 935
通过这些方式,我们确保了只有一个 ZeGoCallPayUtils 实例会被创建。确保整个应用程序中只有一个 TranslationService 实例。为整个应用程序提供一个全局访问点,方便在不同地方使用同一个实例。避免重复创建相同的实例,节省资源。2.然后用构造函数赋值给实例。3.其他地方调用时返回实例。
用Flutter写一个单例
代码小疯子
05-07 798
在Flutter中创建单例可以使用Dart语言中的静态变量和工厂方法的组合来实现
flutter - 设计模式-单例模式
ifredom
10-21 1773
单例模式 效果： 单例模式.无论创建多少个实例，都只返回同一个实例. 只暴露你想暴露的公共成员和方法.(此处公共成员为：instanceVar,公共方法为instanceFun) 使用场景： dart-单例 准确来说，此单例模式是使用Dart编写，用 Dart作为标题更好，不过flutter跟Dart是一家，不用分彼此。 import 'package:flutter/material.d...
flutter 单例实现与factory
tianya1800的博客
08-12 2325
以前一直是复制粘贴，如今有点时间了，开始回头思考一些理所当然的代码，说实话，单例用了很久了，但是依然不知道为啥这么用，今天好好总结下，好摆脱只会复制粘贴的小白。工厂方法构造函数:如果一个构造函数不总是返回一个新对象，则用foctory来定义这个构造函数。例如一个工厂构造函数，可能从缓存中获取一个实例并返回，或者返回一个子类型的实例。使用单例本身目的在于创建一个唯一的对象，避免该对象可能会出现多头使用，造成数据冲突，还一个好处-----减少内存消耗。...
掌握Flutter单例模式的实现与应用
资源摘要信息:"在Flutter开发中，单例模式是一种常见的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。单例模式在Flutter中主要用于管理全局状态、配置信息、全局服务等。由于Flutter本身是一个无...
Flutter(dart)/Java 实现单例模式
qq_52084136的博客
08-04 658
Flutter（dart） 中提供了一种十分方便的方式让我们来实现单列模式： class Singleton { static final Singleton _singleton = Singleton._internal(); factory Singleton() { return _singleton; } Singleton._internal(); } Java中单例模式实现方式就比较多了，分为线程安全和非线程安全的，一般来讲，大部分场景都是需要线程安全的
flutter单例设计模式
haoxuhong的博客
08-02 681
单例设计模式(Singleton Design Pattern) 理解起来非常简单。 一个类只允许创建一个实例，那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。 作为最简单的一种设计模式之一，对于单例本身的概念，大家一看就能明白，但在某些情况下也很容易使用不恰当。相比其他语言，Dart 和 Flutter 中的单例模式也不尽相同，本篇文章我们就一起探究看看它在 Dart 和 Flutter 中的应用。 Flutter(able) 的单例模式 一般来说，要在代码中使用单.
白嫖系列之Flutter--单例
DadaCockWire的博客
08-24 461
#<<秃强>>Flutter之单例 网上已经有很多Flutter的单例模式的例子,至于为什么写,那是因为cv都碰到了问题,没办法,自己还得搞一遍,主要还是新版本的判空机制引起的 文章目录饿汉式懒汉式预加载模式扩展 饿汉式 class Singleton { // 静态私有成员，没有初始化 static final Singleton _instance = Singleton._(); //公开访问点 factory Singleton.getInst
Flutter，Dart的单例模式
challenge51all的专栏
11-11 543
在Flutter中，单例模式是一种常见的设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点。单例模式通常用于管理应用程序中的共享资源，如网络请求、数据库连接和设置。
Flutter设计模式全面解析：单例模式
mzxj7255的博客
05-21 1265
谈到设计模式这个“古老”的话题，大家先别急着划走哈，虽然对它再熟悉不过，几乎是最初开始学习编程到现在伴随着我们整个编程生涯，最早JavaC++语言实现的各种设计模式到现在还会经常有所接触，面试中也是必问的环节，在开发Flutter项目的时候，也会多少借鉴了其它语言设计模式的实现，但始终觉得dart语言实现的设计模式理解不够系统，有的实现还缺点儿dart语言本身的语法特性。加上最近在看一些Flutter框架及常用第三方插件的源码时候，发现这些源码背后或多或少都有设计模式的影子。
Flutter 单例的写法及理解注释
iOSTianNan的博客
08-14 905
网络上的写法很多,借鉴了其中的一种 主要还是看注释吧, 留作记录,防止那天脑子抽抽又给忘记了… import 'package:dio/dio.dart'; import 'dart:io'; import 'dart:math'; /// ------------------------------- /// Created with Flutter Dart File. /// User tianNanYiHao@163.com /// Date: 2020-08-14 /// Time: 14:5
Flutter中单例模式理解及举例
可可的博客
06-01 3637
dart单例模式
Flutter之单例模式的四种方法
weixin_43244083的博客
07-07 2471
单例模式：一个类只允许创建一个实例，那么这个类就是单例类，这种设计模式叫做单例模式。
Flutter 单例模式的多种实现方法与使用场景分析
爱喝水程序员的博客
04-08 1325
单例模式是一种常用的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。在Flutter应用程序中，单例模式可以有效地管理全局状态、资源共享和对象的生命周期。本文将介绍Flutter中实现单例模式的多种方法，并分析它们的使用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值