Java EE 6

Présentation réalisée par Antonio Goncalves.

La spécification Java EE 6, prévue pour mi-2009, est vaste : plus de 27 spécifications !
Afin d'y voir plus clair, Antonio a présenté les principales nouveautés de cette norme.

Rétrospective et futur de J(2)EE

Mais d'abord, un peu d'histoire.
La première version de la norme J2EE a vu le jour en 1998, et ne comportait à l'époque que quelques spécifications. Au fil du temps, elle s'est beaucoup étoffée : Java EE 6, prévue pour mi-2009, regroupe maintenant plus de 27 spécifications, couvrant l'ensemble du spectre depuis l'accès aux données jusqu'à la couche de présentation.

Année   Version   Spécifications   Principaux ajouts
1998    1.0       ?                  
1999    1.2       10               Servlet, JSP, EJB, JMS, RMI
2001    1.3       13               CMP, JCA
2003    1.4       20               Webservices, Deployment
2006    5.0       23               Annotations, EJB3, JPa, WS-*, JSF
2009    6.0       27               EJB 3.1, JPA 2, servlet 3, JSF 2, JAX-RS ?, WebBeans ?

Java EE 5 avait beaucoup fait évoluer la couche service et la couche d'accès aux données, avec notamment les EJB3 et JPA.
Java EE 6 sera, lui, résolument tourné vers la simplification du développement : programmation orientée POJO grâce aux annotations, et suppression d'anciennes spécifications obsolètes (JAX-RPC, les EJB CMP...).

Mais en étant plus riche, Java EE 6 devient aussi plus difficile à implémenter pour les éditeurs de serveurs d'applications. Il sera donc découpé en "profils", chacun correspondant à des sous-ensembles de spécifications répondant à un use-case précisément identifié, et pouvant donner lieu à une certification de compatibilité.
Par exemple, le profil Web (parfois appelé Profil A dans de vieux articles), contiendra le minimum nécessaire pour développer des applications web robustes mais à l'architecture simple : Servlets 3.0, JSP 2.2, EL 1.2, EJB 3.1 "Lite", JTA 1.1, JPA 2.0, JSF 2.0, et peut-être JAX-RS 1.1 et WebBeans 1.0. On notera ici l'absence des EJB, des Webservices, etc.
Pour le moment, seul ce profil est disponible, mais la liste pourra être complétée si de nouveaux use-cases sont identifiés : portlets, web "lite" ?...

Voici maintenant un aperçu des technologies majeures de Java EE 6.

Servlets 3.0

En passant une version majeure, les servlets 3.0 marquent un tournant dans leur modèle de programmation. Plusieurs axes d'amélioration ont été suivis.
Je vous présente ici un résumé des nouveautés ; je vous recommande de lire également un article plus détaillé chez java.net.

Vers un modèle POJO

Après les EJB, c'est au tour de la couche web de céder aux sirènes des annotations.
Les composants habituels (sevlets, filtres, listeners) sont maintenant de simples POJO, décorés des annotations adéquates : @Servlet, @ServletFilter, @ServletContextListener... Toute classe annotée présente dans /WEB-INF/classes ou dans un jar de /WEB-INF/lib est automatiquement découverte et prise en compte. Le descripteur web.xml devient alors facultatif.

Avant :

public class HelloWorldServlet extends HttpServlet {
	public void doGet (HttpServletRequest request, HttpServletResponse response) 
	{ ... }
}

<servlet>
	<servlet-name>HelloWorldServlet</servlet-name>
	<servlet-class>com.company.HelloWorldServlet</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>HelloWorldServlet</servlet-name>
	<url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>

Après :

@Servlet(urlMappings={"/HelloWorld"})
public class HelloWorldServlet {
	@GET
	public void handleGet(HttpServletRequest request, HttpServletResponse response)
	{ ... }
}

A ce point de la présentation, j'ai posé plusieurs questions :

