Pełna agenda – spis modułow

  1. Integracja i monitoring Mikroserwisów
  2. Systemy kolejkowe i skalowanie aplikacji
  3. Apache Kafka – wprowadzenie
  4. Apache Kafka – zaawansowane zagadnienia
  5. Od JDBC do Mapowania Obiektowo Relacyjnego (ORM)
  6. ORM na przykładzie JPA i Hibernate
  7. Anotacje, Spring + Hibernate oraz dobre praktyki
  8. Spring Data
  9. Czysty kod i wzorce projektowe
  10. Czysty kod, Domain Model i dobre praktyki
  11. Stabilny i testowalny kod – czytelne i solidne testy
  12. Maven

Naucz się tworzyć czysty, stabilny i testowalny kod.
Poznaj sprawdzone rozwiązania i przekonaj się jak bardzo ułatwią Ci pracę

Program szkoleniowy dla programisty Java: Spring Boot, Testowanie, Clean Code i Design Patterns, Maven, Integrowanie aplikacji (synchroniczne i asynchroniczne).

Integracje i monitoring Mikroserwisów

Lista lekcji
  1. Integrowanie mikrousług – wyzwania
  2. Sposoby integrowania systemów – synchroniczne i przez systemy kolejkowe
  3. Circuit Breaker Pattern – wzorzec bezpiecznika
  4. Retry Pattern – ponawianie operacji
  5. Load Balancing – rozkładanie ruchu
  6. Service Discovery – proces wykrywania serwisów
  7. Log Aggregation – centralizacja logów
  8. Log Aggregation – demo
  9. Log Aggregation – dobre praktyki logowania
  10. Tracing – wprowadzenie i demo
  11. Tracing – instrumentacja kodu, Brave i Spring Cloud Sleuth
  12. Tracing – przekazywanie trace context
  13. Monitoring – wprowadzenie
  14. Monitoring – modele działania systemów
  15. Monitoring – perspektywy dashboardów
  16. Monitoring – rodzaje metryk, statystyka i interpretacja
  17. Caching – pamięć podręczna
  18. Zadanie domowe

Systemy kolejkowe i skalowanie aplikacji

Lista lekcji
  1. Systemy kolejkowe
  2. Instalacja systemu kolejkowego do testów
  3. JMS
  4. Spring JMS
  5. Gwarancje odebrania wiadomości
  6. Gwarancje dostarczenia wiadomości
  7. Odrzucanie wiadomości
  8. Skalowanie aplikacji opartych o systemy kolejkowe
  9. Wysoka dostępność aplikacji – Leader Election
  10. Idempotentność operacji
  11. Zadanie domowe

Apache Kafka – wprowadzenie

Lista lekcji
  1. Wprowadzenie do systemów kolejkowych
  2. Wyzwania high availability
  3. Problem kolejności odczytu
  4. Grupy konsumentów
  5. Instalacja + konfiguracja Apache Kafka CLI
  6. Ćwiczenia teorii Apache Kafka
  7. Producent wiadomości w Java
  8. Konsument wiadomości w Java
  9. Serializacja Json
  10. Deserializacja Json
  11. Konsument w wątku
  12. Kafka Docker
  13. Aplikacja HWMonitor
  14. Zadanie domowe

Apache Kafka – zaawansowane zagadnienia

Lista lekcji
  1. Producent wiadomości – gwarancje dostarczenia producenta
  2. Producent wiadomości – potwierdzenia ACKS
  3. Producent wiadomości – typy producenta
  4. Producent wiadomości – wydajność producenta
  5. Producent wiadomości – idempotentny producent
  6. Producent wiadomości – bezpieczny producent
  7. Producent wiadomości – bezpieczny producent demo
  8. Konsument wiadomości – szybki konsument
  9. Konsument wiadomości  – strategie commitowania offsetu
  10. Konsument wiadomości – proces rebalancingu
  11. Konsument wiadomości – bezpieczny konsument
  12. Podsumowanie modułu
  13. Zadanie domowe

Od JDBC do Mapowania Obiektowo Relacyjnego (ORM)

Lista lekcji
  1. Korzystanie z relacyjnych baz danych w Java
  2. Transakcyjność w JDBC
  3. CRUD w Relacyjnej bazie danych
  4. Budowanie zapytań w JDBC
  5. Wyrażenia proste
  6. Ataki SQL Injection
  7. Statement – jako podstawowa instrukcja zapytania
  8. Kursory w wyrażeniach
  9. PreparedStatemnt – bezpieczne parametryzowanie zapytań
  10. CallableStatement – wywoływanie procedur i funkcji
  11. Mapowanie danych w JDBC
  12. Problemy i bolączki JDBC
  13. Mapowanie Obiektowo Relacyjne (ORM)
  14. MyBatis jako prosty framework ORM
  15. JdbcTemplate – proste mapowanie danych w Spring
  16. Porównanie MyBatis i JDBCTemplate
  17. Zadanie domowe

ORM na przykładzie JPA i Hibernate

