Condivisione della tecnologia

Diversi modi in cui Flutter può implementare l'aggiornamento parziale

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Sommario

Prefazione

1. L'importanza del rinnovamento locale

1. Concetto

2. Importanza

2. Diversi modi per implementare l'aggiornamento parziale

1. Utilizzare il metodo setState per l'aggiornamento parziale

2. Utilizzare StatefulWidget e InheritedWidget per aggiornare parzialmente l'interfaccia utente

3.ValueNotifier e ValueListenableBuilder

4.Costruttore di flussi

5. Fornitore

6.OttieniX

7. Utilizzare GlobalKey

Prefazione

In Flutter, la gestione dello stato si riferisce a come gestire e aggiornare lo stato dei dati nell'applicazione e aggiornare l'interfaccia utente in base ai cambiamenti di stato. Una gestione efficace dello stato può aiutare gli sviluppatori a creare applicazioni più efficienti e gestibili.

setState è il metodo di gestione dello stato più basilare in Flutter. Quando lo stato cambia, al framework verrà inviata una notifica per ricostruire l'interfaccia utente. Naturalmente sappiamo che quando chiamiamo il metodo setState, la pagina verrà ridisegnata. Quando il layout della pagina è più complesso, a volte dobbiamo solo aggiornare un'interfaccia utente separata. In questo momento, se utilizziamo il metodo setState, avrà prestazioni migliori. Consuma per ridisegnare l'interfaccia utente della pagina corrente.

Quali metodi sono disponibili in Flutter per aggiornare parzialmente l'interfaccia utente? Questo blog elenca diversi modi in cui Flutter può implementare l'aggiornamento parziale?

1. L'importanza del rinnovamento locale

1. Concetto

L'aggiornamento parziale si riferisce all'aggiornamento solo di una parte dell'interfaccia, non dell'intera pagina. Ciò migliora le prestazioni e l'esperienza dell'utente.

2. Importanza

  1. Evita ridisegnazioni non necessarie e migliora le prestazioni
  2. Fornire un'esperienza utente più fluida
  3. Ridurre il consumo di risorse

2. Diversi modi per implementare l'aggiornamento parziale

1. Utilizzare il metodo setState per l'aggiornamento parziale

setState è il metodo di gestione dello stato più comunemente utilizzato in Flutter. Viene utilizzato per notificare al framework le modifiche dello stato, portando alla ricostruzione dell'interfaccia.

Quando creiamo un progetto Flutter, l'esempio del timer generato dal sistema per impostazione predefinita è l'esempio dell'aggiornamento parziale setState.

  1. import 'package:flutter/material.dart';
  2.  
  3. class SetStateMainPage extends StatefulWidget {
  4.   final String title;
  5.   const SetStateMainPage({super.key, required this.title});
  6.  
  7.   @override
  8.   State<SetStateMainPage> createState() => _SetStateMainPageMainPageState();
  9. }
  10.  
  11. class _SetStateMainPageMainPageState extends State<SetStateMainPage> {
  12.   int _count = 0;
  13.  
  14.   @override
  15.   Widget build(BuildContext context) {
  16.     return Scaffold(
  17.       appBar: AppBar(
  18.         title: Text(widget.title),
  19.       ),
  20.       body: Center(
  21.         child: Text(
  22.           '您点击了$_count次',
  23.           style: const TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
  24.         ),
  25.       ),
  26.       floatingActionButton: FloatingActionButton(
  27.           child: const Icon(Icons.add),
  28.           onPressed: () {
  29.             setState(() {
  30.               _count++;
  31.             });
  32.           },
  33.       )
  34.     );
  35.   }
  36. }

Figura 1.setState aggiornamento parziale

Quando la pagina è relativamente semplice, puoi utilizzare direttamente il metodo setState per aggiornare parzialmente l'interfaccia utente.

Scenari di utilizzo: semplici modifiche di stato, come conteggio dei clic sui pulsanti, cambio di stato, ecc.

Precauzioni:

  1. Le chiamate frequenti a setState possono causare problemi di prestazioni
  2. Evitare di chiamare setState nel metodo build

2. Utilizzare StatefulWidget e InheritedWidget per aggiornare parzialmente l'interfaccia utente

        StatefulWidget è un componente con stato,InheritedWidget Utilizzato per condividere i dati all'interno dell'albero dei componenti.

Quando dobbiamo condividere dati, possiamo considerare StatefulWidget e InheritedWidget per aggiornare parzialmente l'interfaccia utente.

Il codice completo è il seguente:

Figura 2. Aggiorna l'interfaccia utente condividendo i dati

  1. import 'package:flutter/material.dart';
  2.  
  3. class MyInheritedWidget extends InheritedWidget {
  4.   final int counter;
  5.   const MyInheritedWidget({
  6.     super.key,
  7.     required this.counter,
  8.     required super.child,
  9.   });
  10.   @override
  11.   bool updateShouldNotify(covariant InheritedWidget oldWidget) {
  12.     return true;
  13.   }
  14.   static MyInheritedWidget? of(BuildContext context) {
  15.     return context.dependOnInheritedWidgetOfExactType<MyInheritedWidget>();
  16.   }
  17. }
  18.  
  19. class InheritedWidgetPage extends StatefulWidget {
  20.   final String title;
  21.   const InheritedWidgetPage({super.key, required this.title});
  22.  
  23.   @override
  24.   State<InheritedWidgetPage> createState() => _InheritedWidgetPageState();
  25. }
  26.  
  27. class _InheritedWidgetPageState extends State<InheritedWidgetPage> {
  28.   int counter = 0;
  29.   void _incrementCounter() {
  30.     setState(() {
  31.       counter++;
  32.     });
  33.   }
  34.  
  35.   @override
  36.   Widget build(BuildContext context) {
  37.     return MyInheritedWidget(
  38.       counter: counter,
  39.       child: Scaffold(
  40.         appBar: AppBar(
  41.           title: Text(widget.title),
  42.         ),
  43.         body: Center(child: Column(
  44.           children: [
  45.             const Divider(),
  46.             const CounterDisplay(),
  47.             const SizedBox(height: 20),
  48.             ElevatedButton(
  49.               onPressed: _incrementCounter,
  50.               child: const Text('add'),
  51.             ),
  52.           ],
  53.         ),),
  54.       ),
  55.     );
  56.   }
  57. }
  58.  
  59. class CounterDisplay extends StatelessWidget {
  60.   const CounterDisplay({super.key});
  61.   @override
  62.   Widget build(BuildContext context) {
  63.     final inheritedWidget = MyInheritedWidget.of(context);
  64.     return Text('点击次数: ${inheritedWidget?.counter}');
  65.   }
  66. }

I principali scenari di utilizzo di questo metodo sono i seguenti: quando si condivide lo stato nell'albero dei componenti, come tema, impostazioni della lingua, ecc.

Il vantaggio è che la condivisione dei dati è conveniente e l'introduzione del codice

Lo svantaggio è che è complicato da usare e le prestazioni potrebbero risentirne.

3.ValueNotifier e ValueListenableBuilder

        ValueNotifier È un semplice strumento di gestione dello stato,ValueListenableBuilder per il monitoraggioValueNotifier Il cambiamento.

Anche l'utilizzo è molto semplice:

1. Istanziare ValueNotifier

2. L'oggetto Widget da monitorare viene racchiuso con ValueListenableBuilder

3. Come modificare i dati attivati ​​da eventi

Rispetto ai metodi precedenti, questo metodo è molto semplice e facile da usare e anche le sue prestazioni sono molto elevate.

Svantaggi: può gestire solo semplici cambiamenti di stato

Il codice completo è il seguente:

  1. import 'package:flutter/material.dart';
  2.  
  3. class ValueNotifierPage extends StatefulWidget {
  4.   final String title;
  5.   const ValueNotifierPage({super.key, required this.title});
  6.  
  7.   @override
  8.   State<ValueNotifierPage> createState() => _ValueNotifierPageState();
  9. }
  10.  
  11. class _ValueNotifierPageState extends State<ValueNotifierPage> {
  12.  
  13.   final ValueNotifier<int> _counter = ValueNotifier<int>(0);
  14.  
  15.   @override
  16.   Widget build(BuildContext context) {
  17.     return Scaffold(
  18.         appBar: AppBar(
  19.           title: Text(widget.title),
  20.         ),
  21.         body: Center(
  22.           child: ValueListenableBuilder<int>(
  23.             valueListenable: _counter,
  24.             builder: (context, value, child) {
  25.               return Text(
  26.                 '您点击了$value次',
  27.                 style: const TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
  28.               );
  29.             },
  30.           )
  31.         ),
  32.         floatingActionButton: FloatingActionButton(
  33.           child: const Icon(Icons.add),
  34.           onPressed: () {
  35.             _counter.value ++;
  36.           },
  37.         )
  38.     );
  39.   }
  40. }

4.Costruttore di flussi

Stream è un oggetto utilizzato per fornire eventi asincroni e gli eventi possono essere inviati tramite StreamController. Se è necessario aggiornare l'interfaccia utente, è possibile inviare un evento allo stream e quindi utilizzare StreamBuilder per ascoltare lo stream. Quando viene ricevuto un nuovo evento, StreamBuilder ricostruirà automaticamente l'interfaccia utente. Questo metodo è adatto per situazioni in cui è necessario monitorare più eventi asincroni.

Quando dobbiamo elaborare flussi di dati asincroni, come richieste di rete, dati in tempo reale, ecc., possiamo prendere in considerazione l'utilizzo di StreamBuilder. Ad esempio, nell'esempio seguente, abbiamo scritto un metodo asincrono che simula una richiesta di rete. Quando la richiesta di rete non restituisce il risultato corretto, possiamo caricare la barra di avanzamento.

Il vantaggio di questo metodo è che può controllare in modo più accurato le richieste asincrone, come lo stato delle richieste di rete, ecc. Tuttavia, Dior è più complesso e potrebbe richiedere più codice.

Il codice completo è il seguente:

  1. import 'dart:async';
  2. import 'package:flutter/material.dart';
  3.  
  4. class StreamBuilderRefreshUIPage extends StatefulWidget {
  5.   final String title;
  6.   const StreamBuilderRefreshUIPage({super.key, required this.title});
  7.  
  8.   @override
  9.   State<StreamBuilderRefreshUIPage> createState() =>
  10.       _StreamBuilderRefreshUIPageState();
  11. }
  12.  
  13. class _StreamBuilderRefreshUIPageState extends State<StreamBuilderRefreshUIPage> {
  14.   late Future<String> _data;
  15.  
  16.   Future<String> fetchData() async {
  17.     // 模拟网络请求延迟
  18.     await Future.delayed(const Duration(seconds: 2));
  19.     // 返回模拟数据
  20.     return 'Hello, Flutter!';
  21.   }
  22.  
  23.   @override
  24.   void initState() {
  25.     // TODO: implement initState
  26.     super.initState();
  27.     _data = fetchData();
  28.   }
  29.  
  30.   @override
  31.   Widget build(BuildContext context) {
  32.     return Scaffold(
  33.       appBar: AppBar(
  34.         title: Text(widget.title),
  35.       ),
  36.       body: Center(
  37.         child: FutureBuilder<String>(
  38.           future: _data,
  39.           builder: (context, snapshot) {
  40.             if (snapshot.connectionState == ConnectionState.waiting) {
  41.               return const CircularProgressIndicator();
  42.             } else if (snapshot.hasError) {
  43.               return Text('Error: ${snapshot.error}');
  44.             } else {
  45.               return Text('Data: ${snapshot.data}');
  46.             }
  47.           },
  48.         ),
  49.       ),
  50.       floatingActionButton: FloatingActionButton(
  51.         onPressed: fetchData,
  52.         tooltip: 'Increment',
  53.         child: const Icon(Icons.add),
  54.       ),
  55.     );
  56.   }
  57. }

5. Fornitore

       Provider È una soluzione di gestione dello stato consigliata da Flutter.Consumer Utilizzato per leggere e monitorare lo stato.

Prendiamo come esempio anche il timer.

