Kurs Spring Boot Backend Developer

Ten kurs jest przeznaczony dla osób, które chcą rozwijać się w obszarze nowoczesnego backendu Java w praktyce produkcyjnej i realnych wdrożeniach. Program prowadzi od uruchomienia aplikacji w Spring Boot, przez budowę i zabezpieczanie REST API, trwałość danych i komunikację zdarzeniową, po mikroserwisy, architekturę pod integracje oraz wdrożenia w środowiskach chmurowych. Kurs jest odpowiedni zarówno dla osób posiadających podstawy Javy i rozpoczynających pracę ze Spring Boot, jak i dla programistów na poziomie regular, mid oraz senior, którzy chcą uporządkować i pogłębić warsztat architektoniczny.

Na początek zbudujesz REST API z warstwą DTO, walidacją, internacjonalizacją (i18n), globalną obsługą wyjątków, programowaniem aspektowym AOP, dokumentacją OpenAPI i obserwowalnością przez Actuator. Trwałość danych zrealizujesz za pomocą Spring Data JPA i Hibernate z migracjami w Liquibase. Następnie rozbijesz monolit na mikroserwisy komunikujące się przez RestClient i HTTP Interface na wirtualnych wątkach, spakowane w Docker i wdrożysz architekturę heksagonalną z Domain-Driven Design (DDD) oraz wzorcem transactional outbox.

Warstwę bezpieczeństwa wdrożysz na Spring Security, JWT i OAuth2 z uwierzytelnianiem dwuskładnikowym MFA i API Gateway, a jakość utrzymasz testami na JUnit, Mockito, MockMvc, Testcontainers i WireMock. Komunikację zdarzeniową oprzesz na Apache Kafka ze wzorcem CQRS oraz RabbitMQ ze wzorcem Saga. Całość domkniesz komunikacją z LLM poprzez Spring AI i wdrożeniami na Kubernetes.

Dodatkowo w ramach mentoringu nauczysz się świadomej pracy z narzędziami AI (Claude Code, Cursor i inne), od precyzyjnego promptowania, przez implementację po krytyczną weryfikację sugestii kodu.

Pełny wykaz nagrań dla tego kursu znajdziesz TUTAJ. Rozpocznij ten kurs dopiero wtedy, gdy skończysz kurs Java Backend Developer lub posiadasz wiedzę z zakresu tego kursu.

Ten moduł to praktyczne wejście w Spring Boot. Utworzysz projekt przez Spring Initializr, dobierzesz zależności przez starters i uruchomisz aplikację jako samodzielny proces z wbudowanym serwerem. Wykorzystasz Maven oraz Gradle. Poznasz mechanizm autokonfiguracji, który sam dobierze ustawienia na podstawie zależności. Przygotujesz pierwsze endpointy REST API. Konfigurację aplikacji uporządkujesz w pliku application.properties (application.yml). W trybie developmentu przygotujesz automatyczny restart aplikacji po zmianie kodu. Na koniec spakujesz aplikację do pliku wykonywalnego jar i uruchamiasz ją z linii poleceń przy użyciu spring-boot-maven-plugin.

Ten moduł nauczy się rozwijać REST API w Spring Boot. Zaczniesz od architektury aplikacji webowych, protokołu HTTP i zasad, na których opiera się REST. Następnie poznasz wzorzec MVC i zasadę działania aplikacji webowej Spring Boot. Utworzysz metody REST kontrolera współpracującego z serwisem oraz obsłużysz path variables i request parameters. Przygotujesz serwis do bezpiecznej wątkowo modyfikacji zasobów. Wydzielisz warstwę DTO i zaimplementujesz pełny cykl operacji na zasobie przez metody POST, PUT, PATCH oraz DELETE. Przechwycisz nagłówki HTTP, zbudujesz odpowiedzi przez ResponseEntity i RequestEntity, zwrócisz właściwe status code oraz utworzysz własne obiekty odpowiedzi i zasoby pobieralne. Zejdziesz też na poziom HttpServletRequest i HttpServletResponse oraz nauczysz się zarządzać cookies i cache. Wprowadzisz globalną i lokalną obsługę wyjątków z własnym typem opisującym błąd. Dodasz interceptory, filtry, monitorowanie zachowania aplikacji, walidację danych i internacjonalizację i18n. Skonfigurujesz profile, obsłużysz JSON body i własne konwertery, a także wykorzystasz zdarzenia synchroniczne i asynchroniczne oraz wysyłkę wiadomości email. Poznasz AOP, udokumentujesz API przez OpenAPI, zintegrujesz warstwę bazodanową przez JDBC i uruchomisz obserwowalność aplikacji w ramach Spring Boot Actuator. Dzięki temu zbudujesz API czytelne dla klientów, bezpieczniejsze w eksploatacji i łatwiejsze w utrzymaniu.

