Quand dois-je utiliser RequestFactory vs GWT-RPC?

Je suis en train de voir si je dois migrer mon gwt-rpc appels à la nouvelle GWT2.1 RequestFactory cal.

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

Ce que je peut distiller à partir de la documentation est qu'il y a une nouvelle classe de Proxy qui simplifie la communication (vous ne passez pas en arrière et en avant de l'entité réelle, mais seulement le proxy, donc il est plus léger et plus facile à gérer)

Est que le point de l'ensemble ou ai-je raté quelque chose d'autre dans la grande image?

InformationsquelleAutor Daghan --- | 2010-11-07
  1. 73

    La grande différence entre GWT RPC et RequestFactory est que le RPC système est "RPC-par-béton de type" tout en RequestFactory est "RPC-par-interface".

    RPC est plus pratique pour commencer avec, parce que vous écrivez moins de lignes de code et l'utilisation de la même classe sur le client et le serveur. Vous pouvez créer un Person classe avec un bouquet de getters et les setters et peut-être une simple logique d'entreprise pour plus de trancher et couper en dés les données dans la Person objet. Cela fonctionne très bien jusqu'à ce que vous finissez par vouloir avoir des spécifiques au serveur, non-GWT-compatible, le code à l'intérieur de votre classe. Parce que le RPC est un système basé sur le même type de béton sur le client et le serveur, vous pouvez frapper un mur de la complexité en fonction des capacités de votre client GWT.

    Pour obtenir autour de l'utilisation de code incompatible, de nombreux utilisateurs de liquidation de la création d'un pair PersonDTO que les ombres du réel Person objet utilisé sur le serveur. Le PersonDTO a juste un sous-ensemble des getters et setters du côté serveur, "domaine", Person objet. Maintenant, vous devez écrire du code qui maréchaux de données entre les Person et PersonDTO objet et tous les autres types d'objet que vous souhaitez transmettre à la client.

    RequestFactory commence par en supposant que vos objets ne vont pas être de GWT-compatible. Il vous suffit de déclarer les propriétés qui doivent être lues et écrites par le code du client dans une interface Proxy, et le RequestFactory composants du serveur de prendre soin de gérer les données et de faire appel à votre service des méthodes. Pour les applications qui ont bien définir la notion de "Entités" ou "Objets de l'identité et de version", la EntityProxy type est utilisé pour exposer la persistance de l'identité sémantique de données pour le code client. Des objets simples sont cartographiées à l'aide de la ValueProxy type.

    Avec RequestFactory, vous payez un coût de démarrage pour accueillir des systèmes plus complexes que GWT RPC supporte facilement. RequestFactory de ServiceLayer offre beaucoup plus de crochets de le personnaliser en ajoutant ServiceLayerDecorator instances.

    • C'est une bonne raison à l'appui de ma décision de passer à RequestFactory. Merci Bob! Il a un sens et je ne comprends pas pourquoi certaines personnes disent que "l'utilisation de RPC dans certains cas et RF dans d'autres en fonction de vos besoins", car il semble qu'avec la RPC, vous devez écrire beaucoup de code colle et que DTO couche
    • Un autre plus pour RequestFactory est qu'il peut être utilisé avec Android et GWT avec exactement le même code.
    InformationsquelleAutor BobV
  2. 28

    Je suis passé par une transition de la RPC à la RF. D'abord je dois dire que mon expérience est limitée, j'ai utilisé beaucoup de EntityProxies à 0.

    Avantages de GWT RPC:

    • Il est très facile à paramétrer, à comprendre et à APPRENDRE!
    • Même classe de base des objets sont utilisés sur le client et sur le serveur.
    • Cette approche économise des tonnes de code.
    • Idéal, lorsque le même modèle que les objets (et les POJO) sont utilisés sur le client et le serveur, Pojo == les Objets de MODÈLE == Otd
    • Facile à déplacer le contenu à partir du serveur vers le client.
    • Facile de partager la mise en œuvre de la logique commune entre le client et le serveur (ce qui peut se révéler comme une critique inconvénient lorsque vous avez besoin d'une autre logique).

    Disadvatages de GWT RPC:

    • Impossible d'avoir différentes de mise en œuvre de certaines méthodes pour le serveur et le client, par exemple, vous pourriez avoir besoin d'utiliser les différentes fonctionnalités de journalisation sur le client et le serveur, ou de différentes méthode equals.
    • VRAIMENT de la MAUVAISE mise en œuvre, qui n'est pas extensible: la plupart des fonctionnalités du serveur est mis en œuvre en tant que méthodes statiques sur un RPC classe. C'EST VRAIMENT POCHE.
    • par exemple, Il est impossible d'ajouter des erreurs côté serveur de la dissimulation de l'
    • Certaines de sécurité XSS préoccupations qui ne sont pas assez élégamment résoluble, voir docs (je ne suis pas sûr de savoir si c'est plus élégant pour RequestFactory)

    Inconvénients de RequestFactory:

    • VRAIMENT DUR à comprendre à partir de la doc officielle, quel est le mérite de l'être! Il commence à complètement terme trompeur de PROCURATIONS - ce sont en fait des Otd RF qui sont créés par RF automatiquement. Les procurations sont définis par des interfaces, par exemple @ProxyFor(Journal.class). IDE vérifie si il existe des méthodes correspondantes sur le Journal. Voilà pour la cartographie.
    • RF ne va pas faire beaucoup pour vous en termes de points communs entre le client et le serveur, car
    • Sur le client que vous avez besoin de convertir des "PROXIES" à votre client des objets du domaine et vice-versa. C'est complètement ridicule. Il pourrait être fait en quelques lignes de code, de manière déclarative, mais il n'y a AUCUN SOUTIEN POUR! Si seulement nous pouvions carte nos objets du domaine de procurations de manière plus élégante, quelque chose comme méthode JavaScript JSON.stringify(..,,) est MANQUANTE dans RF boîte à outils.
    • N'oubliez pas que vous êtes également responsable de la mise en transférables propriétés de vos objets de domaine à la procuration, et ainsi de suite récursivement.
    • MAUVAISE gestion d'ERREUR sur le serveur et de la Pile-traces sont omis par défaut sur le serveur et vous re vide inutile d'exception sur le client. Même lorsque j'ai mis gestionnaire d'erreur personnalisé, je n'ai pas été en mesure d'obtenir à faible niveau de traces de pile! Terrible.
    • De quelques bugs mineurs dans l'IDE de soutien et d'ailleurs. J'ai déposé deux bug demandes qui ont été acceptées. Pas un Einstein était nécessaire pour comprendre que ceux qui étaient en fait des bugs.
    • DOCUMENTATION SUCE. Comme je l'ai mentionné procurations doivent être mieux expliqués, le terme est TROMPEUR. Pour la base commune des problèmes, que j'étais de problèmes, DOCS EST INUTILE. Un autre exemple de l'incompréhension de la DOC est la connexion des annotations JPA pour RF. Il regarde de l'succincte docs qu'ils ont un peu jouer ensemble, et oui, il y a également une question sur StackOverflow. Je recommande d'oublier tout JPA "connexion" avant de comprendre RF.

    Avantages de RequestFactory

    • Excellent forum de support.
    • IDE de soutien est très bonne (mais n'est pas un avantage en contraste avec RPC)
    • La flexibilité de votre client et le serveur de mise en œuvre (loose coupling)
    • De fantaisie, connecté à EntityProxies, au-delà de la simple Otd - cache, des mises à jour partielles, très utile pour mobile.
    • Vous pouvez utiliser ValueProxies le moyen le plus simple de remplacement pour les Dto (mais vous devez le faire tous les pas tellement envie de conversions vous-même).
    • De soutien pour les Haricots, les Validations de la JSR-303.

    Compte tenu des autres inconvénients de GWT en général:

    • Impossible d'exécuter les tests d'intégration (GWT code client + serveur distant) avec JUnit support <= tous les JSNI a se moque de lui (par exemple, localStorage), SOP est un problème.

    • Pas de support pour la configuration du test - headless browser + serveur distant <= pas de simples sans tête de test pour GWT, SOP.

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

    • JSNI est très puissant, mais à ceux brillant pourparlers, ils donnent à des conférences, ils ne parlent que de l'écriture JSNI codes a également quelques règles. De nouveau, essayer de comprendre comment écrire un simple rappel a été une tâche valeur de vrai chercheur.

    En résumé, le passage de GWT RPC à RequestFactory est loin de la situation gagnant-GAGNANT,
    lors de la RPC pour la plupart s'adapte à vos besoins. Vous finissez par écrire des tonnes de conversions à partir d'un client du domaine des objets de procurations et vice-versa. Mais vous avez une certaine souplesse et la robustesse de votre solution. Et de soutien sur le forum est excellent, le samedi ainsi!

    Compte tenu de tous les avantages et les inconvénients que je viens de mentionner, il paie vraiment bien de penser à l'avance si l'une de ces approches fait de l'amélioration de votre solution et à votre développement set-up sans grand compromis.

    • La Caisse JBoss Erai. J'aime leur approche de la RPC.
    InformationsquelleAutor honzajde
  3. 6

    Je trouve l'idée de la création de classes de Proxy pour toutes mes entités assez ennuyeux. Mon Hibernate/JPA, pojo sont auto-générés à partir du modèle de base de données. Pourquoi dois-je maintenant de créer un deuxième miroir de ceux pour le RPC? Nous avons une belle "estivation" cadre qui prend soin de "de-hibernation" le pojo.

    Aussi, l'idée de définir des interfaces de service ne sont pas tout mettre en œuvre côté serveur comme un service de java contrat, mais ne mettre en œuvre les méthodes de sons très J2EE 1.x/2.x pour moi.

    • C'est ennuyeux, mais si vous avez de créer des proxys de toute façon, vous préférez avoir de l'aide supplémentaire que le RF vous donne de la gestion de ces procurations. Pas tout le monde veut envoyer l'ensemble de pojo pour le client - par exemple, considérons un jeu de poker - votre Joueur objet pourrait avoir l'information que tout le monde devrait voir (nombre de cartes en main, les cartes face vers le haut, nombre total de jetons) et d'autres informations qu'un seul joueur devrait voir (face vers le bas cartes).
    • Votre Poker exemple est valable - qui travaillent autour de nous que par le fait d'avoir des annotations (@WireTransient) que notre "estivation" framework utilise pour supprimer des valeurs.
    InformationsquelleAutor Καrτhικ
  4. 4

    Contrairement à RequestFactory qui a une mauvaise gestion d'erreur et d'essai (puisqu'il traite la plupart des choses sous le capot de GWT), RPC permet d'utiliser une approche orientée vers les services. RequestFactory implémente une version plus moderne de l'injection de dépendances de style qui peut constituer une approche utile si vous avez besoin d'invoquer complexe, polymorphe des structures de données. Lors de l'utilisation de RPC vos structures de données devra être plus à plat, car cela permettra à votre marshaling des utilitaires pour traduire entre votre json/xml et java modèles. À l'aide de RPC permet également de mettre en œuvre plus robuste architecture, cité de l'gwt dev section sur le site web de Google.

    "Client/Serveur Simple Déploiement

    La première et la plus simple de penser à des définitions de service est de les traiter comme votre application à l'intégralité de la fin. De ce point de vue, le code côté client est votre "front-end" et tous les code de service qui s'exécute sur le serveur est "back-end." Si vous prenez cette approche, votre implémentations de service ont tendance à être plus généraliste Api qui ne sont pas étroitement couplée à une application spécifique. Vos définitions de service serait susceptible d'accéder directement aux bases de données via JDBC ou mise en veille prolongée ou même des fichiers dans le système de fichiers du serveur. Pour de nombreuses applications, ce point de vue est approprié, et il peut être très efficace, car elle réduit le nombre de niveaux.

    Multi-Niveaux De Déploiement

    En plus complexes, multi-architectures, votre GWT définitions de service pourrait simplement être léger passerelles appel par l'intermédiaire de serveur de back-end des environnements tels que les serveurs J2EE. De ce point de vue, vos services peut être considéré comme le "serveur de la moitié" de votre interface utilisateur de l'application. Au lieu d'être à usage général, les services sont créés pour les besoins spécifiques de votre interface utilisateur. Vos services ont le "front-end" pour le "back-end" les classes qui sont écrites par couture ensemble des appels à des fins plus générales back-end de la couche de services, mise en œuvre, par exemple, comme un cluster de serveurs J2EE. Ce type d'architecture est approprié si vous avez besoin de vos services pour s'exécuter sur un physiquement séparé de l'ordinateur à partir de votre serveur HTTP."

    Noter également que la mise en place d'un seul RequestFactory service nécessite la création autour de 6 classes java où RPC exige seulement 3. Plus de code == plus d'erreurs et de complexité dans mon livre.

    RequestFactory aussi a un peu plus de surcharge pendant le traitement de la requête, comme il se doit le maréchal de sérialisation entre les procurations données réelles et java modèles. Cet ajout d'interface ajoute des cycles de traitement qui peuvent vraiment s'accumuler dans une entreprise ou un environnement de production.

    Je ne pense pas non plus que RequestFactory services sont sérialisation comme les services RPC.

    Dans l'ensemble après l'utilisation à la fois pour un certain temps maintenant, je vais toujours avec RPC comme son plus léger, plus facile à tester et déboguer, et plus rapide, puis à l'aide d'un RequestFactory. Bien que RequestFactory peut-être plus élégant et extensible puis son RPC contre-partie. La complexité supplémentaire de ne pas en faire un meilleur outil nécessaire.

    Mon avis est que la meilleure architecture est d'utiliser deux applications web , un client et un serveur. Le serveur est un simple léger génériques de java application web qui utilise l'servlet.jar de la bibliothèque. Le client GWT. Vous faites Reposant demande via GWT-RPC dans la partie serveur de l'application web client. Le côté serveur du client est juste un passe cependant à apache http client qui utilise un persistant du tunnel dans le gestionnaire de requêtes en cours d'exécution comme une seule servlet dans votre serveur de servlets de l'application web. La servlet application web doit contenir votre base de données de la couche application (hibernate, cayenne, sql, etc..) Cela vous permet de pleinement divorce de l'objet de base de données modèles de la client en fournissant une beaucoup plus extensible et robuste de la développer et de l'unité de test de votre application. Accordé, il nécessite un peu de configuration initiale du temps, mais en fin de compte vous permet de créer une dynamique de demande d'usine assis à l'extérieur de GWT. Cela vous permet de tirer le meilleur des deux mondes. Sans parler d'être en mesure de tester et de faire des changements de votre côté serveur sans avoir à le gwt client compilé ou de construire.

    InformationsquelleAutor 1-14x0r
  5. 0

    Je pense que c'est vraiment utile si vous avez un lourd pojo sur le côté client, par exemple si vous utilisez le mode veille prolongée ou des entités JPA.
    Nous avons adopté une autre solution, à l'aide d'un Django style persistance cadre avec de très légers entités.

    InformationsquelleAutor Uberto
  6. 0

    Le seul bémol que je mettrais est que RequestFactory utilise le binaire de transport de données (deRPC peut-être?) et pas normal GWT-RPC.

    Ce que des questions si vous êtes fait un test avec SyncProxy, Jmeter, un violon, ou tout autre outil qui permet de lire et d'évaluer le contenu de la requête/réponse HTTP (comme GWT-RPC), mais serait plus difficile avec deRPC ou RequestFactory.

    • Sauf qu'en fait RequestFactory ne fournir "pure Java" mise en œuvre hors de la boîte, sans la nécessité pour la 3ème partie outils comme SyncProxy. Voir stackoverflow.com/questions/4853188/...
    InformationsquelleAutor dhartford
  7. 0

    Nous avons un très grand de la mise en œuvre de GWT-RPC dans notre projet.
    En fait, nous avons 50 interfaces de Service avec de nombreuses méthodes de chacun, et nous avons des problèmes avec la taille de TypeSerializers généré par le compilateur qui transforme notre code JS énorme.
    Nous sommes donc analizing à se déplacer vers RequestFactory.
    J'ai été lire pour un couple de jours de creuser dans le web et d'essayer de trouver ce que les autres font.
    L'inconvénient plus important que j'ai vu, et peut-être que je pourrais avoir tort, c'est qu'avec RequestFactory votre sont plus dans le contrôle de la communication entre votre Serveur d'objets de Domaine et votre client celles.
    Ce dont nous avons besoin, c'est d'appliquer le charger /enregistrer le modèle dans un environnement contrôlé. Je veux dire, par exemple client de recevoir l'ensemble de l'objet graphique des objets appartenant à une transaction spécifique, faire ses mises à jour et de les envoyer à l'ensemble de l'arrière du serveur. Le serveur sera responsable de la réalisation de la validation, comparer les anciennes avec les nouvelles valeurs et de faire de la persistance. Si 2 utilisateurs à partir de différents sites obtient la même transaction et de faire quelques mises à jour, la transaction ne devrait pas être la fusion de l'un. Une des mises à jour doit échouer dans mon scénario.
    Je ne vois pas ce que RequestFactory aide à soutenir ce genre de traitement.

    Ce qui concerne
    Daniel

    • Je partage ces préoccupations...avez-vous vous retrouvez avec le RF?
    InformationsquelleAutor Daniel Ardison
  8. 0

    Est-il juste de dire que lors de l'examen limité application SIG, avec 10-20 CRUD'able business objects, et chacun avec ~1-10 propriétés, que c'est vraiment vers le bas à la préférence personnelle de l'itinéraire pour aller avec?

    Si oui, alors peut-être à anticiper comment l'application va à l'échelle pourrait être la clé dans le choix de votre itinéraire GWT RPC ou RequestFactory:

    1. Mon application est prévue pour rester avec ce nombre relativement limité d'entités, mais favorisera l'augmentation de leur nombre. 10-20 objets * de 100 000 enregistrements.

    2. Ma demande va augmenter de manière significative dans l'étendue des entités, mais la relative des nombres de chaque resteront faibles. 5000 objets * 100 enregistrements.

    3. Mon application est prévue pour rester avec ce nombre relativement limité d'entités ET restera en nombre relativement faible, par exemple de 10 à 20 objets * 100 enregistrements

    Dans mon cas, je suis au point de départ d'essayer de prendre cette décision. En outre compliquée par le fait d'avoir à changer l'INTERFACE utilisateur côté client de l'architecture ainsi que de faire le choix du transport. Mon précédent (très) grande échelle GWT INTERFACE utilisateur utilisé le Hmvc4Gwt de la bibliothèque, qui a été remplacé par le GWT MVP des installations.

    InformationsquelleAutor chillyspoon