Guide étape par étape pour intégrer JPA dans une application JEE avec JSF
Tags: java, jsf, jpa
Published: 2023-07-14 01:42:18

---
title: Guide étape par étape pour intégrer JPA dans une application JEE avec JSF
published: true
description: 
tags: #Java, #Jsf, #JPA
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-07-14 01:31 +0000
---

## Introduction
L'intégration de JPA (Java Persistence API) dans une application JEE (Java Enterprise Edition) avec JSF (JavaServer Faces) est essentielle pour la persistance des données dans les applications web. Dans cet article, nous allons explorer les étapes clés pour intégrer JPA dans une application JEE avec JSF. Nous aborderons les aspects tels que l'ajout des dépendances, la configuration de la source de données, le mapping des entités, la gestion des transactions, l'utilisation des requêtes JPA et l'intégration avec JSF.

## Prérequis
Avant de commencer, assurez-vous d'avoir une connaissance de base de JEE, JPA et JSF. Vous devriez également avoir une application JEE existante avec JSF prête à être améliorée avec la persistance des données à l'aide de JPA.

## Points à couvrir :

### 1. Ajouter les dépendances
Pour intégrer JPA et JSF dans votre application, vous devez ajouter les dépendances appropriées. Dans votre fichier de configuration de projet (par exemple, pom.xml pour Maven), spécifiez les dépendances pour JPA et JSF, en utilisant les versions compatibles avec votre environnement. Voici un exemple de dépendances :

```xml
<!-- Dépendances JPA -->
<dependency>
    <groupId>javax.persistence</groupId>
    <artifactId>javax.persistence-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.6.1.Final</version>
</dependency>

<!-- Dépendances JSF -->
<dependency>
    <groupId>javax.faces</groupId>
    <artifactId>javax.faces-api</artifactId>
    <version>3.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.faces</artifactId>
    <version>3.0.1</version>
</dependency>
```

### 2. Configuration de la source de données (DataSource)
Pour utiliser JPA, vous devez configurer une source de données (base de données) dans le fichier de configuration de votre serveur d'application. Selon votre serveur d'application, vous pouvez utiliser différents fichiers de configuration, tels que persistence.xml ou context.xml. Voici un exemple de configuration pour une source de données MySQL :

```xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
    version="2.2">

    <persistence-unit name="my-persistence-unit" transaction-type="JTA">
        <jta-data-source>jdbc/MyDataSource</jta-data-source>
        <class>com.example.MyEntity</class>
        <!-- Autres classes d'entités à inclure -->

        <properties>
            <property name="javax.persistence.schema-generation.database.action" value="update" />
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/mydb" />
            <property name="javax.persistence.jdbc.user" value="myuser" />
            <property name="javax.persistence.jdbc.password" value="mypassword" />
        </properties>
    </persistence-unit>
</persistence>
```

### 3. Mapping des entités
Définissez vos entités (objets persistants) en utilisant les annotations JPA. Utilisez les annotations telles que @Entity, @Table, @Column, @Id, etc. pour mapper les entités aux tables de la base de données. Assurez-vous de mapper correctement les relations entre les entités en utilisant les annotations appropriées comme @OneToOne, @OneToMany, @ManyToOne, etc.

### 4. Gestion des transactions
Utilisez les annotations JPA (@Transactional) ou les API de gestion des transactions pour délimiter les opérations de persistance dans des transactions. Cela garantit que les opérations de lecture et d'écriture dans la base de données sont cohérentes et atomiques.

### 5. Utilisation des requêtes JPA
Utilisez les requêtes JPA pour interagir avec la base de données. Vous pouvez utiliser des requêtes JPQL (Java Persistence Query Language) ou des requêtes nommées pour récupérer, filtrer et manipuler les données persistantes. Assurez-vous de comprendre les différents types de requêtes disponibles et leur utilisation appropriée.

### 6. Intégration avec JSF
Dans vos beans de gestion de vues JSF, injectez ou utilisez les classes de gestion des données pour effectuer les opérations de persistance nécessaires. Les entités peuvent être utilisées pour lier les données de la vue JSF aux objets persistants dans la base de données. Assurez-vous de comprendre comment utiliser les objets EntityManager et les méthodes CRUD pour effectuer les opérations de persistance.

## Un exemple avec un entité User: 

### 1. Création de l'entité User

```java
@Entity
@Table(name = "users")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String nom;
    private String prenom;
    private int age;

    // Getters and setters
    // ...
}
```

### 2. Configuration de la source de données (persistence.xml)

```xml
<persistence-unit name="my-persistence-unit" transaction-type="JTA">
    <!-- ... -->
    <class>com.example.User</class>
    <!-- ... -->
</persistence-unit>
```

### 3. Création du service de gestion des données(UserService)

```java
@Stateless
public class UserService {
    @PersistenceContext(unitName = "my-persistence-unit")
    private EntityManager em;

    public void createUser(User user) {
        em.persist(user);
    }

    public List<User> getAllUsers() {
        TypedQuery<User> query = em.createQuery("SELECT u FROM User u", User.class);
        return query.getResultList();
    }
}
```

###4. Création du bean de gestion de vue JSF (UserBean)

```java
@ManagedBean
@RequestScoped
public class UserBean {
    private User user = new User();
    private List<User> users;

    @EJB
    private UserService userService;

    public void saveUser() {
        userService.createUser(user);
        user = new User(); 
// Réinitialiser l'utilisateur après la sauvegarde
    }

    public List<User> getUsers() {
        if (users == null) {
            users = userService.getAllUsers();
        }
        return users;
    }

    // Getters and setters
    // ...
}
```

### 5. Création de la page JSF pour afficher les utilisateurs(users.xhtml)

```html
<h:html xmlns="http://www.w3.org/1999/xhtml"
        xmlns:h="http://java.sun.com/jsf/html"
        xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Liste des utilisateurs</title>
    </h:head>
    <h:body>
        <h:form>
            <h:panelGrid columns="3">
                <h:outputLabel for="nomInput" value="Nom:"/>
                <h:inputText id="nomInput" value="#{userBean.user.nom}"/>
                <h:message for="nomInput"/>

                <h:outputLabel for="prenomInput" value="Prénom:"/>
                <h:inputText id="prenomInput" value="#{userBean.user.prenom}"/>
                <h:message for="prenomInput"/>

                <h:outputLabel for="ageInput" value="Âge:"/>
                <h:inputText id="ageInput" value="#{userBean.user.age}"/>
                <h:message for="ageInput"/>

                <h:commandButton value="Enregistrer" action="#{userBean.saveUser}"/>
            </h:panelGrid>
        </h:form>

        <h:dataTable value="#{userBean.users}" var="user">
            <h:column>
                #{user.nom}
            </h:column>
            <h:column>
                #{user.prenom}
            </h:column>
            <h:column>
                #{user.age}
            </h:column>
        </h:dataTable>
    </h:body>
</h:html>
```
## Conclusion
Intégrer JPA dans une application JEE avec JSF est une étape importante pour assurer la persistance des données. En suivant les étapes décrites dans cet article, vous pouvez commencer à utiliser JPA dans votre application et bénéficier de ses fonctionnalités puissantes pour la gestion des données. 

### Documentations: 

[JEE](https://docs.oracle.com/javaee/7/index.html)

[JPA](https://docs.jboss.org/hibernate/orm/5.6/userguide/html_single/Hibernate_User_Guide.html#_jpa)

 [JSF](https://javaserverfaces.github.io/docs/2.3/vdldoc/)