Ten moduł pozwoli Ci wdrożyć warstwę bazodanową w Spring Boot opartą na Spring Data JPA i Hibernate. Skonfigurujesz połączenie z bazą danych i źródło danych, a strukturę oraz dane początkowe przygotujesz w plikach schema.sql i data.sql. Zdefiniujesz encje i utworzysz repozytoria. Poznasz działanie transakcji oraz mechanizm flush i batchowania, dzięki czemu zapanujesz nad momentem zapisu i wydajnością operacji. Zapytania zbudujesz przez query methods, a bardziej złożone kryteria wyrazisz za pomocą Specification. Ograniczysz ilość pobieranych danych przez projekcje, uporządkujesz wyniki przez sortowanie i paginację oraz wykonasz zapytania modyfikujące. Problem N+1 rozwiążesz przy użyciu fetch i entity graph, a duże zbiory przejdziesz przez scrolling. Na koniec zarządzisz rozwijaniem schematu bazy za pomocą Liquibase i wersjonowanych migracji.

Ten moduł pokaże Ci przejście od jednej aplikacji webowej do dwóch współpracujących usług, czyli rozbijania monolitu na mikroserwisy. Zaczniesz od serwera zbudowanego w architekturze wielowarstwowej z podziałem na kontroler, serwis, repozytorium, mapper i domenę. Przygotujesz REST API do operacji CRUD, z repozytorium, walidacją i warstwą DTO. Błędy uporządkujesz w jednym miejscu przez globalny exception handler oraz przygotujesz uniwersalną strukturę odpowiedzi, zgodnie ze standardem RFC 7807 Problem Details. Aplikację spakujesz do obrazu przez produkcyjny Dockerfile i całość zestawisz w Docker Compose. Po stronie klienta zbudujesz drugą usługę, która komunikuje się z serwerem po HTTP przy użyciu RestClient. Poznasz dwa podejścia – deklaratywny HTTP Interface z adnotacjami @HttpExchange oraz imperatywny RestClient. Zarządzisz parametrami komunikacji pomiędzy mikroserwisami, a błędy zwrócone przez serwer przetłumaczysz na wyjątki własnego typu. Kluczowym elementem dla szybkości i wydajności komunikacji będzie wdrożenie mechanizmów wspierających wirtualne wątki po stronie serwera i klienta.

Ten moduł nauczy Cię wdrażać architekturę systemu klasy produkcyjnej. Zbudujesz trzy współpracujące serwisy: order-service, payment-service oraz invoice-service, każdy w architekturze heksagonalnej z podziałem na porty i adaptery. Model domenowy oprzesz na Domain-Driven Design (DDD). Zaprojektujesz agregaty realizujące maszynę stanów oraz obiekty wartości, w których zamkniesz reguły biznesowe, zamiast rozpraszać je po serwisach. Obsłużysz koszyk, rezerwację i zwolnienie stanu magazynowego, a złożenie zamówienia zapiszesz atomowo razem z rezerwacją w magazynie w jednej transakcji. Zintegrujesz płatności z bramką TPay. Zarejestrujesz transakcję, obsłużysz webhooki z powiadomieniami, zweryfikujesz podpis MD5 powiadomienia i potwierdzisz płatność bezpośrednio w bramce. Zadbasz o bezpieczną realizację płatności w połączeniu z mechanizmem wirtualnych wątków. Obsługę faktur zrealizujesz przez integrację z systemem Fakturownia. Zdarzenia między serwisami przekażesz wzorcem transactional outbox, dzięki czemu zagwarantujesz niezawodność potwierdzenia płatności i wystawienia faktury. Zadania cykliczne oprzesz na @Scheduled  i rozproszonej blokadzie zrealizowanej za pomocą ShedLock. Wdrożysz odzyskiwanie osieroconych płatności oraz wygaszanie zamówienia, które zbyt długo oczekuje na płatność. Spójność danych zapewnisz przez optimistic locking, granice transakcji, idempotencję webhooków i unikalne ograniczenia w bazie. Całość uruchomisz przez Docker Compose. Postawisz trzy osobne bazy MySQL i trzy serwisy, ustawisz limity zasobów na pamięć i CPU, healthchecki, rotację logów oraz politykę restartów. 