1. Per prima cosa importiamo Provider.

fornitore: ^6.1.2

2. Personalizza la classe ChangeNotifier.

ChangeNotifier è una classe semplice nell'SDK di Flutter. Viene utilizzato per inviare notifiche agli ascoltatori. In altre parole, se definito come ChangeNotifier, puoi iscriverti ai suoi cambiamenti di stato. (Questo è simile al modello familiare dell'osservatore).

Nel codice che vogliamo implementare sono presenti due variabili _counter1 e _counter2. Il codice è definito come segue:

  1. class CounterModel extends ChangeNotifier {
  2.   int _counter1 = 0;
  3.   int _counter2 = 0;
  4.   void addCounter1(){
  5.     debugPrint('counter:$_counter1');
  6.     _counter1 += 1;
  7.     notifyListeners();
  8.   }
  9.   void addCounter2(){
  10.     debugPrint('counter:$_counter2');
  11.     _counter2 += 1;
  12.     notifyListeners();
  13.   }
  14. }

3. Utilizza Customer per racchiudere il widget che vogliamo aggiornare

  1.             Consumer<CounterModel>(
  2.               builder: (context, counterModel, child) {
  3.                 return Row(
  4.                   mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  5.                   children: [
  6.                     Text('计数器1个数: ${counterModel._counter1}'),
  7.                     ElevatedButton(onPressed: (){
  8.                       counterModel.addCounter1();
  9.                     }, child: const Icon(Icons.add),),
  10.                   ],
  11.                 );
  12.               },
  13.             ),

4. Il codice completo è il seguente:

  1. import 'package:flutter/material.dart';
  2. import 'package:provider/provider.dart';
  3.  
  4. class ProviderRefreshPage extends StatefulWidget {
  5.   final String title;
  6.   const ProviderRefreshPage({super.key, required this.title});
  7.  
  8.   @override
  9.   State<ProviderRefreshPage> createState() => _ProviderRefreshPageState();
  10. }
  11.  
  12. class CounterModel extends ChangeNotifier {
  13.   int _counter1 = 0;
  14.   int _counter2 = 0;
  15.   void addCounter1(){
  16.     debugPrint('counter:$_counter1');
  17.     _counter1 += 1;
  18.     notifyListeners();
  19.   }
  20.   void addCounter2(){
  21.     debugPrint('counter:$_counter2');
  22.     _counter2 += 1;
  23.     notifyListeners();
  24.   }
  25. }
  26.  
  27. class _ProviderRefreshPageState extends State<ProviderRefreshPage> {
  28.  
  29.   @override
  30.   Widget build(BuildContext context) {
  31.     return Scaffold(
  32.       appBar: AppBar(
  33.         title: Text(widget.title),
  34.       ),
  35.       body: Center(
  36.         child: Column(
  37.           mainAxisAlignment: MainAxisAlignment.start,
  38.           children: <Widget>[
  39.             const SizedBox(height: 10,), // 添加一些间距
  40.             const Divider(),
  41.             const Text('计数器实例',style: TextStyle(fontSize: 12,fontWeight: FontWeight.bold),),
  42.             Consumer<CounterModel>(
  43.               builder: (context, counterModel, child) {
  44.                 return Row(
  45.                   mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  46.                   children: [
  47.                     Text('计数器1个数: ${counterModel._counter1}'),
  48.                     ElevatedButton(onPressed: (){
  49.                       counterModel.addCounter1();
  50.                     }, child: const Icon(Icons.add),),
  51.                   ],
  52.                 );
  53.               },
  54.             ),
  55.  
  56.             Consumer<CounterModel>(
  57.               builder: (context, counterModel, child) {
  58.                 return Row(
  59.                   mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  60.                   children: [
  61.                     Text('计数器1个数: ${counterModel._counter2}'),
  62.                     ElevatedButton(onPressed: (){
  63.                       counterModel.addCounter2();
  64.                     }, child: const Icon(Icons.add),),
  65.                   ],
  66.                 );
  67.               },
  68.             ),
  69.             const Divider(height: 20,),
  70.           ],
  71.         ),
  72.       ),
  73.     );
  74.   }
  75. }