• L'ordre de déclaration des filtres dans le descripteur web.xml déterminait leur ordre d'éxécution dans la chaîne. Comment préciser leur ordre avec les annotations ? Antonio m'a répondu que l'annotation @ServletFilter n'était réellement utilisable que dans le cas d'un unique filtre. Dans le cas de filtres multiples, il faudra en revenir à la méthode habituelle.
• Le principe fondateur du descripteur de déploiement était de pouvoir modifier les mappings des servlets sans toucher au code. Il sera toujours possible de le faire, les paramétrages réalisés au niveau du descripteur web.xml étant prioritaire sur les annotations. De toute façon, Antonio estime que ce genre de modification n'intervient statistiquement jamais en production, et que pendant la phase de développement il n'est pas grave de devoir modifier le code. Je tends à me ranger à son avis, et par ailleurs, je note que Spring MVC 3.0 rendra l'utilisation d'annorations équivalentes quasiment obligatoire. J'ai également posé cette question le lendemain à Jürgen Höller, architecte et développeur principal (pour ne pas dire exclusif...) de Spring : je vous donnerai son point de vue, très intéressant, dans un prochain billet.

Modularisation et extensibilité

L'auto-découverte des classes annotées est complétée par un mécanisme de contribution dynamique au descripteur web.xml. Il est désormais possible de définir des "fragments web", qui seront également auto-découverts dans les fichiers /META-INF/web.xml des jars du classpath. Les fragments découverts seront alors fusionnés pour produire le fichier web.xml final. Ce mécanisme permettra, par exemple, de déclarer dynamiquement des attributs de contexte :

<web-fragment>
	<context-param>
		<param-name>message</param-name>
		<param-value>Hello World</param-value>
	</context-param>
</web-fragment>

Performance

Pour finir, les Servlets 3.0 proposent un nouveau mode asynchrone (type Comet), permettant de libérer et de réutiliser les threads serveurs pendant que des traitements longs sont effectués par la couche métier. Lorsque la réponse est prête pour un client, un événement est généré et la communication est rétablie avec le client pour lui transmettre la réponse.
Il était temps que ce mode soit intégré dans la norme Java EE : Tomcat le propose depuis sa version 6, disponible depuis plus de 2 ans !

JSF 2.0

De la même manière que les Servlets, JSF 2.0 accueille un modèle de programmation de type POJO + annotations. Le descripteur faces-config.xml devient également optionnel.
Le templating va se baser sur la technologie "facelet", et le support d'Ajax sera amélioré. Il devrait également être plus facile de développer ses propres composants, ce qui devrait favoriser l'apparition de librairies de composants plus riches et plus facilement configurables.

EJB 3.1 "Lite"

Il a été reconnu que, lors du développement d'applications web simples, la technologie EJB3 pourrait apporter de nombreux bénéfices mais était tout simplement "trop" : trop lourde, trop complexe, trop d'options inutilisées (MDB, Timers, etc.)... La version "Lite" adopte une approche pragmatique et ne retient qu'un sous-ensemble réduit de fonctionnalités, sur lesquelles un travail de simplification additionnel a été effectué.

Voici les principales nouveautés :

• Les EJB peuvent se passer d'interface locale. On pourra donc écrire @Stateless @LocalBean public class MyBean {...}.
• Un nouveau type de bean apparaît : le @Singleton ! Ce sera bien entendu un singleton par JVM ; en cas de cluster, il vous revient toujours de synchroniser l'état de vos applications...
• Les méthodes des beans peuvent désormais être déclarées @Asynchronous, ce qui évitera de mettre en place des queues JMS et des MDB juste pour réaliser des opérations asynchrones.
• Les Timers sont également mis à jour. Deux nouvelles syntaxes sont disponibles pour configurer les alarmes : cron-like, ou basée sur Calendar. Il sera également possible d'annoter les méthodes @Schedule pour les déclencher de manière programmée.
• Il sera possible de déployer des EJB Lite directement dans des archives war, comme les servlets. Le déploiement sur les serveurs devrait en être grandement simplifié.
• Le nommage des ressources JNDI sera enfin normalisé ! En utilisant le namespace "global", on obtiendra des noms logiques portables : java:global/com/company/HelloWorld.
• Enfin, la notion de conteneur EJB embarqué fait son apparition. Il sera possible de déclarer et de lancer programmatiquement un conteneur EJB léger, ce qui rendra enfin possible leur utilisation dans n'importe quel environnement : lors des tests unitaires par exemple (initialisation d'un conteneur dans @BeforeClass avant les tests sur les appels EJB), mais aussi pour des traitements en mode batch. Le conteneur léger est donc la pierre angulaire de la nouvelle stratégie de Java EE pour les EJB : "EJBs everywhere !".

