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
Konfiguracja pom.xml properties
Konfiguracja pom.xml w properties

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
Konfiguracja pliku pom.xml w build
Konfiguracja pliku pom.xml w build

Dodawanie dependencji

W konfiguracji ustawień dodamy dependencje.

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

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

Dependencja - baza danych h2
Dependencja – baza danych 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.

Dependencja - Hibernate-core
Dependencja – Hibernate-core

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

Sposoby odświeżania projektu
Sposoby odświeżania projektu

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");
    }
}
Widok pierwszej klasy App
Widok pierwszej klasy App

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.

Konfiguracja persistence.xml
Konfiguracja persistence.xml
  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.

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

4. Tworzone polaczenie do bazy danych oraz 5. ustalany dialekt

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

2 myśli w temacie “JPA #4 – Konfiguracja projektu”

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *