Introduction

JBoss AS simplifie grandement l’utilisation de la persistance en offrant qu’un seul choix de Persistance provider déjà configuré, Hibernate. C’est à la fois un atout et un défaut puisqu’Hibernate est un produit éprouvé et fiable, qui simplifie grandement le développement applicatif et s’intègre parfaitement dans Java persistance API (JPA). Ce document présentera donc les étapes de bases pour configurer une banque de connexions vers un serveur mySQL par JNDI. Ce document présente donc une technique d’utiliser les avantages de JBoss AS avec des entreprise JavaBean de troisième génération. Il ne ce veut cependant pas une référence complète de la création d’une application J2EE.

Configuration du Data Source

La configuration du data source ce fait séparé de l’application J2EE. Cela permet de facilement la modifier sans devoir recompiler l’application. Elle est référé dans cette dernière par son nom JNDI, peut importe son implémentation.

Il faut donc créer un fichier nommer du nom de l’application suivit d’un “-ds”. Ce fichier est de type XML. Pour des fins de démonstrations, nous utiliserons le nom d’application “project”. Donc le fichier “project-ds.xml” contiendra le texte suivant :

<?xml version=”1.0″ encoding=”UTF-8″?>
<datasources>
<local-tx-datasource>
<jndi-name>ProjectDS</jndi-name> (1)
<connection-url>jdbc:mysql://localhost:3306/project</connection-url> (2)
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>root</user-name>
<password>password</password>
<min-pool-size>5</min-pool-size> (3)
<max-pool-size>20</max-pool-size> (4)
<idle-timeout-minutes>0</idle-timeout-minutes>
<track-statements/>
</local-tx-datasource>
</datasources>

Le premier point important (1) est le nom JNDI qui sera utilité. Il est standard d’ajouter les lettres “DS” à la suite pour signifier la nature, data source, du composant. La configuration du chemin d’accès à la base de donnée ce fait au point (2). La base de donnée, ici “project” doit préalablement avoir été créé et que l’utilisateur est les droits appropriés de sur cette dernière. Si on désire utiliser les fonctionnalité de génération automatique de la base de donnée par JPA, il doit avoir les droits create et drop en plus de ceux régulier. La sécurité ce fera au niveau de l’application puisque l’application n’utilise qu’un seul utilisateur pour l’accès aux données. Finalement, les points (3) et (4) permette de gérer le nombre de connexions qui seront généré pour le système­. La création d’une connexion vers la base de données est un processus lourd pour une application web c’est pour cela qu’il est recommander d’en générer plusieurs d’avances. Le nombre de connexions consommé par le système n’a pas une corrélation directe avec le nombre de clients dans le domaine. En effet, il est seulement le nombre limite de requêtes simultanés qu’il peut traiter. Cette technique utilise le principe selon lequel un client est inactif 90% du temps qu’il passe dans un système.

Configuration de la persistance

Le prochain fichier à configurer est le fichier de persistance dans le dossier meta-inf du EAR contenant les Entity Beans. Il est important de préciser ici que ces derniers ont été grandement allégé dans leur troisième génération par rapport aux précédente. Ils n’ont plus de réel différence avec des POJOs (Plan Old Java Object) réguliers. Il sont cependant administré par un entity manager qui gère automatiquement leur persistance et leur mise à jour, tout en laissant la possibilité de le faire manuellement.

Le but du fichier de persistance (persitance.xml) est donc de définir quel data source est utilisé par l’application et quel dialecte est utilisé pour communiquer avec la base de donnée.

<persistence>
<persistence-unit name=”project”> (2)
<jta-data-source>java:/ProjectDS</jta-data-source> (1)
<properties>
<property name=”hibernate.dialect” value=”org.hibernate.dialect.MySQL5Dialect”/>
<property name=”hibernate.hbm2ddl.auto” value=”create-drop”/>
<property name=”hibernate.show_sql” value=”true”/>
<property name=”hibernate.format_sql” value=”true”/>
</properties>

</persistence-unit>
</persistence>

Le point (1) réutilise ici le nom configuré dans l’étape précédente et fera une requête JNDI pour obtenir la data source associé à ce dernier. Le second point configure le persistence-unit name qui sera utilisé pour sélectionner l’entity manager associer à cette persistance.

Création d’un Entity Bean

L’application est maintenant prête à utiliser des entity beans. La troisième génération de ces derniers utiliser pleinement la configuration par annotation plutot que par xml. Elle permet de configurer le mapping entre les objets Java et leurs tables équivalentes.

@Entity (1)
@Table(name=”Student”)
public class StudentEntity {

@Id @Column(name=”user_name”, nullable=false) (2)
private String userName;

@Column(name=”first_name”, nullable=false) (3)
private String firstName;

[...]

@Column(name=”telephone”, nullable=false)
private String telephone;

@OneToMany(mappedBy=”student” ,fetch = FetchType.LAZY)
private List<ScheduleAssignationEntity> groupcourse;

@ManyToOne(fetch = FetchType.LAZY) (4)
@JoinColumn(name=”id_program”)
private ProgramEntity program;

@Version (5)
@Column(name=”version”, nullable=true)
private long version;

[getters et setters pour l'ensemble des attributs]
}

(1) : L’annotation entity definit l’objet comme un entity bean
(2) : La granularité des annotations est assez forte. On peut facilement définir des clefs et options pour chaque attributs.
(3) : l’annotation de column est optionnel mais permet de définir l’option de nullabilité.
(4) : Les entity beans permettent aussi d’effectuer directement le lien entre les objets Java et définir les options de fetch. Ici le patron de conception J2EE Lazy loading est utilisé.
(5) : L’annotation version permet d’implémenter le patron de conception Optimistic Lock

Utilisation de l’entity manager

L’utilisation de l’entity manager est très simple. Tout d’abord, on doit informer le système d’injecter ce dernier dans notre objet en ajoutant l’attribut suivant à notre Session Bean.
@PersistenceContext(unitName = “cheminot”)
private EntityManager em;

Par la suite, on peut utiliser cet attribut directement sans l’instancier. Par exemple pour rechercher un objet par sa clef on peut utiliser la ligne suivante :

GroupCourseEntity group = em.find(GroupCourseEntity.class, id);

Aussi simplement, on peut enregistrer un objet dans la base de donnée par la ligne suivante :

em.persist(schedule);

JPA permet quand même de faire des requêtes sur les objets comme s’ils seraient des tables.
List<GroupCourseEntity> groupes = (List<GroupCourseEntity>) em
.createQuery(
“SELECT g FROM GroupCourseEntity g WHERE g.course.acronym = :acronym AND g.quarter.current = true”)
.setParameter(“acronym”, sigle).getResultList();

Extensibilité de JPA

JPA ne peut être utilisé qu’au niveau des Sessions Beans pour une application conventionnelle. Cette approche favorise une bonne division des couches mais nécessite la création d’objets de transports entre chaqu’unes. Certains cadres applicatifs, tel que Seam, corrige cette situation et permette son utilisation à tout les niveaux.

No tags