Hibernate VF1

HIBERNATE
 Problématique MINI-PROJET
 Outil ORM
 Conception & réalisation d’une
 Modules hibernate application de gestion des oeuvres.
 Mini-projet
EXTENSIBLE MARKUP
LANGUAGE
AMELIORATION DE PROJET
 Introduction  Devoir a rendre
 Les avantages du XML
 Structure d’un document XML
 Les règles de syntaxe
 Validation XML
 Programmation JDOM et
XML NOTRE PLAN
HIBERNATE
 Outil ORM
 Mini-projet
EXTENSIBLE MARKUP
LANGUAGE
 Introduction  Devoir a rendre
 Validation XML
XML NOTRE PLAN
HIBERNATE
 Outil ORM
 Mini-projet
EXTENSIBLE MARKUP
LANGUAGE
 Introduction
 Devoir a rendre
 Validation XML
XML NOTRE PLAN
HIBERNATE
 Outil ORM
 Mini-projet
EXTENSIBLE MARKUP
LANGUAGE
 Introduction
 Devoir a rendre
 Validation XML
XML NOTRE PLAN
PARTIE 1 : XML
STRUCTURE D’UN VALIDATION D’UN PROGRAMMATION
RÈGLES DE SYNTAXE
INTRODUCTION DOCUMENT XML DOCUMENT XML JDOM ET XML
C’EST QUOI XML !
• L’acronyme de eXtensible Markup

Language
• Une recommandation W3C
• Un langage informatique de
balisage dérivé de langage SGML
• Un langage de structuration des

données, et non représentation des
données
1
LES AVANTAGES
STRUCTURE D’UN VALIDATION D’UN PROGRAMMATION
RÈGLES DE SYNTAXE
INTRODUCTION DOCUMENT XML DOCUMENT XML JDOM ET XML
L
Lisibilité Intégrabilité
I
Un document XML est Un document XML est
facilement lisible par utilisable par toutes les
un humain. applications pourvues
d'un parseur.
E D
Extensibilité Disponibilité
l’ensemble des balises XML est un langage libre
admises n’est pas figé ce (nous pouvons l’utiliser
qui permet aux éditeurs sans pouvoir acheter
des documents de créer une licence).
leurs propre balises.
SERVICES TEAM GOAL 2

STRUCTURE D’UN LES RÈGLES DE VALIDATION D’UN PROGRAMMATION
INTRODUCTION DOCUMENT XML SYNTAXE DOCUMENT XML JDOM ET XML
PROLOGUE
COMMENTAIRE
ATTRIBUT
BALISE
D’OUVERTURE
ÉLÉMENT RACINE
CONTENU DE
ÉLÉMENT
BALISE DE
FERMETURE
ELEMENT ETUDIANT INSÉRER DANS

L’ELÉMENT RACINE LPMI 3
INTRODUCTION DOCUMENT XML SYNTAXE DOCUMENT XML JDOM ET XML
LPMI
Place Your
Headline
ETUDIANT @DELEGUE
This is a sample text.
Insert your desired text
REPRESENTATION GRAPHIQUE DE This is a sample
here.
L’ARBRE XML text. Insert your desired
text here.
ADRESSE PRÉNOM DN NOM @NI @SEXE
RUE NUM VILLE JOUR MOIS ANNEE

INTRODUCTION
DOCUMENT XML SYNTAXE DOCUMENT XML JDOM ET XML
Le document doit avoir un seul élément racine
Erreur de syntaxe Document bien forme

INTRODUCTION
Pour chaque balise ouvrante doit

correspondre une balise fermante
Erreur de syntaxe Document bien formé

INTRODUCTION
Pour chaque balise ouvrante doit correspondre

une balise fermante
Erreur de syntaxe Document bien formé

INTRODUCTION
XML est sensible a la case
Incorrect Correct
Les attributs d’un élément doivent êtres

distinctes
Incorrect Correct
INTRODUCTION
Les valeurs des attributs doivent êtres délimitées par

les apostrophes ou les guillemets
Incorrect Correct
Les éléments doivent être correctement

imbriques.
Incorrect Correct
4
INTRODUCTION DOCUMENT XML
DOCUMENT XML SYNTAXE JDOM ET XML
C’est quoi la validation d’un

document XML ?
 La validation consiste à vérifier que la structure d’un document est

conforme à une grammaire .On dit que le document est valide
 La grammaire permet de définir le vocabulaire (l’ensemble des

éléments et des attributs) et les règles à appliquer pour structurer
les données dans les documents XML (l’ordre des éléments,
cardinalités, contenu des éléments....).
4
Quelques Langages de validation !
DOCUMENT TYPE DEFINITION SCHEMA XML RELAX NG SHEMATRON
Est langage dérivée du Est langage dérivée du Est langage qui combine les Est un norme ISO ayant un
Langage SGML Langage XML avantages des DTD et des XML syntaxe XML
schéma
4
JDOM ET XML 2
DOCUMENT XML SYNTAXE
DTD : Document Type Definition
1 3
LA DÉFINITION DES ENTITÉS

LA DÉFINITION DES ÉLÉMENTS
2 4
LA DÉFINITION DES NOTATIONS

LA DÉFINITION DES ATTRIBUTS
Il s’agit d’un. DTD interne
L’élément racine Etudiant doit

contenir obligatoirement les
sous élément CNE,Nom,Prenom
CNE ,Nom et Prenom des

élément qui doivent contenir
des données textuels
Valide
JDOM ET XML 2
DOCUMENT XML SYNTAXE
Il s’agit d’un. DTD externe
L’element racine Etudiant doit

contenir un seul element parmi
la liste de
Valide
Le docement XML est valide

pour le DTD
PARSEUR XML
22
INTRODUCTION
C’EST QUOI UN PARSEUR !
XML parseur
(DOM/JDOM) Application client
Document XML
• est un outil logiciel permettant de Parcourir le contenu d’un texte ou

d’un fichier en l’analysent pour vérifier sa syntaxe ou en extraire des
éléments.
INTRODUCTION
QUELQUES EXEMPLES DES PARSEURS.
SAX DOM
API utilisant une approche hiérarchique pour API basés sur un mode événementiel permettent
construire une structure contenant des objets de réagir à des événements comme le début d'un
représentant les éléments du document, et dont élément ou la fin d'un élément
les méthodes permettent d'accéder Aux
propriétés.
INTRODUCTION
Creation du document xml

JDOM
Encapsulation d'un document XML sous la
forme d'objets Java de l'API
JDOM est une API open source Java dont le but est Exportation d'un document dans un fichier,
de représenter et manipuler un document XML de un flux SAX ou un arbre DOM
manière intuitive pour un développeur Java sans
requérir une connaissance pointue de XML.
Support de XSLT & XPath

STRUCTURE DE PACKAGE
26
INTRODUCTION
org.jdom  SAXBuilder
 Attribute  DOMBuilder
 CDATA  ResultSetBuilder
 Comment
 DocType
 Document
org.jdom.input
 Element
 EntityRef
 Namespace org.jdom.output  XMLOutputter
 SAXOutputter
 ProcessingInstruction
 DOMOutputter
 Text
org.jdom.adapters  JTreeOutputter
 JDOMSource
org.jdom.transform  JDOMResult
LA CLASSE DOCUMENT
28
INTRODUCTION
La classe Document
Exemple 1:
import org.jdom.Document; Création d’un élément

public class TestJDOM2 {
public static void main(String[] args) {
Element racine = new Element("bibliothèque");
Document document = new Document(racine); }}
Création d'un document avec

l'élement racine fournis
LA CLASSE ATTRIBUT
30
INTRODUCTION
La classe Attribute
Exemple 2:
import org.jdom.Attribute;
public class TestJDOM2 { Création d’un autre attribut
public static void main(String[] args) {
Element racine = new Element("bibliothèque");
racine.setAttribute("attribut1", "Valeur2")
racine.setAttribute("attribut2", "Valeur2") x
Création d’un attribut

INTRODUCTION
Exemple 1 La classe XMLOutputter permet d'envoyer

3: le document XML dans un flux.
import java.io.FileOutputStream; 2 Il est possible de fournir plusieurs
import java.text.*; paramètres pour formater la sortie du
import org.jdom.Attribute; document.
import org.jdom.Document; table.setAttribute("width","100%");
import org.jdom.Element; table.setAttribute(new Attribute("border","0"));
import org.jdom.output.Format; table.setAttribute("cellspacing","10");
table.removeAttribute("cellspacing");
import org.jdom.output.XMLOutputter;
public class TestJDom1 { affiche(document);
public static void main(String[] args) { }
static void affiche(Document document)
Element racine = new Element("html"); {
Document document = new Document(racine); try
{
Element body = new Element("body");
XMLOutputter sortie = new
racine.addContent(body); XMLOutputter(Format.getPrettyFormat());
Element table = new Element("table"); Sortie.output(document, System.out);}

body.addContent(table); catch (java.io.IOException e){}}}
Ajouter le nouveau élément ‘body’ On utilise ici un affichage classique avec

au seins de l’élément ‘racine’ getPrettyFormat()
INTRODUCTION JDOM ET XML
DOCUMENT XML SYNTAXE DOCUMENT XML
 Créer l’arborescence suivante :
<personnes>
personnes
<etudiant classe ="LPMI">
<nom> Mohammed </nom>
</etudiant>
etudiant
</personnes>
nom
@classe
import java.io.*; Solution :

import org.jdom.*;
import org.jdom.output.*; static void affiche()
public class JDOM1 {
{ try
static Element racine = new Element("personnes"); {
static org.jdom.Document document = new XMLOutputter sortie = new
Document(racine); XMLOutputter(Format.getPrettyFormat());
public static void main(String[] args) sortie.output(document, System.out);}
{ catch (java.io.IOException e){}}
Element etudiant = new Element("etudiant");
racine.addContent(etudiant); static void enregistre(String fichier)
{
Attribute classe = new Attribute("classe", "LPMI"); try
etudiant.setAttribute(classe); {
Element nom = new Element("nom"); XMLOutputter sortie = new
nom.setText("Nadifi"); XMLOutputter(Format.getPrettyFormat());
etudiant.addContent(nom); sortie.output(document, new
affiche(); enregistre("Exercice1.xml"); FileOutputStream(fichier));}
} 2
catch (java.io.IOException e){}}}
1
Créez tout d'abord le fichier suivant :

Example:
<?xml version="1.0" encoding="UTF-8"?>
personnes <personnes>
<etudiant classe="P2">
<nom> Sliman </nom>
<prenoms>
<prenom> Mohammed </prenom>
etudiant etudiant etudiant <prenom> Amine </prenom>
@classe </prenoms>
nom nom
</etudiant>
<etudiant classe="P1">
prenoms <nom> Khezami </nom>
@classe </etudiant>
@classe
prenom prenom <etudiant classe="P1">
<nom> Lahssiri </nom>
</etudiant>
</personnes>
PARTIE 2 : HIBERNATE
PROBLEMATIQUE OUTIL ORM MODULES HIBERNATE MINI-PROJET
public
public class
class {{
private
private id;
id;
private
private firstname;
firstname;
JDBC
private
private lastname;
lastname;
}} DATABASE
Code Requêtes SQL

public
public class
class {{
private
private id;
id;
private
private firstname;
firstname;
JDBC
private
private lastname;
lastname;
}} DATABASE
ORM
Framework
Avec Hibernate
Mapping objet-relationnel
SGBD
X
Code
Requêtes SQL
PROBLEMATIQUE OUTIL ORM MODULES HIBERNATE MINI-PROJET 2
Que’est-ce que l’ORM ?
L’ORM ( Object Relational Mapping ) est un concept permettant de connecter un modèle

objet à un modèle relationnel.
Couche qui va interagir entre l’application et la base de données.
A pour but d’établir la correspondance entre une table de la base de données, et une
classe du modèle objet.
ORM
Framework
ORM
Gain de temps au niveau du
développement d’une application. L’optimisation des outils proposés.
Abstraction de toute la partie SQL. La difficulté à maîtriser les outils.
Perte de productivité des développeurs alors

La portabilité de l’application d’un
qu'ils apprendre à programmer avec les
point de vue SGBD ORM.
Framework ORM pour Java Configuration au travers de fichiers

(BD Relationnelles et Objet). XML ou d’Annotations.
Requêtes pour CRUD

Très fortement configurable.
(HQL Hibernate Query Language).
Utilisation des POJOs

Très difficile à maîtriser
(Plain Old Java Objects).
Il génère les requêtes indépendantes de la

base de données (HQL).
Permet de créer automatiquement les tables de

la base de données
Fast Performance
DÉBUTER AVEC HIBERNATE
44
hibernate.cfg.xm
hibernate.cfg.xm
<?xml version="1.0" encoding="UTF-8"?> ll
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN“
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
Driver Class
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver
Connection URL </property>
<property
name="hibernate.connection.url">jdbc:mysql://localhost:3306/dbname
Username
</property>
Password <property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password"> </property>
SQL Dialect
Supprimer et recréer le schéma de <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect
la base de données au démarrage </property>
<property name="hbm2ddl.auto"> create </property>
Afficher tous les SQL requêtes
exécutés sur ‘stdout’
<property name="show_sql"> true </property>
</session-factory>
</hibernate-configuration>
1 2
Main
Main
import org.hibernate.Session;
ServiceRegistry serviceRegistry = new
import org.hibernate.SessionFactory;
Import StandardServiceRegistryBuilder().applySettings(configuratio
org.hibernate.boot.registry.StandardServiceRegistryBuilder; n.getProperties()).build();
import org.hibernate.cfg.Configuration;
SessionFactory sessionFactory =
import org.hibernate.service.ServiceRegistry;
configuration.buildSessionFactory(serviceRegistry);
public class App Session session = sessionFactory.openSession();
{
public static void main( String[] args )
session.beginTransaction();
{
Student S1 = new Student("Othmane","Zougari"); session.save(S1);
session.getTransaction().commit();
Configuration configuration = new Configuration();
}}}
configuration.configure("hibernate.cfg.xml");
1 2
Student.java
Student.java
@Table(name="student_lpmi") public void setFirstName(String firstName) {
@Entity this.firstName = firstName;
public class Student { }
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY )
private int id; public String getLastName() {
@Column(name="prenom") return lastName;
private String firstName; }
@Column(name="Nom")
private String lastName; public void setLastName(String lastName) {
this.lastName = lastName;
public Student(String firstName, String lastName) { }
this.firstName = firstName;
this.lastName = lastName; @Override
} public String toString() {
public String getFirstName() { return "Student [id=" + id + ", firstName=" + firstName +

return firstName; ", lastName=" + lastName + "]";
}
}
}
Annotations Rôle
Hibernate considère la classe avec l'annotation
@Entity comme éligible pour être conservée
@Entity dans la base de données.
Si nous voulons un nom de table différent du
nom de la classe, nous pouvons spécifier le
@Table(name="") nom en utilisant l'annotation @Table.
L'annotation @Id est utilisée pour déclarer une
@Id colonne comme clé primaire.
Pour change le nom d’un colonne dans la base

@Column(name="") de données.
Hibernate décide du type de générateur à

@GeneratedValue utiliser, en fonction du support de la base de
données pour la génération de clé primaire.
@Entity
Student.java
Student.java
public class Student {
@Id
import org.hibernate.Session; Main
Main
@GeneratedValue(strategy = GenerationType.IDENTITY )
private int id; Import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
@Column(name=“nom") import org.hibernate.cfg.Configuration;
private String firstName; import org.hibernate.service.ServiceRegistry;
@Column(name="prenom")
private String lastName; public class App
{
public Student(String firstName, String lastName) { public static void main( String[] args )
this.firstName = firstName; {
this.lastName = lastName; Student S1 = new Student("Othmane","Zougari");
} Student S2=new Student("khezami","mohammed");
public String getFirstName() { Student S3=new Student("lahssairi","mohammed");
return firstName; Configuration configuration = new Configuration();
}
configuration.configure("hibernate.cfg.xml").addAnnotatedClass(Student.class);
public void setFirstName(String firstName) { ServiceRegistry serviceRegistry = new

this.firstName = firstName; StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).bui
}
ld();
public String getLastName() { SessionFactory sessionFactory =
return lastName; configuration.buildSessionFactory(serviceRegistry);
}
Session session = sessionFactory.openSession();
public void setLastName(String lastName) { session.beginTransaction();
this.lastName = lastName;
session.save(S1);
}
@Override session.save(S3);
public String toString() { session.save(S3);
return "Student [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName +
session.getTransaction().commit(); }
"]"; }}
}}
DOCUMENTATION
50
RÉCUPÉRATION DES DONNÉES
1 2
Get()
Get() try {
import org.hibernate.SessionFactory; session.beginTransaction();
import
org.hibernate.boot.registry.StandardServiceRegistryBuilder; Student std1 = session.get(Student.class,3);
import org.hibernate.cfg.Configuration; System.out.println(std1);
import org.hibernate.service.ServiceRegistry;
import com.lahssairi.TestProject.Student; /*
Student std1 = session.get(Student.class,4);
public class App System.out.println(std1);
{ */
public static void main( String[] args ) session.getTransaction().commit();
{
}
catch (Exception e) {
configuration.configure("hibernate.cfg.xml").addAnnotatedClass(St e.printStackTrace();
udent.class); session.getTransaction().rollback();
ServiceRegistry serviceRegistry = new }
StandardServiceRegistryBuilder().applySettings(configuration.getP finally {
roperties()).build(); session.close();
SessionFactory sessionFactory = }
configuration.buildSessionFactory(serviceRegistry); }
Session session = sessionFactory.openSession(); }
1 2
Load()
Load() try {
import Student std1 = session.load(Student.class,3);
org.hibernate.boot.registry.StandardServiceRegistryBuilder; //System.out.println(std1);
import org.hibernate.service.ServiceRegistry; /*
import com.lahssairi.TestProject.Student; Student std1 = session.load(Student.class,4);
public class App System.out.println(std1);
{ */
{ session.getTransaction().commit();
}
MODIFICATION DES DONNÉES
OUTIL ORM LES RÈGLES DE PROGRAMMATION
PROBLEMATIQUE
INTRODUCTION LES AVANTAGES MINI-PROJET
MODULES HIBERNATE
SYNTAXE JDOM ET XML 2
1 2
Update
Update try {
import Student std1 = session.get(Student.class,3);
org.hibernate.boot.registry.StandardServiceRegistryBuilder; System.out.println(std1);
import org.hibernate.service.ServiceRegistry; std1.setFirstName("Yassine");
import com.lahssairi.TestProject.Student; std1.setLastName("Ouahid");
public class App
{ System.out.println(std1);
}
SUPPRESSION DES DONNÉES
1 2
Delete
Delete try {
import Student std1 = session.get(Student.class,3);
org.hibernate.boot.registry.StandardServiceRegistryBuilder; session.delete(std1);
import org.hibernate.service.ServiceRegistry; System.out.println(std1);
import com.lahssairi.TestProject.Student;
public class App Student std2 = session.get(Student.class,3);
{ System.out.println(std2);
}
udent.class); }
ServiceRegistry serviceRegistry = new session.getTransaction().rollback();
CYCLE DE VIE
Transient State
Garba
ity save() ge
ent
e of persist() saveOrUpdate()
nc Update()
sta
in
w
Ne
Delete() Garbage
Persistent State Removed State
Get()
Load()
Detach() Save()
Close() saveOrupdate()
Clear() Merge()
Evict() Lock() ge
Garba
Detached State

Hibernate VF1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Hibernate VF1

Transféré par

Droits d'auteur :

Formats disponibles

HIBERNATE

C’EST QUOI XML !

• L’acronyme de eXtensible Markup

• Une recommandation W3C

• Un langage de structuration des

SERVICES TEAM GOAL 2

ELEMENT ETUDIANT INSÉRER DANS

ADRESSE PRÉNOM DN NOM @NI @SEXE

RUE NUM VILLE JOUR MOIS ANNEE

Le document doit avoir un seul élément racine

Erreur de syntaxe Document bien forme

Pour chaque balise ouvrante doit

Erreur de syntaxe Document bien formé

Pour chaque balise ouvrante doit correspondre

Erreur de syntaxe Document bien formé

XML est sensible a la case

Les attributs d’un élément doivent êtres

Les valeurs des attributs doivent êtres délimitées par

Les éléments doivent être correctement

C’est quoi la validation d’un

 La validation consiste à vérifier que la structure d’un document est

 La grammaire permet de définir le vocabulaire (l’ensemble des

Quelques Langages de validation !

DOCUMENT TYPE DEFINITION SCHEMA XML RELAX NG SHEMATRON

DTD : Document Type Definition

LA DÉFINITION DES ENTITÉS

LA DÉFINITION DES NOTATIONS

Il s’agit d’un. DTD interne

L’élément racine Etudiant doit

CNE ,Nom et Prenom des

Il s’agit d’un. DTD externe

L’element racine Etudiant doit

Le docement XML est valide

C’EST QUOI UN PARSEUR !

• est un outil logiciel permettant de Parcourir le contenu d’un texte ou

QUELQUES EXEMPLES DES PARSEURS.

Creation du document xml

Support de XSLT & XPath

import org.jdom.Document; Création d’un élément

public static void main(String[] args) {

Element racine = new Element("bibliothèque");

Document document = new Document(racine); }}

Création d'un document avec

public class TestJDOM2 { Création d’un autre attribut

public static void main(String[] args) {

Element racine = new Element("bibliothèque");

Création d’un attribut

Exemple 1 La classe XMLOutputter permet d'envoyer

Element table = new Element("table"); Sortie.output(document, System.out);}

Ajouter le nouveau élément ‘body’ On utilise ici un affichage classique avec

 Créer l’arborescence suivante :

import java.io.*; Solution :

Créez tout d'abord le fichier suivant :

Code Requêtes SQL

Que’est-ce que l’ORM ?

L’ORM ( Object Relational Mapping ) est un concept permettant de connecter un modèle

Abstraction de toute la partie SQL. La difficulté à maîtriser les outils.

Perte de productivité des développeurs alors

Framework ORM pour Java Configuration au travers de fichiers

Requêtes pour CRUD

Utilisation des POJOs

Il génère les requêtes indépendantes de la

Permet de créer automatiquement les tables de

Connection URL </property>