Vous êtes sur la page 1sur 24

Créer la

Créer la couche de persistance Copyright © 2007, Oracle. Tous droits réservés.

couche de persistance

Copyright © 2007, Oracle. Tous droits réservés.

Objectifs

Ce chapitre traite des sujets suivants :

expliquer le concept de persistance

créer un mapping relationnel objet

utiliser des annotations pour améliorer les entités JPA (Java Persistence API API de persistance Java)

utiliser des entités JPA pour mettre en correspondance

des données d'application avec la base de données

identifier une interrogation JPA et l'utiliser efficacement dans une application

Qu'est-ce que la persistance ?

La couche de persistance permet de mettre en

correspondance les objets et les tables de base de données. Cette couche est associée aux caractéristiques suivantes :

Elle permet la portabilité entre les bases de données et les schémas.

Elle prend en charge les fonctionnalités de lecture,

d'écriture et de mise en mémoire cache.

Elle évite aux développeurs d'avoir à gérer les problèmes liés à la base de données.

Elle facilite les modifications et la gestion des données.

Il est recommandé de l'utiliser dans toutes les applications disposant d'un modèle objet.

Persistance : Présentation

La mise en correspondance d'objets de base de données relationnelle avec des objets Java

facilite le développement d'applications Java EE.

Ce mapping est fourni par des structures telles que l'API de persistance Java EJB 3.0.

Architecture de persistance entité/JPA Modèle Java Schéma
Architecture
de
persistance
entité/JPA
Modèle Java
Schéma

Couche de persistance

Une couche de persistance isole les informations de persistance de la couche applicative.

les informations de persistance de la couche applicative. Les résultats de Créations et mises l'interrogation et
les informations de persistance de la couche applicative. Les résultats de Créations et mises l'interrogation et
les informations de persistance de la couche applicative. Les résultats de Créations et mises l'interrogation et

Les résultats de

Créations et mises

l'interrogation et de

   

à jour d'objets via

 

Objets

Objets

une API de niveau objet.

Persistance

Les résultats sont

Lignes

 

SQL

L'API utilise SQL

renvoyés en tant que données brutes.

L'API utilise SQL renvoyés en tant que données brutes. la création au niveau objets sont des
L'API utilise SQL renvoyés en tant que données brutes. la création au niveau objets sont des
L'API utilise SQL renvoyés en tant que données brutes. la création au niveau objets sont des

la création au niveau objets sont des objets.

ou des appels de base de données spécifiques.

Qu'est-ce qu'un objet POJO ?

Un objet POJO :

est un objet Plain Old Java Object

n'implémente aucune interface spéciale

est indépendant de l'environnement de développement

permet aux développeurs de se concentrer sur la logique métier

contient des définitions de champ et des méthodes

d'accès (accessors)

définitions de champ et des méthodes d'accès ( accessors) 3-6 Copyright © 2007, Oracle. Tous droits
définitions de champ et des méthodes d'accès ( accessors) 3-6 Copyright © 2007, Oracle. Tous droits

API de persistance Java EJB 3.0

Modèle d'entité POJO léger

portable

simplifié

modulaire

Mapping relationnel objet normalisé

annoté

flexible

Interrogations dynamiques

EJB QL pleinement fonctionnel

Entités JPA

Mécanisme de persistance cohérent

API de persistance Java (JPA)

Modèle de programmation simple

persistance des objets POJO (Plain Old Java Objects)

annotations de mapping relationnel objet

méthodes get/set

possibilité d'inclure une logique (validation, etc.)

L'objet EntityManager

gère les manipulations de données

permet l'appel des entités hors du conteneur

Annotations d'entité

@Entity

@Id

@IdClass

@EmbeddedId

@Table, @SecondayTable

@UniqueConstraint

@PrimaryKeyJoinColumn(s)

@NamedQuery(s)

Séquencement

@GeneratedValue

@SequenceGenerator

@TableGenerator

Comment fonctionnent les entités JPA ?

Une entité JPA :

est un objet léger qui gère les données de persistance

est définie sous la forme d'un objet POJO (Plain Old Java Object) avec l'annotation Entity

(aucune interface requise)

doit implémenter l'interface java.io.Serializable pour être transmise par valeur vers une application distante

est mise en correspondance avec une base

de données à l'aide d'annotations

@Table(name="PRODUCTS") @Id @Column(name="PRODID") ORDERS
@Table(name="PRODUCTS")
@Id
@Column(name="PRODID")
ORDERS

@Entity

@Column(name="PRODID") ORDERS @ E n t i t y P O J O Base de données

POJO

Base de données

Fonctionnement de l'API de persistance Java

CreateProducts

Objet Product
Objet
Product

Appel de addProducts

ProductsBean

Entité Product
Entité
Product

Appel de persist

EntityManager

Entité Product Appel de persist EntityManager Insertion d'un enregistrement Table Products 3-11

Insertion d'un enregistrement

Table Products

Mapping O/R JPA

Les stratégies de mapping par défaut pertinentes :

Utilisent des annotations pour remplacer

les valeurs par défaut.

Interfaces de collection utilisées pour les relations :

@OneToOne, @OneToMany, @ManyToOne, etc.

Possibilité de mettre en correspondance un ou plusieurs objets persistants avec une table :

Possibilité d'imbrication

Prise en charge des stratégies d'héritage standard :

Une table par hiérarchie de classes, par classe, etc.

Types de mapping

Le type de mapping définit le mode de stockage

des données et des relations d'un objet dans la base.

Stockage direct dans un champ : Les données d'une variable d'instance sont stockées directement dans une colonne d'une table.

Conversion de type : Les données d'un certain type sont stockées dans une table avec un autre type.

Par exemple, la chaîne "age" de l'objet est stockée

avec le type numérique dans la table.

1 à 1 : Une relation 1 à 1 entre deux classes est stockée dans la base de données.

Indiquer un mapping relationnel objet

La mise en correspondance d'une entité JPA avec une table de base de données est réalisée par défaut, à l'aide d'annotations.

@Entity

// annotation

public class Products implements Serializable {

}

@Column(nullable = false) private String description; private String image;

@Column(nullable = false) private String name;

PRODUCTS PRODID (PK) NAME
PRODUCTS
PRODID (PK)
NAME

@Id

@Column(name="PROD_ID", nullable = false) private Long prodId;

Mettre en correspondance des relations entre les entités

Annotations pour les relations entre entités :

OneToOne

pour les relations entre entités : • OneToOne • OneToMany User Address ServiceRequest ServiceHistory
pour les relations entre entités : • OneToOne • OneToMany User Address ServiceRequest ServiceHistory

OneToMany

User

entre entités : • OneToOne • OneToMany User Address ServiceRequest ServiceHistory • ManyToMany et

Address

entre entités : • OneToOne • OneToMany User Address ServiceRequest ServiceHistory • ManyToMany et

ServiceRequest

ServiceHistory

ManyToMany et AssociationTable

ServiceHistory • ManyToMany et AssociationTable Products U s e r s 3-15 Copyright © 2007, Oracle.
ServiceHistory • ManyToMany et AssociationTable Products U s e r s 3-15 Copyright © 2007, Oracle.

Products

Users

Gérer la persistance des entités JPA

Le cycle de vie d'une entité est géré à l'aide de l'interface EntityManager, qui fait partie de l'API de persistance Java.

Une entité peut être créée à l'aide de :

l'opérateur new (crée une instance détachée)

Une entité est insérée, mise à jour ou supprimée à partir d'une base de données via l'API de persistance Java.

new

base de données via l'API de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité
base de données via l'API de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité

persist()

merge()

via l'API de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité API de persistance

LMD

via l'API de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité API de persistance

Interrogation

de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité API de persistance Java Entités
de persistance Java. new persist() merge() LMD Interrogation remove() find() Entité API de persistance Java Entités

remove()

Java. new persist() merge() LMD Interrogation remove() find() Entité API de persistance Java Entités Base de

find()

new persist() merge() LMD Interrogation remove() find() Entité API de persistance Java Entités Base de données

Entité

API de persistance Java

Entités

Base de

données

Interrogation :

Entity Manager

Extraction d'entités de la base de données

Transactions :

Application de modifications aux entités

Général :

isOpen()

close()

contains(Object entity)

Utilisation :

Gestion par le conteneur (injection)

Initialisation (bootstrap) d'application

(EntityManagerFactory)

Entity Manager

Validation (commit) des Instruction SQL enregistrements Objet EntityManager Base de données
Validation
(commit) des
Instruction
SQL
enregistrements
Objet
EntityManager
Base de
données

Extraction des enregistrements

Résultats de l'interrogation

Interface Entity Manager de l'API de persistance Java

L'API EntityManager sert de point d'accès non typé (indépendant du type de l'objet) :

Accès aux entités et manipulation

Injection à l'aide de l'annotation @PersistenceContext

Création d'un nouvel objet POJO avec le mot-clé new

Elle fournit des opérations de cycle de vie :

persist()

remove()

merge()

Il agit comme instanciateur pour les objets

interrogation.

Cycle de vie d'une entité

Dont la persistance doit être assurée

find()

query()

Gérée

new()

Nouvelle

Supprimée

persist()

find() query() Gérée new() Nouvelle Supprimée persist() remove() Hors de portée merge() refresh() Détachée 3-20

remove()

query() Gérée new() Nouvelle Supprimée persist() remove() Hors de portée merge() refresh() Détachée 3-20

Hors de portée

merge()

refresh()

Détachée

Contexte et portée de persistance

Le contexte gère l'état de l'entité pour EntityManager.

Une entité est gérée pendant la portée de la persistance.

Le contexte suit les entités attachées à une transaction.

Transaction Contexte de persistance Entité Entité détachée
Transaction
Contexte de
persistance
Entité
Entité
détachée

Manipuler des enregistrements avec l'API de persistance Java

JPA QL (JPA Query Language) est un langage

d'interrogation pour des interrogations dynamiques

et statiques exprimées via des métadonnées.

Mapping de persistance SELECT Agit sur Relation UPDATE DELETE Entité Entité EJB Champs ou propriétés
Mapping de persistance
SELECT
Agit sur
Relation
UPDATE
DELETE
Entité
Entité
EJB
Champs ou propriétés
SQL natif
Mise en
correspondance
Annotations, descripteur de
Compilation
Base de données
déploiement ou les deux

Ecrire des instructions SELECT JPA QL de base

Syntaxe d'une instruction SELECT JPA QL :

SELECT [DISTINCT] select_expression FROM abstract_schema_name [AS] identifier_variable [WHERE conditional_expressions(s)] [ORDER BY order_by_item(s)]

Exemple d'interrogation nommée JPA QL :

Rechercher tous les produits

@NamedQuery(name = "Products.findAll", query = "select o from Products o"),

Synthèse

Ce chapitre a traité des sujets suivants :

expliquer le concept de persistance et comment

les entités JPA l'implémentent

créer un mapping relationnel objet à l'aide

d'annotations pour améliorer les beans Entity

identifier une interrogation nommée et l'utiliser efficacement dans une application