Ten moduł to praktyczne wdrożenie warstwy bezpieczeństwa w architekturze mikroserwisów opartej o Spring Security i JWT. Zbudujesz trzy współpracujące usługi, czyli user-service, auth-service oraz API Gateway, każdą w architekturze portów i adapterów z podziałem na warstwę domenową, aplikacyjną, infrastrukturalną i prezentacji. Zobaczysz gdzie przebiega granica zaufania, jak wygląda łańcuch żądania oraz jak rozdzielić tożsamość, uwierzytelnianie i wejście do systemu. Poznasz też logowanie przez zewnętrznych dostawców tożsamości w modelu OAuth2.

W user-service przygotujesz rejestrację konta z haszowaniem hasła, sprawdzaniem unikalności nazwy i adresu email oraz potwierdzeniem hasła. Aktywację oprzesz o kod wysyłany mailem, gdzie wysyłka biegnie asynchronicznie na wirtualnym wątku dopiero po zatwierdzeniu transakcji, więc odpowiedź do klienta wraca od razu, a nieudany commit nie wyśle maila. Dodasz ponowne wysłanie kodu, dwuetapowy reset hasła, konfigurację MFA z sekretem TOTP i kodem QR oraz zmianę roli dostępną tylko dla administratora. Wewnętrzne endpointy udostępnisz tylko dla pozostałych usług i zabezpieczysz odpowiednim nagłówkiem.

W auth-service zaimplementujesz logowanie, które weryfikuje dane w user-service przez RestClient, obsłuży ścieżkę z MFA z weryfikacją kodu TOTP i danymi cache’owanymi w Redis, a następnie wystawi parę tokenów JWT. Uzupełnisz to endpointami odświeżania tokenu i wylogowania.

W API Gateway skonfigurujesz odpowiedni filter i CORS. Filtrem zweryfikujesz token Bearer i zrealizujesz autoryzację, a reguły dostępu dla ścieżek publicznych, użytkownika i administratora opiszesz w konfiguracji. Gateway odczyta tożsamość z tokenu, skonfiguruje odpowiednie nagłówki, dzięki czemu klient nie podszyje się pod inną rolę. Ruch przekażesz transparentnie do usług docelowych przez RestClient, przepisując status i treść odpowiedzi jeden do jednego, a niedostępność usługi zamienisz na odpowiedź 502.

Osobno poznasz logowanie społecznościowe przez zewnętrznych dostawców tożsamości w modelu OAuth2. Skonfigurujesz OAuth2 Login w Spring Security tak, aby użytkownik zalogował się przez Google lub GitHub, bez podawania hasła Twojej aplikacji. Przygotujesz własną stronę logowania i przekierowanie po udanym uwierzytelnieniu. 

Na koniec złożysz z tego spójną granicę zaufania, w której JWT jest weryfikowany wyłącznie na gatewayu i tam zostaje, a usługi downstream ufają przekazanym nagłówkom tożsamości, chronione dodatkowo siecią Docker i sekretem wewnętrznym. Efektem jest bezpieczeństwo rozproszone bez łączenia wszystkich odpowiedzialności w jednym procesie serwerowym.

