Quand dois-je utiliser RequestFactory vs GWT-RPC?


Answers

J'ai traversé une transition de RPC à RF. D'abord, je dois dire que mon expérience est limitée, j'ai utilisé autant d'EntityProxies que de 0.

Avantages de GWT RPC:

  • C'est très facile à mettre en place, à comprendre et à APPRENDRE!
  • Les objets de même classe sont utilisés sur le client et sur le serveur.
  • Cette approche permet d'économiser des tonnes de code.
  • Idéal, lorsque les mêmes objets modèles (et POJOS) sont utilisés sur le client et le serveur, POJO == MODEL OBJECTs == DTO
  • Facile à déplacer des choses du serveur au client.
  • Facile à partager implémentation de la logique commune entre le client et le serveur (cela peut s'avérer être un inconvénient critique lorsque vous avez besoin d'une logique différente).

Les désavantages de GWT RPC:

  • Impossible d'avoir une implémentation différente de certaines méthodes pour le serveur et le client, par exemple, vous pourriez avoir besoin d'utiliser une structure de journalisation différente sur le client et le serveur, ou une méthode différente d'égal à égal.
  • VRAIMENT implémentation BAD qui n'est pas extensible: la plupart des fonctionnalités du serveur sont implémentées en tant que méthodes statiques sur une classe RPC. Qui suce vraiment.
  • Par exemple, il est impossible d'ajouter des erreurs côté serveur obscurcissant
  • Quelques soucis de sécurité XSS qui ne sont pas très élégants, voir docs (je ne suis pas sûr que ce soit plus élégant pour RequestFactory)

Inconvénients de RequestFactory:

  • VRAIMENT difficile à comprendre de la doc officielle, quel est le mérite de celui-ci! Il commence juste à terme complètement faux PROXIES - ce sont en réalité des DTO de RF qui sont créés automatiquement par RF. Les proxys sont définis par des interfaces, par exemple @ProxyFor (Journal.class). IDE vérifie s'il existe des méthodes correspondantes sur Journal. Voilà pour la cartographie.
  • RF ne fera pas beaucoup pour vous en termes de points communs du client et du serveur, car
  • Sur le client, vous devez convertir "PROXIES" à vos objets de domaine client et vice-versa. C'est complètement ridicule. Cela pourrait être fait dans quelques lignes de code, mais il n'y a AUCUN SUPPORT POUR CELA! Si seulement nous pouvions mapper nos objets de domaine aux proxies plus élégamment, quelque chose comme la méthode JavaScript JSON.stringify (.. ,,) est MANQUANT dans la boîte à outils RF.
  • N'oubliez pas que vous êtes également responsable de la définition des propriétés transférables de vos objets de domaine aux proxies, et ainsi de suite de manière récursive.
  • POOR ERROR HANDLING sur le serveur et - Stack-traces sont omis par défaut sur le serveur et vous obtenez des exceptions inutiles vides sur le client. Même lorsque j'ai défini un gestionnaire d'erreurs personnalisé, je n'ai pas pu accéder aux traces de pile de bas niveau! Terrible.
  • Quelques bugs mineurs dans le support IDE et ailleurs. J'ai soumis deux demandes de bogues qui ont été acceptées. Pas besoin d'Einstein pour comprendre que c'étaient des insectes.
  • DOCUMENTATION SUCE. Comme je l'ai mentionné, les procurations devraient être mieux expliquées, le terme est trompeur. Pour les problèmes communs de base, que je résolvais, DOCS EST INUTILE. Un autre exemple de malentendu du DOC est la connexion des annotations de l'APP à RF. Il semble que les docs succincts qu'ils jouent un peu ensemble, et oui, il y a une question correspondante sur StackOverflow. Je recommande d'oublier toute "connexion" JPA avant de comprendre RF.

Avantages de RequestFactory

  • Excellent support de forum.
  • Le support de l'IDE est assez bon (mais n'est pas un avantage contrairement à RPC)
  • Flexibilité de l'implémentation client et serveur (couplage lâche)
  • Des trucs fantaisistes, connectés à EntityProxies, au-delà des simples DTO - mise en cache, mises à jour partielles, très utiles pour les mobiles.
  • Vous pouvez utiliser ValueProxies comme le remplacement le plus simple pour les DTO (mais vous devez vous-même faire toutes les conversions pas si fantaisie).
  • Prise en charge des validations de bean JSR-303.

