Connessione al database

3.1 Collegamento di Hibernate e database

Abbiamo imparato come connettere Hibernate alla nostra applicazione utilizzando Maven e come mappare le tabelle alle classi utilizzando le annotazioni. E ora sorge la domanda successiva: come leggiamo gli oggetti dal database o li salviamo lì?

Non così in fretta. Prima di tutto, devi occuparti di altre tre cose:

• Configurazione di una connessione al database
• Configurazione dell'ibernazione
• Utilizzo di EntityManager

Hibernate nasconde completamente il lavoro con il database dalla tua applicazione, ma per evitare eccessi, deve essere configurato correttamente. Non puoi saltare questa fase, altrimenti come farà Hibernate a sapere in quale database salvare gli oggetti?

Hibernate può essere configurato e fornito informazioni sul database in tre modi

• Utilizza il file delle proprietà
• Utilizzare il file hibernate.cfg.xml
• Utilizzare i metodi del bean di configurazione

E anche se mi piace di più l'ultimo, li incontrerai sicuramente tutti e tre, quindi li analizzeremo tutti e tre qui.

3.2 Autorizzazione nel database

Cominciamo con le più importanti: le connessioni al database. Per fare ciò, dovrai fornire dati in modo che Hibernate possa accedere al database desiderato.

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

Le stesse impostazioni possono essere impostate sotto forma di un file 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> 

In entrambi gli esempi, vediamo le stesse impostazioni con gli stessi valori. È solo che il primo esempio li rappresenta come un file di proprietà e il secondo come un file xml .

Queste impostazioni sono suddivise in tre gruppi:

1. Specificare il tipo di DBMS
• Specificare il dialetto (tipo DBMS), ad esempio Oracle 9.0
• Specificare il nome del driver JDBC per lavorare con questo DBMS
2. Specificare i dati per l'autorizzazione nel database
• URL della banca dati
• nome utente
• parola d'ordine
3. Configurazione del motore di ibernazione
• hibernate.show_sql- Hibernate duplicherà nella console tutte le richieste che esegue
• hbm2ddl.auto- Hibernate cambierà la struttura del database se necessario

Esiste un terzo modo per impostare la configurazione: tramite i bin. Di solito è usato insieme a Spring, quindi lo esamineremo quando impareremo SpringFramework.

3.3 Ottieni SessionFactory

Il passaggio successivo consiste nell'ottenere l'oggetto SessionFactory. Ci sono diversi modi per farlo:

Il primo modo è utilizzare il file hibernate.properties .

Per fare ciò, devi solo scrivere il seguente codice:

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

Se il file hibernate.properties non viene trovato nella directory del progetto corrente, verrà generata un'eccezione.

Il secondo modo è la configurazione tramite hibernate.cfg.xml .

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

Se scrivi tale codice, allora il hibernate.cfg.xml. Se non viene trovato alcun file di questo tipo, il metodo buildSessionFactory()genererà un'eccezione.

Il terzo modo consiste nell'impostare manualmente il file di configurazione .

A volte durante il processo di sviluppo diventa necessario passare a una base di test o modificare alcune altre impostazioni per lavorare con la base, per questo è possibile impostare manualmente il file di configurazione:

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

Metodo quattro: utilizziamo un file hibernate.properties personalizzato:

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

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

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

E infine, puoi semplicemente cucire tutti i parametri necessari direttamente nel codice:

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 Specificare dove cercare le classi Entità

Ma non è tutto. Quando configuriamo un oggetto SessionFactory in Hibernate, questo SessionFactory controlla che tutte le tabelle richieste con i tipi di colonna richiesti esistano nel database.

E affinché SessionFactory sia in grado di farlo, deve essere passato un elenco di classi di entità che deve mappare al database.

Esistono tre modi per passare un elenco di classi di entità:

Metodo uno. In hibernate.cfg.xmlaggiunta una riga come:

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

Esempio:

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

Metodo due. Chiamare il metodo sull'oggetto ConfigurationaddAnnotatedClass() . Esempio:

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

Se ci sono molte classi, puoi aggiungerle in interi pacchetti:

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

3.5 Esempio finale

Ora che abbiamo imparato a configurare l'oggetto SessionFactory, scriviamo il codice che lo utilizzerà.

Consisterà in tre metodi:

1. Configurazione dell'ibernazione
2. Metodo che ottiene tutti i dipendenti dal database
3. Metodo che salva un nuovo dipendente nel database

Questo modello di codice sarebbe simile a questo:

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();
     	}
   }
}

Prima di eseguire una query al database, è necessario creare una sessione separata. Se le richieste sono correlate, possono essere eseguite nella stessa sessione. Se le richieste non sono correlate (e possono passare diversi minuti tra di loro), devono creare le proprie sessioni.

Se vuoi leggere i dati dal database o eseguire una query complessa, devi prima creare un oggetto Query e usarlo per eseguire la tua query.

Inoltre, ogni query al database viene eseguita nella propria transazione. Devi aprirlo, eseguire le operazioni necessarie e quindi chiudere (commit).

Nelle lezioni seguenti, analizzeremo più in dettaglio come funziona tutto questo.