Ten moduł nauczy Cię testowania aplikacji webowych w Spring Boot. Uporządkujesz rodzaje testów według piramidy testów i zobaczysz, kiedy wybrać każdy z nich. Zaczniesz od testów jednostkowych na JUnit, w których izolujesz jedną klasę, podstawiasz zależności przez Mockito i sprawdzasz wynik oraz wywołania czytelnymi asercjami AssertJ. Przejdziesz do testów wycinkowych dla warstwy webowej. Użyjesz MockMvc, podmienisz serwis na @MockitoBean i sprawdzisz odpowiedzi HTTP przez wyrażenia JsonPath. Warstwę bazodanową przetestujesz przez @DataJpaTest oraz TestEntityManager, poznając rollback transakcji między testami oraz różnicę między bazą H2 a bazą produkcyjną. Napiszesz testy integracyjne całej aplikacji, wykorzystasz profil testowy, gdzie żądanie przechodzi przez wszystkie warstwy aż do bazy i z powrotem. Prawdziwą bazę uruchomisz w kontenerze przez Testcontainers i wstrzykniesz jej parametry do konfiguracji. Zewnętrzne API po HTTP zastąpisz atrapą serwera WireMock, na której zdefiniujesz odpowiedzi (stuby) i zweryfikujesz wysłane żądania, w tym scenariusze błędów, idempotencji i niepełnych odpowiedzi. Przetestujesz też przetwarzanie w tle wyzwalane przez harmonogram bez czekania na upływ czasu, wywołując logikę wprost i sprawdzając stan zapisany w bazie. Na koniec rozszerzysz zestaw o testy kontraktowe, które pilnują zgodności między stronami komunikacji, oraz o testy e2e, które sprawdzają pełny przepływ przez uruchomioną aplikację.

Ten moduł to praktyczne wejście w event-driven backend oparty na Apache Kafka. Zaczynasz od teorii, poznajesz rolę brokera, producentów i konsumentów, a także topics, partycje, offsety i consumer groups. Środowisko uruchamiasz w Dockerze przez docker-compose, przechodzisz od pojedynczego brokera do klastra wielobrokerowego. Następnie budujesz aplikację w Spring Boot z konfiguracją gotową do pracy z Apache Kafka, w której wystawiasz endpointy REST do publikacji wiadomości i uruchamiasz konsumentów odbierających dane z tematów. Obsługujesz kolejno formaty String, JSON, Bytes oraz Avro z Schema Registry, a konfigurację producentów, konsumentów i obsługi błędów porządkujesz w abstrakcjach, które eliminują powtórzenia. Uczysz się odporności operacyjnej, czyli mechanizmu retry, kierowania nieprzetworzonych wiadomości na Dead Letter Topic (DLT) i reakcji na błędy deserializacji. Poznajesz też Kafka Streams i przetwarzanie strumieniowe danych. 

W drugiej części łączysz Kafkę ze wzorcem CQRS na przykładzie biura podróży zbudowanego w architekturze heksagonalnej. Po stronie poleceń (command side) modelujesz agregaty rezerwacji, hoteli i dostępności, utrwalasz je w relacyjnej bazie danych przez JPA, kontrolujesz overbooking oraz publikujesz zdarzenia przez transakcyjny outbox z harmonogramem, tak aby zapis i publikacja pozostawały spójne. Po stronie odczytu (query side) budujesz projekcje w MongoDB przez Spring Data MongoDB, konsumujesz zdarzenia, wyliczasz reguły dostępności i udostępniasz gotowy model do szybkiego odczytu przez REST.

Ten moduł to praktyczna komunikacja asynchroniczna w ekosystemie Java na bazie RabbitMQ i Spring AMQP. Uruchomisz brokera z gotową topologią i panelem Management UI, a potem zbudujesz ją świadomie od podstaw. Napiszesz pierwszych producentów i konsumentów na trwałych kolejkach, rozłożysz obciążenie między równoległych odbiorców. Skonfigurujesz topologię, poznasz cztery typy exchange, czyli direct, topic, fanout i headers, i połączysz je z kolejkami przez bindings. Dodasz obsługę nieprawidłowych wiadomości przez DLX/DLQ, ustawisz TTL oraz priorytety, zabezpieczysz publikację przez publisher confirms i returns, a odbiór przez manual ack. Zbudujesz też wzorzec żądanie-odpowiedź RPC, wyślesz wiadomości opóźnione przez delayed message i na koniec zapiszesz zdarzenia atomowo z danymi przez transactional outbox, żeby uniknąć podwójnego zapisu do bazy i brokera.

