Guide d'adaptation de la bibliothèque drift_postgres pour HarmonyOS - Faire fonctionner une base de données PostgreSQL sur HarmonyOS avec des requêtes SQL fortement typées et un stockage distribué haute performance

Introduction

Dans le développement d'applications OpenHarmony, la persistance des données repose généralement sur des bases de données légères locales. Cependant, pour certains scénarios nécessitant une synchronisation approfondie avec une backend PostgreSQL ou une analyse de données hors ligne à grande échelle, l'utilisation traditionnelle de SQLite montre ses limites. La bibliothèque drift_postgres, en tant que pilote PostgreSQL pour le framework de base de données de premier plan drift (anciennement moor) de la communauté Flutter, offre aux développeurs HarmonyOS une solution industrielle pour interagir directement avec Postgres depuis le client. Cet article détaille comment porter cet outil puissant sur la plateforme HarmonyOS, réalisant ainsi une unification de l'architecture des données du client au cloud.

I. Analyse des principes / Concepts de base

1.1 Principes fondamentaux / Concepts de base

drift_postgres ne fait pas tourner un serveur PostgreSQL complet sur l'appareil, mais utilise plutôt le protocole du pilote postgres pour convertir le code Dart fortement généré par drift en instructions SQL compatibles PostgreSQL. Il agit comme une couche d'adaptation abstraite, permettant aux développeurs d'opérer sur la base de données comme s'ils manipulaient des objets.

1.2 Pourquoi l'utiliser sur HarmonyOS ?

1. Adoption rapide : Réutilisation complète du modèle de développement drift, si vous savez utiliser la version SQLite, vous pouvez l'adopter en un instant.
2. Requêtes hautes performances : Utilisation des optimisations d'index spécifiques à Postgres et du traitement JSONB, largement supérieures aux bases de données locales standard.
3. Collaboration multiplateforme HarmonyOS : Dans l'environnement distribué HarmonyOS, Postgres permet une synchronisation de données en temps réel entre plusieurs appareils.

II. Guide de base pour HarmonyOS

2.1 Situation d'adaptation

En raison de sa dépendance sous-jacente au pilote postgres pour la communication par socket, il est nécessaire de configurer les autorisations réseau sur la plateforme OpenHarmony.

1. Prise en charge native : Oui. La bibliothèque Socket principale de Dart fonctionne bien sur HarmonyOS.
2. Prise en charge officielle HarmonyOS : Non officielle, réalisée par la communauté.
3. Dépendances d'adaptasion : Il faut s'assurer que l'autorisation ohos.permission.INTERNET est activée dans module.json5 pour garantir que les connexions à la base de données ne soient pas interceptées par le système.

2.2 Code d'adaptation

Ajoutez les dépendances suivantes dans votre fichier pubspec.yaml :

dependencies:
  drift: ^2.0.0
  drift_postgres: ^2.0.0
  postgres: ^3.0.0 # Pilote de protocole sous-jacent

Dans un projet HarmonyOS, il est recommandé d'utiliser des connexions chiffrées tls pour respecter les normes de sécurité des appplications HarmonyOS.

III. Détail des API principales / Composants

3.1 Prise en main rapide et méthodes principales

3.2 Configuration de base

Nous devons définir la structure des tables de la base de données côté HarmonyOS et initialiser le pool de connexions PostgreSQL.

import 'package:drift/drift.dart';
import 'package:drift_postgres/drift_postgres.dart';
import 'package:postgres/postgres.dart';

// Définition d'une table de mémos HarmonyOS
class Notes extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get titre => text().withLength(min: 1, max: 200)();
  TextColumn get contenu => text().named('corps')();
}

@DriftDatabase(tables: [Notes])
class BaseDeDonneesApp extends _$BaseDeDonneesApp {
  // Étape 1 : Construire la connexion Postgres adaptée pour HarmonyOS
  BaseDeDonneesApp() : super(PgDatabase(
    PointAcces(
      hote: 'votre.db.harmony.com', // Peut aussi être une adresse IP de conteneur local
      baseDeDonnees: 'db_app_harmony',
      utilisateur: 'administrateur',
      motDePasse: 'motdepasse_123456',
    ),
    parametres: const ParametresConnexion(
      modeSsl: ModeSsl.exiger, # Recommandation de sécurité HarmonyOS pour activer SSL
    ),
  ));

