Verbinding maken met de database

3.1 Hibernate en databases koppelen

We hebben geleerd hoe we Hibernate met onze applicatie kunnen verbinden met behulp van Maven, en hoe we tabellen aan klassen kunnen toewijzen met behulp van annotaties. En nu rijst de volgende vraag: hoe lezen we objecten uit de database of slaan we ze daar op?

Niet zo snel. Allereerst moet u nog drie dingen regelen:

• Een databaseverbinding configureren
• Slaapstand instellen
• Werken met EntityManager

Hibernate verbergt het werk met de database volledig voor uw applicatie, maar om excessen te voorkomen, moet deze correct zijn geconfigureerd. U kunt deze fase niet overslaan - hoe weet Hibernate anders in welke database objecten moeten worden opgeslagen?

Hibernate kan op drie manieren worden geconfigureerd en database-informatie krijgen

• Gebruik het eigenschappenbestand
• Gebruik het bestand hibernate.cfg.xml
• Gebruik configuratieboonmethoden

En hoewel ik de laatste het leukst vind, kom je ze zeker alle drie tegen, dus we gaan ze hier alle drie analyseren.

3.2 Autorisatie in de database

Laten we beginnen met de belangrijkste: databaseverbindingen. Om dit te doen, moet u gegevens verstrekken zodat Hibernate kan inloggen op de gewenste database.

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

Dezelfde instellingen kunnen worden ingesteld in de vorm van een xml-bestand:

<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 beide voorbeelden zien we dezelfde instellingen met dezelfde waarden. Het eerste voorbeeld stelt ze alleen voor als een eigenschappenbestand en het tweede als een xml-bestand .

Deze instellingen zijn onderverdeeld in drie groepen:

1. Geef het type DBMS op
• Specificeer het dialect (DBMS-type), bijvoorbeeld Oracle 9.0
• Geef de naam op van het JDBC-stuurprogramma voor het werken met dit DBMS
2. Specificeer gegevens voor autorisatie in de database
• database-URL
• gebruikersnaam
• wachtwoord
3. De slaapstand-engine configureren
• hibernate.show_sql- Hibernate dupliceert in de console alle verzoeken die het uitvoert
• hbm2ddl.auto- Hibernate zal indien nodig de databasestructuur wijzigen

Er is een derde manier om de configuratie in te stellen - via bakken. Het wordt meestal gebruikt in combinatie met Spring, dus we zullen ernaar kijken als we SpringFramework leren.

3.3 Download de SessionFactory

De volgende stap is het ophalen van het SessionFactory-object. Er zijn verschillende manieren om dit te doen:

De eerste manier is om het bestand hibernate.properties te gebruiken .

Om dit te doen, hoeft u alleen maar de volgende code te schrijven:

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

Als het bestand hibernate.properties niet wordt gevonden in de huidige projectdirectory, wordt er een uitzondering gegenereerd.

De tweede manier is configuratie met hibernate.cfg.xml .

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

Als u dergelijke code schrijft, dan wordt de hibernate.cfg.xml. Als een dergelijk bestand niet wordt gevonden, buildSessionFactory()genereert de methode een uitzondering.

De derde manier is om het configuratiebestand handmatig in te stellen .

Soms wordt het tijdens het ontwikkelingsproces nodig om over te schakelen naar een testbasis of andere instellingen te wijzigen voor het werken met de basis, hiervoor kunt u het configuratiebestand handmatig instellen:

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

Methode vier - we gebruiken een aangepast bestand 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();

En tot slot kunt u eenvoudig alle benodigde parameters rechtstreeks in de code naaien:

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 Geef op waar naar Entiteitsklassen moet worden gezocht

Maar dat is nog niet alles. Wanneer we een SessionFactory- object in Hibernate configureren, controleert deze SessionFactory of alle vereiste tabellen met de vereiste kolomtypen in de database aanwezig zijn.

En om de SessionFactory in staat te stellen dit te doen, moet er een lijst met entiteitsklassen worden doorgegeven die aan de database moeten worden toegewezen.

Er zijn drie manieren om een ​​lijst met entiteitsklassen door te geven:

Methode één. Voeg hibernate.cfg.xmleen regel toe als:

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

Voorbeeld:

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

Methode twee. Roep de methode op het configuratieobjectaddAnnotatedClass() aan . Voorbeeld:

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

Als er veel klassen zijn, kun je ze in hele pakketten toevoegen:

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

3.5 Laatste voorbeeld

Nu we hebben geleerd hoe we het SessionFactory-object moeten configureren, gaan we de code schrijven die het zal gebruiken.

Het zal uit drie methoden bestaan:

1. Slaapstand configureren
2. Methode die alle medewerkers uit de database haalt
3. Methode die een nieuwe medewerker opslaat in de database

Dit codesjabloon ziet er ongeveer zo uit:

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

Voordat u een query op de database uitvoert, moet u een afzonderlijke sessie maken. Als de verzoeken gerelateerd zijn, kunnen ze in dezelfde sessie worden uitgevoerd. Als de verzoeken geen verband houden (en er enkele minuten tussen kunnen zitten), moeten ze hun eigen sessies maken.

Als u gegevens uit de database wilt lezen of een complexe query wilt uitvoeren, moet u eerst een Query-object maken en dit gebruiken om uw query uit te voeren.

Ook wordt elke query naar de database uitgevoerd in zijn eigen transactie. U moet het openen, de nodige bewerkingen uitvoeren en vervolgens sluiten (commit).

In de volgende lezingen gaan we dieper in op hoe dit allemaal werkt.