I. Introduction▲
À 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é. À 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.
II. 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 dû à un changement du jdk1.4.1, en tout cas l'ensemble est bien plus agréable à l'usage.
II-A. 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 !
II-B. 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)
II-C. 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.
III. Construction▲
III-A. 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>III-B. 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.
IV. Gestion de source en équipe▲
En natif, maintenant JBuilder supporte : CVS, ClearCase, Visual Source Safe et StarTeam (racheté récemment par Borland).
IV-A. 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.
IV-B. 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... À noter que les commandes administratives (création de projets, branchage...) ne sont pas accessibles dans JBuilder.
V. JavaDoc▲
V-A. 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.
V-B. 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)
V-C. Rendu▲
Après compilation ou sur l'onglet JavaDoc, voici le résultat :
VI. Refactoring/Edition▲
De nombreux ajouts ont été faits sur le refactoring.
VI-A. 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.
VI-B. ErrorInsight▲
Error Insight permet en cours de frappe de proposer des solutions aux problèmes courants :
- 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
VI-C. 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.
VI-D. 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.
VII. 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.
VII-A. 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.
VII-B. Design Patern EJB/DTO▲
JBuilder intègre maintenant le design patern DTO. À 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.
VII-B-1. Diagramme de départ▲
VII-B-2. Choix des options : Façade, Business Delegate, Client Struts▲
VII-B-3. Choix des relations CMR▲
VII-B-4. Nom des "Value Object"▲
On peut remarquer les options de gestion des conflits pour le "Two Way".
VII-B-5. Choix des attributs à générer▲
VII-B-6. Options de l'"Assembler"▲
VII-B-7. Options de la "Façade"▲
Options du "Service Locator"
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.
À 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"...
Voici le résultat d'un DTO :
package com.test;
import java.io.Serializable;
public class EnterpriseDto implements Serializable {
private Integer idEntreprise;
private String raison;
public Integer getIdEntreprise() {
return idEntreprise;
}
public void setIdEntreprise(Integer idEntreprise) {
this .idEntreprise = idEntreprise;
}
public String getRaison() {
return raison;
}
public void setRaison(String raison) {
this .raison = raison;
}
public boolean equals(Object obj) {
if (obj != null ) {
if (this .getClass().equals(obj.getClass())) {
EnterpriseDto that = (EnterpriseDto) obj;
return ( ( (this .getIdEntreprise() == null ) && (that.getIdEntreprise() == null )) ||
(this .getIdEntreprise() != null &&
this .getIdEntreprise().equals(that.getIdEntreprise()))) &&
( ( (this .getRaison() == null ) && (that.getRaison() == null )) ||
(this .getRaison() != null &&
this .getRaison().equals(that.getRaison())));
}
}
return false;
}
public int hashCode() {
return (idEntreprise + "" + raison).hashCode();
}
public String toString() {
return idEntreprise + ", " + raison;
}
}VIII. J2ME▲
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 :
Voici le code nécessaire :
package com.borland.jbuilder.samples.micro.helloworld;
import javax.microedition.lcdui.*;
/**
* A simple displayable containing a simple string label.
*/
public class HelloWorldForm extends Form {
String message = new String ("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() {
public void 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.
*/
private void 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));
}
}IX. 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.
IX-A. 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 (eh oui, c'est possible en Java ;o) )
IX-B. Thread Debugger▲
Le Thread Debugger permet de résoudre les problèmes de blocage liés aux Threads :
IX-C. 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 !
X. 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.
XI. Remerciements▲
Merci à l'équipe de Developpez.com pour son accueil. Special thanks : DeveloppezAdm, Sébastien Meric et Knotty, pour leur soutien, Alacazam pour sa relecture active.
| Voir également |
| Informations détaillées sur JBuilder 9 |
| Le Forum JBuilder |