Discussion :

[valkeke]

Bonjour,

Je suis en train de regarder de prés les rapports que génère le compilateur GWT avec les options

Code :

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

1
2
3
4
5
 
<draftCompile>false</draftCompile>
<compileReport>true</compileReport>
<compilerMetrics>true</compilerMetrics>
<style>OBFUSCATED</style>

Mon but est d'essayer de diminuer l'initial download de mon application.
Est-ce qu'on peut mettre d'autres options pour améliorer tout ça ?

Je parcours les rapports et c'est pas vraiment évidant pour moi d'avoir une idée précise où je peux intervenir afin de réduire l'initial download

Quelqu'un aurait-il des liens, tutoriaux afin de montrer une certaine démarche, pour aider à comprendre comment améliorer tout ça et surtout comment l'exploiter efficacement ??

merci d'avance...

[valkeke]

A voir le nombre de réponse à mon post, je me demande si les rapports de compilation de GWT sont vraiment utilisés ou y a que moi qui a des difficultés

Par exemple, j'ai lu qu'il fallait utiliser de préférence les implémentations des List comme ArrayList que son interface dans les méthodes contenu dans le RPC(en tant que paramètre de retour et de paramètre d'entrée des méthodes), je suis en train de faire des tests et j'avoue que le gain n'est pas vraiment probant...et vous qu'utilisez-vous ?

[adiGuba]

Salut,


Le fait d'utiliser une implémentation précise à la place d'une interface (ex: ArrayList à la place de List) permet de réduire le nombre de type supporté par RPC.
En effet lorsque tu utilises un type via RPC, GWT va automatiquement compiler les classes filles (avec le code de conversion RPC) :
Ainsi pour List tu auras :

• java.util.ArrayList
• java.util.Arrays$ArrayList
• java.util.Collections$EmptyList
• java.util.Collections$SingletonList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

Utiliser le type précis est un peu moins propre et moins souple, mais permet d'éviter un peu de lourdeur.
A noter que tu peux également utiliser la propriété "rpc.blacklist" dans ton .gwt.xml pour déclarer les types à ne pas compiler pour le RPC.
Perso j'utilise ceci :

Code xml :

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

1
2
3
	<extend-configuration-property name="rpc.blacklist" value="-java.util.Stack"/>
	<extend-configuration-property name="rpc.blacklist" value="-java.util.Vector"/>
	<extend-configuration-property name="rpc.blacklist" value="-java.sql.*"/>

Tu peux facilement voir les classes concernées via le fichier *.gwt.rpc généré par la compilation.



Sinon outre l'obfuscation, tu peux aussi utiliser le paramètre -optimize 9.
Seon ton besoin tu peux aussi utiliser -nocheckAssertions (pour virer les assert), -XnoclassMetadata (qui remplace le nom des classes par une chaine courte style "C1234") et -XnocheckCasts (qui vire toutes les checks des casts - du coup plus de ClassCastException mais des erreurs Javascript "étrange").


Un autre gros facteur concerne le mode du stacktrace.
Tu peux définir cela dans ton .gwt.xml via la propriété "compiler.stackMode" :

Code XML :

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

	<set-property name="compiler.stackMode" value="native"/>

Elle peut prendre 3 valeurs :

• "native" : GWT gérera le stacktrace selon le navigateur, pour des résultats variables mais une application assez légère légère.
  Toutefois certains "vieux" navigateurs renvoient un peu n'importe quoi...
• "strip" : GWT supprimera le stacktrace, ce qui permet de générer une application encore plus légère (mais là on n'a plus aucune info si ce n'est le message de l'exception).
• "emulated" : GWT émulera un stacktrace similaire à ce que l'on peut retrouver dans une application Java, mais cela implique un code un peu plus imposant.

Enfin si ton appli est bien séparé en plusieurs parties, tu peux utiliser le code-splitting pour découper ton appli en plusieurs parties (avec GWT.runAsync()). Cela ne réduira pas la taille totale, mais cela permettra de démarrer l'appli sans tout charger...


a++