Valtech Blog | JavaEE

Jazoon 09 : sessions du Mardi 23 Juin

Publié le 23/06/2009, par Anthony Dahanne dans Valtech | 5 Commentaires

Ces sessions ont eu lieu durant Jazoon 09, le Mardi 23 Juin 2009. You can read the original english transcript here.

La keynote de James Gosling : 9:50 à 10:45

En tout début de session, une vidéo nous a été projetée, un film d’animation très amusant sur l’histoire de Java, et comment Java a conquis le monde !(n’hésitez pas à nous donner l’url en commentaire si vous l’avez !)
James a d’abord commencé son discours en plantant le décor : il y a désormais plus de JVM installées que d’humains (!) : sur ordinateur, téléphone, cartes intelligentes (transport), dans les télés, etc… (15 millions de JRE téléchargées par jour) et donc il y a aujourd’hui 6 millions de développeurs Java dans le monde ! On peut donc parler de “Learn Once, Work everywhere” tant la connaissance et l’utilisation de Java sont répandues !
Pour illustrer ces chiffres, James a cité des exemples comme l’assurance maladie brésilienne qui utilise Java et des bases de données pour conserver toutes sortes de documents comme des radios, des ordonnances, etc…
D’ailleurs, le plus important dans Java ce n’est pas le langage mais la plate forme : aujourd’hui toutes sortes de langages tournent dessus : Ruby, Scala, JavaScript, etc…
Glassfish profite de cette plateforme et aussi de Java EE6 : juste en sauvegardant une servlet, sans redéployer, on obtient le résultat en rafraichissant la page dans le navigateur (même en rajoutant un EJB dans la servlet) ! La productivité va s’améliorer !
L’IDE de choix est alors Netbeans, qui dans sa version 6.7 s’intègre au projet Kenai, une sorte de sourceforge où l’on peut faire toute sorte d’opération comme dans un gestionnaire de sources (ex : Subversion), aussi 6.7 amène une meilleure compatibilité Maven, je connais des cast codeurs qui vont aimer !
Sortie de nulle part, mais plutôt marrant un exemple de code Java embarqué : le refactoring d’1 vieille Lincoln en véhicule Hybrid avec du code Java pour mesurer et contrôler le véhicule, code déployé à distance par internet (connexion 3G dans la voiture)
James a aussi évoqué les performances, et a mis fin à la rumeur comme quoi Java est moins performant que C++ en fournissant des chiffres plaçant java comme une plateforme très performante.
Pour la téléphonie mobile, de nouvelles specs arrivent (un peu tard quand on voit iphone os et android ?),le Mobile Service Architecture (MSA ou JSR 248) les rassemblant toutes.
Java 7 sera modulaire (comme Java EE6) et permettra l’utilisation de langages dynamiques, en attendant Java SE 6 a des mises à jour qui arrivent avec entre autres une meilleur intégration dans le navigateur web.
java FX est toujours là ! rien de nouveau à son sujet (meilleur collaboration entre développeurs et designers, se déploit sur mobile comme sur desktop, etc..) si ce n’est que la version 1.2 sort sous peu.
Enfin James nous a rappelés les différentes communautés Java existantes : glassfish, netbeans, java.net
Bref une keynote qui nous montre que Java est sacrément présent, voire même inévitable, et pour de longues années encore ! Sun investissant toujours dans le développement de sa plate forme phare !

Java EE 6 11:00 – 11:50 par Roberto Chinnici de Sun

Java EE est souvent reproché d’être trop compliqué… pour répondre à ces critiques, Java EE6 sera plus flexible, plus modulaire, plus puissant et plus facile à utiliser!
Ainsi ont été créés les profiles, qui répondent aux attentes particulières de chaque utilisateur : par exemple il existe le profil Web qui embarque les JSP, JSF, Bean validation des EJB lite, pour déployer dans un war.
Voyons en détail quelles sont les specs sur lesquelles repose Java EE 6 :

Servlet 3.0

Nouvelles annotations @WebServlet, @WebFilter, @WebListener, la possibilité d’enregistrer de nouveaux composants Web juste en les déposant dans le WEB-INF/lib, plus besoin de web.xml (cool !) et la possibilité d’exécuter des requêtes en mode asynchrone (et avec plusieurs requêtes sur 1 thread…)

JAX-RS 1.1 : RestFul webservices

C’est l’API qui permet d’encapsuler toute la couche technique HTTP de Rest : avec des annotations comme @POST ou @GET , on définit les méthodes qui feront les opération de création ou de récupération des objets; d’ailleurs la transformation JSON ou XML vers objets java est prise en charge par JAX-RS !