Lista lekcji
  1. Standard JPA (Java Persistent API)
  2. Wstęp do Hibernate
  3. Różne sposoby konfiguracji Hibernate
  4. Wstęp do Spring Data
  5. Hibernate vs Spring Data
  6. Architektura Hibernate
  7. Entity manager, cykl życia encji – wstęp
  8. Stan transient – stworzenie niezarejestrowanego obiektu
  9. Stan detached – ręczne wyrejestrowanie obiektu
  10. Stan removed – usuwanie danych
  11. Stan managed – synchronizacja stanu obiektu z bazą danych
  12. Sesja i cache obiektów
  13. Timeouty w Hibernate
  14. Operacje nie aktualizujące cache
  15. Commit/rollback w Hibernate
  16. Create w Hibernate
  17. Read w Hibernate
  18. Update w Hibernate
  19. Delete w Hibernate
  20. Flush w Hibernate
  21. Zadanie domowe

Anotacje, Spring + Hibernate oraz dobre praktyki

Lista lekcji
  1. Anotacje – dane i atrybuty
  2. Anotacje – autogeneracja kluczy głównych
  3. Anotacje – kompozycja i dziedziczenie
  4. Anotacje – powiązania i kolekcje
  5. Anotacje, które warto znać
  6. Relacja one-to-one
  7. Relacja one-to-many
  8. Relacja many-to-one
  9. Relacja many-to-many
  10. Anotacje w Hibernate
  11. Lazy loading, Eager loading, Problem N+1 (query)
  12. Kaskada operacji, deleteOrphans
  13. BestPractice + Hints – śledzenie zapytań SQL
  14. BestPractice + Hints – o czym warto pamiętać
  15. BestPractice + Hints – unikanie niepotrzebnych operacji
  16. BestPractice + Hints – przetwarzanie wsadowe
  17. Zadanie domowe

Spring Data

Lista lekcji
  1. Moja pierwsza aplikacja Spring Data
  2. Wyszukiwanie w Spring Data
  3. Mapowanie odpowiedzi do DTO
  4. Modyfikacja danych w Spring Data
  5. Jpapository vs CrudRepository
  6. Manualne transkacje w Spring
  7. Automatyczne transakcje w Spring
  8. Wyjątki w transakcjach
  9. Rodzaje propagacji transakcji
  10. Read only
  11. Lekcja JPQL, HQL
  12. JOIN a JOIN FETCH
  13. Subquery
  14. Criteria API
  15. Anotacje org.springframework.data
  16. Zadanie domowe

Czysty kod i wzorce projektowe

Lista lekcji
  1. Po co czysty kod
  2. Znaczące nazwy
  3. Funkcje
  4. Refaktoryzacja funkcji – demo
  5. Komentarze
  6. Refaktoryzacja przykładowej aplikacji
  7. Czym jest SOLID
  8. SOLID – SRP
  9. SOLID – SRP demo
  10. SOLID – OCP
  11. SOLID – OCP demo wzorzec obserwatora
  12. SOLID – OCP demo wzorzec dekoratora
  13. SOLID – LSP
  14. SOLID – LSP demo
  15. SOLID – ISP
  16. SOLID – ISP demo
  17. SOLID – DIP
  18. Zadanie domowe

Czysty kod, Domain Model i dobre praktyki

Lista lekcji
  1. KISS YAGNI DRY
  2. Prawo Demeter
  3. Fail Fast
  4. Optional
  5. Anemic Domain Model vs Rich Domain Model
  6. Pętle i streamy
  7. Obsługa błędów
  8. Fasada modułu
  9. Pakietowanie
  10. Zespół to podstawa
  11. Formatowanie kodu
  12. Statyczne analizatory kodu
  13. Tipy & dobre praktyki
  14. Co dalej
  15. Zadanie domowe

Stabilny i testowalny kod – czytelne i solidne testy

Lista lekcji
  1. Czym jest testowanie. Strategie testowania (dwie szkoły).
  2. Piramida testów – tworzenie efetywnie działającego zestawu testów
  3. Testowanie w Junit, możliwości, czytelne testy, testy parametryzowane
  4. Mockito, mocki, spy, adnotacje, argument matcher, argument captor, czego nie mockować
  5. Zasady pisania dobrych testów
  6. Clean Code w testach, matki obiektów
  7. Reużywalne fragmentu testów: klasy steps, assert pattern
  8. Strategie testowania I/O, izolowanie i testy integracyjne
  9. Consumer-Driven Contract, testy REST
  10. Code Coverage, metryki
  11. Testy mutacyjne

Maven

Lista lekcji
  1. Przedstawienie modułu i maven
  2. Wprowadzenie
  3. Instalacja i konfiguracja
  4. Pierwsza aplikacja, Maven Coordinates, Maven Directory Layout
  5. Deklarowanie zależności, scope, wersje
  6. Wersjonowanie, SNAPSHOT, semver
  7. Stworzenie biblioteki jar
  8. Repozytoria: lokalne, remote, struktura repozytorium, konfiguracja remote
  9. Cykl życia, fazy i cele
  10. Pluginy mavenowe
  11. Aggregate pom, Parent pom, Effective pom
  12. Zarządzanie zależnościami: Dependency management, Bill of materials
  13. Budowanie złożonych paczek: fatjar, executable jar, assembly
  14. Paramery i profile, filtrowanie
  15. Deployment, distributionManagement
  16. Proces wydawania oprogramowania: release plugin
  17. Rozwiązywanie popularnych problemów
  18. Podsumowanie