Technologie / Programowanie

Java Persistence API (JPA) — mapowanie obiektowo-relacyjne i integracja z bazami danych

Trzydniowe szkolenie z JPA — JDBC, mapowanie obiektowo-relacyjne (ORM), konfiguracja encji, relacje, JPQL, Criteria API, transakcje, walidacja, cache, tuning wydajności. Warsztaty z Hibernate.

JPA to most między obiektami Java a tabelami SQL — ale źle skonfigurowany most generuje 1000 zapytań zamiast jednego

Każda aplikacja Java Enterprise potrzebuje bazy danych. JDBC działa, ale wymaga ręcznego mapowania każdego wyniku na obiekt. JPA (Java Persistence API) automatyzuje to — @Entity, @OneToMany, JPQL i masz ORM. Ale JPA źle skonfigurowane to pułapka wydajnościowa: problem N+1 (1000 zapytań zamiast 1), EAGER fetch na kolekcjach (ładowanie całej bazy do pamięci), brak cache’u (każde zapytanie uderza w bazę). Różnica między „JPA działa” a „JPA działa wydajnie” to trzy dni szkolenia.

Trzydniowe warsztaty: od JDBC i koncepcji ORM, przez mapowanie encji (relacje, dziedziczenie, fetch strategies), zapytania (JPQL, Criteria API, native SQL), transakcje i walidację, po cache (first/second level), locking (optimistic/pessimistic) i tuning wydajności.

Dla kogo jest to szkolenie?

Dla deweloperów Java pracujących z bazami danych. Szczególnie gdy:

Zaczynasz z JPA/Hibernate i chcesz od razu nauczyć się dobrych praktyk — zamiast odkrywać N+1 problem na produkcji
Używasz Spring Data JPA, ale gdy coś nie działa — nie rozumiesz, co się dzieje pod spodem
Migrujesz z JDBC na JPA i potrzebujesz uporządkowanej wiedzy o mapowaniu, relacjach i transakcjach

Trzy dni: od JDBC do cache’u

Moduł 1: JDBC i podstawy JPA — JDBC (ograniczenia), koncepcja ORM, architektura JPA, EntityManager, konfiguracja persistence.xml.

Moduł 2: Mapowanie — encje (@Entity, @Table), identyfikatory (strategie generowania), dziedziczenie (SINGLE_TABLE, JOINED), relacje (@OneToMany, @ManyToMany), fetch strategies (LAZY/EAGER, N+1).

Moduł 3: Zapytania — JPQL (składnia, parametry, named queries), Criteria API (type-safe), zapytania natywne.

Moduł 4: Transakcje i walidacja — EntityTransaction, @Transactional, wzorzec DAO, Bean Validation.

Moduł 5: Cache i tuning — first/second-level cache, locking (optimistic/pessimistic), batch operations, connection pooling.

Z ponad 2500 szkoleń w ofercie i oceną 4.8/5, EITT jest zaufanym partnerem w rozwoju kompetencji. Skontaktuj się z nami — organizujemy szkolenia JPA/Hibernate zamknięte dla zespołów Java.

Korzyści

Konfigurować JPA — persistence.xml, EntityManager, Hibernate jako provider
Mapować encje na tabele — @Entity, relacje, dziedziczenie, fetch strategies
Pisać zapytania JPQL i Criteria API — parametryzacja, joiny, bulk operations
Zarządzać transakcjami — EntityTransaction, @Transactional, propagation
Konfigurować cache (first/second level) i optymalizować wydajność — batch, locking
Stosować wzorzec DAO i Bean Validation w aplikacjach JPA

Dla kogo jest to szkolenie?

Deweloperzy Java budujący aplikacje bazodanowe z JPA/Hibernate

Backend developerzy migrujący z JDBC na JPA — szukający uporządkowanej wiedzy o ORM

Programiści Spring Boot chcący zrozumieć JPA pod spodem Spring Data

Junior/mid Java developerzy uczący się mapowania obiektowo-relacyjnego

Architekci aplikacji Java Enterprise oceniający strategie dostępu do danych

Deweloperzy Java EE przechodzący na Jakarta EE i potrzebujący aktualnej wiedzy o JPA

Wymagania wstępne

Programowanie w Java — klasy, interfejsy, kolekcje, generics (minimum 1 rok)
Znajomość SQL i relacyjnych baz danych — SELECT, JOIN, transakcje
Podstawowa znajomość Java EE (serwlety, JNDI) — mile widziana, ale nie wymagana

Program szkolenia

Java Database Connectivity (JDBC) — połączenie, zapytania, ograniczenia
Mapowanie obiektowo-relacyjne (ORM) — koncepcja, korzyści, impedance mismatch
Specyfikacja JPA — architektura, EntityManager, persistence unit
Konfiguracja persistence.xml — datasource, provider (Hibernate), ustawienia

Mapowanie tabel i kolumn — @Entity, @Table, @Column, @Id
Generowanie identyfikatorów — IDENTITY, SEQUENCE, TABLE, UUID
Strategie dziedziczenia — SINGLE_TABLE, JOINED, TABLE_PER_CLASS
Relacje — @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
Fetch strategies — LAZY vs EAGER, N+1 problem, rozwiązania

JPQL — składnia, parametry, named queries, bulk operations
Criteria API — type-safe queries, predykaty, joiny
Zapytania natywne (Native SQL) — kiedy i jak używać

Transakcje JPA — EntityTransaction, @Transactional, propagation
JPA w środowisku JEE/Jakarta — container-managed vs application-managed
Wzorzec DAO — Data Access Object, separacja logiki dostępu do danych
Bean Validation — @NotNull, @Size, @Valid, walidacja encji

First-level cache — persistence context, detach, merge
Second-level cache — konfiguracja, regiony, eviction
Blokowanie encji — optimistic locking (@Version), pessimistic locking
Tuning — batch insert/update, fetch size, connection pooling

Formy realizacji

Online

Wygoda uczestnictwa z dowolnego miejsca
Interaktywne sesje na żywo z trenerem
Materiały dostępne przez 30 dni
Brak kosztów dojazdu

Stacjonarnie

Bezpośredni kontakt z trenerem i grupą
Intensywne warsztaty praktyczne
Networking z innymi uczestnikami
Pełne skupienie na nauce

Tematy szkolenia

Najczęściej zadawane pytania

Czy to szkolenie uczy Hibernate czy JPA?

JPA jako specyfikację — ale z Hibernate jako implementacją (provider). JPA definiuje standard (adnotacje, EntityManager, JPQL), Hibernate go implementuje. Rozumiejąc JPA, możesz zmienić provider (EclipseLink, OpenJPA) bez zmiany kodu.

Czy muszę znać Spring, żeby wziąć udział?

Nie — szkolenie uczy czystego JPA (bez Spring Data). Jeśli używasz Spring Boot, to szkolenie pokaże Ci, co Spring Data robi pod spodem. Musisz znać Javę (klasy, kolekcje) i SQL.

W jakim formacie i jak długo trwa szkolenie?

Szkolenie trwa 3 dni (9:00-16:00), dostępne online i stacjonarnie. Intensywne warsztaty z pisaniem kodu JPA/Hibernate.

Czy po szkoleniu otrzymam certyfikat?

Tak, każdy uczestnik otrzymuje imienny certyfikat ukończenia szkolenia wydany przez EITT.

Czy omawiamy problem N+1?

Tak — to jeden z kluczowych tematów. Omawiamy LAZY vs EAGER fetch, problem N+1, rozwiązania (JOIN FETCH, @BatchSize, EntityGraph) i tuning wydajności zapytań JPA.