Spring & Hibernate

Question 1

Pytanie: Co to jest Spring Framework?

Answer 1

Odpowiedź: Spring to wszechstronny framework do tworzenia aplikacji w Javie. Umożliwia tworzenie aplikacji od pojedynczych modułów do kompleksowych rozwiązań korporacyjnych. Spring dostarcza infrastrukturę, dzięki której programiści mogą skupić się na tworzeniu aplikacji bez martwienia się o aspekty infrastrukturalne.

Question 2

Pytanie: Jakie są główne moduły Spring Framework?

Answer 2

Odpowiedź: Główne moduły Springa to: Core Container, AOP (Aspect-Oriented Programming), Data Access/Integration, Web, Security, Messaging, Testing i inne.

Question 3

Pytanie: Co to jest Inversion of Control (IoC) w Springu?

Answer 3

Odpowiedź: IoC to projektowy wzorzec, w którym obiekty nie tworzą zależności samodzielnie, ale zależności są wstrzykiwane przez zewnętrzny system. W Springu kontener IoC zarządza cyklem życia obiektów i wstrzykuje zależności.

Question 4

Pytanie: Co to jest Hibernate?

Answer 4

Odpowiedź: Hibernate to framework ORM (Object-Relational Mapping), który umożliwia mapowanie obiektów Java na tabele w bazie danych i odwrotnie.

Question 4

Pytanie: Co to jest sesja w Hibernate?

Answer 4

Odpowiedź: Sesja w Hibernate reprezentuje pojedynczą jednostkę rozmowy między aplikacją a bazą danych. Umożliwia tworzenie, odczyt, modyfikację i usuwanie obiektów.

Odpowiedź: Sesja w Hibernate to krótkotrwały obiekt, który działa jako most między aplikacją a bazą danych. Reprezentuje pojedynczą jednostkę pracy z bazą danych. Główne funkcje sesji to:

1. Tworzenie, odczytywanie, aktualizowanie i usuwanie obiektów: Sesja umożliwia operacje CRUD na obiektach, które są mapowane na rekordy w bazie danych.
2. Zarządzanie pierwszym poziomem pamięci podręcznej: Sesja posiada pierwszy poziom pamięci podręcznej, który przechowuje obiekty w trakcie jej życia.
3. Zarządzanie transakcjami: Można rozpocząć i zakończyć transakcję bazodanową za pomocą sesji.
4. Fabrykowanie zapytań: Umożliwia tworzenie zapytań, zarówno w języku HQL (Hibernate Query Language), jak i natywnych zapytań SQL, do interakcji z bazą danych.
5. Zarządzanie stanem obiektów: Sesja śledzi stan obiektów i potrafi wykryć zmiany w obiektach, które są przez nią zarządzane.
6. Łączenie i rozłączanie obiektów: Można łączyć obiekty z sesją lub je od niej odłączać.

Ważne jest, aby pamiętać, że sesja w Hibernate nie jest wątkowo bezpieczna, co oznacza, że każdy wątek powinien mieć swoją własną sesję. Po zakończeniu pracy z bazą danych sesję należy zamknąć, aby zwolnić zasoby.

Question 4

Pytanie: Jakie są główne zalety korzystania z Hibernate?

Answer 4

Odpowiedź: Hibernate oferuje: abstrakcję od konkretnego dialektu bazy danych, cache drugiego poziomu, leniwe ładowanie, mapowanie obiektowo-relacyjne i wiele innych.

Question 5

Pytanie: Jakie są różnice między @Autowired a @Resource w Springu?

Answer 5

Odpowiedź: @Autowired dokonuje wstrzyknięcia zależności przez typ, podczas gdy @Resource dokonuje wstrzyknięcia przez nazwę. @Autowired jest specyficzny dla Springa, podczas gdy @Resource jest częścią standardu Java.

Question 5

Pytanie: Jakie są różnice między @Component, @Service, @Repository i @Controller w Springu?

Answer 5

Odpowiedź: Wszystkie te adnotacje są używane do wskazania, że klasa jest komponentem Springa. @Component to ogólna adnotacja. @Service wskazuje, że klasa jest używana jako serwis. @Repository wskazuje, że klasa jest używana jako repozytorium danych. @Controller wskazuje, że klasa jest kontrolerem w modelu MVC.

Pytanie: Jakie są różnice między @Component, @Service, @Repository i @Controller w Springu?

Odpowiedź: W Springu adnotacje @Component, @Service, @Repository i @Controller służą do wskazywania, że klasa jest komponentem zarządzanym przez kontener Springa (Spring Bean). Te adnotacje pozwalają na automatyczne wykrywanie komponentów za pomocą skanowania klasy. Oto różnice i specyficzne zastosowania każdej z tych adnotacji:

1. @Component: Jest to ogólna adnotacja wskazująca, że klasa jest komponentem Springa. Może być używana w przypadku, gdy żadna z innych adnotacji nie pasuje dokładnie do przeznaczenia klasy.
2. @Service: Wskazuje, że klasa wykonuje usługę w warstwie usług (service layer) aplikacji. Jest to specjalizacja adnotacji @Component i nie dodaje dodatkowej funkcjonalności w porównaniu z @Component, ale służy do wskazania celu klasy.
3. @Repository: Używana w klasach, które dostarczają dostęp do danych, czyli w warstwie dostępu do danych (DAO layer). Dodatkowo, adnotacja @Repository zapewnia tłumaczenie wyjątków na wyjątki typu Spring DataAccessException.
4. @Controller: Wskazuje, że klasa jest kontrolerem w modelu MVC i jest używana w warstwie prezentacji. W połączeniu z Spring MVC, klasy oznaczone tą adnotacją są komponentami, które mogą obsługiwać żądania HTTP.

Wszystkie te adnotacje są specjalizacjami adnotacji @Component i służą głównie celom semantycznym oraz dokumentacyjnym, aby wskazać przeznaczenie klasy w architekturze aplikacji. Jednakże, jak w przypadku @Repository, niektóre z tych adnotacji mogą dostarczać dodatkowej funkcjonalności.

Question 5

Pytanie: Jakie są strategie dziedziczenia w Hibernate?

Answer 5

Odpowiedź: Hibernate oferuje trzy strategie dziedziczenia: pojedyncza tabela, tabela po tabeli i połączona.

W Hibernate istnieją trzy główne strategie dziedziczenia, które pozwalają na mapowanie hierarchii klas Java na schemat bazy danych. Oto one:

1. Strategia jednej tabeli (Single Table Strategy):
   
   • Wszystkie klasy w hierarchii dziedziczenia są mapowane na jedną tabelę w bazie danych.
   • Tabela ta zawiera kolumny dla wszystkich atrybutów wszystkich klas w hierarchii.
   • Wprowadzana jest dodatkowa kolumna dyskryminatora (często nazywana “DTYPE” w Hibernate), która wskazuje, do której klasy w hierarchii należy dany rekord.
   • Rekordy dla podklas mają wartości null w kolumnach, które nie są dla nich odpowiednie.
2. Strategia tabeli konkretnej klasy (Table Per Concrete Class Strategy):
   
   • Każda klasa w hierarchii dziedziczenia jest mapowana na własną, oddzielną tabelę.
   • Tabela dla konkretnej klasy zawiera kolumny dla wszystkich atrybutów tej klasy, włącznie z atrybutami klasy nadrzędnej.
   • Nie ma dodatkowej kolumny dyskryminatora, ponieważ każda tabela reprezentuje konkretną klasę.
   • W tej strategii nie jest możliwe ustawienie klucza głównego jako klucza obcego w innych tabelach, ponieważ nie ma gwarancji unikalności między tabelami.
3. Strategia jednej tabeli na klasę (Table Per Class Strategy):
   
   • Każda klasa w hierarchii dziedziczenia ma swoją własną tabelę.
   • Tabela dla podklasy zawiera tylko kolumny dla atrybutów zdefiniowanych w tej podklasie, nie dla atrybutów klasy nadrzędnej.
   • Klucze główne są dzielone między tabelami, co oznacza, że rekord w tabeli podklasy ma ten sam klucz główny co odpowiadający mu rekord w tabeli klasy nadrzędnej.
   • Ta strategia jest często uważana za kompromis między dwiema wcześniejszymi strategiami.

Wybór odpowiedniej strategii dziedziczenia zależy od konkretnych wymagań aplikacji i modelu danych. Każda strategia ma swoje zalety i wady, dlatego ważne jest zrozumienie ich charakterystyki przed podjęciem decyzji.

Question 6

Pytanie: Co to jest AOP w Springu?

Answer 6

Odpowiedź: AOP (Aspect-Oriented Programming) to paradygmat programowania, który koncentruje się na aspektach aplikacji, takich jak logowanie, bezpieczeństwo itp., które są rozproszone po całej aplikacji.

AOP, czyli Aspect-Oriented Programming (Programowanie zorientowane aspektowo), to paradygmat programowania, który koncentruje się na “przekrojowych” (ang. “cross-cutting”) troskach w aplikacji. Przekrojowe troski to te aspekty programu, które wpływają na wiele modułów i są często rozproszone w całym kodzie, takie jak logowanie, zarządzanie transakcjami, bezpieczeństwo itp.

AOP w Springu oferuje sposób na modularizację przekrojowych trosk poprzez oddzielenie logiki biznesowej od logiki przekrojowej. Oto kilka kluczowych koncepcji związanych z AOP w Springu:

1. Aspect (Aspekt): Moduł, który definiuje przekrojową troskę. Aspekt jest odpowiedzialny za wstrzykiwanie określonego zachowania w określone miejsca w kodzie.
2. Join Point (Punkt przecięcia): Miejsce w kodzie, gdzie aspekt może być wstrzyknięty. W Spring AOP, join point zawsze reprezentuje wywołanie metody.
3. Advice (Porada): Działanie podejmowane przez aspekt w danym join point. Istnieje kilka typów porad, takich jak “before” (przed), “after” (po), “after-returning” (po zwróceniu wartości), “after-throwing” (po zgłoszeniu wyjątku) i “around” (wokół, gdzie porada otacza wywołanie metody).
4. Pointcut (Wyrażenie przecięcia): Wyrażenie, które określa, dla których join points ma zostać zastosowana dana porada. Pozwala to na precyzyjne określenie, gdzie w kodzie ma zostać wstrzyknięty aspekt.
5. Target (Cel): Obiekt, którego metoda jest wywoływana i na którym działają aspekty.
6. Proxy (Pełnomocnik): Obiekt stworzony przez Spring AOP, który “opakowuje” docelowy obiekt i dodaje do niego dodatkowe zachowanie (aspekty).
7. Weaving (Tkanko): Proces łączenia aspektów z innym kodem aplikacji do utworzenia utkanej wersji kodu. W Spring AOP, tkanko może odbywać się w czasie kompilacji, ładowania klasy lub w czasie wykonywania.

AOP w Springu jest realizowane głównie za pomocą proxy opartych na interfejsach lub klasach, co oznacza, że tworzone są dynamiczne pełnomocniki, które “opakowują” docelowe obiekty i wstrzykują aspekty w odpowiednich miejscach.

Question 6

Pytanie: Jakie są główne zalety korzystania z Spring Boot?

Answer 6

Odpowiedź: Spring Boot oferuje: automatyczną konfigurację, wbudowane narzędzia do monitorowania i zarządzania aplikacją, szeroką gamę wstępnie skonfigurowanych komponentów i wiele innych.

Spring Boot to projekt z ekosystemu Spring, który ma na celu ułatwienie tworzenia aplikacji opartych na Springu. Głównym celem Spring Boot jest minimalizacja konfiguracji wymaganej do uruchomienia aplikacji Springowej. Oto kilka kluczowych zalet Spring Boot:

1. Szybkie i łatwe rozpoczęcie pracy: Spring Boot oferuje szereg “starterów”, które są zestawami zależności dobrze do siebie pasujących, co pozwala szybko zacząć pracę z konkretnymi modułami (np. Spring Data, Spring Security).
2. Konwencja nad konfiguracją: Spring Boot dostarcza domyślne konfiguracje, które są zazwyczaj odpowiednie dla wielu aplikacji, zmniejszając potrzebę ręcznej konfiguracji.
3. Wbudowany serwer: Spring Boot zawiera wbudowane instancje serwerów aplikacji (takich jak Tomcat, Jetty, czy Undertow), co pozwala na uruchomienie aplikacji bezpośrednio z IDE bez konieczności osobnego wdrażania na serwer aplikacji.
4. Mikrousługi i chmura: Spring Boot jest dobrze przystosowany do budowy mikrousług i wspiera różne wzorce i narzędzia chmurowe, co ułatwia tworzenie skalowalnych i elastycznych aplikacji.
5. Zarządzanie zależnościami: Spring Boot zarządza wersjami zależności, co ułatwia zarządzanie zależnościami i ich kompatybilnością.
6. Aktuatory i monitoring: Spring Boot Actuator dostarcza gotowe punkty końcowe do monitorowania i zarządzania aplikacją w czasie działania, co jest ważne w produkcji.
7. Łatwe testowanie: Spring Boot ułatwia testowanie aplikacji poprzez dostarczanie narzędzi do testowania, w tym wsparcie dla testów integracyjnych.
8. Rozszerzalność: Można łatwo rozszerzać konfigurację domyślną i dostosowywać aplikację do swoich potrzeb.