6.OttieniX

Possiamo anche utilizzare GetX per implementare un aggiornamento parziale dell'interfaccia utente.

Per prima cosa installa GetX:

get: ^4.6.6

Quindi incapsuliamo le variabili in GetxController.

  1. class CounterManagerController extends GetxController {
  2.   final counter1 = 0.obs;
  3.   final counter2 = 0.obs;
  4.   void incrementCount1() {
  5.     counter1.value++;
  6.   }
  7.   void incrementCount2() {
  8.     counter2.value++;
  9.   }
  10. }

Quindi usa Obx per avvolgere il widget che deve visualizzare la logica.

Obx(()=&gt; Text('Numero contatore 1: ${controller.counter2.value}'))

Il codice completo è il seguente:

  1. import 'package:flutter/material.dart';
  2. import 'package:get/get.dart';
  3.  
  4.  
  5. class CounterManagerController extends GetxController {
  6.   final counter1 = 0.obs;
  7.   final counter2 = 0.obs;
  8.   void incrementCount1() {
  9.     counter1.value++;
  10.   }
  11.   void incrementCount2() {
  12.     counter2.value++;
  13.   }
  14. }
  15.  
  16. class GetXRefreshUIPage extends StatelessWidget {
  17.   final String title;
  18.   const GetXRefreshUIPage({super.key, required this.title});
  19.  
  20.   @override
  21.   Widget build(BuildContext context) {
  22.     final CounterManagerController controller = Get.put(CounterManagerController());
  23.     return Scaffold(
  24.       appBar: AppBar(
  25.         title: Text(title),
  26.       ),
  27.       body: Center(
  28.         child: Column(
  29.           mainAxisAlignment: MainAxisAlignment.start,
  30.           children: <Widget>[
  31.             const SizedBox(
  32.               height: 10,
  33.             ), // 添加一些间距
  34.             const Divider(),
  35.             const Text(
  36.               '计数器实例',
  37.               style: TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
  38.             ),
  39.             Row(
  40.               mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  41.               children: [
  42.                 Obx(()=> Text('计数器1个数: ${controller.counter1.value}')),
  43.                 ElevatedButton(
  44.                   onPressed: () {
  45.                     controller.incrementCount1();
  46.                   },
  47.                   child: const Icon(Icons.add),
  48.                 ),
  49.               ],
  50.             ),
  51.             Row(
  52.               mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  53.               children: [
  54.                 Obx(()=> Text('计数器1个数: ${controller.counter2.value}')),
  55.                 ElevatedButton(
  56.                   onPressed: () {
  57.                     controller.incrementCount2();
  58.                   },
  59.                   child: const Icon(Icons.add),
  60.                 ),
  61.               ],
  62.             ),
  63.             const Divider(
  64.               height: 20,
  65.             ),
  66.           ],
  67.         ),
  68.       ),
  69.     );
  70.   }
  71. }

Naturalmente, ci sono molti altri modi per implementare l'aggiornamento parziale in GetX. Puoi dare un'occhiata alla sua documentazione. Ecco solo un'idea di implementazione.

7. Utilizzare GlobalKey

I tre metodi di implementazione precedenti sono tutti implementati tramite il framework Se non si desidera importare questo framework, è possibile utilizzare GlobalKey per implementare la funzione di aggiornamento parziale dell'interfaccia utente.

Una chiave univoca in tutta l'applicazione GlobalKey identifica in modo univoco gli elementi GlobalKey fornisce l'accesso agli elementi associati, ad esempioBuildContext .perStatefulWidgets, GlobalKey fornisce ancheStateAccesso.

Nella nostra demo del timer, se aggiorniamo parzialmente l'interfaccia utente tramite GlobalKey, prima estraiamo il widget da aggiornare parzialmente e lo incapsuliamo in un componente separato.

Il codice completo è il seguente. Incapsuliamo il Widget da aggiornare parzialmente e forniamo un'interfaccia per l'aggiornamento dei dati interni, onPressed.

  1. class CounterText extends StatefulWidget {
  2.   const CounterText(Key key) : super(key: key);
  3.   @override
  4.   State<StatefulWidget> createState() {
  5.     return CounterTextState();
  6.   }
  7. }
  8.  
  9. class CounterTextState extends State<CounterText> {
  10.   String _text="0";
  11.  
  12.   @override
  13.   Widget build(BuildContext context) {
  14.     return Center(
  15.       child: Text(_text,style: const TextStyle(fontSize: 20),),
  16.     );
  17.   }
  18.   void onPressed(int count) {
  19.     setState(() {
  20.       _text = count.toString();
  21.     });
  22.   }
  23. }

Quindi istanzia GlobaKey nella nostra interfaccia principale:

  1.   int _count   = 0;
  2.   int _count2  = 0;
  3.   GlobalKey<CounterTextState> textKey = GlobalKey();
  4.   GlobalKey<CounterTextState> textKey2 = GlobalKey();

Nel caso in cui sia necessario aggiornare l'interfaccia utente, richiamare l'interfaccia fornita nel passaggio precedente tramite GlobalKey e aggiornare.

Il codice completo è il seguente:

  1. import 'package:flutter/material.dart';
  2.  
  3. class GlobalKeyRefreshPage extends StatefulWidget {
  4.   final String title;
  5.   const GlobalKeyRefreshPage({super.key, required this.title});
  6.  
  7.   @override
  8.   State<GlobalKeyRefreshPage> createState() => _GlobalKeyRefreshPageState();
  9. }
  10.  
  11. class _GlobalKeyRefreshPageState extends State<GlobalKeyRefreshPage> {
  12.   int _count   = 0;
  13.   int _count2  = 0;
  14. //包裹你定义的需要更新的weight
  15.   GlobalKey<CounterTextState> textKey = GlobalKey();
  16.   GlobalKey<CounterTextState> textKey2 = GlobalKey();
  17.  
  18.   @override
  19.   Widget build(BuildContext context) {
  20.     return Scaffold(
  21.       appBar: AppBar(
  22.         title:  Text(widget.title),
  23.       ),
  24.       body: Center(
  25.         child: Column(
  26.           mainAxisAlignment: MainAxisAlignment.start,
  27.           children: <Widget>[
  28.             const SizedBox(
  29.               height: 10,
  30.             ), // 添加一些间距
  31.             const Divider(),
  32.             const Text(
  33.               '计数器实例',
  34.               style: TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
  35.             ),
  36.             Row(
  37.               mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  38.               children: [
  39.                 CounterText(textKey),
  40.                 ElevatedButton(
  41.                   onPressed: () {
  42.                     _count++;
  43.                     textKey.currentState?.onPressed(_count);
  44.                   },
  45.                   child: const Icon(Icons.add),
  46.                 ),
  47.               ],
  48.             ),
  49.             Row(
  50.               mainAxisAlignment: MainAxisAlignment.spaceEvenly,
  51.               children: [
  52.                 CounterText(textKey2),
  53.                 ElevatedButton(
  54.                   onPressed: () {
  55.                     _count2++;
  56.                     textKey2.currentState?.onPressed(_count2);
  57.                   },
  58.                   child: const Icon(Icons.add),
  59.                 ),
  60.               ],
  61.             ),
  62.             const Divider(
  63.               height: 20,
  64.             ),
  65.           ],
  66.         ),
  67.       ),
  68.     );
  69.   }
  70. }
  71.  
  72.  
  73. class CounterText extends StatefulWidget {
  74.   const CounterText(Key key) : super(key: key);
  75.   @override
  76.   State<StatefulWidget> createState() {
  77.     return CounterTextState();
  78.   }
  79. }
  80.  
  81. class CounterTextState extends State<CounterText> {
  82.   String _text="0";
  83.  
  84.   @override
  85.   Widget build(BuildContext context) {
  86.     return Center(
  87.       child: Text(_text,style: const TextStyle(fontSize: 20),),
  88.     );
  89.   }
  90.   void onPressed(int count) {
  91.     setState(() {
  92.       _text = count.toString();
  93.     });
  94.   }
  95. }

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta