A quoi ça me sert ?

J’ai un certain nombre de PDF de “chevet” pour mon travail, que ce soit de la documentation de référence comme celle de Spring, d’Hibernate ou de Seam ou du livre en version électronique acheté sur Internet (Seam in Action, Open-Source ESB in action). Bref tout ce petit monde représente quelques kilos et deux ou trois forêts abattues une fois imprimés et là avec ce petit gadget de 260 g, j’embarque tout le monde. Idem pour les documents de mes projets convertis en RTF ou PDF (on peut passer en mode paysage pour regarder des présentations). Mais ce n’est pas tout, l’engin est livré avec une carte pleine de classiques de la littérature de Balzac à Zola en passant par Conan Doyle, ce qui me permet de joindre l’agréable à l’utile.

L’encre sympathique

Franchement l’e-ink est un procédé vraiment bluffant. On a l’impression de lire une page de papier légèrement glacé. La vision n’est pas plus altérée que sur du papier en changeant l’angle de la “page”, aucun scintillement ni aucune fatigue oculaire ne se manifeste après plusieurs heures de lecture. En fait, l’engin est la plupart du temps passif : ce n’est que lors d’un changement de page qu’un peu d’énergie est consommée pour effacer l’ancien contenu et en afficher un nouveau (un peu dans le genre d’un Télécran pour les plus vieux d’entre vous ). Ce qui permet à l’engin d’assurer une autonomie d’environ 8000 pages avant de devoir être rechargé.

L’écran n’est ni rétro-éclairé, ni tactile (bien qu’il existe des readers plus chers supportant ces fonctionnalités) ce qui donne au lecteur le même niveau d’expérience visuel qu’avec un vrai livre (pas de lecture sans lumière par exemple).

Capacité et formats supportés

Au chapitre de la capacité pas de soucis à avoir, l’engin dispose en standard de 192 Mo auxquels peuvent s’ajouter une carte Memory Stick Pro Duo et une carte SD HC, soit plus de 32 Go possibles. A 1 ou 2 mo le livre, ça  permet d’embarquer quelques rayons de bibliothèque…

Sinon le lecteur supporte à peu près tous les formats e-book actuels: EPUB eBook, BBeB eBook, Adobe PDF (les 3 avec ou sans DRM) Microsoft Word, TXT, RTF. Au chapitre des PDF que j’ai pas mal testé, on dispose de deux niveaux de zoom qui permettent de lire un format A4 sans problème. On déplorera cependant une mise en page un peu éclatée lorsque l’on zoom dans ce genre de format. J’ai également pu tester le format EPUB sans DRM, la lecture est agréable et le texte reste bien mis en page avec le zoom.

Dans la série “trucs pas utiles” (pour moi en tout cas), le lecteur supporte les formats audio MP3 et AAC, ainsi que les formats d’image jpeg, gif, png et bmp (ce qui avec un affichage en noir et blanc est assez peu intéressant).

Autour du reader

Le lecteur de Sony est fourni avec le logiciel Windows e-book library qui permet de gérer sa bibliothèque, la mise à jour du firmware du lecteur et la gestion des fichiers DRM. Une version Mac du logiciel devrait voir le jour cet été comme indiqué ici. Sinon on pourra toujours utiliser le très bon logiciel Calibre qui fonctionne également sous Linux et qui vous permettra de gérer votre bibliothèque électronique bien plus efficacement.

Ce qui manque

On déplorera l’absence total d’un système de recherche, ce qui est dommage pour un dispositif pouvant embarquer autant de livres. Pour les personnes ayant des problèmes de vue, il aurait été intéressant de pouvoir inverser le contraste des caractères (blanc sur fond noir). Enfin, j’aurais aimé pouvoir télécharger les articles de mes blogs préférés pour pouvoir les lire tranquillement dans les transports, pour l’instant ça ne semble pas hyper simple de le faire. Tant pis, je continuerai à le faire depuis mon iPhone.

Sur le front des e-books payant

A part quelques exceptions plutôt du côté de la littérature technique (Manning, O’Reilly, Apress) et plutôt au format PDF qui n’est certainement pas le meilleur pour e-book, on est encore loin d’avoir une offre crédible en la matière. La Fnac qui fait la promotion des livres électroniques présente un catalogue anémique (aucune nouveauté) à des prix scandaleux. Bref encore une révolution électronique absolument pas gérée par les acteurs du marché. Comme quoi aucun enseignement n’a été tiré de la nullité des majors du disque… Espérons que les éditeurs ou les distributeurs prendront le temps d’organiser ça de façon un peu plus intelligente comme ça à l’air d’être le cas dans le monde anglophone.

Sur le front des e-books gratuits

En revanche là, il y de quoi faire . Pour peu que vous aimiez les grands classiques, vous pouvez vous constituer une bibliothèque de tous les grands auteurs français et anglophone pour 0 €. Evidemment, ce n’est pas là que vous allez trouver le roman de l’été ou le dernier Harry Poter (pour ma part ça ne me dérange pas trop), mais pour du Dickens (même en VF), du Jules Vernes ou du Maupassant, vous trouverez votre bonheur.

Conclusion : si le marché de l’e-book grand public n’est pas encore ouvert  un e-book reader est d’ors et déjà très intéressant pour embarquer de la littérature technique, de la documentation Home Made, des livres un peu parallèles ou de la littérature ayant dépassée la DLC des droits d’auteurs .

Quelques liens pour conclure

Pour bien démarrer sur le sujet voici quelques liens permettant de récupérer des e-books ou des informations sur l’univers de la lecture électronique.

Le projet Gutenberg ( une bibliothèque bien fournie de livres gratuits en anglais et français) : http://www.gutenberg.org/wiki/Main_Page

Starting the tutorial

We start this tutorial with 3 Eclipse projects : an EAR, an EJB and a WAR project. These projects are showed in the following picture

The 3 projects are linked with the Eclipse configuration files which contains informations about EAR, EJB and WAR projects. In this article the projects are based on JBoss Seam, but all the tutorial could be used in any project type.

On the disk, the 3 projects are 3 directories in the workspace folders. Useless to say it’s not the Maven way to organize projects.

Creation of the parent Project

First step, we create a Maven parent project which will contain our EAR, EJB and WAR projects (that Maven call modules). In this parent project we can define global parameters for the modules. To create this project click on “File/New/Porject…”

Choose Maven Project in the Maven category and click on Next, this opens the “New Maven Project” wizard :

You can go to the next step after checking that “Create a simple project” is unchecked.

In this dialog box you have to choose an archetype (a template for your project). In Catalog choose Nexus Indexer which brings a richer list than the internal default one. In the filter field enter “pom” to reach the “pom-root” archetype”. Select it and click on “Next”.

In this last dialog box you choose the project name. click on “Finish”. Now you have a new project in your workspace. In my case it’s “pfm77-parent”

Creating the Maven modules

In the same way we created parent project, we’re going to create the children projects or modules. click on “File/New/Project…”

Choose “Maven Module” then click on “Next”. A new wizard opens :

Enter the name for the EAR module and the name of the parent project then click on “Next.

Don’t forget to choose “Nexus Indexer” in the catalog, enter “ear” in the filter field. Choose the “ear-jee5″ archetype then click on “finish”

To create the EJB and WAR modules, we’ll use the same wizard choosing archetypes “ejb-jee5″ and “webapp-jee5″.

After all those wizards and clicks, we have 4 new projects in the workspace :

The physical structure of these Eclipse projects are different. If you look on your disk, you’ll see a Maven hierarchy (a main project and modules in in the folder of the main project). It’s one of the m2eclipse benefits : supporting sub-projects in Eclipse. But it’s not the only advantage of the plugin.

Benefits of m2eclipse

1) Managing sub-projects in Eclipse

As we saw, you can have a Maven hierarchy that m2eclipse make look likes different Eclipse project in the IDE. This also works when you import existing maven project in the worskpace from the disk or versioning system.

2) Managing Maven dependencies

The plugin use the pom.xml files to download and add jar files in your project.

3) Maven build in Eclipse

The least we can wait for this plugin. A m2eclipse project has 2 builders : the standard Eclipse one and the maven one.

4) A nice user interface to manage pom.xml files

You can use this interface to look for dependencies or exclude a sub-dependency easily. It was rather bugy in the past but with version 0.99 of m2eclipse it starts to be very usefull.

5) Automatic management of Eclipse projects configuration

That’s an important benefit that is not very well documented on m2eclipse site. M2eclipse uses pom.xml information to generate and maintain Eclipse configuration files for the project. For instance the projects we just created are not Eclipse project. They were created from Maven Archetypes that have nothing to do with Eclipse. So the eclipse configuration files of these new project (.classpath, .project files and .settings folder) were generated by m2eclipse from the pom files. When pom files are modified, m2eclipse will change Eclipse configuration files automatically. For instance, let’s have a look at the Facets of the EJB project (right-click on the project, and choose properties/facets) :

M2eclipse have added this EJB3 facets by analyzing the pom.xml file. So if you change Eclipse configuration on the project there can be some chance that you touch a configuration driven by m2eclipse. So take care of your modification. To be sure you won’t go battle wth m2eclipse in the configuration you should check the m2eclipse documentation. This page show all the Maven parameters (with green checkboxes) that are used by m2eclipse to build and maintain Eclipse WTP configuration files.

To finish with this point, you’ll have to be extremely carrefull when you put those project under versioning system. The best solution is to ignore Eclipse configuration files and let m2eclipse do the job on the other systems (you’ll have to create local configuration on each IDE to configure information that are not in Maven files like deploying servers for instance).

Copying Files

Let’s go back to our tutorial : moving WTP projects to maven/WTP projects. The next step consist to copy files from our old WTP project to the newly created Maven/WTP projects. You can do this by dragging files from file system (Explorer, Finder, or whatever you use) to Eclipse using the “resources” perspective which is the more close to filesystem perspective. To keep it simple try to stick with the default Maven layout, It will make pom files lighter.

• For the EAR module you’ll put the content of META-INF in src/main/application/META-INF all the other files in te project will be build from pom.xml
• For the EJB module, all your classes should be put in src/main/java, resources files like properties or META-INF folder should be in src/main/resources.
• For the WAR module you’ll use the same folders as EJB for classes and resources. The site files will be copied in src/main/webapp folder (be carefull and don’t take the WEB-INF/lib folder)

You should ignore Manifest files in all the project because they can cause runtime errors.

Now we have to deal with our pom files

Pom pom pom pom

It’s not a symphony but almost (sorry for that). The setting of our 4 pom.xml files will ask some patience (it’s the Maven feng-shui side) but we will get trough.

Parent project

I won’t detail all my pom.xml files content : I want to keep my readers till the end. Instead I’ll show you the result and comment the main part of each file

• Introduction : here I tell Maven that it is a pom project that drive construction of sub-projects (modules).
• modules : here are the modules contained by this parent project.
• properties : here I define variables that will be used in configuration of all the modules (libraries version for instance)
• repositories : in this section I add Maven repositories used by my project. For me it’s JBoss repositories for Seam and java.net to get all Jee5 dependencies
• dependencyManagement : In this part, I declare all the dependencies used by my modules. Declaring them here, I can set their version once for all.
• build : in this final section I can set up compilation configuration once for all.

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cos</groupId>
  <artifactId>pfm77-parent</artifactId>
  <packaging>pom</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>pfm77-parent Multi Project</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>pfm77-ear</module>
    <module>pfm77-ejb</module>
    <module>pfm77-war</module>
  </modules>

  <properties>
    <seam.version>2.0.3.CR1</seam.version>
    <jsf.version>1.2_10</jsf.version>
    <richfaces.version>3.2.1.GA</richfaces.version>
  </properties>

  <repositories>
    <repository>
      <id>jboss</id>
      <name>JBoss Repository</name>
      <url>http://repository.jboss.org/maven2</url>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
    <repository>
      <id>jboss-snapshots</id>
      <name>JBoss Snapshot Repository</name>
      <url>http://snapshots.jboss.org/maven2</url>
      <releases>
        <enabled>false</enabled>
      </releases>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
    <repository>
          <id>java.net1</id>
          <name>Java.Net Maven1 Repository, hosts the javaee-api dependency</name>
          <url>http://download.java.net/maven/1</url>
          <layout>legacy</layout>
      </repository>
  </repositories>

 <dependencyManagement>
 <dependencies>

  <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.8.0</version>
      <scope>compile</scope>
       </dependency>
        <dependency>
      <groupId>org.ostermiller</groupId>
      <artifactId>utils</artifactId>
      <version>1.07.00</version>
      <scope>compile</scope>
    </dependency>
    </dependencies>
 </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>

    </plugins>
  </build>

</project>

EAR project

In the pom file, we can get rid of compilation plug-in because we configured it in the parent project. But we’ll have to add all the depending jars and their version. The m2eclipse auto-completion tools are very usefull for this. Right-click on the project and choose “Maven/add Maven dependency”. The following dialog box opens

With this box you can search in Maven repositories the right jar and version for your project and add it the pom.xml file. With time some sub-depencies can appear in the project. You can exclude them by using the “Dependency graph” in pom editor. This view show a graph like this one :

If yo want to exclude a jar you can do it via the context menu and choosing “Exclude Maven Artefact…” (wasn’t working in version 0.98 of m2eclipse). Now, back to our pom file of EAR module here are its content

• header : I specify that it’s an EAR module and I don’t forget to point to the Parent project
• In the dependencies I don’t forget EJB and War modules
• In the build section I add the Maven EAR plugin. In the configuration of the plugin I give the directory where to put the lib and ask Maven to generate my application.xml file
• In the modules section of the plugin, I add my EJB and WAR modules that I defined at the beginning of the file as dependencies

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>pfm77-parent</artifactId>
    <groupId>cos</groupId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <groupId>cos</groupId>
  <artifactId>pfm77-ear</artifactId>
  <packaging>ear</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>pfm77-ear JEE5 Assembly</name>
  <url>http://maven.apache.org</url>

  <dependencies>
    <dependency>
      <groupId>cos</groupId>
      <artifactId>pfm77-ejb</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <type>ejb</type>
      <scope>compile</scope>

    </dependency>
    <dependency>
      <groupId>cos</groupId>
      <artifactId>pfm77-war</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <type>war</type>
      <scope>compile</scope>

    </dependency>

    <dependency>
      <groupId>org.jboss.seam</groupId>
      <artifactId>jboss-seam</artifactId>
      <version>${seam.version}</version>
      <type>ejb</type>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <groupId>javax.el</groupId>
          <artifactId>el-api</artifactId>
        </exclusion>
        <exclusion>
          <artifactId>javassist</artifactId>
          <groupId>javassist</groupId>
        </exclusion>
        <exclusion>
          <artifactId>dom4j</artifactId>
          <groupId>dom4j</groupId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.ostermiller</groupId>
      <artifactId>utils</artifactId>
    </dependency>

    <dependency>
      <groupId>org.richfaces.framework</groupId>
      <artifactId>richfaces-api</artifactId>
      <version>${richfaces.version}</version>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <artifactId>commons-collections</artifactId>
          <groupId>commons-collections</groupId>
        </exclusion>
        <exclusion>
          <artifactId>commons-logging</artifactId>
          <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-ear-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <version>5</version>
          <defaultLibBundleDir>lib</defaultLibBundleDir>
          <generateApplicationXml>true</generateApplicationXml>

          <modules>
            <ejbModule>
              <groupId>cos</groupId>
              <artifactId>pfm77-ejb</artifactId>
            </ejbModule>
            <ejbModule>
              <groupId>org.jboss.seam</groupId>
              <artifactId>jboss-seam</artifactId>
            </ejbModule>
            <webModule>
              <groupId>cos</groupId>
              <artifactId>pfm77-war</artifactId>
              <contextRoot>PFM77</contextRoot>
            </webModule>
          </modules>

        </configuration>
      </plugin>
    </plugins>
    <finalName>pfm77-ear</finalName>
  </build>