W drugiej części zaprojektujesz i wdrożysz rozproszoną transakcję biznesową wzorcem Saga w wariancie orkiestrowanym. Zrealizujesz proces rezerwacji złożony z trzech kroków w osobnych mikroserwisach, czyli flight-service, hotel-service i payment-service, koordynowanych przez orkiestrator booking-service. Każdy serwis dostaje własną bazę w podejściu Database per Service, więc zamiast jednej transakcji rozłożysz pracę na sekwencję lokalnych transakcji, a przy odmowie któregoś kroku uruchomisz kompensacje w odwrotnej kolejności. Stan procesu poprowadzisz maszyną stanów. Kod ułożysz w architekturę heksagonalną z portami, adapterami i przypadkami użycia oraz warstwą JPA. Komunikację między serwisami poprowadzisz wyłącznie przez RabbitMQ z wymianami komend i odpowiedzi. Zdarzenia będziesz wysyłać niezawodnie przez outbox, a powtórzone dostarczenia z gwarancją at-least-once zabezpieczysz idempotencją na tabeli przetworzonych wiadomości. Klientowi udostępnisz proces w modelu initiate + poll przez REST API, gdzie startujesz sagę i odpytujesz jej stan aż do zakończenia.

Ten moduł nauczy Cię, jak wykorzystać możliwości AI w aplikacji Spring Boot, używając Spring AI. Napiszesz projekt w architekturze heksagonalnej. Zbudujesz jeden stabilny kontrakt REST API, który tłumaczy żądanie na wybranego dostawcę modelu AI. Podłączysz wielu providerów (OpenAI, Anthropic oraz dostawców zgodnych z API OpenAI). Poznasz kluczowe abstrakcje Spring AI: ChatModel, ChatClient, ChatOptions oraz dowiesz się, jak monitorować zużycie tokenów i inne parametry z odpowiedzi modelu. Przygotujesz endpoint synchroniczny i strumieniowy. Wymusisz odpowiedzi strukturalne przez structured output, a wybór typu ograniczysz allowlistą zamiast ładowania dowolnej klasy z classpathu. Streaming zrealizujesz mostkując Flux z Project Reactor na SSE (Server-Sent Events) przez SseEmitter na stacku Spring MVC. Zadbasz o bezpieczne rozłączenie klienta po skorzystaniu z modelu AI. Wykorzystasz wirtualne wątki do obsługi wielu równoległych, blokujących wywołań sieciowych. Uporządkujesz walidację żądań, mapowanie DTO, globalną obsługę błędów HTTP oraz obserwowalność przez Micrometer Observation, a na koniec spakujesz aplikację do obrazu Docker.

Ten moduł zamyka ścieżkę od artefaktu kodu i obrazu kontenera do publicznego adresu usługi HTTP. Zaczniesz od podstaw, czyli różnicy między Docker, Kubernetes i GKE (Google Kubernetes Engine). Utworzysz zarządzany klaster w chmurze Google, zrozumiesz podział na Master Node i Worker Node oraz rolę komponentów klastra, takich jak API Server, etcd, Scheduler, Controller Manager, kubelet i kube-proxy. Do pracy z klastrem użyjesz gcloud oraz kubectl. Wdrożysz aplikację Spring Boot z obrazu Dockera, najpierw poleceniami imperatywnymi, a potem deklaratywnie przez manifesty YAML. Poznasz cztery kluczowe obiekty i ich odpowiedzialności, czyli Pod, ReplicaSet, Deployment oraz Service w typach ClusterIP, NodePort i LoadBalancer. Przećwiczysz skalowanie liczby replik, aktualizacje bez przestojów w strategii RollingUpdate, rollback do wcześniejszej rewizji oraz samonaprawianie się aplikacji po usunięciu Poda. Nauczysz się porządkować zasoby za pomocą Namespace, Labels i Annotations oraz diagnozować klaster. 

W drugiej części zbudujesz przykład mikroserwisowy złożony z dwóch usług Spring Boot. Uruchomisz je lokalnie z Docker Compose, a następnie wdrożysz do klastra, gdzie do wykrywania usług posłuży wbudowany DNS Kubernetes. Na koniec skonsolidujesz publiczne wejście HTTP dla wielu usług pod jednym punktem dostępu, za pomocą obiektu Ingress z kontrolerem Nginx.