JPA #4 – Konfiguracja projektu

W ramach kursu wkraczamy w pierwszy etap tworzenia projektu czyli jego konfigurację. Dodamy trochę od siebie w pliku pom.xml, a następnie utworzymy pierwszą klasę w Javie. Później zajmiemy się dostosowaniem Hibernate oraz Entity Managerem.

Wcześniejszą teorię w praktyce pokażę na przykładzie projektu Maven w IDE IntelliJ Community. Jest to darmowa wersja IDE, ale w zupełności wystarczy na nasze potrzeby.

Konfiguracja pliku pom.xml

Konfigurację zaczynamy od pliku pom.xml. Dodajmy od razu kilka podstawowych rzeczy.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>hotelreservationjpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.release>15</maven.compiler.release>
    </properties>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <release>${maven.compiler.release}</release>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.200</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.23.Final</version>
        </dependency>
    </dependencies>

</project>

Properties:

1. Kodowanie znaków w plikach źródłowych
2. Wersję używanej Javy

Build:

1. Filtrowanie rzeczy, które mamy w resources (chodzi o to, że kiedy Maven napotka pewną zmienną podstawi pod nią odpowiednią wartość)
2. Kompilator do Javy

Dodawanie dependencji

W konfiguracji ustawień dodamy dependencje.

dependecies – zależności od innych modułów

Pierwszą z nich jest zależność na bazę H2.

H2 jest to mała baza danych, którą możemy postawić w pamięci lub w postaci pliku gdzieś na naszym komputerze. Może robić także za standardową bazę danych gdzieś na zewnątrz na serwerze. Innymi slowy – jest łatwa, szybka i przyjemna dzięki braku nadmiernej konfiguracji. Dzięki temu bardzo często używa się jej w takich małych projektach, bo możemy taką bazę danych w prosty sposób stworzyć i coś sprawdzić.

Druga rzecz, którą ustawimy to oczywiście Hibernate.

Dodajemy dependencję Hibernate-core i jego najnowszą wersję (obecnie: 5.4.23.final)

Po dokonaniu zmian należy odświeżyć projekt, bo inaczej wprowadzone zmiany nie będą działać. Można to zrobić na dwa sposóby – klikając w prawym górnym rogu na ikonkę Maven z zębatką lub po lewej stronie prawy klik na pom.xml –> maven –> reload project. IDE tego za nas automatycznie już nie robi.

Tworzenie pierwszego pliku App

Utwórz sobie nową paczkę ze ścieżką main–>java–> new package i nazwij pl.clockworkjava.hotelreservation.jpa.

W paczce stwórz nową klasę Javy o nazwie App.java (klasa z dużej litery, App utarło się jako taka klasa główna aplikacji)

Oraz standardowe, popularne, znane na całym świecie pierwsze „Hello” wypisywane na ekranie.

package pl.clockworkjava.hotelreservation.jpa;

public class App {

    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

W terminalu wyjściowym powinniśmy zobaczyć tylko wypisanie Hello bo dodaliśmy jak na razie tylko dependencje, a musimy dodać jeszcze plik konfiguracyjny w formie xml dla Hibernate żeby on tam w ogóle zaczał działać.

Konfiguracja ustawień Hibernate w pliku persistence.xml

W resources utwórz katalog MET-INF, a w nim plik persistence.xml. Ważna jest lokalizacja pliku. Żeby Hibernate go załadował musi być w ścieżce dostępu resources–>META-INF–>persistence.xml

Pierwszym tagiem jaki musimy zdefiniować jest persistence.

Tutaj określamy namespace. Nie ma sensu tego zapamiętywać i śmiało można skorzystać z szerokich zasobów internetu i poszukać wzoru dla persistence xml.

Następnie miedzy tagami persistence definiujemy persistence-unit. Możemy mieć ich wiele, a każdy odpowiada za jedno połączenie z bazą danych.

<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
 http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">

    <persistence-unit name="thePersistenceUnit" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>

        <properties>
            <property name="connection.driver_class" value="org.h2.Driver"/>
            <property name="hibernate.connection.url" value="jdbc:h2:./db/repository"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.use_sql_comments" value="true" />
        </properties>