Spring Boot jest szczególnie korzystny dla początkujących programistów Spring, ponieważ znacznie upraszcza proces konfiguracji i wdrożenia aplikacji, ale jest również ceniony przez doświadczonych deweloperów za oszczędność czasu i usprawnienie procesu tworzenia aplikacji.

Question 7

Pytanie: Jak Hibernate radzi sobie z problemem N+1?

Answer 7

Odpowiedź: Hibernate oferuje strategie ładowania, takie jak leniwe i chciwe ładowanie, oraz możliwość korzystania z HQL lub kryteriów do optymalizacji zapytań.

Pytanie: Jak Hibernate radzi sobie z problemem N+1?

Odpowiedź: Problem N+1 występuje, gdy podczas ładowania encji i jej powiązań z innych encjami, system wykonuje jedno zapytanie, aby pobrać główną encję, a następnie dodatkowe zapytania dla każdej powiązanej encji. W efekcie, dla N powiązanych encji, wykonuje się N+1 zapytań do bazy danych. Hibernate oferuje kilka sposobów radzenia sobie z tym problemem:

1. Eager Fetching (Ładowanie zachłanne): Można skonfigurować powiązania między encjami tak, aby były ładowane “zachłannie” (FetchType.EAGER). Oznacza to, że powiązane encje są ładowane od razu w momencie ładowania głównej encji. W praktyce często używa się tego w połączeniu z JOIN FETCH w HQL lub JPQL, aby zmusić Hibernate do wykonania złączenia i pobrania wszystkich potrzebnych danych w jednym zapytaniu.
2. Batch Fetching (Ładowanie wsadowe): Można skonfigurować Hibernate, aby ładował powiązane encje w paczkach (batchach) określonego rozmiaru. Na przykład, jeśli rozmiar paczki wynosi 10, a mamy 30 powiązanych encji, Hibernate wykona 3 zapytania, każde dla 10 encji.
3. Second Level Cache (Drugi poziom pamięci podręcznej): Hibernate oferuje drugi poziom pamięci podręcznej, który może być używany do przechowywania często używanych encji. Jeśli encje są już w pamięci podręcznej, nie ma potrzeby wykonywania dodatkowych zapytań do bazy danych.
4. Subselect Fetching (Ładowanie podzapytaniem): Dla kolekcji, można skonfigurować ładowanie za pomocą podzapytania. Gdy główna encja jest ładowana, Hibernate generuje podzapytanie, które ładuje powiązane encje dla wszystkich głównych encji w bieżącej sesji.
5. Named Entity Graphs: W JPA 2.1 wprowadzono koncepcję Named Entity Graphs, która pozwala na precyzyjne określenie, które atrybuty encji powinny być ładowane (zarówno zachłannie, jak i leniwie) dla danego zapytania.

Aby skutecznie radzić sobie z problemem N+1 w Hibernate, ważne jest zrozumienie charakterystyki danych i wzorców dostępu do nich w aplikacji, a następnie odpowiednie dostosowanie strategii ładowania. Monitoring wydajności i analiza generowanych zapytań SQL są kluczowe w identyfikowaniu i rozwiązywaniu problemów związanych z tym zagadnieniem.

Question 8

Pytanie: Jak w Springu można zabezpieczyć aplikację?

Answer 8

Odpowiedź: Można użyć Spring Security, który oferuje autentykację, autoryzację, ochronę przed atakami CSRF, integrację z OAuth2 i wiele innych funkcji bezpieczeństwa.

W Springu do zabezpieczania aplikacji najczęściej używa się modułu Spring Security. Jest to rozbudowany framework, który oferuje szeroki zakres funkcji związanych z uwierzytelnianiem, autoryzacją oraz ochroną przed różnymi rodzajami ataków. Oto kilka kroków i funkcji, które można wykorzystać do zabezpieczenia aplikacji w Springu:

1. Dodanie zależności Spring Security:
   Aby rozpocząć pracę z Spring Security, należy dodać odpowiednie zależności do projektu.
2. Konfiguracja bezpieczeństwa:
   
   • Można skonfigurować bezpieczeństwo zarówno za pomocą konfiguracji XML, jak i konfiguracji opartej na Javie.
   • W konfiguracji określa się, które ścieżki są zabezpieczone, jakie mają wymagania dotyczące uwierzytelniania i autoryzacji, jakie źródło danych jest używane do uwierzytelniania użytkowników itp.
3. Uwierzytelnianie:
   
   • Spring Security oferuje wiele mechanizmów uwierzytelniania, takich jak uwierzytelnianie oparte na formularzu, uwierzytelnianie HTTP Basic, uwierzytelnianie oparte na tokenach JWT itp.
   • Można zdefiniować własne serwisy uwierzytelniania, które łączą się z bazą danych, serwisem LDAP, OAuth2 lub innym źródłem danych.
4. Autoryzacja:
   
   • Po uwierzytelnieniu użytkownika można określić, jakie uprawnienia (role) ma przypisane i na tej podstawie kontrolować dostęp do różnych części aplikacji.
   • Za pomocą adnotacji takich jak @PreAuthorize można określić, które metody mogą być wywoływane przez użytkowników z określonymi uprawnieniami.
5. Ochrona przed atakami:
   
   • Spring Security oferuje ochronę przed wieloma powszechnymi atakami, takimi jak CSRF (Cross-Site Request Forgery), XSS (Cross-Site Scripting) czy Session Fixation.
   • Domyślnie włączona jest ochrona przed atakami CSRF w aplikacjach opartych na formularzach.
6. Integracja z HTTPS:
   
   • Można skonfigurować Spring Security, aby wymuszać komunikację za pomocą protokołu HTTPS dla określonych ścieżek lub dla całej aplikacji.
7. Wylogowywanie:
   
   • Spring Security oferuje mechanizm wylogowywania, który pozwala na bezpieczne zakończenie sesji użytkownika.
8. Remember-Me:
   
   • Funkcja “Remember-Me” pozwala na utrzymanie sesji użytkownika nawet po zamknięciu przeglądarki, dzięki specjalnym ciasteczkom.
9. Integracja z OAuth2 i JWT:
   
   • Dla aplikacji, które wymagają uwierzytelniania opartego na tokenach lub integracji z zewnętrznymi dostawcami uwierzytelniania, Spring Security oferuje wsparcie dla OAuth2 i JWT.

Aby skutecznie zabezpieczyć aplikację w Springu, ważne jest zrozumienie różnych aspektów bezpieczeństwa i odpowiednie skonfigurowanie Spring Security zgodnie z wymaganiami aplikacji. Regularne aktualizacje i monitorowanie są kluczowe, aby zapewnić, że aplikacja jest chroniona przed nowymi zagrożeniami i podatnościami.

Question 9

Pytanie: Jakie są różnice między @Bean a @Component w Springu?

Answer 9

Odpowiedź: @Bean jest używane w konfiguracji Java do deklarowania komponentu, podczas gdy @Component jest używane bezpośrednio na klasach, aby wskazać, że są one komponentami Springa.

Question 10

Pytanie: Jakie są różnice między save() a persist() w Hibernate?

Answer 10

Odpowiedź: Metoda save() zwraca identyfikator po zapisaniu obiektu, podczas gdy persist() nie zwraca niczego. persist() również gwarantuje, że obiekt zostanie zarządzany przez kontekst trwałości od razu po wywołaniu metody.

Question 11

Pytanie: Jakie są różnice między @RequestMapping a @GetMapping w Spring MVC?

Answer 11

Odpowiedź: @RequestMapping jest ogólną adnotacją, która może być używana do mapowania zarówno żądań HTTP GET, jak i POST (oraz innych metod HTTP). @GetMapping jest specjalizowaną wersją @RequestMapping, która jest przeznaczona wyłącznie do obsługi żądań HTTP GET.

Question 11

Pytanie: Co to jest Spring Data JPA?

Answer 11

Odpowiedź: Spring Data JPA to podprojekt Spring Data, który ułatwia tworzenie repozytoriów danych w sposób deklaratywny, bez konieczności pisania implementacji DAO. Umożliwia korzystanie z funkcji CRUD oraz tworzenie zapytań bazodanowych za pomocą nazw metod.

Question 12

Pytanie: Jak w Springu można zarządzać transakcjami?

Answer 12

Odpowiedź: W Springu można zarządzać transakcjami za pomocą adnotacji @Transactional. Spring oferuje zarówno programowe, jak i deklaratywne zarządzanie transakcjami.

Question 12

Pytanie: Jakie są różnice między @Entity a @Table w Hibernate?

Answer 12

Odpowiedź: @Entity wskazuje, że klasa jest encją i jest mapowana na tabelę w bazie danych. @Table jest używane do określenia nazwy tabeli oraz innych opcji tabeli, jeśli domyślna nazwa tabeli lub inne ustawienia nie są odpowiednie.

Question 13

Pytanie: Co to jest Spring Boot Actuator?

Answer 13

Odpowiedź: Spring Boot Actuator dostarcza zestaw narzędzi gotowych do produkcji, które pomagają monitorować i zarządzać aplikacją Spring Boot. Umożliwia dostęp do różnych metryk, zdrowia aplikacji, informacji o środowisku i innych.

Question 13

Pytanie: Jakie są różnice między session.get() a session.load() w Hibernate?

Answer 13

Odpowiedź: session.get() od razu zwraca obiekt lub null, jeśli obiekt o danym identyfikatorze nie istnieje. session.load(), jeśli obiekt nie istnieje, rzuca wyjątek ObjectNotFoundException. Ponadto session.load() może zwrócić proxy obiektu bez rzeczywistego wczytywania z bazy danych do momentu pierwszego dostępu do jakiejkolwiek właściwości obiektu.

Question 13

Pytanie: Co to jest Spring Cloud?

Answer 13

Odpowiedź: Spring Cloud dostarcza narzędzia do budowy niezawodnych, skalowalnych i dystrybuowanych systemów mikrousług. Umożliwia integrację z zewnętrznymi systemami, konfigurację, odkrywanie usług, obwody obwodów i wiele innych.

Question 14

Pytanie: Jakie są główne zalety korzystania z Spring MVC?

Answer 14

Odpowiedź: Spring MVC oferuje: jasny podział odpowiedzialności, wsparcie dla różnych formatów widoków (np. JSP, Thymeleaf), wsparcie dla walidacji danych, międzynarodowość, obsługę plików, a także integrację z różnymi źródłami danych.

Question 14

Pytanie: Jak Hibernate radzi sobie z problemem równoczesnego dostępu (concurrency)?

Answer 14

Odpowiedź: Hibernate oferuje różne strategie blokowania, takie jak optymistyczne i pesymistyczne blokowanie, aby radzić sobie z problemami równoczesnego dostępu.

Hibernate i problem równoczesnego dostępu (concurrency):

Hibernate radzi sobie z problemem równoczesnego dostępu poprzez różne strategie zarządzania równoczesnością. Oto kilka z nich:

1. Optimistic Locking (Optymistyczne blokowanie): Hibernate używa tej strategii w sytuacjach, gdy konflikty są rzadkie. Zamiast blokować dostęp do rekordu, Hibernate pozwala wielu transakcjom na równoczesne modyfikowanie tego samego rekordu. Jednak podczas zapisywania zmian, Hibernate sprawdza, czy inna transakcja nie zmodyfikowała już tego rekordu. Jeśli tak się stało, Hibernate zgłasza wyjątek StaleObjectStateException lub OptimisticLockException.
2. Pessimistic Locking (Pesymistyczne blokowanie): W tej strategii Hibernate blokuje rekord w bazie danych, uniemożliwiając innym transakcjom dostęp do niego do momentu zakończenia bieżącej transakcji. Jest to bardziej restrykcyjne podejście i może prowadzić do problemów wydajności, ale zapewnia większą kontrolę nad równoczesnością.
3. Wersjonowanie: Hibernate może automatycznie wersjonować encje, co pozwala na śledzenie zmian w rekordach. Działa to dobrze z optymistycznym blokowaniem, ponieważ Hibernate może porównać wersje rekordu przed i po modyfikacji, aby stwierdzić, czy doszło do konfliktu.

Poziomy izolacji w bazach danych:

Poziomy izolacji określają, jak transakcje oddziałują ze sobą. Oto standardowe poziomy izolacji:

1. Read Uncommitted (Niezaangażowane odczyty): Najniższy poziom izolacji. Transakcje mogą odczytywać niezaangażowane dane z innych transakcji. Może prowadzić do problemów, takich jak “brudne odczyty”.
2. Read Committed (Zaangażowane odczyty): Transakcje mogą odczytywać tylko zaangażowane dane z innych transakcji. Zapobiega to brudnym odczytom.
3. Repeatable Read: Jeśli transakcja odczyta wiersz, gwarantuje się, że w trakcie trwania tej transakcji żadna inna transakcja nie zmieni tego wiersza. Może jednak prowadzić do problemów z “fantomowymi odczytami”.
4. Serializable: Najwyższy poziom izolacji. Gwarantuje, że transakcje są wykonywane w sposób szeregowy, co eliminuje wszystkie problemy związane z równoczesnością.

Poziomy izolacji a warstwa ORM:

Warstwa ORM, tak jak Hibernate, nie ustala poziomów izolacji; są one zwykle konfigurowane na poziomie bazy danych. Jednak Hibernate może wykorzystywać te poziomy izolacji w celu zapewnienia spójności danych. Na przykład, używając optymistycznego blokowania w połączeniu z odpowiednim poziomem izolacji, Hibernate może zapewnić, że dane są zawsze aktualne i spójne, nawet w obliczu równoczesnych modyfikacji.

Question 15

Pytanie: Co to jest Spring Batch?

Answer 15

Odpowiedź: Spring Batch to framework do tworzenia wydajnych i skalowalnych aplikacji wsadowych. Umożliwia organizację, przetwarzanie i zapisywanie dużej ilości danych.

Question 16

Gdzie w modelu MVC znajdują się @Service?

Answer 16

W modelu MVC (Model-View-Controller), adnotacja @Service w Springu jest związana z warstwą “Model”. Oto jak to się rozkłada:

1. Model: Reprezentuje dane i logikę biznesową aplikacji. W Springu klasy oznaczone adnotacją @Service oraz @Repository (i czasem @Component, jeśli ma ona charakter logiki biznesowej) znajdują się w tej warstwie. Klasy @Service zwykle zawierają logikę biznesową i operacje związane z danymi, które są wykonywane na modelu. Klasy @Repository są związane z dostępem do danych.
2. View: Odpowiada za prezentację danych użytkownikowi. W aplikacjach webowych opartych na Spring MVC, widokami są zwykle strony JSP, Thymeleaf, FreeMarker lub inne technologie do renderowania stron.
3. Controller: Odpowiada za obsługę żądań użytkownika, przetwarzanie danych wejściowych i zwracanie odpowiedniego widoku. W Spring MVC klasy oznaczone adnotacją @Controller lub @RestController pełnią tę rolę.

Podsumowując, w modelu MVC klasy oznaczone adnotacją @Service znajdują się w warstwie “Model” i są odpowiedzialne za logikę biznesową aplikacji.

Question 17

Na co wpływa scope w beanie?

Answer 17

W kontekście Spring Framework, zakres (scope) beana określa cykl życia i widoczność instancji beana w kontenerze Springa. Zakres beana ma kluczowe znaczenie, ponieważ wpływa na to, jak i kiedy instancje beanów są tworzone, zarządzane i niszczone przez kontener Spring. Oto najważniejsze zakresy (scopes) dostępne w Springu:

1. Singleton (Domyślny)
   - Charakterystyka: Tylko jedna instancja beana jest utworzona na cały kontener IoC (Inversion of Control).
   - Wpływ: Bean jest utworzony tylko raz, a ta sama instancja jest współdzielona w całej aplikacji. Zmiany stanu w beanie singleton będą widoczne dla wszystkich innych komponentów, które go używają.
2. Prototype
   - Charakterystyka: Każde odwołanie do beana powoduje utworzenie nowej instancji.
   - Wpływ: Zapewnia, że każdy komponent używający beana otrzymuje nową, niezależną instancję. Użyteczne, gdy potrzebujemy zachować stan między różnymi odwołaniami.
3. Request
   - Charakterystyka: Instancja beana jest tworzona na każde żądanie HTTP.
   - Wpływ: Użyteczne w aplikacjach webowych, gdzie chcemy, aby bean był związany z pojedynczym żądaniem HTTP.
4. Session
   - Charakterystyka: Instancja beana jest utworzona na sesję HTTP.
   - Wpływ: Bean jest współdzielony w ramach jednej sesji użytkownika, ale różne sesje będą miały różne instancje beana.
5. Application
   - Charakterystyka: Instancja beana jest utworzona na poziomie aplikacji ServletContext.
   - Wpływ: Bean jest współdzielony między wszystkimi żądaniami i sesjami w obrębie pojedynczej aplikacji webowej.
6. WebSocket
   - Charakterystyka: Instancja beana jest tworzona na zakres WebSocket.
   - Wpływ: Użyteczne dla aplikacji korzystających z komunikacji WebSocket.

Wpływ Wyboru Zakresu
Wybór zakresu beana ma bezpośredni wpływ na zarządzanie zasobami, zachowanie stanu i sposób interakcji komponentów w aplikacji:

• Zarządzanie Stanem: Singletony są stanowe, jeśli przechowują dane, które mogą się zmieniać, podczas gdy beany prototype są zawsze stanem początkowym.
• Zarządzanie Zasobami: Singletony są bardziej efektywne pod względem zużycia pamięci, ponieważ istnieje tylko jedna instancja, niezależnie od liczby odwołań.
• Wydajność: Utworzenie beana może być kosztowne, więc częste tworzenie nowych instancji (jak w przypadku prototype) może wpływać na wydajność.

Wybór odpowiedniego zakresu dla beana powinien być podyktowany wymaganiami aplikacji, w tym zarządzaniem stanem, wydajnością i użytecznością w konkretnym kontekście aplikacji.

Question 18

Co to jest strategia dziedziczenia w hibernate?

Answer 18

W Hibernate, który jest popularnym frameworkiem do mapowania obiektowo-relacyjnego (ORM) w Javie, strategia dziedziczenia odnosi się do sposobu, w jaki hierarchie dziedziczenia w obiektach Javy są mapowane na struktury tabel w bazie danych. Wybór odpowiedniej strategii dziedziczenia zależy od różnych czynników, takich jak struktura modelu danych i wymagania dotyczące wydajności. Istnieją trzy główne strategie dziedziczenia w Hibernate:

1. Single Table Strategy (Strategia Tabeli Pojedynczej)
   - Charakterystyka: Wszystkie klasy w hierarchii dziedziczenia są mapowane na pojedynczą tabelę w bazie danych.
   - Zalety: Zapewnia dobrą wydajność, ponieważ nie ma potrzeby wykonywania łączenia tabel (join operations) podczas odpytywania o dane. Jest to również proste w implementacji.
   - Wady: Tabela może zawierać wiele kolumn, które są nullowalne, gdyż różne klasy mogą mieć różne atrybuty. Może prowadzić do marnotrawstwa miejsca i problemów z wydajnością dla bardzo dużych hierarchii.
2. Joined Table Strategy (Strategia Tabeli Połączonej)
   - Charakterystyka: Każda klasa w hierarchii ma swoją własną tabelę, a wszystkie tabele są połączone za pomocą kluczy obcych.
   - Zalety: Eliminuje problem kolumn nullowalnych, który występuje w strategii tabeli pojedynczej. Pozwala na bardziej znormalizowaną strukturę bazy danych.
   - Wady: Wydajność może być niższa w porównaniu do strategii tabeli pojedynczej, zwłaszcza przy operacjach odpytywania, które wymagają łączenia tabel.
3. Table Per Class Strategy (Strategia Tabeli na Klasę)
   - Charakterystyka: Każda klasa w hierarchii dziedziczenia jest mapowana na swoją własną tabelę. Tabele nie są bezpośrednio połączone kluczami obcymi.
   - Zalety: Zapewnia jasną strukturę i unika problemów z nullowalnymi kolumnami.
   - Wady: Może być nieefektywna w przypadku odpytywania o dane, ponieważ wymaga operacji UNION, aby zebrać dane z wielu tabel. Może również prowadzić do redundancji danych.

Wybór Strategii
Wybór odpowiedniej strategii dziedziczenia w Hibernate zależy od specyfiki aplikacji, wymagań dotyczących wydajności, struktury bazy danych i innych czynników projektowych. Każda strategia ma swoje zalety i wady, dlatego ważne jest, aby zrozumieć wymagania swojej aplikacji i zdecydować, która strategia będzie najbardziej odpowiednia.

Question 19

How is a complex key mapped in Hibernate? I.e. in an application if there is a primary key of a pair of columns, how is it implemented with Hibernate?

Answer 19

In Hibernate, a complex or composite primary key - a primary key made up of more than one column - can be mapped using the @Embeddable and @EmbeddedId annotations or using the @IdClass annotation. Both approaches allow Hibernate to understand that the primary key of an entity is composed of multiple fields.

Using @Embeddable and @EmbeddedId

1. Define a Class for the Composite Key: Create a class that represents the composite key and annotate it with @Embeddable. This class should include all the fields that make up the primary key and should implement Serializable.

   java
   @Embeddable
   public class ComplexKeyId implements Serializable {
       private Long part1;
       private Long part2;
       // getters, setters, hashCode, equals
   }

2. Use the Composite Key in the Entity: In your entity class, use the @EmbeddedId annotation to denote that this class uses a composite key.

   java
   @Entity
   public class MyEntity {
       @EmbeddedId
       private ComplexKeyId id;
       // other fields, getters, setters
   }

Using @IdClass

1. Define a Class for the Composite Key: Similar to the first method, but this time you annotate the class with @IdClass at the entity level. The key class itself is not annotated with @Embeddable.

   java
   public class ComplexKeyId implements Serializable {
       private Long part1;
       private Long part2;
       // getters, setters, hashCode, equals
   }

2. Use the Composite Key in the Entity: In the entity class, annotate each field of the composite key with @Id. Also, annotate the entity class with @IdClass, pointing to the key class.```java
   @Entity
   @IdClass(ComplexKeyId.class)
   public class MyEntity {
   @Id
   private Long part1;

   @Id
   private Long part2;
   // other fields, getters, setters } ```

Considerations

• equals() and hashCode(): It’s crucial that both the entity and the key classes properly implement equals() and hashCode() because Hibernate uses these methods for identity comparison and caching.
• Serializable Interface: The composite key class must implement Serializable as Hibernate requires all primary key classes to be serializable.
• No-arg Constructor: Both the entity and the composite key class should have a public or protected no-arg constructor as Hibernate instantiates them using reflection.

The choice between @Embeddable/@EmbeddedId and @IdClass often depends on whether the key fields are only related to the identity or if they also logically belong to the entity class. If the fields are used as normal fields within the entity, @IdClass is often more appropriate. Otherwise, @Embeddable/@EmbeddedId might be more suitable.

Question 20

What is the “N+1 Selects Problem”?

Answer 20

The problem you’re referring to in Hibernate is commonly known as the “N+1 Selects Problem” or “N+1 Query Problem.” It occurs in the context of lazy loading when Hibernate executes an additional query for each record that needs to be fetched, leading to a significant performance hit.

What is the N+1 Selects Problem?

Suppose you have an entity A with a one-to-many relationship to entity B. When you fetch A and then access its collection of B, Hibernate, by default, lazily loads each B entity. If you have N entities of A, Hibernate will execute one query to fetch all A entities and then N additional queries to fetch the B entities for each A. Hence, a total of N+1 queries are executed.

How to Overcome the N+1 Selects Problem

1. Eager Fetching:
   
   • You can switch from lazy loading to eager fetching using the @OneToMany(fetch = FetchType.EAGER) annotation. However, this approach can lead to other performance issues like loading too much data.
2. Join Fetch in HQL/JPQL:
   
   • When writing HQL or JPQL queries, you can use the JOIN FETCH clause to fetch the associated entities in the same query.
   • Example: SELECT a FROM A a JOIN FETCH a.bs
3. Batch Fetching:
   
   • Hibernate allows batch fetching of associations. By setting a batch size, you can reduce the number of queries executed.
   • Example: @OneToMany(fetch = FetchType.LAZY) @BatchSize(size = 10) will fetch associated entities in batches of 10.
4. Subselect Fetching:
   
   • This strategy fetches the associated collections for all entities retrieved in a single additional query.
   • It’s configured via the @Fetch(FetchMode.SUBSELECT) annotation.
5. Criteria API or QueryDSL:
   
   • Using the Criteria API or QueryDSL to create queries can help control fetching strategy more precisely.
6. Using Entity Graphs:
   
   • Entity graphs, introduced in JPA 2.1, allow for more control over what should be fetched eagerly or lazily on a per-query basis.

Best Practices

• Analyze Your Use Case: Before deciding on a fetching strategy, analyze your specific use case. Sometimes, what works in one scenario may not be efficient in another.
• Monitoring: Use SQL monitoring to understand the actual queries generated and their impact.
• Balancing Act: Remember, eager fetching can lead to fetching too much data, and lazy loading can lead to the N+1 problem. Find a balance based on your application’s needs.

It’s important to test and profile your application to identify the best fetching strategy for your specific use case, as the optimal solution can vary depending on the data model and the application’s access patterns.

Question 21

What’s the difference between session and transaction in Hibernate?

Answer 21

In the context of Hibernate, which is a popular framework for object-relational mapping in Java, the concepts of “session” and “transaction” are fundamental and have distinct roles in the framework’s architecture:

Session

1. Definition: A Session in Hibernate is a single-threaded, short-lived object representing a conversation between the application and the persistent store. It wraps a JDBC connection and is the primary interface for the persistence operations.
2. Role: The Session acts as a cache for the objects it retrieves or saves. It tracks the persistent objects and ensures they are synchronized with the database when necessary.
3. Lifecycle:
   
   • The lifecycle of a Session starts when it is opened and ends when it is closed.
   • A Session is typically opened when a logical transaction starts and closed when the transaction ends.
4. Operations: The Session provides methods to create, read, update, and delete entities. It also offers query execution capabilities.
5. Context: It’s a key part of Hibernate’s internal workings, providing the context for the persistence operations and caching.

Transaction

1. Definition: A Transaction in Hibernate is a single-threaded, short-lived object representing a series of operations that either all succeed or all fail. It’s a concept borrowed from database systems to ensure data integrity.
2. Role: Transactions in Hibernate are used to ensure that a set of operations either all happen or none happen. If any operation in the transaction fails, the transaction can be rolled back to ensure the database remains in a consistent state.
3. Lifecycle:
   
   • The lifecycle of a Transaction begins when it is started and ends when it is either committed or rolled back.
   • A Transaction is typically started right after a Session is opened and ended before the Session is closed.
4. Operations: In a transaction, multiple operations are treated as a single unit of work. This means that either all operations succeed, or none are applied.
5. ACID Properties: Transactions in Hibernate follow the ACID properties (Atomicity, Consistency, Isolation, Durability) typical in database management systems.

Key Differences

• Scope and Function: A Session is broader in scope, providing an interface for performing CRUD operations and managing persistent objects, whereas a Transaction is specifically for managing the atomicity and consistency of multiple operations.
• Lifecycle: A Session can span multiple transactions, but a transaction is contained within a Session.
• Purpose: The Session is about interacting with the database and managing objects, while the Transaction is about ensuring data integrity and consistency for a set of operations.

In practice, when using Hibernate, operations are typically performed within a Session, and multiple operations are grouped together within a Transaction to ensure they either all succeed or fail as a unit, maintaining the integrity of the database.

Question 22

How is the lifecycle of session handled in the default setting of spring boot?

Answer 22

In a typical Spring Boot application, the lifecycle of a Hibernate session is managed automatically by Spring’s transaction management infrastructure. This automated management is facilitated by Spring’s integration with Hibernate through the Spring Data JPA module. Here’s how it typically works in the default setting:

Session Management in Spring Boot

1. SessionFactory Creation:
   
   • Spring Boot auto-configures a SessionFactory (or EntityManagerFactory in JPA terminology) based on the application properties defined in application.properties or application.yml.
   • This SessionFactory is a Spring bean and is created once when the application starts.
2. Opening and Closing Sessions:
   
   • In Spring Boot, a Hibernate Session is opened and closed automatically for each transaction.
   • When a method annotated with @Transactional is executed, Spring starts a new Hibernate session and binds it to the current thread. This is known as session-per-request or session-per-transaction pattern.
   • At the end of the transaction, the session is automatically closed by Spring.
3. Transaction Management:
   
   • The @Transactional annotation is key in managing transactions. When a method annotated with @Transactional is called, Spring begins a transaction.
   • If the method completes successfully, the transaction is committed, and any changes made during the transaction are persisted to the database.
   • If an exception occurs, the transaction is rolled back, and the session changes are not saved.
4. Session Context:
   
   • Spring manages the session context, ensuring that the same session is used throughout a single transaction, even across different DAOs or repositories involved in that transaction.
   • This management includes handling lazy loading scenarios within the scope of the transaction.
5. Exception Handling:
   
   • Spring provides a translation mechanism where it converts Hibernate or JPA exceptions into its own Data Access Exceptions. This makes error handling more consistent and integrates better with Spring’s overall exception handling strategies.

Advantages of Spring’s Session Management

• Simplicity: Developers don’t need to manually open and close sessions or manage transactions.
• Consistency: The session management is consistent across the application, reducing the likelihood of errors like lazy initialization exceptions.
• Declarative Transaction Management: The @Transactional annotation makes transaction management declarative rather than programmatic, simplifying the code and enhancing readability.

Customization

While the default settings work well for many applications, Spring Boot also allows for extensive customization of session and transaction management to suit specific requirements, such as defining different transactional behaviors for different methods or working with multiple data sources.

In summary, Spring Boot simplifies Hibernate session and transaction management by automating these processes, allowing developers to focus more on business logic rather than boilerplate code associated with session and transaction handling.

Question 23

What are different database types and where are they typically used?

Answer 23

W świecie baz danych istnieje kilka różnych typów, które są używane w zależności od wymagań aplikacji i specyfiki danych. Oto główne typy baz danych i ich typowe zastosowania:

1. Relacyjne bazy danych (RDBMS): Są to najpopularniejsze bazy danych, wykorzystujące model relacyjny do organizowania danych w tabelach. Przykłady to MySQL, PostgreSQL i Oracle. Są one często stosowane w aplikacjach biznesowych, systemach zarządzania treścią, aplikacjach e-commerce i wszędzie tam, gdzie potrzebna jest silna integralność danych.
2. NoSQL:
   
   • Dokumentowe: Bazy takie jak MongoDB czy Couchbase przechowują dane w formacie dokumentów (zazwyczaj JSON). Są idealne do pracy z dużymi ilościami danych o zmiennych schematach, jak np. w aplikacjach mobilnych, platformach content management i big data.
   • Kolumnowe: Przykłady to Cassandra lub HBase. Są one używane głównie w systemach wymagających wysokiej skalowalności i szybkiego przetwarzania dużych ilości danych, np. w systemach analitycznych i Big Data.
   • Grafowe: Neo4j i Amazon Neptune to przykłady baz danych grafowych, które są optymalne do modelowania złożonych relacji, jak w sieciach społecznościowych, rekomendacji produktów czy analizie grafów.
