Un plugin Eclipse offre la possibilité de vérifier en directe une expression régulière : myregexp. Ce plugin existe aussi en version en ligne ici.

Le site d’update est : http://update.zeroturnaround.com/update-site. Le plugin à installer : JRebel m2eclipse.

Par défaut, Maven utilise javac pour compiler les sources Java. Or, dans certains cas, le compilateur eclipse (JDT) accepte de compiler des classes là où javac sort en erreur. Par exemple, voici un code qui compile avec le JDT et pas avec javac :

package com.test;

public class GenericMethod {

    private Object value;

    @SuppressWarnings("unchecked")
    public <X> X getValue() {
        return (X) value;
        // le cast n'est obligatoire que pour que javac compile
        // avec le compilateur eclipse, il n'est pas nécessaire
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

Voici la classe pour appeler la méthode :

package com.test;

public class GenericMethodTest {

    public static void main(String[] args) {
        GenericMethod method = new GenericMethod();
        method.setValue(3);

        int[] array = new int[] {1, 2};

        array[0] = method.getValue();
        System.out.println(array[0]);
    }
}

Avec javac, la ligne 11 de la classe GenericMethodTest provoque l’erreur suivante :

type parameters of <X>X cannot be determined;no unique maximal instance exists for type variable X with upper bounds int,java.lang.Object

Il peut donc être essentiel d’utiliser dans le processus de build un autre compilateur que javac. Il est possible de configurer le plugin maven-compiler-plugin afin d’utiliser un compilateur alternatif. Par exemple, pour utiliser le compilateur eclipse c’est très simple :

<project>
  [...]
  <build>
    [...]
    <plugins>
      [...]
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <compilerId>eclipse</compilerId>
        </configuration>
        <dependencies>
          <dependency>
            <groupId>org.codehaus.plexus</groupId>
            <artifactId>plexus-compiler-eclipse</artifactId>
          </dependency>
        </dependencies>
      </plugin>
  [...]
</project>

Le build maven fonctionne parfaitement, en revanche l’utilisation du compilateur alternatif a des effets secondaires lorsqu’il est utilisé par le plugin eclipse m2e. La modification des fichiers .classpath et .project ne fonctionne plus correctement et cela provoque :

• La nature java du projet n’est pas détectée,
• Les dépendances ne sont plus récupérées,
• Les répertoires sources (src/main/java, src/main/resources, etc.) ne sont plus référencés

Le problème du nouveau plugin m2e c’est qu’il ne reconnaît les projets maven en tant que projets java que lorsque le compilateur utilisé est javac. Pour configurer un projet eclipse utilisant le compilateur eclipse, il est donc nécessaire d’indiquer à m2e qu’il s’agit bien d’un projet Java :

<pluginManagement>
  <plugins>
    <plugin>
      <groupId>org.eclipse.m2e</groupId>
      <artifactId>lifecycle-mapping</artifactId>
      <version>1.0.0</version>
      <configuration>
        <lifecycleMappingMetadata>
          <pluginExecutions>
            <pluginExecution>
              <pluginExecutionFilter>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <versionRange>[2.0,)</versionRange>
                <goals>
                  <goal>compile</goal>
                  <goal>testCompile</goal>
                </goals>
              <parameters>
                <compilerId>eclipse</compilerId>
              </parameters>
             </pluginExecutionFilter>
             <action>
               <configurator>
                 <id>org.eclipse.m2e.jdt.javaConfigurator</id>
               </configurator>
             </action>
           </pluginExecution>
          </pluginExecutions>
        </lifecycleMappingMetadata>
      </configuration>
    </plugin>
  </plugins>
</pluginManagement>

Dès que m2e reconnaît le projet en tant que projet java, la fonction Update project configuration, configurera les répertoires sources et mettra à jour le classpath du projet.

La seule solution que j’ai trouvé c’est d’utiliser un proxy compatible avec l’authentification NTML entre mon IDE et le proxy à “contourner”. C’est cet intermédiaire qui va prendre en charge l’authentification à la place d’Eclipse.

CNTML me paraît être une bonne solution. Il s’installe sous windows en tant que service et il n’y a qu’un seul fichier de configuration pour lui indiquer le proxy pour aller sur internet.

Avant toute chose, il faut vérifier que maven est configuré pour aller chercher des librairies sur le repository JBoss : le fichier settings.xml (~/.m2/settings.xml ou $MAVEN_HOME/conf/settings.xml) doit contenir le code XML suivant :

<settings>
 ...
  <profiles>
    ...
    <profile>
      <id>jboss-public-repository</id>
      <repositories>
        <repository>
          <id>jboss-public-repository-group</id>
          <name>JBoss Public Maven Repository Group</name>
          <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>
          <layout>default</layout>
          <releases>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </releases>
          <snapshots>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </snapshots>
        </repository>
      </repositories>
      <pluginRepositories>
        <pluginRepository>
          <id>jboss-public-repository-group</id>
          <name>JBoss Public Maven Repository Group</name>
          <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>
          <layout>default</layout>
          <releases>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </releases>
          <snapshots>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
          </snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>

  </profiles>

  <activeProfiles>
    <activeProfile>jboss-public-repository</activeProfile>
  </activeProfiles>
  ...
</settings>

Ensuite, pour créer le projet dans Eclipse, il faut commencer par installer le catalogue JBoss : Windows -> Preferences… puis dans la fenêtre Maven -> Achetypes cliquer sur le bouton  Add Remote Catalog… Saisir https://repository.jboss.org/nexus/content/groups/public/archetype-catalog.xml dans l’intitulé Catalogue File et JBoss dans Description. Après l’opération, il ne reste plus qu’à accéder au wizard de création d’un projet Maven (File -> New -> Project… puis Maven project) et de sélectionner l’archetype jboss-javaee6-webapp.

Le squelette de l’application est celui-ci :

/home/…/jboss-webapp-j2ee6
|– pom.xml
|– readme.html
|– readme.md
`– src
|– main
|   |– java
|   |   `– test
|   |       `– jboss_webapp_j2ee6
|   |           |– controller
|   |           |   `– MemberRegistration.java
|   |           |– data
|   |           |   `– MemberListProducer.java
|   |           |– model
|   |           |   `– Member.java
|   |           |– rest
|   |           |   |– JaxRsActivator.java
|   |           |   `– MemberResourceRESTService.java
|   |           `– util
|   |               `– Resources.java
|   |– resources
|   |   |– import.sql
|   |   `– META-INF
|   |       `– persistence.xml
|   `– webapp
|       |– index.html
|       |– index.xhtml
|       |– resources
|       |   |– css
|       |   |   `– screen.css
|       |   `– gfx
|       |       |– banner.png
|       |       `– logo.png
|       `– WEB-INF
|           |– beans.xml
|           |– faces-config.xml
|           `– templates
|               `– default.xhtml
`– test
|– java
|   `– test
|       `– jboss_webapp_j2ee6
|           `– test
|               `– MemberRegistrationTest.java
`– resources
`– arquillian.xml

Ce qui équivaut à une application de départ avec un exemple JSF2 s’appuyant sur une base de données embarquée avec quelques classes constituant un modèle MVC, un exemple de service web REST, et un exemple de test unitaire avec Arquillian. A noter aussi, l’utilisation d’un EJB3 archivé dans un WAR et non un EAR comme il aurait fallu le faire avec J2EE5.

Pour déployer l’application il faut la packager et utiliser le plugin JBoss de déploiement déjà configuré par l’archetype (maven package jboss-as:deploy). Attention, pour que tout se déroule correctement, il faudra avoir démarré votre serveur JBoss7 au préalable.

Si l’option Decorate Classes with Test Case est activée (Window > Preferences… > General > Appearance > Label Decorations), les classes qui sont testées sont représentées avec un icon différent :

La même marque verte apparaît au niveau de la marge de l’éditeur Java au début des méthodes testées :

A partir d’une classe, un menu contextuel permet les actions suivantes :

• Ouvrir la classe de test associée
• Générer la classe de test si celle-ci n’existe pas
• Exécuter la classe de test en entier
• Exécuter les méthodes de test associées à une sélection de méthodes de la classe d’origine

Le plugin sait aussi prendre en compte les refactorings de la classe testée :

• Si la classe testée est renommée, la classe de test est renommé elle aussi
• Idem, si la méthode testée est renommée, les méthodes de test le sont aussi
• Si la classe testée change de package, la classe de test change aussi de package

Enfin, la dernière fonctionnalité que je trouve très utile dans certains contextes, MoreUnit peut générer les mocks des objets utilisés dans la classe testée. Il est compatible avec Mockito et EasyMock. Il ne reste plus qu’a les paraméter.

Installation

Il est nécessaire d’installer les plugins suivant dans eclipse :

• TPTP qui est dispoinble à partir du site d’update : http://download.eclipse.org/tptp/updates/galileo/
• JBoss Tools (notamment Test and Performances -> TPTP Profile On JBoss Server) qui est disponible à partir du site d’update : http://download.jboss.org/jbosstools/updates/development/

Puis il faut créer un serveur JBoss depuis la vue Server.

TPTP

JBoss TPTP

Exécution

Pour exécuter le profilage, il faut démarrer votre serveur JBoss avec le bouton Profile. Eclipse vous demande de choisir le type d’informations à mesurer. Une seule possibilité à la fois (je n’ai pas encore compris pourquoi je ne peux pas avoir plusieurs data collector en même temps…) :

Avant de cliquer sur le bouton Finish, n’hésitez pas à ajouter ou modifier les filtres par défaut en double-cliquant sur Java Profiling. Cela va vous permettre de focaliser votre attention sur votre code et non celui des librairies tierces que vous utilisez :

Après le démarrage de votre serveur en mode profile, le collecteur de données se synchronise à intervalle de temps régulier. Pour éviter d’enregistrer des informations inutiles, vous pouvez le mettre en pause par exemple.

Problèmes rencontrés et astuces

JRebel

Il faut savoir que JRebel ne fonctionne pas lorsqu’on utilise TPTP. Donc si vous utilisez cet outil, il faudra le désactiver (démarrer votre serveur JBoss sans les paramètres JRebel) pour pouvoir profiler votre application.

Profiles indisponibles

Si lorsque vous essayez de démarrer votre serveur en mode profile vous avez une exception vous parlant de collecteur de données, vérifier que vos plugins soient bien à jour.

Performances

TPTP est très gourmand en mémoire donc ne vous étonnez pas de voire les performances de votre application chuter rapidement. J’ai aussi remarqué que les performances d’éclipse s’effondrent rapidement lors de l’analyse des données quand celles-ci sont très volumineuses.

import static org.testng.AssertJUnit.*;

Pour profiter de l’autocompletion sans ajouter cette ligne au préalable, il faut se diriger dans le menu : Window -> Preferences puis Java -> Editor -> Content Assist -> Favorites et ajouter le nouveau type org.testng.AssertJUnit.

Mes recherches m’ont permis de découvrir qu’il était possible de paramétrer le démarrage des processus Eclipse a l’ouverture d’un workspace dans le fenêtre Window -> Preferences puis General -> Startup and Shutdown.

Mes la solution réelle à mes problèmes de lenteur a été de supprimer un répertoire de mon workspace : WORKSPACE_HOME/.metadata/.plugins/org.eclipse.core.resources/.projects. Eclipse ne freeze plus au démarrage par contre il faut reconfigurer tous les projets du workspace. Par exemple, j’ai du  réactiver maven sur mes projets et les reconnecter à subversion. Pour les projets maven multimodule il m’a fallu supprimer les sous-modules puis les réimporter à partir du projet père.

Créer son projet multi-module

Avec le wizard de création de projet : File -> New -> Project…, créer un nouveau projet Maven puis cocher la case “Create simple project (skip archetype selection)” puis remplir le formulaire suivant :

Le fichier pom.xml doit être généré de la sorte :

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany.app</groupId>
  <version>0.0.1-SNAPSHOT</version>
  <artifactId>app-root</artifactId>
  <packaging>pom</packaging>
</project>

Pour construire un ou plusieurs sous module, il faut ouvrir le pom.xml avec l’éditeur pour de fichier POM et cliquer sur l’icone “New module project”. Cette fonctionnalité existe aussi à partir du menu contextuel de la vue “Project explorer”. Voici ce que nous avons pour l’instant :

Matérialiser ses projets Maven

Pour cela il faut importer le sous module comme un nouveau projet : File -> Import... Sélectionner ensuite “Materialize Maven Project”, enfin sélectionner le projet que nous avons créer ci dessus dans la boite de dialogue suivante. Voici le résultat dans eclipse :

Après cette opération vous avez bien tous les sous modules sous la forme de projet Eclipse dissociés.