Menu Zamknij

Kurs Java

Cena kursu

  • Cena spotkania grupowego wynosi 90 zł netto za 60 minut (110,7 zł brutto za 60 minut).
  • Cena spotkania indywidualnego wynosi 140 zł netto za 60 minut (172,2 zł brutto za 60 minut).
  • Płacisz zawsze za 25 kolejnych spotkań grupowych.
  • Płacisz zawsze za jedno kolejne spotkanie indywidualne.
  • Pierwsze spotkanie grupowe gratis.
  • Istnieje możliwość wystawienia faktury VAT.

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.

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.

Materiały video

Wstecz 1 z 16 Dalej
Wstecz 1 z 16 Dalej

Newsletter

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