Menu Zamknij

Kurs Java

Opis kursu

  • Profesjonalne przygotowanie do pracy na stanowisku programisty w wybranym języku programowania oraz powiązanymi z nim bibliotekami oraz frameworkami.
  • Nauka od podstaw po zaawansowane rozwiązania komercyjne.
  • Zoptymalizowany kod napisany zgodnie z dobrymi praktykami programistycznymi.
  • Szkolenie według planu dopasowanego do najnowszych standardów IT.
  • Nagrania ze spotkań grupowych, które możesz oglądać kiedy tylko chcesz.
  • Ogromna ilość zadań teoretycznych i praktycznych o różnym poziomie trudności.
  • Wsparcie mentora przy rozwiązywaniu problemów związanych z pytaniami teoretycznymi, zadaniami praktycznymi i projektami komercyjnymi.
  • Elastyczny kontakt z mentorem.
  • Profesjonalne przygotowanie do rozmowy kwalifikacyjnej.
  • Profesjonalnie przygotowane portfolio z rozbudowanymi projektami komercyjnymi.
  • Skuteczne techniki nauki programowania.
promocja ikona
PROMOCJA – pierwsze spotkanie GRATIS

Już teraz

zapisz się na kurs​

  • Java
Zostaw swoje namiary, a skontaktuję się z Tobą w sprawie kursu
Wycena indywidualna

    * - pola obowiązkowe

    Administratorem danych osobowych jest KM PROGRAMS KRZYSZTOF MAKOWSKI z siedzibą przy ul. Cicha 7, 42-454 Niegowonice, Polska. Dane osobowe osób korzystających z formularza kontaktowego przetwarzane są w celu identyfikacji nadawcy oraz obsługi zapytania przesłanego przez udostępniony formularz. Więcej informacji o przetwarzaniu danych osobowych, w tym o przysługujących Ci uprawnieniach, znajduje się w Polityce Prywatności.

    Plan kursu

    • Wyjaśnienie różnic pomiędzy JVM, JRE, JDK.
    • Różnica pomiędzy kompilatorem oraz interpreterem.
    • Czym jest bytecode?
    • Omówienie kolejnych kroków potrzebnych do zbudowania aplikacji Java.
    • Czym jest IDE?
    • Instalacja potrzebnych narzędzi na wybranym systemie operacyjnym.
    • Instalacja i zarządzanie pluginami IDE.
    • Piszemy pierwszą aplikację Java.
    • Przegląd wersji języka Java i omówienie różnic pomiędzy nimi.
    • Różnica pomiędzy typowaniem statycznym oraz dynamicznym.
    • Omówienie pojęcia zmiennej.
    • Typy całkowitoliczbowe.
    • Problemy związane z liczbami zmiennoprzecinkowymi.
    • Słowa kluczowe var oraz final.
    • Wykaz operacji możliwych do wykonywania na danych liczbowych.
    • Różne wersje operacji dzielenia danych liczbowych.
    • Prezentacja i formatowanie danych
    • Sposoby pozyskiwania danych.
    • Pobieranie danych od użytkownika.
    • Wyjaśnienie pojęcia pseudolosowości.
    • Losowanie liczby całkowitej z zadanego przedziału.
    • Losowanie bezpieczne wątkowo.
    • Losowanie danych zmiennoprzecinkowych.
    • Przegląd innych sposobów pozyskiwania danych do aplikacji.
    • Wyjaśnienie pojęcia warunku logicznego.
    • Omówienie sposobów sprawdzania prostych warunków.
    • Instrukcje warunkowe.
    • Operator trójargumentowy warunkowy.
    • Instrukcje warunkowe dla warunków rozłącznych.
    • Instrukcje switch oraz switch expressions.
    • Pętle while, do while oraz for.
    • Różne postaci pętli for.
    • Pętle nieskończone i te które nie wykonają się ani razu.
    • Instrukcje break oraz continue.
    • Praktyczne wykorzystanie instrukcji warunkowych oraz pętli.
    • Podział kodu aplikacji na metody.
    • Omówienie pojęcia sygnatury (nagłówka) metody.
    • Różne postaci sygnatury metody.
    • Różnica pomiędzy parametrami oraz argumentami metod.
    • Sprawdzanie poprawności argumentów metody.
    • Zwracanie przez metodę wyniku jej działania. Słowo kluczowe return.
    • Metody o zmiennej ilości argumentów.
    • Przeciążanie metod.
    • Parametry głównej metody main.
    • Budowanie struktury aplikacji opartej na metodach.
    • Praktyczne przykłady wykorzystania metod.
    • Wyjaśnienie potrzeby stosowania tablic.
    • Implementacja i zarządzanie tablicami jednowymiarowymi.
    • Implementacja i zarządzanie tablicami dwuwymiarowymi.
    • Przegląd metod klasy Arrays do zarządzania tablicami.
    • Kopiowanie płytkie oraz głębokie tablic.
    • Porównywanie elementów w tablicach.
    • Tablice nieregularne.
    • Przykłady praktycznego wykorzystania tablic.
    • Sposoby kodowania znaków.
    • Typ char do przechowania pojedynczego znaku.
    • Omówienie struktury obiektu do przechowywania ciągu znaków.
    • String Pool.
    • Prezentacja najważniejszych cech napisów.
    • Dlaczego napisy są niemodyfikowalne?
    • Przegląd metod klasy String do zarządzania napisami.
    • Porównywanie napisów.
    • Parsowanie napisów. Konwersja danych innego typu do napisu.
    • Praktyczne przykłady zastosowania napisów.
    • Zarządzanie znakami w napisie.
    • Przegląd metod klasy Character do zarządzania znakami.
    • Klasy StringBuffer oraz StringBuilder.
    • Klasa StringJoiner.
    • Teoria wyrażeń regularnych.
    • Przykłady wykorzystania wyrażeń regularnych.
    • Wykorzystanie wartości Unicode w wyrażeniach regularnych.
    • Klasy Pattern oraz Matcher.
    • Przegląd innych klas do przetwarzania napisów.
    • Stos i sterta.
    • Zasady przechowywania w pamięci typów prostych i referencyjnych.
    • Omówienie przebiegu procesu garbage collection.
    • Garbage Collection Roots.
    • Kolejne fazy mechanizmu GC: mark, sweep, compact.
    • Prezentacja obszarów pamięci zarządzanych przez GC.
    • Young Generation oraz Old Generation.
    • Klasyfikacja i opis poszczególnych rodzajów GC.
    • Przygotowanie aplikacji Java do pracy z konkretnym GC.
    • Prezentacja klasyfikacji błędów i wyjątków.
    • Wyjątki kontrolowane i niekontrolowane.
    • Słowa kluczowe throw oraz throws.
    • Propagacja wyjątków.
    • Blok try-catch.
    • Sekcja finally.
    • Obsługa wyjątków niekontrolowanych oraz kontrolowanych.
    • Ponowne rzucanie wyjątków.
    • Sposoby rejestrowania informacji o błędach i ostrzeżeniach.
    • Dobre praktyki rzucania i przechwytywania wyjątków.
    • Zapisywanie danych do pliku tekstowego w podanej lokalizacji.
    • Prezentacja różnych trybów pracy przy zapisie do plików tekstowych.
    • Odczytywanie danych różnej postaci z pliku tekstowego.
    • Omówienie sposobów prawidłowego zamykania połączenia z zasobem.
    • Wykorzystanie sekcji try do pracy z zasobami.
    • Filtrowanie i walidacja danych pobieranych z plików tekstowych.
    • Praktyczne przykłady przetwarzania plików tekstowych.
    • Przetwarzanie danych z plików innych niż tekstowe.
    • Klasa oraz obiekt.
    • Omówienie założeń hermetyzacji oraz enkapsulacji.
    • Pola składowe.
    • Specyfikatory dostępu.
    • Różne postaci konstruktorów.
    • Wywołanie jednego konstruktora z innego.
    • Metody składowe instancyjne.
    • Gettery oraz settery.
    • Słowo kluczowe this.
    • Klasy zagnieżdżone i wewnętrzne.
    • Rekordy.
    • Typy wyliczeniowe enum.
    • Klasa Object oraz klasa Objects.
    • Metody equals oraz hashCode.
    • Metoda toString.
    • Składniki statyczne.
    • Bloki inicjujące.
    • Przegląd wbudowanych klas Java – BigDecimal, BigInteger
    • Przegląd wbudowanych klas Java – data i czas.
    • Klasy lokalne oraz klasy osłonowe.
    • Dziedziczenie
    • Prezentacja składników, które można albo nie można dziedziczyć.
    • Przesłanianie metod.
    • Metody oraz klasy final.
    • Utility class.
    • Polimorfizm statyczny oraz dynamiczny.
    • Operator instanceof.
    • Kompozycja, agregacja, asocjacja.
    • Klasy abstrakcyjne.
    • Interfejsy.
    • Implementacja anonimowa klasy abstrakcyjnej oraz interfejsu.
    • Interfejsy funkcyjne.
    • Prezentacja składników możliwych do użycia w interfejsie.
    • Typy generyczne.
    • Przegląd interfejsów wbudowanych.
    • Przegląd metod domyślnych i statycznych z interfejsów wbudowanych.
    • Wyrażenia lambda.
    • Wyrażenia lambda a zasięg zmiennych.
    • Funkcje wyższych rzędów.
    • Klasy oraz interfejsy zapieczętowane.
    • Dziedziczenie wielokrotne. Problem diamentowy.
    • Inne dobre praktyki programowania obiektowego i nie tylko.
    • Klonowanie obiektów (interfejs Cloneable).
    • Rzutowanie obiektów.
    • Serializacja i deserializacja obiektów (interfejs Serializable).
    • Praktyczne przykłady wykorzystania dobrych praktyk programowania obiektowego i nie tylko.
    • Hierarchia kolekcji w Java.
    • Wzorzec projektowy Iterator.
    • Interfejsy Iterable, Spliterator, Collection.
    • Interfejs List, jego implementacje oraz metody.
    • Interfejs Set, jego implementacje oraz metody.
    • Interfejs Queue, jego implementacje oraz metody.
    • Interfejs Deque, jego implementacje oraz metody.
    • Przedstawienie różnic pomiędzy implementacjami różnych kolekcji.
    • Przegląd metod klasy Collections do zarządzania kolekcjami.
    • Prezentacja metod statycznych do tworzenia i kopiowania kolekcji.
    • Klasy abstrakcyjne ułatwiające implementację właściwości kolekcji.
    • Omówienie zasady usuwania duplikatów (hash function, hash table).
    • Interfejs Map, jego implementacje i metody.
    • Zastosowanie interfejsów funkcyjnych do pracy z metodami kolekcji.
    • Przetwarzanie danych z kolekcji i map za pomocą widoków i zakresów.
    • Mechanizm słabych referencji.
    • Klasy Properties, BitSet, EnumSet, EnumMap.
    • Praktyczne przykłady wykorzystania kolekcji i map.
    • Programowanie funkcyjne.
    • Sposoby tworzenia strumieni.
    • Przygotowanie kolekcji i map do pracy ze strumieniami.
    • Omówienie zasady działania strumieni.
    • Metody pośrednie i końcowe.
    • Przegląd wszystkich metod strumieni.
    • Zastosowanie wyrażeń lambda do pracy ze strumieniami.
    • Typ Optional i jego metody.
    • Praca z wbudowanymi kolektorami.
    • Implementacja własnych kolektorów.
    • Konwersja strumienia do dowolnej postaci wynikowej. 
    • Strumienie typów prostych.
    • Strumienie równoległe.
    • Przegląd mechanizmów Java pod kątem pracy ze strumieniami.
    • Referencje do metod.
    • Biblioteka StreamEx.
    • Praktyczne przykłady wykorzystania strumieni.
    • Klasa Class oraz metoda getClass().
    • Pozyskiwanie informacji o elementach znajdujących się w klasie.
    • Dostęp do składników prywatnych.
    • Tworzenie i kontrolowanie obiektów. Wywoływanie metod.
    • Praca z tablicami.
    • Wzorzec projektowy Proxy oraz klasa Proxy.
    • Praktyczne przykłady wykorzystania programowania obiektowego.
    • JavaBeans.
    • Klasy i metody uogólnione.
    • Ograniczenia typów.
    • Zmienność typów.
    • Symbole wieloznaczne.
    • Wymazywanie typów.
    • Metody pomostowe.
    • Prezentacja ograniczeń uogólnień.
    • Połączenie mechanizmów refleksyjności i uogólnienia.
    • Informacje o ogólnych typach w JVM.
    • Praca ze strumieniami wejściowymi oraz wyjściowymi.
    • Odczytywanie i zapisywanie bajtów.
    • Pliki o swobodnym dostępie.
    • Pliki mapowane w pamięci.
    • Zarządzanie ścieżkami, plikami, katalogami.
    • Praca z plikami w formacie ZIP.
    • Odczytywanie danych ze wskazanego URL.
    • Parsowanie i konwersja danych w formatach XML oraz JSON.
    •  Złożoność obliczeniowa algorytmu.
    • Złożoność pamięciowa algorytmu.
    • Algorytmy badające właściwości geometryczne.
    • Algorytmy badające właściwości matematyczne.
    • Konwersje pomiędzy systemami liczbowymi.
    • Badanie ciągów liczbowych.
    • Sortowanie ciągów danych. 
    • Metoda dziel i zwyciężaj. 
    • Metody numeryczne.
    • Programowanie zachłanne.
    • Algorytmy na tekstach.
    • Wybrane algorytmy kryptograficzne.
    • Rekurencja.
    • Przegląd wybranych struktur danych.
    • Klasyfikacja wzorców projektowych.
    • Implementacja wzorców kreacyjnych.
    • Implementacja wzorców strukturalnych.
    • Implementacja wzorców czynnościowych.
    • Pojęcie procesu i wątku.
    • Różne sposoby implementacji i uruchamiania wątków.
    • Przerywanie wątku.
    • Różne sposoby implementacji i uruchamiania procesu.
    • Zarządzanie wartościami zmiennych lokalnych w wątku.
    • Wątki użytkownika oraz wątki daemon.
    • Problem współdzielenia zasobów.
    • Livelock i deadlock.
    • Synchronizacja.
    • Omówienie metod wait i notify.
    • Locks.
    • Różne sposoby implementacji problemu producent – konsument.
    • Semafory.
    • Synchronizacja pracy wielu wątków przy użyciu mechanizmu latch.
    • Zadania współbieżne – Executor, interfejs ExecutorService.
    • Przechwytywanie wyników obliczeń – Callable, Future.
    • Cykliczne wykonywanie wątków – ScheduledExecutorService.
    • Wartości atomowe.
    • Kolejki blokujące.
    • Klasa ConcurrentHashMap.
    • Przegląd innych struktur danych bezpiecznych dla wątków.
    • Strategie bezpiecznego korzystania z wątków. 
    • Obliczenia asynchroniczne – klasa CompletableFuture. 
    • Synchroniczna i asynchroniczna komunikacja HTTP. 
    • Algorytmy równoległe do zarządzania strumieniami i tablicami. 
    • Framework Fork / Join. 
    • RxJava. 
    • Omówienie Flow API. 
    • Mechanizmy reaktywne do zarządzania strumieniami. 
    • Implementacja aplikacji wykorzystującej programowanie reaktywne.
    • Omówienie architektury i sposobu działania aplikacji Maven.
    • Instalacja i konfiguracja aplikacji Maven.
    • Analiza szablonów projektów Maven.
    • Tworzenie oraz zarządzanie projektem z wykorzystaniem Maven.
    • Omówienie Maven Coordinates.
    • Analiza pliku konfiguracyjnego pom.xml.
    • Cykl życia, fazy i cele projektu Maven.
    • Praca z bibliotekami zewnętrznymi – dependencies.
    • Zarządzanie parametrami scope oraz version w dependencies.
    • Optional dependencies oraz dependency exclusions. 
    • Klasyfikacja repozytoriów Maven (central, local, remote). 
    • Zarządzanie wersją projektu Maven. 
    • Implementacja aplikacji wielomodułowych w oparciu o Maven. 
    • Zarządzanie wersjami dependencies – BOM. 
    • Przegląd pluginów Maven. 
    • Praca z pluginem Flatten Maven Plugin. 
    • Wymuszanie wersji – Maven Enforcer Plugin. 
    • Zarządzanie zasobami projektu – Maven Resources Plugin.
    • Generowanie pliku wynikowego JAR – Maven Assembly Plugin. 
    • Parametry, profile oraz filtrowanie. 
    • Generowanie repozytoriów. 
    • Projekt Lombok oraz inne często używane dependencies. 
    • Implementacja kompletnej aplikacji produkcyjnej w oparciu o Maven.
    • Nauka języka Groovy na potrzeby pracy z Gradle. 
    • Instalacja i konfiguracja narzędzia Gradle. 
    • Prezentacja architektury Gradle. 
    • Interfejsy Script, Project, Gradle, Setting, Task oraz Action. 
    • Cykle życia narzędzia Gradle. 
    • Omówienie przeznaczenia skryptu init.gradle. 
    • Omówienie przeznaczenia skryptu settings.gradle. 
    • Omówienie przeznaczenia skryptu build.gradle.
    • Struktura i zasada działania aplikacji opartej o Gradle. 
    • Struktura i zasada działania aplikacji wielomodułowej opartej o Gradle. 
    • Gradle Properties. 
    • Implementowanie tasków. 
    • Task dependencies. 
    • Rozbudowa możliwości narzędzia Gradle za pomocą pluginów. 
    • Gradle Wrapper. 
    • Przegląd publicznych repozytoriów Gradle. 
    • Omówienie rodzajów dependencies i zarządzanie nimi w aplikacji Gradle.
    • Praca z zasobami statycznymi. 
    • Generowanie pliku wynikowego JAR na podstawie projektu Gradle. 
    • Generowanie repozytoriów. 
    • Implementacja kompletnej aplikacji produkcyjnej w oparciu o Gradle.
    • Konfiguracja projektu do pracy z narzędziami do testowania.
    • Omówienie pojęcia asercji. 
    • Praktyczne przykłady asercji pochodzących z frameworka JUnit. 
    • Praktyczne przykłady asercji pochodzących z frameworka Hamcrest. 
    • Praktyczne przykłady asercji pochodzących z biblioteki AssertJ. 
    • Implementacja klas rozszerzających możliwości asercji. 
    • Wprowadzenie do Test-Driven Development (TDD). 
    • Omówienie techniki TDD na praktycznym przykładzie. 
    • Wprowadzenie do Behavior-Driven Development (BDD). 
    • Omówienie techniki BDD na praktycznym przykładzie.
    • Omówienie i zarządzanie cyklem życia obiektów klasy testowej. 
    • Adnotacje i metody cyklu życia obiektów klasy testowej. 
    • Praktyczne przykłady wykorzystania argumentów metod testujących. 
    • Testowanie wyjątków. 
    • Testy powtarzalne. 
    • Testy zagnieżdżone. 
    • Testy parametryzowane. 
    • Testy dynamiczne. 
    • Testy równoległe.
    •  Testy integracyjne. 
    • Przygotowanie danych dla testów – praca z zasobami zewnętrznymi. 
    • Zastosowanie interfejsów w pracy z testami. 
    • Mechanizm rozszerzeń frameworka JUnit. 
    • Omówienie pojęcia mock object. 
    • Adnotacje stosowane przy pracy z mock objects. 
    • Omówienie i praktyczne przykłady techniki Given When Then. 
    • Przykłady definiowania różnych zachowań mockowanych metod. 
    • Przechwytywanie i zarządzanie argumentami mockowanych metod.
    •  Weryfikacja działania mockowanych obiektów. 
    • Weryfikacja ilości i rezultatów wywołań mockowanych metod. 
    • Wymuszanie sekwencji konkretnych wywołań mockowanych metod. 
    • Konfiguracja i praktyczne przykłady wykorzystania partial mocks. 
    • Konfiguracja i praktyczne przykłady wykorzystania spy objects. 
    • Wstrzykiwanie mock objects do klas testowych. 
    • Mechanizmy frameworka Mockito do pracy z techniką BDD. 
    • Wykaz dobrych praktyk implementowania testów jednostkowych. 
    • Pokrycie testów. 
    • Generowanie raportów z wynikami testów.
    • Omówienie architektury frameworka Spring.
    • Przegląd wersji frameworka Spring.
    • Wzorzec projektowy Dependency Injection – przypomnienie.
    • Wzorzec projektowy Inversion of Control – przypomnienie.
    • Omówienie i praktyczny przykład zasady działania kontenera Spring.
    • Omówienie i praktyczny przykład działania kontekstu aplikacji Spring.
    • Omówienie cyklu życia komponentu Spring.
    • Przykłady wykorzystania metod cyklu życia komponentu Spring.
    • Konfiguracja aplikacji na potrzeby pracy z frameworkiem Spring.
    • Przegląd adnotacji frameworka Spring. 
    • Automatyczne wiązanie komponentów Spring. 
    • Manualne wiązanie komponentów Spring. 
    • Przygotowanie konfiguracji Java do pracy z komponentami Spring. 
    • Łączenie kilku konfiguracji. 
    • Problem niejednoznaczności podczas wstrzykiwania komponentów. 
    • Zasięg komponentów Spring. 
    • Spring Expression Language (SpEL).
    • Pobieranie danych konfiguracyjnych z plików konfiguracyjnych.
    • Sposoby wstrzykiwania danych konfiguracyjnych do komponentów. 
    • Programowanie aspektowe z wykorzystaniem frameworka Spring.
    • Praktyczne przykłady wykorzystania programowania aspektowego.
    • Zarządzanie profilami aplikacji.
    • Omówienie architektury platformy Docker.
    • Zasada działania obrazu oraz kontenera.
    • Różnica pomiędzy kontenerem Docker oraz maszyną wirtualną.
    • Instalacja platformy Docker.
    • Praca z Docker CLI. 
    • Tworzenie i zarządzanie obrazami Docker. 
    • Image Layers. 
    • Praca z repozytoriami Docker Hub. 
    • Osadzenie przygotowanego obrazu w repozytorium Docker Hub.
    • Tworzenie i zarządzanie kontenerami Docker. 
    • Omówienie cyklu życia kontenera Docker. 
    • Instrukcje do zarządzania cyklem życia kontenera Docker. 
    • Kopiowanie plików z maszyny lokalnej do kontenera. 
    • Kopiowanie plików z kontenera do maszyny lokalnej. 
    • Klasyfikacja rodzajów danych przechowywanych w kontenerach. 
    • Tworzenie i zarządzanie volumes w platformie Docker. 
    • Różnica pomiędzy anonymous volumes oraz named volumes. 
    • Tworzenie i zarządzanie bind mounts w platformie Docker. 
    • Omówienie różnic pomiędzy volumes oraz bind mounts.
    • Tworzenie volumes tylko do odczytu. 
    • Uruchamianie przykładowych kontenerów z wykorzystaniem Docker. 
    • Omówienie struktury pliku konfiguracyjnego Dockerfile. 
    • Praca z argumentami oraz zmiennymi środowiskowymi. 
    • Komunikacja kontenera z zewnętrznym REST API. 
    • Komunikacja kontenera z aplikacjami uruchomionymi w localhost. 
    • Komunikacja container to container z użyciem networks w platformie Docker. 
    • Przegląd sterowników do konfiguracji zachowania networks. 
    • Omówienie zasady działania narzędzia Docker Compose.
    • Instalacja narzędzia Docker Compose.
    • Struktura pliku konfiguracyjnego narzędzia Docker Compose.
    • Przygotowanie kontenera bazy danych.
    • Konfiguracja kontenerów do pracy z wieloma bazami danych.
    • Przykład tworzenia utility containers.
    • Zagadnienia uzupełniające
    • Omówienie architektury aplikacji bazodanowej. 
    • Instalacja środowiska bazodanowego. 
    • Przygotowanie aplikacji do wdrożenia komunikacji bazodanowej. 
    • Język SQL – tworzenie i zarządzanie tabelami. 
    • Język SQL – klucz główny, klucze obce, composite keys. 
    • Język SQL – CRUD. 
    • Język SQL – relacje (many-to-one, one-to-one, many-to-many). 
    • Język SQL – pobieranie danych z tabel w relacjach (joins). 
    • Język SQL – grupowanie i agregacja. 
    • Język SQL – optymalizacja struktury tabel.
    • Język SQL – optymalizacja zapytań. 
    • Język SQL – subqueries. 
    • Język SQL – indeksy. 
    • Język SQL – praktyczne przykłady zarządzania danymi w tabelach. 
    • Omówienie zasady działania biblioteki JDBC. 
    • Wskazanie zalet i wad bezpośredniego wykorzystania JDBC. 
    • Przegląd bibliotek zewnętrznych do komunikacji bazodanowej. 
    • Wprowadzenie do biblioteki JDBI. 
    • Przygotowanie aplikacji do pracy z biblioteką JDBI.
    •  Połączenie aplikacji z bazą danych z wykorzystaniem JDBI. 
    • Tworzenie tabel w bazie danych z wykorzystaniem JDBI. 
    • Implementacja operacji CRUD z wykorzystaniem JDBI. 
    • Parametryzacja zapytań z wykorzystaniem JDBI. 
    • Praca z mapperami pobranych danych z wykorzystaniem JDBI. 
    • Optymalizacja wstawiania dużej ilości danych do bazy danych. 
    • Transakcje z wykorzystaniem JDBI. 
    • Implementacja uogólnionej warstwy zarządzania danymi z bazy danych. 
    • Przygotowanie kompletnej aplikacji bazodanowej z użyciem JDBI.
    • Omówienie zasady działania podejścia Object-Relational Mapping (ORM).
    • Wyjaśnienie różnicy pomiędzy JPA oraz Hibernate.
    • Analiza architektury ORM na przykładzie JPA / Hibernate. 
    • Przygotowanie aplikacji do pracy z JPA / Hibernate. 
    • Połączenie aplikacji z bazą danych z wykorzystaniem JPA / Hibernate. 
    • Tworzenie modelu tabel z wykorzystaniem klas mapujących. 
    • Analiza strategii generowania kluczy głównych. 
    • Implementacja sesji oraz transakcji z wykorzystaniem JPA / Hibernate. 
    • Omówienie cyklu życia obiektu JPA / Hibernate.
    • Implementacja kodu zarządzającego sesją oraz transakcją. 
    • Implementacja operacji CRUD z wykorzystaniem JDBI. 
    • Implementacja relacji bazodanowych z wykorzystaniem JPA / Hibernate. 
    • Mapowanie kolekcji w JPA / Hibernate. 
    • Dziedziczenie i kompozycja w JPA / Hibernate. 
    • Omówienie języka JPQL. 
    • Praktyczne przykłady wykorzystania języka JPQL. 
    • Wykorzystanie zapytań języka SQL w pracy z JPA / Hibernate.
    • Sposoby optymalizacji komunikacji bazodanowej.
    • Optimistic locking oraz pessimistic locking. 
    • Mechanizmy cache z wykorzystaniem JPA / Hibernate.
    • Implementacja generycznego repozytorium z użyciem JPA / Hibernate.
    • Kompletna aplikacja bazodanowa z użyciem JPA / Hibernate.
    • Dobre praktyki porównywania obiektów JPA / Hibernate
    • Wykorzystanie Docker-a do konteneryzacji serwera bazy danych.
    • Konfiguracja połączenia z bazą danych na potrzeby testowania aplikacji.
    • Omówienie architektury aplikacji webowej.
    • Omówienie właściwości protokołu HTTP.
    • Usystematyzowanie informacji na temat formatu danych JSON.
    • Prezentacja właściwości REST.
    • Analiza właściwości aplikacji RESTful.
    • Konfiguracja i uruchomienie serwera aplikacji webowej.
    • Konfiguracja routingu aplikacji webowej.
    • Zarządzanie obiektem reprezentującym żądanie HTTP.
    • Zarządzanie obiektem reprezentującym odpowiedź na żądanie HTTP.
    • Przechwytywanie parametrów żądania HTTP.
    • Zarządzanie cookies.
    • Przetwarzanie danych związanych z sesją.
    • Filtry aplikacji webowej.
    • Przekierowania.
    • Przechwytywanie i obsługa błędów aplikacji webowej.
    • Optymalizacja parametrów konfiguracji aplikacji webowej.
    • Implementowanie warstwy security dla aplikacji webowej.
    • Implementacja kompletnej aplikacji webowej z warstwą bazodnową.
    • Konteneryzacja aplikacji webowej z wykorzystaniem Docker.
    • Omówienie architektury GIT.
    • Konfiguracja i personalizacja ustawień GIT.
    • Klasyfikacja repozytoriów GIT.
    • Tworzenie repozytorium lokalnego.
    • Klasyfikacja obszarów do zarządzania plikami w repozytorium.
    • Zarządzanie plikami w ramach obszarów repozytorium.
    • Przegląd wszystkich operacji GIT.
    • Aplikacje i wtyczki do pracy z GIT.
    • Praca ze zdalnym repozytorium GIT.
    • Dobre praktyki tworzenia repozytoriów GIT.
    • Sposoby porządkowania struktury repozytorium.
    • GitHub Pages.
    • Omówienie architektury wielowarstwowej.
    • Omówienie wzorca Domain-Driven Design (DDD).
    • Omówienie architektury heksagonalnej.
    • Zarządzanie zasobami w formacie JSON.
    • Komunikacja z zewnętrznym REST API.
    • Wysyłanie wiadomości email.
    • Generowanie szablonów stron HTML.
    • Konwersja do plików PDF.
    • Parsowanie i konwersja do danych w formacie XML.
    • Praca z parametrami wiersza poleceń.
    • Generowanie dokumentacji. 
    • Rejestrowanie danych z wykorzystaniem loggerów.
    • Debugowanie kodu aplikacji. 
    • Modułowość Java.
    • Implementacja kompletnych aplikacji komercyjnych.
    • Przygotowanie portfolio kursanta na potrzeby rozmowy kwalifikacyjnej.
    Pobierz plan kursu

    Materiały video

    Newsletter

    Zobacz również moje inne kursy

    Zapisz się na KURS i zyskaj - licencja JetBrains na 6 miesięcy za darmo!

    Wybierz swój KURS