Bean Validation 1.0 (JSR-303)

Cette API est arrivée un peu tard comme l’a dit Roberto, elle sert à définir des contraintes sur des champs d’un formulaire Web par exemple…
Pour en avoir parlé un peu plus tard avec Emmanuel Bernard, (qui a participé à la spec BeanValidation), il existe un ensemble d’annotations pré définies (@Max, @Min, etc…) et il suffit d’une dizaine de lignes de code pour en rajouter dans son projet.

EJB 3.1

Finies les interfaces ! un fichier source par EJB !
Une nouveauté remarquable : on peut désormais définir des tâches périodique, un peu comme dans Cron, avec l’annotation @Schedule : quand je pense quand dans mon projet actuel on a écrit des MBeans qui sont appelées par des tâches Cron pour raffraîchir le cache, je me dis que que EJB 3.1 a du bon !
EJB 3.1 lite peut tourner dans Java SE (super pour tester sans deployer !) et aussi être embarqué dans un simple war !
Le speaker manque de temps tant pour JPA 2.0 (quand on utilise Hibernate avec les annotations çà doit pas bien changer…) et JNDI (qui proposent de nouveaux modes d’accès )
Du très bon ce Java EE 6 !

“Design Patterns” in Dynamic Languages 12:00 – 12:50 par Neal Ford (nealford.com)