</project>

EJB project

Next step the EJB pom file. Not a lot of things to say about it except concerning the Maven EJB plugin which is used to set the EJB version.

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>pfm77-parent</artifactId>
    <groupId>cos</groupId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <groupId>cos</groupId>
  <artifactId>pfm77-ejb</artifactId>
  <packaging>ejb</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>pfm77-ejb JEE5 EJB</name>
  <url>http://maven.apache.org</url>
  <dependencies>

    <dependency>
      <groupId>javaee</groupId>
      <artifactId>javaee-api</artifactId>
      <version>5</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.jboss.seam</groupId>
      <artifactId>jboss-seam</artifactId>
      <version>${seam.version}</version>
      <scope>provided</scope>

    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.2.0.ga</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.ostermiller</groupId>
      <artifactId>utils</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<version>5.1.6</version>
    	<scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-ejb-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <ejbVersion>3.0</ejbVersion>

        </configuration>
      </plugin>
    </plugins>
    <finalName>pfm77-ejb</finalName>
  </build>
</project>

WAR project

Last but not least the WAR pom file. Notice that we’re not using Maven war plugin in this pom file, the default values of War packaging are enough.

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>pfm77-parent</artifactId>
    <groupId>cos</groupId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <groupId>cos</groupId>
  <artifactId>pfm77-war</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>pfm77-war JEE5 Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.jboss.seam</groupId>
      <artifactId>jboss-seam-ui</artifactId>
      <version>${seam.version}</version>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.seam</groupId>
          <artifactId>jboss-seam</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.jboss.seam</groupId>
      <artifactId>jboss-seam-debug</artifactId>
      <version>${seam.version}</version>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.seam</groupId>
          <artifactId>jboss-seam</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.jboss.seam</groupId>
      <artifactId>jboss-seam-pdf</artifactId>
      <version>${seam.version}</version>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.seam</groupId>
          <artifactId>jboss-seam</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.richfaces.ui</groupId>
      <artifactId>richfaces-ui</artifactId>
      <version>${richfaces.version}</version>
    </dependency>

    <dependency>
      <groupId>org.richfaces.framework</groupId>
      <artifactId>richfaces-impl</artifactId>
      <version>${richfaces.version}</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
        <exclusion>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
        </exclusion>
        <exclusion>
          <groupId>javax.faces</groupId>
          <artifactId>jsf-api</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.richfaces.framework</groupId>
          <artifactId>richfaces-api</artifactId>
        </exclusion>
        <exclusion>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
        </exclusion>
        <exclusion>
          <groupId>javax.faces</groupId>
          <artifactId>jsf-impl</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

  </dependencies>
  <build>

    <finalName>pfm77-war</finalName>
  </build>
</project>

Generating Eclipse configuration

Now that we have our pom files, we’ll ask m2eclipse to refresh eclipse config files by accessing the “Maven/update configuration file” in the context menu of each project. Doing this refresh .classpath, .project files and .settings folder of our projects.

First Maven build and first fix

From the context menu of the parent project (not the EAR), choose “Run as…/Maven install” or “Maven package”. Maven is launched but the build fails. Don’t panic this issue is caused by a conflict in Maven resolution and Workspace resolution. Disable Worksapce resolution in the parent project by choosing “Maven/Disable Workspace Resolution” in contextual menu of the parent project. Launch the build again and “voila”. You get an ear file in the target directory of the EAR project. In command line you’ll have to launch “mvn install” from parent project folder to have the same result.

What about WTP ?

Before using WTP to deploy your project you’ll have to copy the application.xml file from the target folder (of the EAR project) to the “src/main/application/META-INF” folder and do it again each time EAR modules change (which is not so often). And now ? Beleive it or not but it’s over and it works. In the server view choose your server (if you don’t have one you can create a “local deployer”). In the contextual menu choose “Add remove…” and add your project.

