Discussion :

[rolintoucour]

Bonjour,

Je termine mes études d'ingé au CNAM, et je dois faire un dossier d'étude sur GWT. J'aurais désiré connaître le fonctionnement interne du framework (sûrement un pattern, comme de la DI je suppose ?) qui permet de déclarer des interfaces avec des annotations, par exemple pour accéder à une image depuis le code Java :

@source("mon_image.gif")
public ImageResource openMonImage();

Comment GWT arrive à écrire la vraie méthode qui fait le boulot ensuite ?

[Invité]

Bonjour,

Concernant GWT, la partie cliente est transformée en javascript.

Google a donc développé un compilateur spécifique qui prends en entrée du code Java et produit du code javascript.

[rolintoucour]

Bonsoir,

Je pense assez bien avoir compris le processus de compilation (permutations etc...). Ma question visait plus précisément à comprendre ce que GWT fait à partir de l'interface que l'on annote : est-elle convertie tout d'abord en Java, si oui comment (avant le JS), ou est-elle directement convertie en Javascript ?

[TokTokTok]

C'est une bonne question de comprendre la magie de GWT pour voir comment il fait pour faire du javascript avec du java. Le sujet m’intéresse si tu as des docs complètes là dessus, sur la compile gwt, je suis preneur.

"est-elle convertie tout d'abord en Java", tu fais référence à quoi ?

Ce que je sais, c'est que la permutation de java en javascript est l'une des derrière étapes du gwt compile. Tu peux le voir via tes traces de ton compilateur.

Au niveau build, il doit y avoir un check de toutes tes annotations, une vérification que tu as un uibinder associé aux classes où il y a cette annotation, il doit avoir ensuite un processus de mapping, entre ton XML uibinder et ta classe java avec tes annotations (cf com.google.gwt.uibinder.rebind.model.OwnerClass -> findUiFields). tu dois avoir un parseur HTML perso afin de checker ton XML uibinder de ta classe (UiBinder.xsd ??) ...

Désolé de ne pas être plus précis, mais ce n'est que de la supposition. Je te conseille de re-compiler les sources GWT et de tester, c'est une bonne piste pour commencer ton dossier d'étude ... Il y a un fichier ant, cela doit être faisable sans y perdre des heures ...
http://google-web-toolkit.googlecode.com/svn/trunk

[adiGuba]

Salut,

Ma question visait plus précisément à comprendre ce que GWT fait à partir de l'interface que l'on annote : est-elle convertie tout d'abord en Java, si oui comment (avant le JS), ou est-elle directement convertie en Javascript ?

C'est le "Deffered Binding".
Il s'applique pour tous les types que tu instancies par GWT.create().


Tu as deux type de Deffered Binding :




1. Le Deffered Binding par remplacement

Grosso-modo cela consiste à remplacer un type par un autre.
Par exemple lorsque le compilateur GWT trouve ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

MonType instance = GWT.create(MonType.class);

Il va chercher comment générer le type "MonType", à partir des infos contenu dans les fichiers .gwt.xml.

On peut donc y définir une classe concrête de remplacement, par exemple :

Code XML :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<replace-with class="com.company.client.anywhere.MonTypeImpl">
	<when-type-is class="com.company.client.MonType" />
</replace-with>

Ici GWT remplacera MonType par MonTypeImpl, ce qui donnera l'équivalence suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
//MonType instance = GWT.create(MonType.class);
MonType instance = new com.company.anywhere.MonTypeImpl();

Bien sûr la classe MonTypeImpl existe déjà...

L'intérêt c'est qu'on a la possibilité de modifier le type selon des propriétés comme par exemple l'user.agent ou la locale :
[code=XML]<replace-with class="com.company.client.anywhere.MonTypeImpl">
<when-type-is class="com.company.client.MonType" />
</replace-with>

<replace-with class="com.company.client.anywhere.MonTypeImplIE6">
<when-type-is class="com.company.client.MonType" />
<when-property-is name="user.agent" value="ie6" />
</replace-with>
Désormais, MonType sera toujours remplacé par MonTypeImpl, sauf pour la permutation d'IE6 où on utilisera MonTypeImplIE6 à la place...





2. Le Deffered Binding par génération

Le remplacement est suffisant pour les cas les plus simple, mais ce n'est pas suffisant pour des choses plus complexe. On peut alors utilisé des generateurs.

Code XML :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<generate-with class="com.company.rebind.MonTypeGenerator">
	<when-type-assignable class="com.company.client.MonType" />
 </generate-with>

Désormais, lorsque le compilateur touvera un GWT.create(MonType.class), il va utiliser la classe MonTypeGenerator pour générer le code correspondant.


Cette classe étend com.google.gwt.core.ext.Generator et possède une méthode generate() qui sera appelée avec le nom du type et surtout un GeneratorContext qui permet d'accéder aux infos du code source (nom des méthodes, annotations, etc), tout en permettant en même temps de générer une classe Java.

Cette classe sera elle-même compilé en javascript par la suite...





Plus d'info ici : https://developers.google.com/web-to...BasicsDeferred



a++

[rolintoucour]

Hello,

Ta réponse fait me poser 2 nouvelles questions :

- le deferred binding, n'est-ce pas le fait de charger une permutation après chargement de la page (et exécution du script de détection du contexte) ? Sinon pourquoi ce nom de liaison différée ? Quel lien avec le fonctionnement de GWT.Create ?

- Comment le GWT.create() arrive à créer des instanciations d'interface ? Comment opère-t-il et y'a-t-il un pattern là-dedans ? (ça m'intéresse, ça fera bien dans mon dossier...)

[adiGuba]

- le deferred binding, n'est-ce pas le fait de charger une permutation après chargement de la page (et exécution du script de détection du contexte) ?

Non le deffered binding c'est le fait de choisir une implémentation de classe/interface selon le contexte (propriété GWT tel que locale, user.agent, etc.)

Sinon pourquoi ce nom de liaison différée ? Quel lien avec le fonctionnement de GWT.Create ?

En général la liaison du code est faite soit à la compilation (pour les langages natif comme le C/C++), soit à l'exécution pour les langages tournant sur une JVM (comme Java) où on parle de liaison tardive.

Dans le premier cas tu dois donc compiler ton application pour chaque cible.
Dans le second une compilation suffit, mais tu utilises du code différent à l'exécution selon la machine hôte...


Là tu as un cas un peu "bâtard", dans le sens où la liaison est faite à la compilation GWT, mais qu'il faut quand même utiliser du code différent selon l'hôte (le navigateur).
Comme il n'y a pas de possibilité de liaison tardive en JavaScript, Google a utilisé ce qu'ils nomment du deffered-binding en GWT.

En gros lorsque tu utilises GWT.create(X), le compilateur par rechercher dans les fichiers de configuration *.gwt.xml les tags <replace-with> ou <generated-with> correspondant, afin de déterminer le bon type à utiliser...

- Comment le GWT.create() arrive à créer des instanciations d'interface ? Comment opère-t-il et y'a-t-il un pattern là-dedans ? (ça m'intéresse, ça fera bien dans mon dossier...)

Ben c'est le deffered-binding qui fait cela.

Lorsque tu fais un GWT.create() avec une interface, tu dois OBLIGATOIREMENT définir un <replace-with> ou <generated-with> qui permettent :

• De définir le type à utiliser (selon des variables tel que la locale, l'user.agent ou autre) via <replace-with>.
• De générer une classe dynamiquement via <generated-with>, grâce aux Generators...

a++

[midou99]

Je te conseille ce livre

http://books.google.fr/books/about/P...UC&redir_esc=y