Considérant les autres inconvénients de GWT en général:

  • Impossible d'exécuter les tests d'intégration (code client GWT + serveur distant) avec le support JUnit fourni <= tous les JSNI doivent être modifiés (par exemple localStorage), la SOP est un problème.

  • Pas de support pour la configuration des tests - navigateur sans tête + serveur distant <= pas de test simple sans tête pour GWT, SOP.

  • Oui, il est possible d'exécuter des tests d'intégration au sélénium (mais ce n'est pas ce que je veux)

  • JSNI est très puissant, mais lors de ces discussions brillantes qu'ils donnent lors de conférences, ils ne parlent pas beaucoup de cette écriture. Les codes JSNI ont aussi quelques règles. Encore une fois, comprendre comment écrire un simple rappel était une tâche digne d'un vrai chercheur.

En résumé, la transition de GWT RPC à RequestFactory est loin de la situation WIN-WIN, lorsque RPC répond à vos besoins. Vous finissez par écrire des tonnes de conversions d'objets de domaine client vers des proxies et vice-versa. Mais vous obtenez une certaine flexibilité et robustesse de votre solution. Et le soutien sur le forum est excellent, le samedi aussi!

Compte tenu de tous les avantages et inconvénients que je viens de mentionner, il est très utile de penser à l'avance si l'une ou l'autre de ces approches apporte une amélioration à votre solution et à votre configuration de développement sans grands compromis.

Question

J'essaye de comprendre si je devrais migrer mes appels de gwt-rpc aux nouveaux cals de RequestFactory de GWT2.1.

La documentation de Google mentionne vaguement que RequestFactory est une meilleure méthode de communication client-serveur pour les "services orientés données"

Ce que je peux distiller de la documentation est qu'il y a une nouvelle classe de proxy qui simplifie la communication (vous ne passez pas l'entité réelle mais juste le proxy, donc c'est plus léger et plus facile à gérer)

Est-ce le point entier ou est-ce que je manque quelque chose d'autre dans la grande image?




La seule mise en garde que je mettrais est que RequestFactory utilise le transport de données binaire (deRPC peut-être?) Et non le GWT-RPC normal.

Cela n'a d'importance que si vous effectuez des tests intensifs avec SyncProxy, Jmeter, Fiddler ou tout outil similaire capable de lire / évaluer le contenu de la requête / réponse HTTP (comme GWT-RPC), mais plus difficile avec deRPC ou RequestFactory.




Contrairement à RequestFactory qui a une mauvaise gestion des erreurs et des capacités de test (puisqu'il traite la plupart des choses sous le capot de GWT), RPC vous permet d'utiliser une approche plus orientée service. RequestFactory implémente une approche de type injection de dépendance plus moderne qui peut fournir une approche utile si vous avez besoin d'appeler des structures de données polymorphes complexes. Lorsque vous utilisez RPC, vos structures de données devront être plus plates, car cela permettra à vos utilitaires de marshaling de traduire entre vos modèles json / xml et java. L'utilisation de RPC vous permet également de mettre en œuvre une architecture plus robuste, telle que citée dans la section gwt dev sur le site Web de Google.

"Déploiement simple client / serveur

La première et la plus simple façon de penser aux définitions de service consiste à les traiter comme le backend complet de votre application. De ce point de vue, le code côté client est votre «frontal» et tout le code de service qui s'exécute sur le serveur est «back end». Si vous adoptez cette approche, vos implémentations de service auront tendance à être des API plus générales qui ne sont pas étroitement couplées à une application spécifique. Vos définitions de service accèderont probablement directement aux bases de données via JDBC ou Hibernate ou même des fichiers dans le système de fichiers du serveur. Pour de nombreuses applications, cette vue est appropriée et peut être très efficace car elle réduit le nombre de niveaux.

Déploiement multi-niveaux

Dans les architectures multi-niveaux plus complexes, vos définitions de service GWT peuvent simplement être des passerelles légères qui appellent des environnements serveur back-end tels que les serveurs J2EE. De ce point de vue, vos services peuvent être considérés comme la «moitié serveur» de l'interface utilisateur de votre application. Au lieu d'être généraux, les services sont créés pour les besoins spécifiques de votre interface utilisateur. Vos services deviennent le «frontal» des classes «back end» qui sont écrites en assemblant des appels vers une couche de services back-end plus générale, implémentée, par exemple, en tant que cluster de serveurs J2EE. Ce type d'architecture est approprié si vous avez besoin que vos services dorsaux s'exécutent sur un ordinateur physiquement séparé de votre serveur HTTP. "

Notez également que la configuration d'un seul service RequestFactory nécessite la création d'environ 6 classes Java, alors que RPC n'en nécessite que 3. Plus de code == plus d'erreurs et de complexité dans mon livre.

RequestFactory a également un peu plus de temps au cours du traitement des demandes, car il doit marshaler la sérialisation entre les proxys de données et les modèles java réels. Cette interface ajoutée ajoute des cycles de traitement supplémentaires qui peuvent réellement s'additionner dans un environnement d'entreprise ou de production.

Je ne crois pas non plus que les services RequestFactory soient des services de sérialisation comme les services RPC.

Dans l'ensemble, après avoir utilisé les deux depuis un certain temps maintenant, je vais toujours avec RPC comme son plus léger, plus facile à tester et déboguer, et plus rapide, puis en utilisant un RequestFactory. Bien que RequestFactory puisse être plus élégant et plus extensible que sa partie compteur RPC. La complexité ajoutée n'en fait pas un meilleur outil nécessaire.

Mon opinion est que la meilleure architecture est d'utiliser deux applications Web, un client et un serveur. Le serveur est une webapp java générique légère et simple qui utilise la bibliothèque servlet.jar. Le client est GWT. Vous effectuez une requête RESTful via GWT-RPC dans le côté serveur de l'application Web client. Le côté serveur du client n'est qu'un passage vers le client http apache qui utilise un tunnel persistant dans le gestionnaire de requêtes que vous avez exécuté en tant que servlet unique dans votre application web de servlet serveur. L'application Web de servlet doit contenir votre couche d'application de base de données (hibernate, cayenne, sql etc.) Cela vous permet de divorcer complètement les modèles d'objet de base de données du client réel fournissant une manière beaucoup plus extensible et robuste de développer et de tester votre application. Certes, cela nécessite un peu de temps d'installation initiale, mais à la fin vous permet de créer une demande dynamique usine assis en dehors de GWT. Cela vous permet de tirer parti du meilleur des deux mondes. Sans parler de pouvoir tester et modifier votre serveur sans que le client gwt ne soit compilé ou construit.




Est-il juste de dire que lorsque l'on considère une application MIS limitée, disons avec 10-20 objets métier CRUD, et chacun avec ~ 1-10 propriétés, qu'en est-il vraiment de la préférence personnelle avec quelle route aller?

Si oui, alors peut-être que la projection de la façon dont votre application va évoluer pourrait être la clé dans le choix de votre route GWT RPC ou RequestFactory:

  1. Mon application devrait rester avec ce nombre relativement limité d'entités mais augmentera massivement en termes de nombre. 10-20 objets * 100 000 enregistrements.

  2. Mon application va augmenter de manière significative dans l'étendue des entités mais les nombres relatifs de chacune resteront faibles. 5000 objets * 100 enregistrements.

  3. Mon application devrait rester avec ce nombre relativement limité d'entités ET restera en nombre relativement faible de par exemple 10-20 objets * 100 enregistrements

Dans mon cas, je suis au tout début d'essayer de prendre cette décision. En outre compliqué en ayant à changer l'architecture de côté de client d'UI aussi bien que faire le choix de transport. Ma précédente interface utilisateur GWT à grande échelle utilisait la bibliothèque Hmvc4Gwt, qui a été remplacée par les installations MVP de GWT.