  @override
  int get versionSchema => 1;
}

3.3 Personnalisation avancée : Gestion de types personnalisés

Pour les types de données spécifiques côté HarmonyOS (comme les coordonnées de journalisation), nous pouvons utiliser la fonction de mappage de types de drift_postgres.

// Adaptation pour le type JSONB spécifique à Postgres
class ConvertisseurPosition extends TypeConverter<map dynamic="">, String> {
  const ConvertisseurPosition();
  @override
  Map<string dynamic=""> depuisSql(String depuisDb) => json.decode(depuisDb);
  @override
  String versSql(Map<string dynamic=""> valeur) => json.encode(valeur);
}

// Utilisation du convertisseur personnalisé dans la définition de table pour stocker les informations de position des appareils HarmonyOS
class Appareils extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get donneesSupplementaires => text().map(const ConvertisseurPosition())();
}
</string></string></map>

IV. Scénarios d'application typiques

4.1 Scénario 1 : Synchronisation hors ligne des commandes pour une version HarmonyOS d'une grande plateforme e-commerce

Lorsque l'utilisateur opère sur son téléphone HarmonyOS avec un réseau instable (comme dans un ascenseur), drift_postgres peut mettre en cache localement les données, puis, une fois le réseau rétabli, utiliser son mécanisme de transactions pour synchroniser par lots vers la base principale.

// Logique pratique de synchronisation par lots des données de commandes HarmonyOS
Future<void> synchroniserCommandes(List<commande> commandesDistantes) async {
  await lot((b) {
    // Utilisation de l'interface batch de drift pour réduire considérablement la surcharge réseau
    b.insererToutes(commandes, commandesDistantes);
    print("Synchronisation par lot des données de commandes HarmonyOS terminée");
  });
}
</commande></void>

4.2 Scénario 2 : Tableau de bord collaboratif distribué

Entre une tablette HarmonyOS et un téléphone, en se connectant directement à la même instance PostgreSQL, l'utilisation de permet de rafraîchir en temps réel les données du tableau de bord. Lorsque le téléphone modifie l'état, la tablette met à jour l'interface utilisateur avec un délai quasi nul.

 // Écoute réactive des données du tableau de bord HarmonyOS
Stream<list>> observerTaches() {
  return (select(taches)
    ..orderBy([(t) => TermeTri.desc(t.misAJour)]))
    .watch();
}
</list>

4.3 Scénario 3 : Rapport de journal structuré de niveau médical

Les applications de santé HarmonyOS doivent stocker des données de fréquence cardiaque et de pression artérielle extrêmement structurées. La contrainte de type fort de drift_postgres empêche fondamentalement les données illégitimes d'entrer dans la base de production.

// Logique d'écriture protectrice pour garantir l'exactitude des données
Future<int> sauvegarderDonneesSanteSecurise(String pressionArterielle) async {
  if (!valider(pressionArterielle)) return -1;
  return await inserer(donneesSante).DonneesSanteCompanion.inserer(
    pression: pressionArterielle,
    creeLe: DateTime.now(),
  ));
}
</int>

V. Défis d'adaptation sur la plateforme OpenHarmony

5.1 Stabilité et maintien des connexions Socket

Le système HarmonyOS contrôle très strictement les connexions réseau des processus en arrière-plan, et lorsque l'applicasion passe en arrière-plan, la connexion Socket est facilement rompue.

Astuce : Il est recommandé côté HarmonyOS d'utiliser le mécanisme de secours du pool de connexions de drift_postgres. Dans ParametresConnexion, définissez un tempsInactif raisonnable. Lorsque l'utilisateur ramène l'application au premier plan, déclenchez activement une simple requête de type SELECT 1 pour s'assurer que les connexions dans le pool sont actives, empêchant ainsi les erreurs de requête dues au dépassement du délai Socket.

5.2 Optimisation des performances de pagination pour de grands volumes de données

Lors du traitement de l'affichage de dizaines de milliers d'enregistrements sur des appareils grand écran HarmonyOS (tels que les tablettes), une mauvaise construction SQL entraîne un blocage notable de l'interface.

Attention : Ne faites surtout pas le mappage et la conversion de grandes quantités de données dans le thread principal (Main Isolate). drift prend lui-même en charge computeWithDatabase. Il est recommandé côté HarmonyOS d'initialiser la base de données dans un sous-thread (Isolate) dédié, en utilisant le support d'isolation de drift, permettant au thread UI de se concentrer sur le rendu des animations fluides HarmonyOS.

VI. Démonstration pratique complète

Voici un exemple complet d'opérations de base de données qui peut être exécuté directement dans un projet HarmonyOS, incluant la connexion, la définition de table et les opérations CRUD.

import 'package:flutter/material.dart';
import 'package:drift/drift.dart' as d;
import 'package:drift_postgres/drift_postgres.dart';
import 'package:postgres/postgres.dart';

// --- Le code généré par la bibliothèque doit être inclus ici pour compréhension ---
// Simulation de la logique principale générée

class ApplicationTachesHarmonyOS extends StatefulWidget {
  @override
  _ApplicationTachesHarmonyOSState createState() => _ApplicationTachesHarmonyOSState();
}

class _ApplicationTachesHarmonyOSState extends State<applicationtachesharmonyos> {
  late BaseDeDonneesApp db;

  @override
  void initState() {
    super.initState();
    // Initialisation de la connexion à la base de données backend spécifique à HarmonyOS
    db = BaseDeDonneesApp();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("Base de données PostgreSQL HarmonyOS - Pratique")),
      body: StreamBuilder<list>>(
        stream: db.select(db.notes).watch(),
        builder: (context, snapshot) {
          if (!snapshot.hasData) return CircularProgressIndicator();
          return ListView.builder(
            itemCount: snapshot.data!.length,
            itemBuilder: (context, index) {
              final note = snapshot.data![index];
              return ListTile(
                title: Text(note.titre),
                subtitle: Text(note.contenu),
                trailing: IconButton(
                  icon: Icon(Icons.delete, color: Colors.red),
                  onPressed: () => db.supprimerNote(note.id),
                ),
              );
            },
          );
        },
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => _afficherDialogueAjoutNote(),
        child: Icon(Icons.add),
      ),
    );
  }

  void _afficherDialogueAjoutNote() {
    // Logique de dialogue omise, démonstration directe de l'insertion de données dans la base de données HarmonyOS
    db.inserer(db.notes).inserer(
      NotesCompanion.inserer(
        titre: "Notes d'apprentissage HarmonyOS",
        contenu: "Aujourd'hui j'ai appris à me connecter à PostgreSQL distant depuis HarmonyOS",
      )
    );
    print("Ajout réussi d'un enregistrement au mémo HarmonyOS");
  }
}

// Définition des classes générées par la bibliothèque à titre indicatif
typedef Note = dynamic; // Dans la pratique, généré par drift
typedef NotesCompanion = dynamic;
</list></applicationtachesharmonyos>

VII. Conclusion

Avec drift_postgres, nous avons complété une pièce essentielle de l'architecture des applications Flutter for OpenHarmony : l'adaptation d'une base de données relationnelle distante haute performance. Qu'il s'agisse de l'expérience de développement fortement typée ou des performances de requête très compétitives, c'est actuellement la solution de stockage privilégiée pour les projets de moyenne et grande envergure sur HarmonyOS. Bien sûr, tout en bénéficiant de la commodité, il est essentiel de prêter une attention constante à la maintenance des connexions Socket et à l'optimisation de l'isolation des multi-threads Isolate sur la plateforme HarmonyOS.

Rappel des connaissances :

1. Comprendre comment drift mappe le protocole PostgreSQL sur la plateforme HarmonyOS.
2. Maîtriser la configuration du pool de connexions PostgreSQL initial pour HarmonyOS.
3. Apprendre à effectuer la conversion de types et la synchronisation de données par lots dans des scénarios complexes.

Approfondir HarmonyOS, c'est maîtriser les données.