Défis liés à la gestion de flux de travail complexes sur plusieurs applications Retool
Lorsqu'ils développent des solutions à grande échelle dans Retool, les architectes se heurtent souvent aux limites des conceptions à application unique. Les flux de travail complexes couvrant plusieurs domaines d'activité nécessitent de répartir les fonctionnalités dans des applications distinctes. Cependant, cela pose des problèmes de partage des données, de gestion des états et de synchronisation.
L'un des principaux problèmes est de maintenir un état cohérent entre les applications. Le transfert de données entre applications nécessite souvent des solutions de contournement telles que le stockage de résultats intermédiaires dans des tables temporaires ou dans localStorage. Cette approche est sujette aux erreurs et difficile à maintenir au fur et à mesure que le système grandit.
Un autre défi consiste à reproduire les modèles d'interface utilisateur et la logique d'entreprise communs à toutes les applications. Sans architecture modulaire, les développeurs finissent par dupliquer le code, ce qui entraîne des incohérences et des problèmes de maintenance.
Stratégies de partage des données et de l'état entre les applications
1. Bibliothèque de requêtes : Créez des requêtes réutilisables dans la bibliothèque de requêtes pour encapsuler des opérations de données complexes. Cela favorise la cohérence et réduit la duplication entre les applications.
2. Composants personnalisés : Créez des composants d'interface utilisateur réutilisables qui peuvent être partagés entre les applications. Cela est particulièrement utile pour les visualisations complexes ou les interfaces spécifiques à un domaine.
3. Flux de travail : Utilisez Retool Workflows pour orchestrer des processus en plusieurs étapes couvrant plusieurs applications. Les flux de travail peuvent gérer des opérations asynchrones et une logique de branchement complexe.
4. Paramètres URL : Transmettre l'état entre les applications à l'aide de paramètres URL. Cela permet de créer des liens profonds et de maintenir le contexte lors de la navigation entre les applications.
Le fil de discussion à l'adresse https://community.retool.com/t/specific-links-prod-vs-stg/20668 traite des stratégies de gestion des URL spécifiques à l'environnement pour les applications, ce qui est crucial lors de la mise en œuvre d'architectures multi-applications.
Techniques de synchronisation des mises à jour de données entre les applications
Le maintien de la cohérence des données entre les applications nécessite une attention particulière aux modèles de mise à jour :
1. Architecture pilotée par les événements : Utilisez le système d'événements de Retool pour déclencher des mises à jour dans les applications lorsque les données changent. Ce système peut être mis en œuvre à l'aide d'événements et d'écouteurs personnalisés.
2. Interrogation : Pour les mises à jour moins urgentes, installer des mécanismes d'interrogation pour vérifier périodiquement les changements.
3. WebSockets : Pour les mises à jour en temps réel, envisagez de mettre en œuvre une connexion WebSocket pour transmettre les modifications aux clients connectés.
Étude de cas : Architecture d'une solution d'entreprise à grande échelle avec Retool
Prenons l'exemple d'une grande plateforme de commerce électronique construite sur Retool. Le système est divisé en plusieurs applications :
1. Gestion des commandes
2. Contrôle des stocks
3. Service à la clientèle
4. Tableau de bord analytique
Pour garantir l'évolutivité et la maintenabilité :
1. Mettre en œuvre un module d'authentification partagé à l'aide de composants personnalisés et de la bibliothèque de requêtes.
2. Utiliser Retool Workflows pour gérer une logique de traitement des commandes complexe couvrant plusieurs applications.
3. Développer un système centralisé de gestion des états à l'aide d'une combinaison de la bibliothèque de requêtes et d'événements personnalisés.
4. Créer des composants d'interface utilisateur réutilisables pour des éléments communs tels que les affichages de produits et les formulaires de commande.
5. Mettre en œuvre un système de mise à jour en temps réel basé sur WebSocket pour les niveaux d'inventaire et les statuts des commandes.
Performance des applications basées sur Retool
À mesure que les applications Retool gagnent en complexité et gèrent des ensembles de données plus importants, l'optimisation des requêtes devient cruciale pour maintenir les performances et la réactivité.
Goulets d'étranglement courants dans les requêtes Retool
L'un des problèmes de performance les plus courants dans les applications Retool provient du traitement inefficace des grands ensembles de données. La création de nombreuses requêtes pour simuler la fonctionnalité d'un tableau croisé dynamique peut ralentir considérablement une application. Un autre goulot d'étranglement fréquent se produit lorsque les applications effectuent plusieurs appels d'API en séquence, en particulier lorsqu'elles traitent avec des services externes avec des limites de taux ou une latence élevée, comme lorsqu'on essaie d'envoyer des centaines de notifications WhatsApp via Twilio, ce qui démontre la nécessité d'élaborer des stratégies pour traiter les opérations en vrac plus efficacement.
Exploiter les fonctions d'agrégation SQL
Au lieu de s'appuyer sur le traitement côté client, utilisez les fonctions d'agrégation intégrées de SQL pour réduire la quantité de données transférées. En voici un exemple :
SELECT users.id,
users.first_name || ' ' | nom_de_famille_des_utilisateurs AS full_name,
string_agg(stories.title, ',') AS titles
FROM users
INNER JOIN writers ON users.id = writers.user_id
INNER JOIN stories ON writers.story_id = stories.id
GROUP BY 1, 2
Cette approche consolide les données au niveau de la base de données, réduisant ainsi la charge sur le front-end de Retool.
Utiliser des opérations JOIN efficaces
Lorsque vous traitez des données connexes, préférez les opérations JOIN efficaces à plusieurs requêtes distinctes. Un JOIN bien structuré permet de récupérer toutes les données nécessaires en une seule requête :
SELECT users.id,
users.first_name || ' ' | nom_de_famille_des_utilisateurs AS nom_complet,
titre_des_histoires
FROM utilisateurs
INNER JOIN écrivains ON utilisateurs.id = écrivains.user_id
INNER JOIN histoires ON écrivains.story_id = histoires.id
Exploiter les transformateurs JavaScript pour un traitement efficace des données
Les transformateurs JavaScript de Retool offrent de puissantes possibilités de post-traitement des résultats des requêtes. Voici quelques techniques avancées :
Remodelage des données :
Utilisez des réducteurs pour remodeler efficacement les structures de données. Par exemple, pour regrouper les histoires par auteur :
return data.reduce((hash, value) => {
const {story_name, ...rest} = value;
if(hash[value.id]){
hash[value.id].story_names.push(story_name);
} else {
hash[value.id] = {...rest, story_names: [story_name]};
}
return hash;
}, {});
Traitement parallèle :
Pour les opérations impliquant plusieurs appels asynchrones, utilisez Promise.all pour les exécuter simultanément :
const promises = arr.map(item => {
return query.trigger({ additionalScope: { id: item } });
});
return Promise.all(promises);
Mise en œuvre de mécanismes de mise en cache pour améliorer les performances des requêtes
Utiliser des variables d'état temporaires :
Stocker les données fréquemment consultées dans des variables d'état temporaires afin d'éviter les appels redondants à l'API ou les requêtes à la base de données.
Mettre en place une mise en cache côté client :
Pour les données qui ne changent pas fréquemment, envisagez d'utiliser le localStorage du navigateur pour mettre les résultats en cache, ce qui réduira la charge du serveur et améliorera les temps de réponse.
Meilleures pratiques pour la gestion de grands ensembles de données dans les applications Retool
1. Pagination :
Mettre en œuvre la pagination pour les grands ensembles de données afin de charger les données en plus petits morceaux. Cela permet de réduire les temps de chargement initiaux et d'améliorer la réactivité globale de l'application.
2. Chargement paresseux :
Utilisez les techniques de chargement paresseux pour différer le chargement des données non critiques jusqu'à ce qu'elles soient nécessaires. Cela peut s'avérer particulièrement utile dans les applications de tableaux de bord complexes.
3. Anti-rebond et régulation du débit :
Lorsqu'il s'agit d'entrées utilisateur qui déclenchent des requêtes (par exemple, fonctionnalité de recherche), il convient de mettre en œuvre un anti-rebond et une régulation du débit afin de limiter la fréquence des appels à l'API.
4. Optimiser le transfert de données :
Ne demandez à votre source de données que les champs nécessaires. Évitez d'extraire des enregistrements entiers si seules des colonnes spécifiques sont nécessaires pour l'affichage ou le traitement.
5. Utiliser des structures de données efficaces :
Choisissez des structures de données adaptées à votre cas d'utilisation. Par exemple, pour les recherches, il est préférable d'utiliser des objets plutôt que des tableaux afin d'obtenir des temps d'accès plus rapides.
Problèmes courants avec les applications Retool
Manipulation et affichage des données
Problématique: Les utilisateurs éprouvent souvent des difficultés à manipuler et à afficher des données, en particulier lorsqu'ils ont affaire à des structures de données complexes ou à du JSON imbriqué.
Solution: Utilisez les transformateurs JavaScript et les fonctions lodash pour remodeler les données. Pour les structures imbriquées, utilisez des méthodes comme `formatDataAsArray()` ou des fonctions personnalisées pour aplatir et mapper les données de manière appropriée.
Pourquoi cela se produit-il? Retool Les composants visuels du logiciel 's' sont parfois limités dans la manipulation de structures de données complexes, ce qui nécessite des manipulations de données supplémentaires.
Exécution et performance des requêtes
Problème: Problèmes liés aux délais d'attente des requêtes, en particulier lorsqu'il s'agit de grands ensembles de données ou de requêtes multiples.
Solution: Optimisez les requêtes, utilisez la pagination et envisagez d'utiliser les flux de travail Retool pour les opérations complexes ou de longue durée. Pour les requêtes multiples, utilisez Promise.all() dans les requêtes JavaScript pour les exécuter simultanément.
Origine du problème: Retool dispose de limites de temps intégrées pour éviter la surutilisation des ressources, qui peut se produire en cas de requêtes inefficaces ou de gros volumes de données.
Interactions des composants et gestion des états
Problème: Difficultés de gestion de l'état des composants, en particulier dans les applications complexes comportant de nombreux éléments interdépendants.
Solution: Utiliser efficacement les variables Temporary State, exploiter l'objet `retoolContext` et créer des gestionnaires d'événements personnalisés pour gérer le flux de données entre les composants.
Pourquoi cela se produit-il? Au fur et à mesure que les applications gagnent en complexité, la gestion de l'état et des interactions entre les composants devient de plus en plus difficile sans une stratégie claire.
Authentification personnalisée et intégration de l'API
Problème: Difficultés liées à la mise en place de flux d'authentification personnalisés ou à l'intégration avec des API complexes.
Solution: Utiliser les options d'authentification personnalisées de Retool, exploiter la bibliothèque de requêtes pour les appels d'API réutilisables et utiliser des requêtes JavaScript pour les interactions d'API plus complexes.
Pourquoi cela se produit-il? Chaque API a des exigences d'authentification uniques, et les options intégrées de Retool ne couvrent pas toujours tous les scénarios.
Personnalisation de l'interface utilisateur et Design Responsive
Problème: Limitations dans la personnalisation des composants de l'interface utilisateur ou dans la création de layouts responsifs.
Solution: Utilisez des feuilles de style CSS personnalisées lorsque c'est possible, tirez parti des composants de conteneurs pour contrôler la mise en page et envisagez des composants personnalisés pour des besoins d'interface utilisateur très spécifiques.
Raison d'être: Retool donne la priorité au développement rapide plutôt qu'à une personnalisation poussée, ce qui entraîne certaines limitations dans le contrôle fin de l'interface utilisateur.
Travailler avec des données de date et d'heure
Problème: Difficultés liées au formatage, à la manipulation et à l'affichage cohérent des données relatives à la date et à l'heure.
Solution: Utilisez la bibliothèque intégrée moment.js pour les manipulations de dates, et tirez parti des transformateurs JavaScript pour les opérations complexes liées aux dates.
Pourquoi cela se produit-il? La gestion de la date et de l'heure est intrinsèquement complexe, et différentes sources de données peuvent fournir des dates dans des formats différents.
Gestion des relations de plusieurs à plusieurs
Problème: Difficulté d'afficher et de gérer les relations de plusieurs à plusieurs dans les tables et les formulaires.
Solution: Utilisez des requêtes personnalisées pour joindre les données de manière appropriée, tirez parti des transformateurs JavaScript pour remodeler les données et envisagez d'utiliser des composants imbriqués ou des éléments d'interface utilisateur personnalisés pour les relations complexes.
Pourquoi cela se produit-il? Retool Les composants par défaut d'EMC sont optimisés pour les structures de données les plus simples, ce qui nécessite un travail supplémentaire pour les relations complexes.