    </persistence-unit>

</persistence>

W tym wypadku łączymy się z bazą H2.

1. Klasa do Driver
2. Namiar na bazę danych (w danej lokalizacji stworzy nam się miejsce, w którym będzie przechowywana nasza baza danych)
3. Ustawiamy dialekt Hibernate (SQL ma to do siebie, że podstawowe polecenia działają wszędzie, ale bardziej skomplikowane zapytania zaczynają różnić się składnią języka w zależności od bazy danych)
4. Ustawiamy czy za każdym uruchomieniem aplikacji tworzymy bazę danych od nowa, aktualizujemy czy zostaje ona zupełnie niezmieniona (Uwaga: create-drop jest równoznaczne z kasowaniem bazy przy starcie programu i stawianiem jej od nowa, jest to tylko do celów testowych i w normalnie działającym programie byłaby to katastrofa!)
5. W logach będą się pokazywać zapytania SQL jakie są wykonywane
6. W logach będą widoczne dodatkowe komentarze

5 i 6 jest bardzo pomoce przy nauce JPA i przy debugowaniu także z naszego punktu widzenia są to obecnie cenne informacje.

Myślę, że trzeba jeszcze wspomnieć, że używamy HIbernate w standardowej aplikacji bez Springa.

W Spring Data pewne rzeczy ustawione są domyślnie, więc nie byłoby potrzeby tworzenia pliku persistence.xml. Na przykład jeśli Spring Boot wykryje, że w dependencjach mamy bazę danych H2 to automatycznie załaduje sobie h2.Driver i ustawi dialekt. Podobnie z innymi bazami danych. Oczywiście to wszystko możemy zmienić w pliku z properties Springowym i nie musimy tworzyć dodatkowego pliku persistence.xml.

Podsumowując dotychczasowe działania – mamy dependencje w pliku pom.xml i konfiguracje w persistence.xml.

Nic jednak się nie podzieje bez stworzenia naszego Entity Managera.

Utworzenie Entity Manager

Przypomnijmy, że Entity Manager jest to główny element w Hibernate, który odpowiada za komunikację z baza danych, za to żeby na podstawie konfuguracji i na podstawie adnotacji w obiekcie stworzyć odpowiednie zapytanie do bazy danych.

Entity Manager tworzymy za pomocą wzorca projektowego Factory.

Najpierw tworzymy za pomocą metody statycznej createEntityManagerFactory i dodajemy nazwę Persistence Unit (nazwę bierzemy z pliku persistence.xml i tagu persistence-unit). Następnie tworzymy factoryEntityManager o często używanym skrócie em.

package pl.clockworkjava.hotelreservation.jpa;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class App {

    private static EntityManagerFactory factory = Persistence.createEntityManagerFactory("thePersistenceUnit");
    private static EntityManager em  = factory.createEntityManager();

    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

Dopiero teraz po odpaleniu programu zaczyna być w nim trochę więcej życia i możemy obejrzeć w końcu całą inicjalizację naszego Hibernate.

1. Ładuje się persistence unit
2. Widzimy używaną przez nas wersję Hibernate
3. Ładują się adnotacje Hibernate

Po dobrze wykonanej konfiguracji pojawil sie katalog H2 z plikiem db/repository.mv.db ( taki ustalilismy podczas konfiguracji) – plik naszej bazy danych od tego momentu ma swoją „fizyczną” lokalizację.

Kod aplikacji znajdziesz w publicznym repozytorium GitHub.

By być na bieżąco i mieć realny wpływ na tematykę tworzonych przeze mnie artykułów zapraszam do dołączenia do mojego newslettera.

---

Informacje oparte zostały o materiał darmowego kursu wprowadzającego w świat JPA i Hibernate „Fundamenty JPA i Hibernate” dostępnego w formie wideo na platformie ClockworkJava.

Pozostałe artykuły z cyklu:

1. Czym jest persystencja?
2. ORM, JPA i Hibernate
3. Podstawowe elementy
4. Konfiguracja projektu
5. Pierwsza encja
6. Create
7. Read
8. Update
9. Delete
10. Relacja One-to-One
11. Relacja One-to-Many