3. Bazy danych klucz-wartość: Redis i DynamoDB to przykłady baz danych tego typu. Są one szybkie i skalowalne, idealne do przechowywania sesji użytkowników, w systemach cache’owania oraz tam, gdzie potrzebna jest szybka odczyt-zapis pary klucz-wartość.
4. Obiektowe bazy danych: Takie jak db4o czy ObjectDB. Są one używane w aplikacjach, które intensywnie korzystają z programowania obiektowego i wymagają przechowywania obiektów aplikacji bezpośrednio w bazie danych.
5. Bazy danych czasowych (Time Series Database, TSDB): InfluxDB i TimescaleDB to przykłady baz danych zaprojektowanych do efektywnego przechowywania i zarządzania sekwencyjnymi danymi czasowymi. Są one używane w monitoringu, telemetryce, finansach (do przechowywania danych o cenach) i wszędzie tam, gdzie dane są zbierane w regularnych odstępach czasu.

Każdy z tych typów baz danych ma swoje unikalne cechy i jest zoptymalizowany do różnych scenariuszy użycia, co wpływa na wybór odpowiedniej technologii w zależności od wymagań projektu.

Question 24

Can I add a @Transaction on 1 method and then later create another transaction within a call to another method?

Answer 24

In Spring, using the @Transactional annotation, you can define transaction boundaries at the method level. However, the behavior when one @Transactional method calls another @Transactional method depends on the transaction propagation settings.

Default Behavior

By default, Spring uses the PROPAGATION_REQUIRED transaction propagation. Under this setting:

1. If there’s no existing transaction, Spring starts a new one.
2. If there’s an existing transaction, Spring joins the existing transaction rather than creating a new one.

Nested Transactions

If you need to create a new transaction within a call to another @Transactional method, you can use different propagation settings:

1. PROPAGATION_REQUIRES_NEW:
   
   • This setting forces Spring to start a new transaction. If there’s an existing transaction, it’s suspended, and a new transaction is started.
   • This is useful when you need the called method to run within its own transaction, independent of the transaction of the calling method.

   java
   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void someMethod() {
       // New transaction started, even if called from another @Transactional method
   }

2. PROPAGATION_NESTED:
   
   • This option allows the method to execute in a nested transaction if a transaction is already running. If the nested transaction fails, it can be rolled back without affecting the outer transaction.
   • This requires database support for savepoints. Not all databases support nested transactions.

   java
   @Transactional(propagation = Propagation.NESTED)
   public void someMethod() {
       // Nested transaction started within the current transaction
   }

Considerations

• Transaction Management: Be cautious with complex transaction management as it can lead to harder-to-debug issues.
• Performance: Using PROPAGATION_REQUIRES_NEW can have performance implications, as each transaction involves overhead.
• Use Case: Use nested or new transactions judiciously, typically in scenarios where a set of operations needs to succeed or fail independently of the calling method’s transaction.

In summary, while you can create new or nested transactions within a @Transactional method, it’s important to understand the implications and choose the right propagation behavior based on your use case. The default behavior in Spring joins the existing transaction, but you can alter this with different propagation settings to suit specific requirements.

Question 25

Czym jest cache pierwszego i drugiego poziomu w Hibernate?

Answer 25

W Hibernate, który jest popularnym frameworkiem do mapowania obiektowo-relacyjnego (ORM) w Javie, istnieją dwa rodzaje cache’owania - cache pierwszego poziomu (First-Level Cache) i cache drugiego poziomu (Second-Level Cache). Oba te cache’e mają na celu poprawę wydajności poprzez zmniejszenie liczby zapytań do bazy danych.

Cache Pierwszego Poziomu (First-Level Cache)

1. Definicja: Cache pierwszego poziomu jest wbudowany w sesję Hibernate i jest domyślnie włączony. Każda sesja ma swój własny, niezależny cache pierwszego poziomu.
2. Działanie:
   
   • Gdy obiekt jest pobierany z bazy danych, jest on również przechowywany w cache’u pierwszego poziomu.
   • Jeśli ten sam obiekt jest ponownie żądany w ramach tej samej sesji, Hibernate pobiera go z cache’u zamiast ponownie wykonywać zapytanie do bazy danych.
3. Zakres: Cache pierwszego poziomu jest ograniczony do jednej sesji. Nie jest współdzielony między różnymi sesjami.
4. Zarządzanie: Hibernate automatycznie zarządza cache’em pierwszego poziomu, i nie wymaga od programisty żadnych dodatkowych konfiguracji.

Cache Drugiego Poziomu (Second-Level Cache)

1. Definicja: Cache drugiego poziomu w Hibernate jest opcjonalny i może być włączony przez programistę. Jest on współdzielony między różnymi sesjami Hibernate.
2. Działanie:
   
   • Cache drugiego poziomu przechowuje dane na poziomie klasy encji lub kolekcji, które mogą być współdzielone między różnymi sesjami.
   • Gdy obiekt jest żądany, Hibernate najpierw sprawdza cache pierwszego poziomu, a następnie cache drugiego poziomu, zanim zdecyduje się na zapytanie do bazy danych.
3. Konfiguracja:
   
   • Cache drugiego poziomu wymaga konfiguracji, w tym wyboru dostawcy cache (np. EhCache, Infinispan).
   • Można konfigurować, które klasy lub kolekcje powinny być cache’owane.
4. Zalety:
   
   • Zmniejsza obciążenie bazy danych poprzez zmniejszenie liczby zapytań.
   • Poprawia wydajność aplikacji, szczególnie w rozproszonych i skalowalnych środowiskach.

Różnice

• Zakres: Cache pierwszego poziomu jest ograniczony do sesji, natomiast cache drugiego poziomu jest współdzielony między sesjami.
• Zarządzanie: Cache pierwszego poziomu jest zarządzany automatycznie, podczas gdy cache drugiego poziomu wymaga konfiguracji.
• Użycie: Cache drugiego poziomu jest szczególnie przydatny w środowiskach rozproszonych i skalowalnych, gdzie wiele sesji musi uzyskiwać dostęp do tych samych danych.

Wykorzystanie obu poziomów cache’owania w Hibernate może znacznie poprawić wydajność aplikacji poprzez zmniejszenie liczby zapytań do bazy danych i szybszy dostęp do danych.