Ansluter till databasen

3.1 Länka Hibernate och databaser

Vi lärde oss hur man ansluter Hibernate till vår applikation med Maven, och hur man mappar tabeller till klasser med anteckningar. Och nu uppstår nästa fråga - hur läser vi objekt från databasen eller sparar dem där?

Inte så fort. Först och främst måste du ta itu med ytterligare tre saker:

• Konfigurera en databasanslutning
• Ställer in Hibernate
• Arbetar med EntityManager

Hibernate döljer helt arbetet med databasen från din applikation, men för att undvika överdrifter måste den konfigureras korrekt. Du kan inte hoppa över det här steget - hur ska Hibernate annars veta vilken databas objekt ska sparas i?

Hibernate kan konfigureras och ges databasinformation på tre sätt

• Använd egenskapsfilen
• Använd filen hibernate.cfg.xml
• Använd metoder för konfigurationsbönor

Och även om jag gillar den sista mest, kommer du definitivt att stöta på alla tre, så vi kommer att analysera alla tre här.

3.2 Auktorisering i databasen

Låt oss börja med det viktigaste - databasanslutningar. För att göra detta måste du tillhandahålla data så att Hibernate kan logga in på önskad databas.

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

Samma inställningar kan göras i form av en xml-fil:

<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> 

I båda exemplen ser vi samma inställningar med samma värden. Det är bara det att det första exemplet representerar dem som en egenskapsfil och det andra som en xml-fil .

Dessa inställningar är indelade i tre grupper:

1. Ange typen av DBMS
• Ange dialekt (DBMS-typ), till exempel Oracle 9.0
• Ange namnet på JDBC-drivrutinen för att arbeta med detta DBMS
2. Ange data för auktorisering i databasen
• databas url
• Användarnamn
• Lösenord
3. Konfigurera Hibernate Engine
• hibernate.show_sql- Hibernate kommer att duplicera i konsolen alla förfrågningar som den utför
• hbm2ddl.auto- Hibernate ändrar databasstrukturen om det behövs

Det finns ett tredje sätt att ställa in konfigurationen - genom papperskorgar. Det används vanligtvis tillsammans med Spring, så vi ska titta på det när vi lär oss SpringFramework.

3.3 Skaffa SessionFactory

Nästa steg är att hämta SessionFactory-objektet. Det finns flera sätt att göra detta:

Det första sättet är att använda filen hibernate.properties .

För att göra detta behöver du bara skriva följande kod:

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

Om filen hibernate.properties inte hittas i den aktuella projektkatalogen kommer ett undantag att skapas.

Det andra sättet är konfiguration med hibernate.cfg.xml .

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

Om du skriver en sådan kod kommer hibernate.cfg.xml. Om ingen sådan fil hittas buildSessionFactory()kommer metoden att skapa ett undantag.

Det tredje sättet är att ställa in konfigurationsfilen manuellt .

Ibland under utvecklingsprocessen blir det nödvändigt att byta till en testbas eller ändra några andra inställningar för att arbeta med basen, för detta kan du ställa in konfigurationsfilen manuellt:

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

Metod fyra - vi använder en anpassad hibernate.properties-fil:

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

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

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

Och slutligen kan du helt enkelt sy alla nödvändiga parametrar direkt i koden:

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 Ange var du ska leta efter Entitetsklasser

Men det är inte allt. När vi konfigurerar ett SessionFactory- objekt i Hibernate kontrollerar denna SessionFactory att alla nödvändiga tabeller med de nödvändiga kolumntyperna finns i databasen.

Och för att SessionFactory ska kunna göra detta måste den passeras en lista med entitetsklasser som den behöver mappa till databasen.

Det finns tre sätt att skicka en lista över entitetsklasser:

Metod ett. Lägg hibernate.cfg.xmltill en rad som:

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

Exempel:

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

Metod två. Anropa metoden på konfigurationsobjektetaddAnnotatedClass() . Exempel:

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

Om det finns många klasser kan du lägga till dem i hela paket:

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

3.5 Sista exempel

Nu när vi har lärt oss hur man konfigurerar SessionFactory-objektet, låt oss skriva koden som kommer att använda det.

Det kommer att bestå av tre metoder:

1. Konfigurerar Hibernate
2. Metod som får alla anställda från databasen
3. Metod som sparar en ny anställd i databasen

Den här kodmallen skulle se ut ungefär så här:

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

Innan du kör en fråga till databasen måste du skapa en separat session. Om förfrågningarna är relaterade kan de köras i samma session. Om förfrågningarna inte är relaterade (och det kan gå flera minuter mellan dem), måste de göra sina egna sessioner.

Om du vill läsa data från databasen eller köra en komplex fråga måste du först skapa ett frågeobjekt och använda det för att köra din fråga.

Dessutom exekveras varje fråga till databasen i sin egen transaktion. Du måste öppna den, utföra de nödvändiga åtgärderna och sedan stänga (commit).

I de följande föreläsningarna kommer vi att analysera mer i detalj hur det hela fungerar.