Bref, plein de bonnes choses en perspective.
Pour plus de détails, je vous invite à compléter votre lecture avec un article fort complet sur TheServerSide.

JPA 2.0

La spécification JPA est maintenant totalement découplée de la spécification EJB, ce qui devrait favoriser son adoption dans les environnements Java SE.

Trois grandes nouveautés au programme :

• L'apparition de l'API Criteria, inspirée d'Hibernate.
• La possibilité de mapper des collections d'éléments simples (List<String> par exemple) à l'aide de l'annotation CollectionOfElements.
• La sauvegarde d'un ordre de tri en base, avec @OrderedBy("lastLoginDate") et @OrderColumn("loginOrder"). JPA crée automatiquement une colonne supplémentaire en base pour conserver cet ordre.

Je me demande l'impact que ce dernier élément aura sur les politiques de locking des enregistrements, car s'il faut modifier l'intégralité des lignes de la table à chaque changement d'ordre...

JAX-RS 1.1

JAX-RS apporte le support des architectures REST au monde Java EE. Il s'agit par ailleurs de la seule spécification de Java EE 6 qui est déjà validée et qui dispose d'une implémentation de qualité production à cette date (Jersey, intégré à Glassfish v3). La version 1.1 ne sera en principe qu'un renommage de la version 1.0 pour marquer son intégration dans la version définitive de Java EE 6.

Sans surprise, on retrouve là encore les annotations :

• @Path pour indiquer l'URI de la ressource : @Path("/helloworld") public class MyResource { ... }
• @GET, @PUT, @DELETE, etc. pour spécifier quelles méthodes appeler en réponse aux différentes actions HTTP.
• @Produces et @Consumes pour indiquer les représentations acceptées pour la ressource. Par exemple : @Produces("text/plain").
• La capture des paramètres sur l'URI est possible grâce à @QueryParam :

@Path("/users/{username}")
public class UserResource {
	@GET
	@Produces("text/xml")
	public String getUser(@PathParam("username") String userName) 
	{ ... }
}

La documentation de Jersey est très complète et couvre la plupart des use-cases.

WebBeans 1.0

Pour finir, Antonio nous a un peu parlé de WebBeans (JSR 299), surtout pour expliquer que c'était la spécification qui portait encore le plus d'incertitudes.
Censés combler le fossé entre la partie web (Servlets, JSF) et la partie métier (EJB, webservices), les WebBeans sont fortement inspirés des travaux autour de JBoss Seam (ce qui n'est assurément pas une surprise, étant donné que c'est Gavin King qui dirige la JSR...).

La seule information à peu près intéressante lâchée par Antonio serait la présence d'un scope "conversation", qui s'intercalerait entre les scopes "request" et "session". Une "conversation" pourrait couvrir un ensemble de requêtes formant un ensemble logique, comme par exemple un processus de validation de commande. Le problème de la gestion des fenêtres multiples d'un même navigateur pourrait également être résolue élégamment de cette manière.

Vous pouvez suivre les dernières péripéties de cette spécifications sur le blog de Gavin King.

Conclusion

En une heure, Antonio ne pouvait évidemment pas entrer dans les détails de chacune des 27 spécifications de Java EE 6. Je trouve qu'il a su identifier les évolutions les plus marquantes et nous en expliquer l'esprit de manière satisfaisante. Nous avons ainsi eu un aperçu plutôt précis de ce qui nous attend en 2009 (ou 2015, pour les utilisateurs de Websphere...).

A mon sens, ce sont les Servlets 3.0 qui auront le plus d'impact sur les développeurs, et peut-être les EJB Lite intégrés aux applications web. J'attends impatiemment leur support dans Spring et sur Tomcat !

Note : Je tiens à remercier Antonio d'avoir pris le temps de relire ce compte-rendu afin d'en éliminer les erreurs et approximations, et d'avoir accepté de mettre à disposition les slides utilisés lors de sa présentation (ODF, 2.5Mo, licence Creative Commons) !