Cette présentation avait pour but de montrer qu’il n’est pas toujours nécessaire de se référer aux patterns du Gang Of Four, surtout dans les nouveaux langages dynamiques comme Groovy ou Ruby, qui sont déjà équipés pour faire face à des problème récurrents.
Quelques exemples (j’ai pas pu tout noter ! le présentateur a cité les patterns iterator, strategy, template, interpreter, decorator, recorder, adapter)
Pour le pattern iterator : est il nécessaire en Ruby de créer 3/4 classes pour implémenter ce pattern ? et non, il suffit d’appeler collection.each{[x| puts x} … plus rapide non ?
Pour interpreter aussi (pour rappel ce design pattern a été créé pour ajouter des fonctionnalités au langage utilisé), rien de plus simple que de créer un nouveau DSL en Groovy en créant de nouveaux comportements à une classe existante, Integer dans l’exemple.
Pour conclure, Neal a cité qu’avec les langages dynamiques, apparaissent de nouveaux design pattern, grâce à leur syntaxe plus riche; profitons des outils fournis par ces nouveaux langages plut que d’essayer de reproduire des situations inadéquates !

Gradle : A build system for Java 14:00 – 14:50, par Hans Dockter

Au tout début de la présentation, Hans rend honneur à Ant et Maven en nous rappelant leurs fonctionnements, défauts et avantages.( un peu comme Eric Lemerdy et Grégory Boissinot dans leur podcast Gradle que je vous conseille d’ailleurs tout particulièrement)
Avec Ant, souvent on copie colle des taches , c’est souvent répétitif… Dans Ant il n’y a pas de listeners pour surveiller ou logger les phases de build…
Avec Gradle, on peut importer des scripts ant et invoquer des tâches Ant, en Groovy. (et même déployer le résultat de son build sur apache Ivy)
Maven est quant à lui un framework qui repose sur les conventions et a introduit la gestion des dépendances; par contre il faut 25 lignes de XML avant de pouvoir écrire le moindre script de construction; aussi Maven n’utilise que des dépendances transitives, ce que Gradle peut éviter en spécifiant ses dépendances.
D’ailleurs Gradle peut réutiliser et importer en groovy les builds maven; et même envoyer le resultat de son build sur un repository maven.
Gradle se veut un langage de builds et non un framework de builds, afin de pouvoir plus souple qu’un framework.
Enfin, Gradle peut s’utiliser sans s’installer sur tout système d’intégration continue grâce à un script bash ou shell qui télécharge sur la machine d’intégration continue les librairies nécessaires.

Next Generation Enterprise Builds: Maven, Mercury, and Tycho (pour les builds OSGi) par Jason van Zyl de Sonatype

Maven 3.0

Sera mieux intégré dans les IDE (eclipse, netbeans, intellij, sera plus rapide, resoudra mieux les dépendances, aura un nouveau système de plugins
Maven 3 sera plus concentré sur les tests d’intégration, il aura un cycle de vie déclaré, qui permettra aux outils l’embarquant de prédire la séquence de build et donc de pouvoir sauter des étapes.
Enfin Maven 3 utilisera Mercury, un nouveau moteur de transport et de gestion, qui pourra d’ailleurs être utilisé avec autre chose de que des POMs (des gems ou les dépendances Eclipse P2)

M2eclipse

M2Eclipse, le plugin maven pour Eclipse va pouvoir choisir les bonnes actions maven à appeler lors d’une sauvegarde, et non pas tout le cycle maven.
Il pourra aussi gérer les projets Flex, et importer dans Eclipse les préférences du projet Maven (modification des préférences du workspace)

Nexus

Seulement 5% des utilisateurs de Maven Central utilisent un repository manager comme Nexus ou Archiva.
On peut voir Nexus comme un gestionnaire de binaires pour l’entreprise, en plus d’un système de cache évolué !
Nexus va pouvoir être utilisé à travers Eclipse, son API pourra aussi être appelée via REST (ce qui facilitera la création de plugins ! )

Hudson

Dans sa prochaine version, Hudson intégrera un nouveau moteur de workflow : drools workflow integration (avec un editeur de workflow), une couche REST pour être interrogé et commandé par des plugins, et aussi pour unifier l’intégration avec m2eclipse, nexus et bien sûr Maven.

Testing Zen 16:00 – 16:20 par Thomas Mueller, Day

Session rapide de 20 minutes, où Thomas, après nous avoir donnés 10 raisons à la question “Pourquoi tester ?”, nous cite 3 moyens de tester…
En faisant du “fuzz testing”, où l’on génère des données pour tester.
Avec Emma, pour faire de la couverture de code.
Et enfin les tests de base de donnée : pour cela, il faut utiliser une base de données Java comme HSQL (bien), Derby (pas bien) ou encore H2 (la meilleure, celle sur laquelle travaille Thomas actuellement d’ailleurs )
A la question : “Pourquoi ne pas utiliser de mocks au lieu de peupler une base de données ?” il répond “C’est trop long à initialiser… mais en même temps j’en utilise rarement”…

Creating Performance Test Data with benerator, par Volker Bergmann

D’habitude lors de tests de performance, on préfère utiliser des données de production…
Mais parfois, pour des raisons de disponibilité (nouveau système) ou de confidentialité (outsourcing, etc…) on ne peut pas injecter des données de production dans les tests…
Volker a alors développé Benerator, un créateur de jeux de tests, qui peuplera une base, ou un fichier plat, ou LDAP, ou JCR, etc…
A tester avec le plugin benclipse ou le plugin Maven 2.

La journée s’est terminée avec un speech très amusant sur la prédictibilité des technologies par Neal Ford, c’était vraiment sympa, plein de référence à la science fiction et aux succès récents et à ceux qui le sont devenus que plus tard, excellente réflexion et conclusion : “Le meilleur moyen de connaître le futur, c’est de le faire soi même”
Un autre speech de fin sur l’agilité, par Ivar Jacobson, rien de nouveau…

Port of an J2EE application (with Hibernate) to Ruby on Rails (1.2.3)

Publié le 21/04/2008, par Anthony Dahanne dans Architecture | Comments Off

Last week, I ported a J2EE application, using Hibernate for persistence and Capestry for the MVC part of the application to Ruby.
I logically choosed Ruby on Rails as it is the main Web framework for Ruby.
In this post, I describe how I did to perform such a port…
!Important! the application I first wrote this application in Franch, I tried to refactor the code in English, but… I haven(t finished at this time, … sorry folks !

Introducing the bank on line application

This application is composed of 3 models : Client, Compte (account) and Operation
A client has n Comptes (through reference_client) and a Compte has n Operations (through compte_id) :

The application allow the user to :
*login
*see a list of his accounts (after being logged in)
*see the details of one of his account (actually a list of the operations on an account)
*order a transfer between 2 accounts provided that the balance is positive (and the accounts exist)
Quite simple from a user point of view…

Creating the application with Ruby on Rails 1.2.3

The best way to port this new application to RoR, was to create a new RoR project
rails bankonline -d sqlite3
(by the way, I was using the sqlite3 database, to allow an easy installation of the application, the J2EE application was using HSQLDB)
cd bankonline
I was using for this Rad Rails visual editor on a windows platform (no comment…)
The first step to port this application was to create the 3 models.
ruby script/generate model Client
ruby script/generate model Compte
ruby script/generate model Operation
Then I put the contraints on each of these models (the has_many and belongs_to relationships to stick to my diagram), editing their definition files in app/models and also the database definition files, in db/migrate
Once this is done, I can run
rake db:migrate
to load all my db/migrate scripts. (in case I want to revert the changes, I can use rake db:migrate VERSION=0, or VERSION=1 if only want to reverse the migration after the script)

To fill the database with data, I add another migration script :
ruby script/generate migration add_data
I edit it to add some lines in the database and then I migrate :
rake db:migrate

Then the 3 corresponding controllers :
ruby script/generate controller login
ruby script/generate controller gestion

Implementing the login system (session based)

For this, I took example on the depot application login system, from the pragmatic programmers’ book “Agile Web Development with Rails”, but I chose to use not encrypted passwords.
I also chose to use database based sessions, so I edited the config/environment.rb file, line 31, to allow :
config.action_controller.session_store = :active_record_store
Then, I add to create a new table to hold the session data :
rake db:sessions:create

Of course, you need a little bit of code in your app/controllers/login_controller.rb, you have to implement the login and logout methods (or actions, to speak rails); you may also notice the apparition of a “before_filter” call.
The authorize filter is defined in the app/controllers/application.rb file, it will be loaded for every controller, and will check tha t a valid client is in session, or else, it will redirect to the login action, in the login controller.
Finally, you will have to define the views, both in app/views/login, they’re called login.rhtml and logout.rhtml
One last thing : you also need to modify the layout, in app/views/layouts/login.rhtml to display the flash notice before the yield (which includes the display of the view)


<%= flash[:notice] %>

Implementing the account listings and the transfer functionality

We have to code the controller, GestionController, located in gestion_controller.rb
You’ll notice that I’ve replaced the service class in Hibernate by methods inside the controller in Rails, I didn’t want to put it in the model, since the model can’t know how to transfer money.(I think we can discuss that point, but as long as the helpers are dedicated to the view…)
I’ve also used exceptions to raise errors (if the origin account balance is smaller than the transfer amount)
You also have to include the flash notice in the layout, app/views/layouts/gestion.rhtml

That’s it !
launch your rails app
ruby script/server
and try it out in your web browser at : http://localhost:3000/login/login

In a few days I’ll complete this article with the tests and fitnesse fixtures …
To continue …

First version of Bank online RoR to download

BlazeDS: User hibernate4gwt as Hibernate adapter

Publié le 17/04/2008, par Bruno Marchesson dans Architecture | Comments Off

Foreword

I am currently working on a EJB3 / Flex3 project and face a very familiar issue.
BlazeDS is an open-source library, published by Adobe, to send messages from Flex code to java one (and vice-versa). The source code is an extract of LiveCycle Data Services, its commercial ancestor, still alive and handling more functionalities.
One of the most missing features of BlazeDS is an adapter to send Hibernate beans from a Java server to the Flex/Action Script client side, whereas this adapter is available in LiveCycle DataService (but it costs a lot of $$$, including runtime fees).

Hibernate4GWT ?
Hibernate4GWT is a open-source library I am working on since more than one year now to allow sharing Hibernate beans from server to GWT client side. But, despites of its name, the core of the library is really independent of GWT (don’t worry, you won’t have to add GWT libraries to your Flex project ):

The ‘clone’ operation consists of converting Hibernate beans to pure, regular beans. Proxies are removed, and Persistent collections converted to their classic counterparts. Of course, persistence information handled by proxies and persistent collections are stored to be reused when the POJO comes back.
The ‘merge’ operation takes the neutral bean and merges it back to a Hibernate bean. Proxies and persistent collections are regenerated accordingly to what was undone by the clone operation.

Defining your own adapter
It is pretty simple, and well documented here.
So here is the code:

/**
* Hibernate adapter for BlazeDS
* It is based on hibernate4gwt core and delegates Hibernate beans management to it.
* @author bruno.marchesson
*
*/
public class HibernateAdapter extends JavaAdapter
{
/**
* The Hibernate bean manager
*/
private HibernateBeanManager _beanManager;

//————————————————————————-
// Java adapter override
//————————————————————————-
/**
* Adapter initialisation
*/
@Override
public void initialize(String name, ConfigMap config)
{
// Call base method
//
super.start();

// Get EntityManagerFactory
//
Object entityManagerFactory = getEntityManagerFactory();

// Create hibernate bean manager
//
_beanManager = new HibernateBeanManager();
_beanManager.setEntityManagerFactory(entityManagerFactory);
}

/**
* Invoke adapter
*/
@Override
public Object invoke(Message message)
{
RemotingMessage remotingMessage = (RemotingMessage) message;

// Merge input arguments
//
List mergedParameters = (List) _beanManager.merge(remotingMessage.getParameters());
remotingMessage.setParameters(mergedParameters);

// Call Java adapter
//
Object result = super.invoke(message);

// Clone result
//
return _beanManager.clone(result);
}

//————————————————————————-
// Internal methods
//————————————————————————-
/**
* @return the Entity Manager Factory
*/
protected Object getEntityManagerFactory()
{
// JNDI Lookup for Entity Manager Factory
//
Context context = new InitialContext();

Object entityManagerFactory = context.lookup(“your_emf_jndi_name”);
if (entityManagerFactory == null)
{
throw new RuntimeException(“Unable to find EntityManagerFactory”);
}
return entityManagerFactory;
}
}

It is pretty straightforward: the only difficulty is to set the Hibernate session factory or the entityManagerFactory to the HibernateBeanManager. In our case, we use the JNDI name of the EntityManagerFactory (declared in the EJB3 “persistence.xml” file), but you can inject easily it in another way depending on your code.
The “invoke” method is the heart of the adapter: before server call, the input arguments are merged to Hibernate entities, and the result of the process call is cloned before going to the server side.

Stateful/Stateless mode
Previously, I mentioned that the persistence information hold by proxies and collections is stored in the ‘clone’ operation and reused in the ‘merge’ one.
Basically, Hibernate4GWT provides 2 ways of storing such information: on the server (the stateful mode) or on the pojo (stateless mode).

Stateful mode:
The proxy is stored in the HTTP session. As a consequence, your entity beans do not have any technical inheritance. Magic, isn’t it ?

To make it work, just edit the Hibernate Adapter below as follows :

In the ‘init’ method, add the following line:
_beanManager.setPojoStore(new HttpSessionPojoStore());
At the very beginning of the ‘invoke’ method, put the following line :
HttpSessionPojoStore.setHttpSession(FlexContext.getHttpRequest().getSession(true));

Stateless mode:
The entity beans store minimal persistence information, by inheriting from LazyPojo abstract class. No information is stored on server, which can be very helpful in clustered environments.

First, your entities must inherit from net.sf.hibernate4gwt.pojo.LazyPojo:
public class MyPojo extends LazyPojo
{…}

And here is the LazyPojo class in ActionScript (your value objects have to inherits from it, in a symmetric way to your entity hierarchy) :

package com.mypackage.client.vo
{
import com.adobe.cairngorm.vo.IValueObject;
import mx.collections.ArrayCollection;

[RemoteClass(alias="net.sf.hibernate4gwt.pojo.LazyPojo")]
public class LazyPojo implements IValueObject
{
/**
* The internal lazy properties collection
*/
private var _lazyProperties:ArrayCollection;

/**
* Constructor of Lazy Pojo abstract class.
*/
public function LazyPojo()
{
_lazyProperties = new ArrayCollection();
}

/**
* Getter for lazy properties collection
*/
public function get lazyProperties():ArrayCollection
{
return _lazyProperties;
}

/**
* Setter for lazy properties collection
*/
public function set lazyProperties(value:ArrayCollection):void
{
_lazyProperties = value;
}
}
}

The future
BlazeDS is not currently supported by Hibernate4GWT : it means that it as not been tested in different configurations (remoting, messaging, etc…), and there is no dedicated distribution or documentation for Flex applications.
Nevertheless, Hibernate4GWT is currently under heavy refactoring : the code has been split in different jars, and an official new distribution and documentation is scheduled for the end of Q2. It will include GWT new tutorial, some more functionality… and probably BlazeDS support

Stay tuned !

JPA pour uniformiser la persistance Java ?

Publié le 12/10/2007, par Romain Linsolas dans Architecture | Ajouter un commentaire

Avec l’arrivée des EJB3, Sun a mis en place une nouvelle API, « Java Persistence API » également connue sous le sigle JPA. JPA est une spécification qui définit un framework de persistance, introduite dans la JSR-220 (nom officiel de la spécification EJB3.0).Les frameworks de persistance, également connus sous le nom d’ORM (Object Relationnal Mapping), ont pour objectif de fournir un mapping objet/relationnel entre les SGBDR et les applications Java. Les plus répandus sur le marché sont Hibernate ou encore TopLink. JPA a tenu compte de l’ensemble de ces frameworks pour standardiser l’univers de la persistance en Java.

Persistence in J2EE : JPA tutorial and example

Publié le 19/07/2007, par Guillaume Tardif dans Architecture | Comments Off

I’m currently performing a study on J2EE persistence tools and frameworks, and I came accross this great JPA tutorial using implementations by Hibernate and Toplink.

Serge Tahé provides very clear and simple explanations based on easy to run examples, both in Hibernate and Toplink (and with a great variety of databases – I ran most of them with Derby, just because I already had it running on my machine). The tutorial exposes progressive examples going from very basic peristence code to quite advanced mapping configurations, and explores some of the limits of the tools, as well as behavior differences between Hibernate and toplink. It is accessible to a large public : almost from java beginners to expert who do not yet have a deep experience in JPA.

All in french unfortunately for those of you who don’t speak our wonderful language…