Then click on “publih” and tadaaa, your project is deployed with WTP (if it’s not, you just have to restart all this tutorial over ). The only issue is a WEB-INF directory in the root of the EAR which contains a copy of the lib directory of the good WEB-INF directory of the war module. This problem should be harmless for a local deployment and is caused by this Eclipse bug.

Conclusion

So m2eclipse is not working out of the box with WTP project. However it’s a powerfull tool even without this need. About Seam and Maven, JBoss is working on making developer life more simple. JBoss tools 3.1 should include extensions to ease the work with m2eclipse and Seam and Seam 3.0 should be totally mavenized, so easier to be build with Maven.

We’ll keep an eye on it…

Voici les outils ou technologies que j’aimerai au moins explorer, au mieux expérimenter pendant cette fin d’année :

• Le développement d’application iPhone : là c’est sûr, un beau projet iPhone vient de me tomber dessus. J’essaierai de vous tenir informés de mon avancée sur le sujet
• Le développement pour Androïd : c’est pas fait, mais le comparatif avec l’iPhone m’intéresse
• Mener mon premier projet full agile : ça vient aussi
• Mettre en oeuvre Seam 2.2 la première version vraiment JEE (voir mon ticket JIRA préféré sur le sujet)
• Utiliser Asap Eclipse 3.5 et JBoss tools 3.0 : ça devrait commencer la semaine prochaine
• Faire des tests avec Google Application Engine
• Lancer le projet Open Source que je dois lancer depuis une éternité.

Beaucoup de sujets sur le feu. Bon mettons que je n’en fasse que a moitié ce serait déjà pas mal. J’essaierai aussi de produire un peu plus de contenu sur mon blog.

Par ailleurs, grâce au plugin wptouch next presso est maintenant optimisé pour la plupart des terminaux mobiles (iPhone/iPod Touch, Android, Blackberry…).

Vos retours sur le sujet sont bienvenus.

Le concept, les principes et les acteurs

Avant tout, juste un petit point sur le concept des RIA. Je discutais du sujet il y a quelque jours avec un décideur qui m’expliquait qu’il faisait des RIA il y a déjà 10 ans avec Delphi. A ce compte, moi aussi il ya dix ans je faisais des RIA avec Lotus Notes. Cette anecdote illustre combien le concept n’est pas forcément clair.

L’idée générale des RIA est d’amener une expérience riche au sein d’une navigation Web. Plus prosaïquement : donner à l’utilisateur l’impression qu’il utilise un client lourd (une application “installée” sur son ordinateur) sans l’obliger à quitter son navigateur. Rien de révolutionnaire en soit, mais la facilité de mise en oeuvre de ce logiciel client riche pour l’utilisateur lève les principaux freins à son adoption. Les RIA permettent donc de déployer un applicatif client serveur sans aucune intervention de l’utilisateur (quand la configuration de son ordinateur est correcte).Pour une définition plus fouillée des RIA, faites un tout sur cet excellent article sur le sujet qui aborde aussi le concept de RDA (Rich Desktop Application).

Aujourd’hui deux principes prévalent pour la mise en oeuvre des RIA. Le premier repose sur l’idée que le navigateur ne propose pas d’outils suffisamment sophistiqués pour concevoir une interface riche. La technologie s’appuie donc sur un plugin qui vient enrichir le navigateur, c’est le cas des solutions d’Adobe, Microsoft ou Sun.

L’autre principe s’appuie sur les outils standard du navigateur à savoir le HTML et le language javascript. Ce mélange mis en oeuvre par Microsoft dans Internet Explorer 5 en 1999 grace au contrôle ActiveX “XMLHTTP” a été baptisé Ajax (Asynchronous Javascript And Xml) en 2005 puis standardisé par le W3C en 2006. Aujourd’hui beaucoup d’acteurs gravitent autour d’Ajax et s’appuient sur ses concepts simples et les fonctionnalités évoluées de HTML pour proposer des bibliothèque de composants Ajax permettant de concevoir des applications riches dans le navigateur. Parmi les pus populaires on peut citer JQuery, Dojo, YUI (Yahoo) et GWT (Google). Dans l’univers Java, des technologies comme Wicket ou JSF permettent d’embarquer de l’Ajax sans avoir à produire le Javascript et le HTML nécessaire pour le mettre en oeuvre. Côté JSF on peut citer des acteurs comme RichFaces ou IceFaces.

