Cet article vous montrera comment utiliser Maven pour créer un projet Java EE 6 (JSF2, EJB3.1, JPA2, Maven 3) sous Eclipse et GlassFish 3.
Outils utilisés :
- Eclipse
- GlassFish
- Maven
- MySQL
1. Créer un projet Web à partir du model Maven.
Pour commencer,créez un projet Maven sous Eclipse :
File >
New >
Other...
Suivant : choisissez le chemin de votre Workspace
Puis
suivant, à l'étape suivante vous devez l'archetype
maven-archetype-webapp pour créer un projet Web prêt à compiler et déployer :
Renseignez le
Group Id et l'
Artifact Id
Finish, votre projet ressemble à l'arborescence ci-dessous :
2. La couche présentation avec JSF.
On va maintenant se pencher sur la couche présentation.
Remplacez le contenue de votre
web.xml par :
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>
<context-param>
<param-name>javax.faces.DEFAULT_SUFFIX</param-name>
<param-value>.xhtml</param-value>
</context-param>
</web-app>
Ajouter la dépendance javaee-api,entre les balises <dependencies> et </dependencies>, à votre
pom.xml :
Veillez à ce que le
scope soit
provided, votre application utilise ainsi les librairies fournies par GlassFish au moment d'exécution, et celles fournies par Maven au moment de compilation.
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>6.0</version>
<scope>provided</scope>
</dependency>
On passe maintenant à la création d'une page JSF, supprimer la page index.jsp et créer une autre index.xhtml dans le répertoire webapp de votre projet :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Test JSF Page</title>
</h:head>v
<h:body>
<h:form name="monForm">
<h1>Page de test</h1>
<h:outputText value="Test outputText" />
</h:form>
</h:body>
</html>
Votre projet est prêt pour le test, déployer et tester votre application :
Développons notre page JSF, supposons que nous souhaitons créer un champs texte dont le contenu sera affiché dans la page après un clique sur un bouton ...
Pour cela créer un fichier beans.xml dans le WEB-INF :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
</beans>
Créer ensuite le bean suivant :
package com.elmaroufy.testwebapp;
import javax.enterprise.context.RequestScoped;
import javax.inject.Named;
@Named
@RequestScoped
public class TestBean {
private String test;
public String getTest() {
return test;
}
public void setTest(String test) {
this.test = test;
}
public void myAction(){
}
}
Modifier également votre page index.xhtml :
<h:inputText value="#{testBean.test}" />
<h:commandButton value="Test" action="#{testBean.myAction}" />
<h:outputText value=" #{testBean.test}" />
3. l'accès au données avec JPA :
Préparer votre base de données, j'ai choisis une BDD MySL, et n'oubliez pas de copiez le connecteur Java Mysql dans le répertoire
lib\ext de votre
domaine GlassFish.
Avant d'intégrer JPA à votre application, vous allez créer un Pool de connexion dans votre GlassFish :
Démarrer la console GlassFish, allez dans ressources > JDBC > Pools de connexions > Nouveau ...
Cliquer sur
suivant
Renseignez les paramétrés suivants :
Url : jdbc:mysql://localhost:3306/testdb
URL : jdbc:mysql://localhost:3306/testdb
User : testuser
DatabaseName : testdb
Password : password
Adapter ces valeurs à votre base de données.
Toujours dans la console, allez dans allez dans ressources > JDBC > Ressources JDBC > Nouveau ...
Nom JNDI : jndi/testdb
Nom du pool : le pool de connexion que vous venez de créer
Retournez sur Eclipse.
La première chose que vous allez effectuer pour votre implémentation de la couche d'accès aux données est la création du fichier
persistence.xml.
Rassurez-vous que le fichiez est crée dans le répertoire
META-INF qui doit, à son rôle, figurer dans le sous répertoire
\src\main\resources :
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="testpu" transaction-type="JTA">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<jta-data-source>jndi/testdb</jta-data-source>
<class>com.elmaroufy.testwebapp.TestEntity</class>
<properties>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
</properties>
</persistence-unit>
</persistence>
Noter que
- On utilise ici l'implémentation de JPA qui est fournie avec GlassFish, à savoir EclipseLink (
<provider> )
-
<jta-data-source> est le nom de la ressource JDBC que vous venez de créer via la console GlassFish
-
<class> est la classe enity, on se contente dans cet article d'une seule classe
Passons directement à la création de la classe Entity :
package com.elmaroufy.testwebapp;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class TestEntity implements Serializable {
@Id
@GeneratedValue
private Long id;
@Column
private String label;
/* getters et setters */
}
Et la classe DAO:
package com.elmaroufy.testwebapp;
import java.io.Serializable;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@javax.ejb.Singleton
public class TestDao implements Serializable {
@PersistenceContext(unitName = "testpu")
private EntityManager em;
public void saveTestEntity(TestEntity testEntity) {
em.persist(testEntity);
}
}
Vous pouvez ainsi injecter facilement votre DAO dans une couche supérieure, ici on injecte la DAO directement dans notre bean JSF :
Voici à quoi ressemblera la classe TestBean après la modification
package com.elmaroufy.testwebapp;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;
@Named
@RequestScoped
public class TestBean {
@Inject
private TestDao testDao;
private String test;
public String getTest() {
return test;
}
public void setTest(String test) {
this.test = test;
}
public void myAction(){
TestEntity testEntity = new TestEntity();
testEntity.setLabel(test);
testDao.saveTestEntity(testEntity);
}
}
Le projet est maintenant prêt pour un test opérationnel :
Vérifiez que l'insertion a bien été effectuée en BDD :
Vous pouvez compléter votre projet en :
- Utilisant
Hibernate à la place de EclipseLink
- Rajouter les logs avec
SLF4J
- Rajouter des
JUnit
Développons notre page JSF, supposons que nous souhaitons créer un champs texte dont le contenu sera affiché dans la page après un clique sur un bouton ...
