Hibernate

Bonjour tout le monde, Aujourd'hui, je voudrais vous parler l'Hibernate écrit en java qui vous permet d'éviter les travaux fastidieux et redondant.
Source:Hibernate
Java Persistence/OneToMany - Wikibooks

1.Introduction générale.

1.1Définition:
Hibernate est une solution open source de type Object Relational Mapping qui permet de faciliter le développement de la couche persistance d'une application.
Hibernate permet donc de représenter une base de données en objets java et vice versa.

1.2Avantage
->Très populaire notamment en raison de son ouverture à de nombreuses bases de données.
Les bases de données sont supportées sont les principales du marché:MySQL,SQL Serveur, PostgreSQL, Oracle etc
->Open source
->Bonnes Performances
1.3Inconvénances ??

2.Installation

Hibernate a besoin de plusieurs éléments pour fonctionner:
Une classe de type Javabean qui encapsule les données d'une occurrence d'une table.
Un fichier de configuration qui assure la correspondance entre la classe et la table(mapping).
Des propriétés de configuration notamment des informations concernant la connexion à la base de données.

2.1Configuration
Pour éclipse:
Côté jars:
a.Télécharger la dernière version qui se trouve dans le lien:Hibernate ORM
b.Décompressez-le, et copiez tous les jars:
hibernate-release-X.X.X/lib/required/*; collez-les dans le projet
c.Depuis Éclipse, Double cliquez le projet 'Properties', allez dans le Java Build Path, et importez les jars.

Java Build Path
Côté config hibernate
d.Créez un file nommé 'hibernate.cfg.xml'; définit les propriétés comme suivant:

<!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>
        <!-- jdbc connecting setting -->
        <property name="connection.driver_class">com.mysql.cj.jdbc.Driver??</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/HibernateDB??</property>
        <property name="connection.username">UserName??</property>
        <property name="connection.password">Password??</property>
        
        <!-- JDBC connecting pool size -->
        <property name="connection.pool_size">1</property>
        
         <!-- Select our SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Echo the SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Set the current session context -->
        <property name="current_session_context_class">thread</property>
    </session-factory>
</hibernate-configuration>

Pour exécuter Hibernate, il faut lui fournir un certain nombre de propriétés concernant sa configuration pour qu'il puisse se connecter à la base de données.

Proprités du fichier:hibernate.cfg.xml

2.2 Entity:La création d'une classe qui va encapsuler les données
Cette classe doit respecter des Javabeans, notamment,
a.Encapsuler les propriétés dans ses champs private
b.avec des getters et setters
c.et avoir un constructeur par défaut.

public class Student {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="id")
    private int id;
    
    @Column(name="first_name")
    private String firstName;
    
    @Column(name="last_name")
    private String lastName;
    
    @Column(name="email")
    private String email;
    
    public Student() {}
    
    public Student(String firstName, String lastName, String email) {
        super();
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
      ...//getters et setters, toString();
}

Note:les types utilisables pour les propriétés sont:
les types primitifs; les classes String, Dates, Les Wrappers; n'import qui encapsule une autre table ou une partie de la table.

2.3 Mapping file:La création d'un fichier de correspondance
Pour assurer le mapping,Hibernate a besoin d'un fichier de correspondance (mapping file) au format XML qui va contenir des informations sur la correspondance entre la classe définie et la table de la base de donnée.
Endroit du fichier:dans le même répertoire que la classe correspondant.
Nommage:nom de la classe suivi par '.hbm.xml'.

<?xml version=""?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD //EN"
"http://hibernatesourceforgenet/hibernate-mapping-dtd">
<hibernate-mapping>
   <class name="Personnes" table="personnes">
      <id name="idPersonne" type="int" column="idpersonne">
         <generator class="native"/>
      </id>
      <property name="nomPersonne" type="string" not-null="true" />
      <property name="prenomPersonne" type="string" not-null="true" />
      <property name="datenaissPersonne" type="date">
      <meta attribute="field-description">date de naissance</meta>
      </property>
   </class>
</hibernate-mapping>

tag<class>
tag<id>
tag<property>
2.4 @ManyToOne vs @OneToMany
Expliquation
Étude de cas:
Un étudiant a plusieurs posts. voilà ce que présente la base de donnée:
un étudiant -> plusieurs posts
Dans la classe Student, mettez l'annocation:@OneToMany

//getters et setters sont supprimés pour le simplifier.
@Entity
@Table(name="student")
public class Student {
//en fait, dans la table 'student', il n'y a pas un champs comme 'posts'.
    @OneToMany(mappedBy="student" ,cascade=CascadeType.ALL,orphanRemoval=true)
    private List<Post> posts = new ArrayList<>();
    public void addPost(Post post) {
        this.posts.add(post);
        post.setStudent(this);
    }

    public void removePost(Post post) {
        this.posts.remove(post);
        post.setStudent(null);
    }
}

Dans la classe Post, mettez

@Entity
@Table(name="post")
public class Post {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="post_id")
    private int postId;

    @Column(name="post_content")
    private String postContent;
    
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="student_id")
    private Student student;
//très très important.Utilisez un objet au lieu un identité de cet objet(parent).
}

Conslusion:
Comme vous le verrez dans un prochain article, les collections bidirectionnelles sont bien meilleures que les collections unidirectionnelles car elles reposent sur l'association @ManyToOne, qui est toujours efficace en termes d'instructions SQL générées.

3. L'utilisation d'Hibernate

Pour utiliser Hibernate dans le code, il est nécessaire de réaliser plusieurs opérations:

• création d'une instance de la classe
• création d'une instance de la class SessionFactory
• création d'une instance de la classe Session qui va permettre d'utiliser les services h'Hibernate.

Configuration configuration = new Configuration();
configuration.addClass(Student.class);
        SessionFactory factory = configuration
                .configure("hibernate.cfg.xml")//if not explicit, project will look for "hibernate.cfg.xml" this default file.
                .addAnnotatedClass(Student.class)
                .buildSessionFactory();
        Session session = factory.getCurrentSession();
        List<Student> students = session.createQuery("from Student").getResultList();
        session.beginTransaction();
        session.getTransaction().commit();
//pour ajouter les données dans la BD;
Student student = new Student("Paul","Wall","paul@afdtech.com");
            student.addPost(new Post("glad to work at AFD.TECH"));
            student.addPost(new Post("eager to find a mission"));
            session.save(student);

4. QR pour l'entretien

FAQ Hibernate
4.1 Que nous apporte Hibernate?
R:Le fait de manipuler directement les données d'une base sous forme d'objet est beaucoup plus pratique, cela nous permet de nous défaire de toute la couche SQL.
4.2 De quoi a besoin Hibernate pour fonctionner?
R:Hibernate a aussi besoin d'autres api pour fonctionner. En premier lieu, il ne faut pas oublier le driver JDBC de votre base de données.
4.3 Qu'est-ce que le fichier Hibernate.properties?
Le fichier hibernate.properties sert à configurer l'accès à la base de données. On va donc y configurer les différentes infos nécessaires à une connexion JDBC. On peut aussi configurer le pool de connexion via ce fichier.
4.4Qu'est ce que le fichier Hibernate.cfg.xml ?
Le fichier Hibernate.cfg.xml a presque la même utilité que le fichier Hibernate.properties. Soit on configure la connexion JDBC dans le fichier properties, soit on le configure ici. Les deux cas sont équivalents.
La seule différence de ce fichier est qu'il sert également à mapper les différents fichiers de mapping de l'application.
Continue..