Quoiqu’il en soit, l’acteur qui a popularisé le plus Ajax et en a fourni une “proof of concept” est certainement Google qui dès 2004 avec Gmail puis en 2005 avec Google maps a fait la démonstration qu’Ajax était viable et pouvait être utilisé pour concevoir des applications très sollicités  et hautement interactives. Google a ainsi été le pionnier du Web 2.0 où d’autres acteurs l’ont suivi rapidement comme Facebook ou Netvibes.

En schématisant on peut donc dire que l’univers RIA compte 4 acteurs majeurs :

• Adobe avec Flex ;
• Microsoft avec Silverlight ;
• Sun / Oracle avec JavaFx (Ok, celui là est franchement discutable) ;
• Google avec GWT en tant que tête de pont de la mise en oeuvre d’Ajax.

En route vers le Web 3.0

Cette semaine s’est tenu le Google I/O, la conférence développeur de Google à San Francisco. Les annonces faites lors de cet événement sont peut être les prémices d’une nouvelle “révolution” du Web. Ces annonces ont tourné autour de deux points :

• HTML 5 : la plupart des nouvelles versions des navigateurs supportent en avant première les nouveauté d’HTML 5 (annoncé pour 2010). Tim O’Reilly, brillant analyste résume assez bien cette conférence sur son blog. Pour faire court, HTML 5 enrichit son ancêtre en intégrant nativement les technologies suivantes :
  • Canvas : qui permet de générer dynamiquement du contenu graphique sur la page web en cours ;
  • L’intégration de la vidéo : aujourd’hui une telle intégration nécessite un plugin. HTML 5 supportera nativement la vidéo permettant ainsi de créer des applications de manipulation d’images comme du montage vidéo ;
  • La Géolocalisation déjà présente sur la plupart des terminaux mobiles comme l’iPhone ou Androïd ;
  • AppCache et Database qui permettent de répliquer une application Web pour la mettre en mode offline
  • Web workers qui permet de paralléliser des traitements serveurs et clients et d’augmenter significativement la performance d’une application web
• Google Wave : le nouvel outil hyper-communiquant de Google qui sortira cette année. Cet article de 01 résume assez bien cet outil. Plus qu’un bureau communiquant, Wave sera apparemment une plate-forme SaaS dans laquelle les développeurs pourront enrichir l’écosystème applicatif à l’instar de Salesforce ou de l’appsotre d’Apple. Bref, un croisement fonctionnel entre la messagerie, le forum de discusssion, la messagerie instantanée, le réseau social et le travail collaboratif, le tout en opensource et librement extensible. Wave va probablement révolutionner notre façon de communiquer sur Internet. Et quoi qu’il en soit, il constitue la Killer App (tout comme Maps le fut en 2005) pour pousser HTML 5 et Google Web Toolkit.

Conclusion

Google semble mettre toutes ses forces sur HTML 5 et les évolutions d’Ajax qui en découleront, et sur le papier (ou l’écran) ça à l’air très très prometteur. Face à ces évolutions alléchantes qui seront partie intégrantes de tous les navigateurs modernes sur toutes les plate-formes, les investissements colossaux des acteurs qui parient sur des technologies propriétaires avec des plug-in à adapter à chaque plate-forme et chaque navigateur semblent un peu plus hasardeux.

Mais, personne ne dispose d’une boule de cristal et les prophètes sur le sujet se sont maintes fois trompés par le passé. La seule certitude que l’on puisse avoir c’est que la conception d’applications en ligne et l’ergonomie de ces applications d’ici 5 ans n’aura pas grand chose à voir avec celle d’aujourd’hui.

Allez c’est reparti sur Du Seam, du Spring et un peu de nuages…