Connexion à la base de données

3.1 Lier Hibernate et les bases de données

Nous avons appris à connecter Hibernate à notre application à l'aide de Maven et à mapper des tables à des classes à l'aide d'annotations. Et maintenant, la question suivante se pose - comment lire les objets de la base de données ou les y enregistrer ?

Pas si vite. Tout d'abord, vous devez vous occuper de trois autres choses :

• Configuration d'une connexion à une base de données
• Configuration de l'hibernation
• Travailler avec Entity Manager

Hibernate masque complètement le travail avec la base de données de votre application, mais pour éviter tout excès, il doit être configuré correctement. Vous ne pouvez pas ignorer cette étape - sinon, comment Hibernate saura-t-il dans quelle base de données enregistrer les objets ?

Hibernate peut être configuré et recevoir des informations de base de données de trois manières

• Utiliser le fichier de propriétés
• Utiliser le fichier hibernate.cfg.xml
• Utiliser les méthodes du bean de configuration

Et bien que j'aime le plus le dernier, vous rencontrerez certainement les trois, nous allons donc les analyser tous les trois ici.

3.2 Autorisation dans la base de données

Commençons par le plus important - les connexions à la base de données. Pour ce faire, vous devrez fournir des données afin qu'Hibernate puisse se connecter à la base de données souhaitée.

hibernate.dialect= org.hibernate.dialect.Oracle9Dialect
hibernate.connection.driver_class= oracle.jdbc.driver.OracleDriver 
hibernate.connection.url= jdbc:oracle:thin:@localhost:1521:supershop
hibernate.connection.username=root
hibernate.connection.password=secret
hibernate.show_sql=true
hibernate.hbm2ddl=update

Les mêmes paramètres peuvent être définis sous la forme d'un fichier xml :

<hibernate-configuration>	
	<session-factory>	
        	
    	<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>  	
    	<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property> 	
    	<property name="connection.url">jdbc:oracle:thin:@localhost:1521:supershop</property>  	
    	<property name="connection.username">root</property>  	
    	<property name="connection.password">secret</property>
    	<property name="hibernate.show_sql ">true</property>        
    	<property name="hbm2ddl.auto">update</property> 	
     	
	</session-factory>	
</hibernate-configuration> 

Dans les deux exemples, nous voyons les mêmes paramètres avec les mêmes valeurs. C'est juste que le premier exemple les représente comme un fichier de propriétés et le second comme un fichier xml .

Ces paramètres sont divisés en trois groupes :

1. Spécifiez le type de SGBD
• Spécifiez le dialecte (type de SGBD), par exemple, Oracle 9.0
• Spécifiez le nom du pilote JDBC pour travailler avec ce SGBD
2. Spécifier les données d'autorisation dans la base de données
• URL de la base de données
• nom d'utilisateur
• mot de passe
3. Configuration du moteur d'hibernation
• hibernate.show_sql- Hibernate dupliquera dans la console toutes les requêtes qu'il exécute
• hbm2ddl.auto- Hibernate modifiera la structure de la base de données si nécessaire

Il existe une troisième façon de définir la configuration - via les bacs. Il est généralement utilisé en conjonction avec Spring, nous l'examinerons donc lorsque nous apprendrons SpringFramework.

3.3 Obtenir la SessionFactory

L'étape suivante consiste à obtenir l'objet SessionFactory. Il y a plusieurs moyens de le faire:

La première consiste à utiliser le fichier hibernate.properties .

Pour cela, il vous suffit d'écrire le code suivant :

SessionFactory sessionFactory = new Configuration().buildSessionFactory();

Si le fichier hibernate.properties n'est pas trouvé dans le répertoire du projet en cours, une exception sera levée.

La deuxième méthode est la configuration à l'aide de hibernate.cfg.xml .

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Si vous écrivez un tel code, alors le hibernate.cfg.xml. Si aucun fichier de ce type n'est trouvé, la méthode buildSessionFactory()lèvera une exception.

La troisième méthode consiste à définir manuellement le fichier de configuration .

Parfois, au cours du processus de développement, il devient nécessaire de passer à une base de test ou de modifier d'autres paramètres pour travailler avec la base. Pour cela, vous pouvez définir manuellement le fichier de configuration :

SessionFactory sessionFactory = new Configuration().configure("hibernate-dev.cfg.xml").buildSessionFactory();

Méthode 4 - nous utilisons un fichier personnalisé hibernate.properties :

ClassLoader classLoader = Thread.currentThread().getClassLoader();

Properties properties = new Properties();
properties.load(classLoader.getResourceAsStream("hibernate-dev.properties"));

SessionFactory sessionFactory = new Configuration()
            .addProperties(properties)
            .buildSessionFactory();

Et enfin, vous pouvez simplement coudre tous les paramètres nécessaires directement dans le code :

Properties properties = new Properties();
properties.put(Environment.DRIVER, "com.mysql.jdbc.Driver");
properties.put(Environment.URL, "jdbc:mysql://localhost:3306/supershop");
properties.put(Environment.USER, "root");
properties.put(Environment.PASS, "password");

SessionFactory sessionFactory = new Configuration()
            .setProperties(properties)
            .buildSessionFactory();

3.4 Spécifier où chercher les classes Entity

Mais ce n'est pas tout. Lorsque nous configurons un objet SessionFactory dans Hibernate, cette SessionFactory vérifie que toutes les tables requises avec les types de colonnes requis existent dans la base de données.

Et pour que la SessionFactory puisse le faire, il faut lui transmettre une liste de classes d'entités qu'elle doit mapper à la base de données.

Il existe trois façons de transmettre une liste de classes d'entité :

Première méthode. En hibernate.cfg.xmlajouter une ligne comme:

<mapping class="class-qualified-name" />

Exemple:

<mapping class="com.codegym.data.User" />
<mapping class="com.codegym.data.Employee" />
<mapping class="com.codegym.data.Task" />

Deuxième méthode. Appelez la méthode sur l'objet ConfigurationaddAnnotatedClass() . Exemple:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addAnnotatedClass(com.codegym.data.User.class)
   	.buildSessionFactory();

S'il existe de nombreuses classes, vous pouvez les ajouter dans des packages entiers :

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addPackage("com.codegym.data")
   	.buildSessionFactory();

3.5 Dernier exemple

Maintenant que nous avons appris à configurer l'objet SessionFactory, écrivons le code qui l'utilisera.

Il comportera trois méthodes :

1. Configuration de la veille prolongée
2. Méthode qui récupère tous les employés de la base de données
3. Méthode qui enregistre un nouvel employé dans la base de données

Ce modèle de code ressemblerait à ceci :

class EmployeeManager {
    private SessionFactory sessionFactory;

    public void class init() {
    	this.sessionFactory = new Configuration()
        	.configure()
        	.buildSessionFactory();
   }

   public List<Employee> getAllEmployes() {
         try (Session session = sessionFactory.openSession()) {
  	          Query<Employee> query = session.createQuery("from Employee", Employee.class);
    	        return query.list();
         }
   }

   public void addEmployee(Employee employee ) {
     	try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
       	    session.save(employee);
            transaction.commit();
     	}
   }
}

Avant d'exécuter une requête dans la base de données, vous devez créer une session distincte. Si les demandes sont liées, elles peuvent être exécutées dans la même session. Si les demandes ne sont pas liées (et que plusieurs minutes peuvent s'écouler entre elles), elles doivent créer leurs propres sessions.

Si vous souhaitez lire des données de la base de données ou exécuter une requête complexe, vous devez d'abord créer un objet Query et l'utiliser pour exécuter votre requête.

De plus, chaque requête à la base de données est exécutée dans sa propre transaction. Vous devez l'ouvrir, effectuer les opérations nécessaires, puis fermer (valider).

Dans les conférences suivantes, nous analyserons plus en détail comment tout cela fonctionne.