A chaque fois que l'on utilise un produit Borland, on se demande ce
qu'ils vont bien pouvoir imaginer dans la version suivante. JBuilder 8
était déjà un produit très abouti, arrivé à maturité.
Et pourtant, vous allez voir que cette nouvelle version va
vite vous devenir indispensable tant l'ajout fonctionnel est important.
Il faut dire que le marché de l'IDE java est fortement concurrentiel.
Après la disparition de Visual J++, Visual Café, Visual age
(c'est peut-être à cause du préfix "Visual" ;o) ), JBuilder est vite
devenu l'IDE java N°1. C'était sans compter des petits nouveaux :
IntelliJ, Eclipse et d'autres qui offrent maintenant des IDE de qualité
à bas prix ou même gratuit.
Face à cette compétition, Borland est toujours obligé d'en faire plus et
d'innover pour rester leader sur ce secteur.
Le résultat de cette évolution : un environnement très élaboré.
A ma connaissance, jamais un IDE ne sera allé aussi loin pour le
confort des développeurs (je ne connais pas non plus tous les autres
IDE du marché). Voici peut être l'occasion d'un nouvel article.
Remerciements
Merci à l'équipe de Developpez.com pour son accueil.
Special thanks : DeveloppezAdm, Sébastien Meric et Knotty, pour leur
soutient, Alacazam pour sa relecture active.
1. L'IDE
La première chose qui choque à l'utilisation de cette nouvelle version,
c'est la fluidité de l'IDE en général.
C'était souvent un reproche que l'on pouvait faire à cet outil,
le choix du 100% java (Swing) a rendu l'IDE un peu lourd à l'utilisation.
Peut-être est-ce du à un changement du jdk1.4.1, en tout cas l'ensemble est
bien plus agréable à l'usage.
1.1. Nouveau look & feel
Borland a ajouté un nouveau look & feel : le Borland Look&Feel.
Il vient s'ajouter aux traditionnels : Metal, Windows et CDE/Motif.
Loin d'être un gadget, l'interface devient tout de suite plus agréable,
les fontes sont réduites, l'ensemble prend moins de place.
Cela ressemble à visual studio .NET !
1.2. Gestion de projet / Ajout des drag & drop
On peut maintenant faire du drag & drop avec les fichiers d'une
branche à une autre, d'un projet à un autre et de l'explorateur
windows à un projet (pratique pour ajouter des nouveaux fichiers
à un projet)
1.3. Gestion de projet / Gestion fichiers & répertoires contextuels
La gestion d'ajout de fichiers et de répertoires peut maintenant se
faire aussi contextuellement sur la vue projet.
2. Construction
2.1. ANT
La grande nouveauté sur ANT vient de la possibilité d'exporter son
projet JBuilder vers ANT. Très pratique pour automatiser des tâches
en lignes de commande. Sur les tests que j'ai pu faire, l'assistant
configure les chemins, la compilation, le nettoyage, la javadoc,
la fabrication des jars...
Les tests sur les EJB semblent concluants, compilation, stubs et
déploiements... (utilisation de iastool pour BES)
Voici le résultat de l'export d'un projet contenant des classes à
compiler plus la création d'un jar applicatif:
<?xml version="1.0" encoding="UTF-8"?> <!-- Exported by JBuilder on 6 juin 2003 17:04:47 --> <!-- It is RECOMMENDED that JBuilder builds and Ant builds done with
this exported Ant file be kept separate and be written to different
directories. For example, the JBuilder output directory might be "classes"
and the Ant output directory might be "classes.ant". -->
<project basedir="." default="rebuild" name="untitled3.jpx">
<property name="jbuilder.home" value="C:/java/JBuilder9"/>
<property name="jdk.home" value="${jbuilder.home}/jdk1.4"/>
<property name="dest" value="classes.ant"/>
<property name="Generated.Source" value="${dest}/Temporary_Files"/>
<property name="src" value="src"/>
<path id="project.class.path">
<pathelement location="${dest}"/>
<pathelement location="${jdk.home}/lib/dt.jar"/>
<pathelement location="${jdk.home}/lib/tools.jar"/>
</path> <!-- Patternset to exclude files from the output directory: -->
<patternset id="dest.exclude">
<exclude name="Temporary_Files/"/>
<exclude name="Generated Source/"/>
<exclude name="package cache/"/>
<exclude name="dependency cache/"/>
<exclude name="jsp cache/"/>
</patternset>
<target depends="init" name="javacompile">
<javac bootclasspathref="project.class.path" debug="true" deprecation="true" destdir="${dest}" nowarn="false" target="1.2">
<src path="${src}"/>
<src path="${Generated.Source}"/>
</javac>
</target>
<target depends="resource" name="archive">
<jar compress="false" destfile="untitled3.jar">
<fileset dir="${dest}">
<patternset refid="dest.exclude"/>
<include name="**/*.*"/>
</fileset>
</jar>
</target>
<target name="cleanup">
<delete file="untitled3.jar"/>
<delete failonerror="false" includeemptydirs="true">
<fileset dir="${dest}"/>
</delete>
</target>
<target name="resource">
<copy todir="${dest}">
<fileset dir="${src}">
<include name="**/*.jpe"/>
<include name="**/*.jpeg"/>
<include name="**/*.rmf"/>
<include name="**/*.wav"/>
<include name="**/*.mid"/>
<include name="**/*.midi"/>
<include name="**/*.au"/>
<include name="**/*.gif"/>
<include name="**/*.png"/>
<include name="**/*.jpg"/>
<include name="**/*.aiff"/>
<include name="**/*.properties"/>
</fileset>
</copy>
</target>
<target name="javadoc"/>
<target depends="cleanup" name="clean"/>
<target name="precompile"/>
<target depends="javacompile" name="compile"/>
<target name="postcompile"/>
<target depends="archive,javadoc,resource" name="package"/>
<target name="deploy"/>
<target depends="precompile,compile,postcompile,package,deploy" name="make"/>
<target depends="clean,make" name="rebuild"/>
<target name="init">
<mkdir dir="${dest}"/>
<mkdir dir="${Generated.Source}"/>
</target>
</project>
2.2. Build / jar
On peut maintenant utiliser la gestion de filtre avec des critères
de filtre, d'inclusion/exclusion et de récursivité en
plus des paramètres traditionnels.
3. Gestion de source en équipe
En natif, maintenant JBuilder supporte : CVS, ClearCase, Visual Source Safe
et StarTeam (racheté récemment par Borland).
3.1. CVS
L'intégration CVS a été encore améliorée, dans les nouveautés,
la possibilité à partir de JBuilder de faire les tâches d'administration
(création de versions labellisées, suppression d'un label,
déplacement d'un label, Merge et création de branches.
3.2. StarTeam
StartTeam bénéficie de l'intégration complète de son interface
dans l'IDE, l'ensemble des opérations est accessible via cette interface
tout en ayant les raccourcis standards des fichiers...
A noter que les commandes administratives (création de projets,
branchage...) ne sont pas accessibles dans JBuilder.
4. JavaDoc
4.1. Ajout de tag
On peut maintenant paramétrer les tags JavaDoc. JBuilder laisse la possibilité
d'ajouter de nouveaux tags. On peut également préciser où on peut les
placer et comment ils sont représentés.
4.2. Audit de code
L'éditeur offre maintenant l'audit de code sur la JavaDoc en prenant
en compte les tags ajoutés. Le tout est vérifié par l'IDE qui affiche
des erreurs en cas de problème. (comme avec le code java)
4.3. Rendu
Après compilation ou sur l'onglet JavaDoc, voici le résultat :
5. Refactoring / Edition
De nombreux ajouts ont été faits sur le refactoring.
5.1. Recherche de la méthode surchargée
Le refactoring se voit ajouter la fonctionnalité suivante : Dans l'arborescence,
sur une méthode, on peut maintenant trouver directement
l'implémentation de la méthode surchargée.
5.2. ErrorInsight
Error Insight permet en cours de frappe de proposer des solutions
aux problèmes courrants :
Classe ou fichier avec un mauvais nom => Renommer
Classe introuvable => Rechercher / Création de classe / Création d'interface
Classe devrait être abstraite => Rendre abstrait / Implémenter les méthodes
Constructeur introuvable => Création du constructeur / Surcharge du constructeur
Exception non attrapée => Englober avec un try...catch / ajouter un throws
Méthode non trouvée => Création de la méthode / Proposer une autre méthode
Package incorrect => Modifier la déclaration / déplacer le fichier
Package introuvable dans l'import => Supprimer l'import / Création du package
Types incompatibles => Ajout d'un cast
Type introuvable => Trouver avec classInsight / Création de la classe / Création de l'interface / Proposer des classes similaires
Variable introuvable => Créer une variable / Création d'un champ / Proposer une correction
5.3. Templates
Le système des templates (ctrl+j) a été modifié. Nous avons maintenant
la possibilité d'ajouter les imports nécessaires à la macro et de différencier
les macros pour java, html ou autres.
5.4. L'édition synchronisée
C'est le petit gadget qui devient vite indispensable.
Cette fonctionnalité intéressante est utilisable sur les templates et
toute autre partie de code java. En sélectionnant un morceau de code
et en activant l'édition synchronisée (dans la marge), on peut changer
en une seule fois tous les éléments communs.
6. J2EE
JBuilder supporte maintenant les serveurs suivants :
BES 5.x
Generic App Server (spec seule)
IPlanet Application Server 6.x
Sybase Enterprise Application Server 4.x
Tomcat 3.3
Tomcat 4.0
Tomcat 4.1
WebLogic Application Server 6.x
WebLogic Application Server 7.x
WebSphere Application Server 5.X
WebSphere Application Advanced Edition 4.x
WebSphere Application Single Server 4.x
Oracle 9ias (Développé par Oracle, install sur le CD)
Ces OpenTools sont livrés avec JBuilder, d'autres comme Jonas ou JBoss sont
disponibles en téléchargement sur Internet.
JBuilder est devenu l'environnement proposé en standard pour BES, Weblogic et Sybase.
Borland distribue une version de JBuilder spéciale Weblogic, je pense que
l'intégration est identique. Cette version est distribuée par BEA.
Le designer a été revu pour être plus rapide.
6.1. Intégration de la console BES
JBuilder intègre maintenant la console de BES directement dans l'IDE,
ce qui permet de suivre les logs ou de faire les tâches d'administration
sur les serveurs. Il n'y a donc plus qu'une JVM en mémoire pour ces deux
outils.
6.2. Design Patern EJB / DTO
JBuilder intègre maintenant le design patern DTO. A partir d'un Entity,
JBuilder génère toutes les classes nécessaires à l'élaboration du
Design Patern DTO : le Value Object, la Façade, le Business Delegate,
le service locator...
L'ensemble semble supporter le "Two Way". Les relations CMR sont prises
en compte lors de la génération.
La génération prend en compte également la génération des écrans Struts.
6.2.1. Diagramme de départ
6.2.2. Choix des options : Façade, Business Delegate, Client Struts
6.2.3. Choix des relations CMR
6.2.4. Nom des "Value Object"
On peut remarquer les options de gestion des conflits pour le "Two Way".
6.2.5. Choix des attributs à générer
6.2.6. Options de l'"Assembler"
6.2.7. Options de la "Façade"
6.2.8. Options du "Service Locator"
6.2.9. Diagramme final
L'ensemble est bien fait, très pratique. Il semblerait que le wizard
soit capable de gérer des cycles itératifs avec modification de code.
A vérifier en situation réelle.
Je critiquerais le choix des implémentations (locator...) je n'ai pas
trouvé la possibilité de modifier les Templates
(c'est en dur dans l'openTool ?).
J'hésite aujourd'hui entre l'outil fabuleux ou le gadget inutile pour
faire de la génération à la "Rational Rose"...
Le développement J2ME est maintenant intégré en standard dans JBuilder,
du peu que j'ai vu, c'est très simple à utiliser.
Voici un exemple d'application en action:
/**
* A simple displayable containing a simple string label.
*/ publicclass HelloWorldForm extends Form {
String message = newString ("JBuilder rocks!");
/**
* Create a new HelloWorldForm displayable object
*/ public HelloWorldForm() { // create a new form with "Hello World" as the title super ("Hello World"); // listen for command events this .setCommandListener(new CommandListener() { publicvoid commandAction(Command c, Displayable d) { if (c.getCommandType() == Command.EXIT) { // exit the midlet
HelloWorldMidlet.quit();
}
}
}
); // initialize the ui elements try {
jbInit();
}
catch (Exception e) {
e.printStackTrace();
}
}
/**
* UI initialization.
*/ privatevoid jbInit() throws Exception { // add the display string this .append(message);
// register to receive notification for quit commands this .addCommand(new Command("Exit", Command.EXIT, 1));
}
}
8. OptimizeIt
OptimizeIt est la grande nouveauté du produit.
L'intégration du produit est complète, OptimizeIt se lance depuis JBuilder,
s'exécute dans JBuilder, et plus intéressant : il s'exécute directement
dans la JVM de JBuilder, donc on évite le chargement de deux JVM en mémoire,
plus de communication en mode socket, le résultat est bien plus rapide
que la version stand alone.
L'intégration dans JBuilder se fait via une troisième icône
(après l'exécute & le debug).
La configuration se fait comme d'habitude, un nouvel onglet permet
de choisir le type d'exécution : Profiler, Thread Debugger, Code coverage.
Cette fenêtre permet aussi de définir des groupes de classes pour ne pas
"polluer" les stats.
8.1. Profiler
Le Profiler permet de suivre l'état de la mémoire, le garbage collector,
les Threads, les classes chargées.
Il permet aussi de voir les "Hot spots" du programme ainsi que le
parcours d'exécution. On peut voir le détail pour chaque Thread ou
globalement.
Autre type de vue : le graphe d'exécution qui permet de voir où est perdu le temps:
Autre outil du Profiler: le suivi des instances du programme :
On peut voir exactement la taille occupée, le nombre d'instances et dans quel élément ils sont conservés :
Un autre outil permet de voir les fuites de mémoire (et oui, c'est possible en java ;o) )
8.2. Thread Debugger
Le Thread Debugger permet de résoudre les problèmes de blocage liés aux Threads :
8.3. Code Coverage
Le "Code coverage" est un outil qui permet de voir la couverture de
code lors d'une exécution. Cet outil est particulièrement pratique
pour vérifier si les tests couvrent tous les cas.
Il est à noter que la version Server Trace (pour les serveurs J2EE)
n'est pas livrée avec JB9. On ne peut pas tout avoir !
Voici un nouvel outil dont on aurait tort de se passer pour améliorer
nos programmes.
Dans le test que j'ai utilisé pour ces captures j'ai d'ailleurs
remarqué de gros problèmes de performances avec le SimpleDateFormat.
Très instructif !
Conclusion
Voici un aperçu des nouveautés de JBuilder 9. Ce document n'est pas exhaustif,
la documentation signale d'autres nouveautés que je n'ai pas pu étudier.
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur.
La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de
l'autorisation de l'auteur.