master spring and spring boot

Master Spring und Spring Boot

Spring und Spring Boot Frameworks sind die Frameworks Nr. 1 für die Erstellung von Unternehmensanwendungen in der Java-Welt.

In diesem Kurs lernen Sie Spring und Spring Boot von ZERO .

Ich bin fest davon überzeugt, dass der beste Weg zum Lernen darin besteht, etwas zu tun, und wir haben diesen Kurs so konzipiert, dass er praxisorientiert ist.

Sie erstellen eine Webanwendung, eine REST-API und eine Full-Stack-Anwendung mit Spring, Spring Boot, JPA, Hibernate, React, Spring Security, Maven und Gradle.

Sie lernen, Anwendungen mit Docker zu containerisieren. Sie erfahren, wie Sie diese Anwendungen in AWS bereitstellen.

Am Ende des Kurses wissen Sie alles, was Sie brauchen, um ein großartiger Spring- und Spring Boot-Entwickler zu werden.

Tools installieren

Unsere Empfehlungen

• Verwenden Sie die neueste Java-Version
• Verwenden Sie die neueste Version von „Eclipse IDE for Enterprise Java Developers“.
• Denken Sie daran: Spring Boot 3+ funktioniert nur mit Java 17+

Java installieren

• Windows – https://www.youtube.com/watch?v=I0SBRWVS0ok
• Linux – https://www.youtube.com/watch?v=mHvFpyHK97A
• Mac – https://www.youtube.com/watch?v=U3kTdMPlgsY

Fehlerbehebung

• Fehlerbehebung bei der Java-Installation – https://www.youtube.com/watch?v=UI_PabQ1YB0

Eclipse installieren

• Windows – https://www.youtube.com/watch?v=toY06tsME-M
• Andere – https://www.youtube.com/watch?v=XveQ9Gq41UM

Fehlerbehebung

• Java in Eclipse konfigurieren – https://www.youtube.com/watch?v=8i0r_fcE3L0

Vorträge

Erste Schritte – Beherrschen Sie Spring Framework und Spring Boot

• Erste Schritte – Beherrschen Sie Spring Framework und Spring Boot

Erste Schritte mit Java Spring Framework

• Schritt 01 – Verstehen der Notwendigkeit des Java Spring Framework
• Schritt 02 – Erste Schritte mit Java Spring Framework
• Schritt 03 – Erstellen eines neuen Spring Framework-Projekts mit Maven und Java
• Schritt 04 – Erste Schritte mit der Java-Gaming-Anwendung
• Schritt 05 – Lose Kopplung und feste Kopplung verstehen
• Schritt 06 – Einführung in die Java-Schnittstelle, um die App lose zu koppeln
• Schritt 07 – Einbinden des Spring Frameworks, um Java-Apps lose zu koppeln
• Schritt 08 – Ihr erstes Java Spring Bean und Starten der Java Spring-Konfiguration
• Schritt 09 – Erstellen weiterer Java Spring Beans in der Spring Java-Konfigurationsdatei
• Schritt 10 – Implementieren der automatischen Verkabelung in der Java-Konfigurationsdatei von Spring Framework
• Schritt 11 – Fragen zum Spring Framework – Was werden wir lernen?
• Schritt 12 – Spring IOC-Container verstehen – Anwendungskontext und Bean Factory
• Schritt 13 – Erkundung von Java Bean vs. POJO vs. Spring Bean
• Schritt 14 – Erkundung der automatischen Verkabelung von Spring Framework Beans – Primär- und Qualifikationsanmerkungen
• Schritt 15 – Verwenden von Spring Framework zum Verwalten von Beans für die Java Gaming App
• Schritt 16 – Weitere Fragen zum Java Spring Framework – Was werden wir lernen?
• Schritt 17 – Spring Framework mit Java erkunden – Abschnitt 1 – Überprüfung

Verwenden Sie Spring Framework zum Erstellen und Verwalten Ihrer Java-Objekte

• Schritt 01 – Spring Framework zum Erstellen und Verwalten Ihrer Java-Objekte erhalten
• Schritt 02 – Erkunden von Primär- und Qualifikationsanmerkungen für Federkomponenten
• Schritt 03 – Primär und Qualifier – Welche Spring-Annotation sollten Sie verwenden?
• Schritt 04 – Erkundung des Spring Framework – verschiedene Arten der Abhängigkeitsinjektion
• Schritt 05 – Java Spring Framework – Wichtige Terminologie verstehen
• Schritt 06 – Java Spring Framework – Vergleich von @Component und @Bean
• Schritt 07 – Warum gibt es Abhängigkeiten in Java Spring-Anwendungen?
• Schritt 08 – Übung/Lösung für ein reales Java Spring Framework-Beispiel
• Schritt 09 – Erkunden des Spring Framework mit Java – Abschnitt 2 – Rückblick

Erkunden der erweiterten Funktionen von Spring Framework

• Schritt 01 – Erkundung der verzögerten und eifrigen Initialisierung von Spring Framework Beans
• Schritt 02 – Vergleich der verzögerten Initialisierung mit der eifrigen Initialisierung
• Schritt 03 – Erkundung der Java Spring Framework Bean Scopes – Prototyp und Singleton
• Schritt 04 – Vergleich von Prototyp und Singleton – Bean Scopes des Spring Framework
• Schritt 05 – Spring Beans erkunden – PostConstruct und PreDestroy
• Schritt 06 – Entwicklung von Jakarta EE – Vergleich mit J2EE und Java EE
• Schritt 07 – Erkunden von Jakarta CDI mit Spring Framework und Java
• Schritt 08 – Erkundung der Java Spring XML-Konfiguration
• Schritt 09 – Erkunden von Java-Annotationen im Vergleich zur XML-Konfiguration für Java Spring Framework
• Schritt 10 – Erkunden von Spring Framework-Stereotypenanmerkungen – Komponente und mehr
• Schritt 11 – Kurzübersicht – Wichtige Anmerkungen zum Spring Framework
• Schritt 12 – Kurzübersicht – Wichtige Spring Framework-Konzepte
• Schritt 13 – Erkundung des Spring Big Picture – Framework, Module und Projekte

Erste Schritte mit Spring Boot

• Schritt 01 – Erste Schritte mit Spring Boot – Ziele
• Schritt 02 – Die Welt vor Spring Boot verstehen – 10.000 Fuß Übersicht
• Schritt 03 – Einrichten eines neuen Spring Boot-Projekts mit Spring Initializr
• Schritt 04 – Erstellen Sie eine Hello World-API mit Spring Boot
• Schritt 05 – Das Ziel von Spring Boot verstehen
• Schritt 06 – Spring Boot Magic verstehen – Spring Boot Starter-Projekte
• Schritt 07 – Spring Boot Magic verstehen – Automatische Konfiguration
• Schritt 08 – Schneller erstellen mit Spring Boot DevTools
• Schritt 09 – Bereiten Sie die Produktion mit Spring Boot vor – 1 – Profile
• Schritt 10 – Bereiten Sie die Produktion mit Spring Boot vor – 2 – ConfigurationProperties
• Schritt 11 – Bereiten Sie die Produktion mit Spring Boot vor – 3 – Eingebettete Server
• Schritt 12 – Bereiten Sie die Produktion mit dem Spring Boot – 4 – Aktuator vor
• Schritt 13 – Spring Boot vs. Spring vs. Spring MVC verstehen
• Schritt 14 – Erste Schritte mit Spring Boot – Überprüfung

Erste Schritte mit JPA und Hibernate mit Spring und Spring Boot

• Schritt 01 – Erste Schritte mit JPA und Hibernate – Ziele
• Schritt 02 – Einrichten eines neuen Spring Boot-Projekts für JPA und Hibernate
• Schritt 03 – H2-Konsole starten und Kurstabelle in H2 erstellen
• Schritt 04 – Erste Schritte mit Spring JDBC
• Schritt 05 – Einfügen fest codierter Daten mit Spring JDBC
• Schritt 06 – Einfügen und Löschen von Daten mit Spring JDBC
• Schritt 07 – Abfragen von Daten mit Spring JDBC
• Schritt 08 – Erste Schritte mit JPA und EntityManager
• Schritt 09 – Entdecken Sie die Magie von JPA
• Schritt 10 – Erste Schritte mit Spring Data JPA
• Schritt 11 – Erkundung der Funktionen von Spring Data JPA
• Schritt 12 – Den Unterschied zwischen Hibernate und JPA verstehen

Erstellen Sie eine Java-Webanwendung mit Spring Framework, Spring Boot und Hibernate

• Schritt 00 – Einführung in die Erstellung einer Web-App mit Spring Boot
• Schritt 01 – Erstellen einer Spring Boot-Webanwendung mit Spring Initializr
• Schritt 02 – Kurzer Überblick über das Spring Boot-Projekt
• Schritt 03 – Erster Spring MVC Controller, @ResponseBody, @Controller
• Schritt 04 – 01 – Erweitern des Spring MVC Controllers zur Bereitstellung einer HTML-Antwort
• Schritt 04 – 02 – Schritt-für-Schritt-Anleitung zum Codieren und Debuggen
• Schritt 05 – Umleitung zu einer JSP mit Spring Boot – Controller, @ResponseBody und View Resolver
• Schritt 06 – Übung – LoginController und Login-Ansicht erstellen
• Schritt 07 – Kurzübersicht – Wie funktioniert das Web – Anfrage und Antwort
• Schritt 08 – Erfassen von QueryParams mit RequestParam und First Look at Model
• Schritt 09 – Kurzer Überblick – Bedeutung der Protokollierung mit Spring Boot
• Schritt 10 – DispatcherServlet, Modell 1, Modell 2 und Front Controller verstehen
• Schritt 11 – Erstellen eines Anmeldeformulars
• Schritt 12 – Anmeldeinformationen in einer JSP mithilfe von Model anzeigen
• Schritt 13 – Fügen Sie eine fest codierte Validierung von Benutzer-ID und Passwort hinzu
• Schritt 14 – Erste Schritte mit Todo-Funktionen – Erstellen von Todo und TodoService
• Schritt 15 – Erstellen der ersten Version der List-Todos-Seite
• Schritt 16 – Sitzung vs. Modell vs. Anfrage verstehen – @SessionAttributes
• Schritt 17 – JSTL zum Spring Boot-Projekt hinzufügen und Todos in einer Tabelle anzeigen
• Schritt 18 – Hinzufügen des Bootstrap-CSS-Frameworks zum Spring Boot-Projekt mithilfe von Webjars
• Schritt 19 – Formatieren von JSP-Seiten mit dem Bootstrap-CSS-Framework
• Schritt 20 – Fügen wir ein neues Todo hinzu – erstellen Sie eine neue Ansicht
• Schritt 21 – TodoService erweitern, um die Todo hinzuzufügen
• Schritt 22 – Validierungen mithilfe der Spring Boot Starter-Validierung hinzufügen
• Schritt 23 – Verwenden von Command Beans zum Implementieren neuer Todo-Seitenvalidierungen
• Schritt 24 – Implementieren der Funktion zum Löschen von Aufgaben – Neue Ansicht
• Schritt 25 – Update Todo implementieren – 1 – Update Todo-Seite anzeigen
• Schritt 26 – Update Todo implementieren – 1 – Änderungen an Todo speichern
• Schritt 27 – Zieldatumsfeld zur Todo-Seite hinzufügen
• Schritt 28 – Hinzufügen einer Navigationsleiste und Implementieren von JSP-Fragmenten
• Schritt 29 – Vorbereitung auf Spring Security
• Schritt 30 – Einrichten von Spring Security mit Spring Boot Starter Security
• Schritt 31 – Konfigurieren von Spring Security mit benutzerdefiniertem Benutzer- und Passwort-Encoder
• Schritt 32 – Refactoring und Entfernen der Hardcodierung der Benutzer-ID
• Schritt 33 – Einrichten eines neuen Benutzers für die Todo-Anwendung
• Schritt 34 – Spring Boot Starter Data JPA hinzufügen und H2-Datenbank vorbereiten
• Schritt 35 – 01 – Konfigurieren von Spring Security, damit die H2-Konsole funktioniert
• Schritt 36 – Todo zu einer Entität machen und Todo-Bevölkerungsdaten in H2 umwandeln
• Schritt 37 – TodoRepository erstellen und Listen-Todos-Seite aus der H2-Datenbank verbinden
• Schritt 38 – 01 – Alle Todo-App-Funktionen mit der H2-Datenbank verbinden
• Schritt 38 – 02 – Erkunden der Magie von Spring Boot Starter JPA und JpaRepository
• Schritt 39 – OPTIONAL – Überblick über die Verbindung der Todo-App mit der MySQL-Datenbank
• Schritt 40 – OPTIONAL – Docker installieren
• Schritt 41 – OPTIONAL – Todo-App mit der MySQL-Datenbank verbinden

Erstellen einer Java REST API mit Spring Boot, Spring Framework und Hibernate

• Schritt 00 – Erstellen einer REST-API mit Spring Boot – Ein Überblick
• Schritt 01 – Initialisieren eines REST-API-Projekts mit Spring Boot
• Schritt 02 – Erstellen einer Hello World REST API mit Spring Boot
• Schritt 03 – Erweitern der Hello World REST API, um eine Bean zurückzugeben
• Schritt 04 – Was passiert im Hintergrund? Spring Boot Starter und Autokonfiguration
• Schritt 05 – Erweitern der Hello World REST API mit einer Pfadvariablen
• Schritt 06 – Entwerfen der REST-API für Social-Media-Anwendungen
• Schritt 07 – User Bean und UserDaoService erstellen
• Schritt 08 – Implementieren von GET-Methoden für Benutzerressourcen
• Schritt 09 – Implementierung der POST-Methode zum Erstellen einer Benutzerressource
• Schritt 10 – Verbesserung der POST-Methode, um den korrekten HTTP-Statuscode und den korrekten Standort-URI zurückzugeben
• Schritt 11 – Implementierung der Ausnahmebehandlung – 404-Ressource nicht gefunden
• Schritt 12 – Implementierung einer generischen Ausnahmebehandlung für alle Ressourcen
• Schritt 13 – Implementieren der DELETE-Methode zum Löschen einer Benutzerressource
• Schritt 14 – Validierungen für die REST-API implementieren
• Schritt 15 – Übersicht über erweiterte REST-API-Funktionen
• Schritt 16 – Offene API-Spezifikation und Swagger verstehen
• Schritt 17 – Konfigurieren der automatischen Generierung der Swagger-Dokumentation
• Schritt 18 – Erkundung der Inhaltsverhandlung – Implementierung der Unterstützung für XML
• Schritt 19 – Erkundung der Internationalisierung für die REST-API
• Schritt 20 – Versionierung REST API – URI-Versionierung
• Schritt 21 – Versionierung der REST-API – Anforderungsparameter, Header und Inhaltsverhandlung
• Schritt 22 – Implementierung von HATEOAS für die REST-API
• Schritt 23 – Implementieren der statischen Filterung für die REST-API
• Schritt 24 – Dynamische Filterung für die REST-API implementieren
• Schritt 25 – APIs mit Spring Boot Actuator überwachen
• Schritt 26 – Erkunden von APIs mit Spring Boot HAL Explorer
• Schritt 27 – REST-API mit H2 mithilfe von JPA und Hibernate verbinden – eine Übersicht
• Schritt 28 – Benutzerentität und einige Testdaten erstellen
• Schritt 29 – Erweitern der REST-API für die Verbindung mit H2 mithilfe von JPA und Hibernate
• Schritt 30 – Erstellen einer Post-Entität mit einer Viele-zu-Eins-Beziehung zur Benutzerentität
• Schritt 31 – Implementierung einer GET-API zum Abrufen aller Beiträge eines Benutzers
• Schritt 32 – Implementieren einer POST-API zum Erstellen eines Beitrags für einen Benutzer
• Schritt 33 – Erkunden von JPA- und Hibernate-Abfragen für die REST-API
• Schritt 34 – REST-API mit MySQL-Datenbank verbinden – eine Übersicht
• Schritt 34z – OPTIONAL – Docker installieren
• Schritt 35 – OPTIONAL – REST-API mit MySQL-Datenbank verbinden – Implementierung
• Schritt 36 – Implementierung der Basisauthentifizierung mit Spring Security
• Schritt 37 – Verbesserung der Spring-Sicherheitskonfiguration für die Basisauthentifizierung

Erstellen einer Java Full Stack-Anwendung mit Spring Boot und React

• Schritt 01 – Erste Schritte – Full Stack Spring Boot und React-Anwendung
• Schritt 02 – Erkunden, was und warum Full-Stack-Architekturen sind
• Schritt 03 – JavaScript- und EcmaScript-Verlauf verstehen
• Schritt 04 – Visual Studio-Code installieren
• Schritt 05 – Installation von NodeJS und NPM
• Schritt 06 – Erstellen einer React-App mit Create React App
• Schritt 07 – Erkunden wichtiger NodeJS-Befehle – Erstellen Sie eine React-App
• Schritt 08 – Visual Studio-Code erkunden und React-App erstellen
• Schritt 09 – Erkunden der Ordnerstruktur „React App erstellen“.
• Schritt 10 – Erste Schritte mit React Components
• Schritt 11 – Erstellen Ihrer ersten Reaktionskomponente und mehr
• Schritt 12 – Erste Schritte mit State in React – useState-Hook
• Schritt 13 – JSX erkunden – Ansichten reagieren
• Schritt 14 – Befolgen der JavaScript-Best Practices – Refactoring in Module
• Schritt 15 – JavaScript weiter erkunden

Erkunden von Reaktionskomponenten anhand eines Gegenbeispiels

• Schritt 01 – Erkunden von Reaktionskomponenten anhand eines Gegenbeispiels
• Schritt 02 – Erste Schritte mit der React-Anwendung – Zähler
• Schritt 03 – Erste Schritte mit der React-Anwendung – Zähler – 2
• Schritt 04 – Erkunden des Reaktionsstatus mit dem useState-Hook – Hinzufügen des Status zum Zähler
• Schritt 05 – Erkundung des Reaktionszustands – Was passiert im Hintergrund?
• Schritt 06 – React Props erkunden – Zählerinkrementwert festlegen
• Schritt 07 – Erstellen mehrerer Zählerschaltflächen
• Schritt 08 – React State nach oben verschieben – Counter und Counter Button einrichten
• Schritt 09 – React State nach oben verschieben – Methoden der übergeordneten Komponente aufrufen
• Schritt 10 – Erkunden der React Developer Tools
• Schritt 11 – Reset-Taste zum Zähler hinzufügen
• Schritt 12 – Refactoring der React Counter-Komponente

Erstellen einer Java Todo Full Stack-Anwendung mit Spring Boot und React

• Schritt 01 – Erste Schritte mit der React Todo Management App
• Schritt 02 – Erste Schritte mit der Anmeldekomponente – Todo React App
• Schritt 03 – Anmeldekomponente weiter verbessern – Todo React App
• Schritt 04 – Hinzufügen einer hartcodierten Authentifizierung – Todo React App
• Schritt 05 – Bedingte Anzeige von Nachrichten in der Anmeldekomponente – Todo React App
• Schritt 06 – Hinzufügen von React Router Dom und Routing von der Anmeldung zur Willkommenskomponente
• Schritt 07 – Hinzufügen einer Fehlerkomponente zu unserer React-App
• Schritt 08 – Hartcodierung aus der Willkommenskomponente entfernen
• Schritt 09 – Erste Schritte mit der React List Todo-Komponente
• Schritt 10 – Anzeigen weiterer Todo-Details in der React List Todo-Komponente
• Schritt 11 – Erstellen von React-Header-, Footer- und Logout-Komponenten
• Schritt 12 – Bootstrap zur React-Front-End-Anwendung hinzufügen
• Schritt 13 – Verwenden von Bootstrap zum Stylen der Todo React-Frontend-Anwendung
• Schritt 14 – Refactoring von React-Komponenten in einzelne JavaScript-Module
• Schritt 15 – Teilen des Reaktionsstatus mit mehreren Komponenten über den Authentifizierungskontext
• Schritt 16 – Aktualisieren des Reaktionsstatus und Überprüfen von Aktualisierungen über den Authentifizierungskontext
• Schritt 17 – isAuthenticated in „React State – Auth Context“ setzen
• Schritt 18 – Sichere Reaktionsrouten mit authentifizierter Route schützen – 1
• Schritt 19 – Sichere Reaktionsrouten mit authentifizierter Route schützen – 2

Verbinden der Spring Boot REST API mit React Frontend – Java Full Stack Application

• Schritt 01 – Festlegen des Todo REST API-Projekts für die React Full Stack-Anwendung
• Schritt 02 – Aufrufen der Spring Boot Hello World REST-API über die React Hello World-Komponente
• Schritt 03 – Aktivieren von CORS-Anfragen für die Spring Boot REST API
• Schritt 04 – Aufrufen der Spring Boot Hello World Bean und Path Param REST API von React
• Schritt 05 – Refactoring des Spring Boot REST API-Aufrufcodes in ein neues Modul
• Schritt 06 – Befolgen der Best Practices von Axios in der Spring Boot REST API
• Schritt 07 – Erstellen der Retrieve Todos Spring Boot REST API Get-Methode
• Schritt 08 – Anzeigen von Todos aus der Spring Boot REST API in der React App
• Schritt 09 – Erstellen der Spring Boot REST-API-Methoden „Retrieve Todo“ und „Delete Todo“.
• Schritt 10 – Löschfunktion zum React Frontend hinzufügen
• Schritt 11 – Benutzernamen in React Auth-Kontext festlegen
• Schritt 12 – Todo React-Komponente erstellen, um die Todo-Seite anzuzeigen
• Schritt 13 – Hinzufügen von Formik- und Moment-Bibliotheken zur Anzeige der Todo React-Komponente
• Schritt 14 – Hinzufügen einer Validierung zur Todo React-Komponente mithilfe von Formik
• Schritt 15 – Hinzufügen der Update Todo- und Create Todo-REST-API zur Spring Boot-Backend-API
• Schritt 16 – Update-Funktion zum React Frontend hinzufügen
• Schritt 17 – Hinzufügen der Funktion „Neues Todo erstellen“ zum React Frontend
• Schritt 18 – Sichern der Spring Boot REST API mit Spring Security
• Schritt 19 – Hinzufügen eines Autorisierungsheaders in React to Spring Boot REST API-Aufrufen
• Schritt 20 – Konfigurieren von Spring Security, um alle Optionsanfragen zuzulassen
• Schritt 21 – Aufrufen des Basisauthentifizierungsdienstes beim Anmelden bei der React App
• Schritt 22 – Verwenden von „async“ und „await“, um die Basic Auth API aufzurufen
• Schritt 23 – Einrichten des Basis-Authentifizierungstokens in den Authentifizierungskontext
• Schritt 24 – Einrichten von Axios Interceptor zum Hinzufügen des Autorisierungsheaders
• Schritt 24A – Debuggen von Problemen mit Basic Auth und Spring Boot
• Schritt 25 – Erste Schritte mit JWT und Spring Security
• Schritt 26 – Integration der Spring Security JWT REST API mit React Frontend
• Schritt 27 – Debuggen von Problemen mit JWT Auth und Spring Boot

Java Full Stack-Anwendung (Spring Boot und React) mit JPA und Hibernate verbinden

• Schritt 01 – Full Stack React und Spring Boot mit JPA und Hibernate
• Schritt 02 – Full Stack React & Spring Boot mit JPA & Hibernate – Tabellen vorbereiten
• Schritt 03 – Full Stack React & Spring Boot mit JPA & Hibernate – Todo CRUD-Operationen
• Schritt 04 – Full Stack React & Spring Boot mit JPA & Hibernate – Neues Todo hinzufügen
• Schritt 05 – Full Stack React & Spring Boot mit JPA & Hibernate – Verbindung mit MySQL

Erkunden Sie Unit-Tests mit JUnit

• Schritt 01 – Was ist JUnit und Unit Testing?
• Schritt 02 – Ihr erstes JUnit-Projekt und Green Bar
• Schritt 03 – Ihr erster Code und erster Unit-Test
• Schritt 04 – Erkunden anderer Assert-Methoden
• Schritt 05 – Erkundung einiger wichtiger JUnit-Anmerkungen

Erkunden von Mocking mit Mockito für Spring Boot-Projekte

• Schritt 00 – Einführung in den Abschnitt – Mockito in 5 Schritten
• Schritt 01 – Einrichten eines Spring Boot-Projekts
• Schritt 02 – Probleme mit Stubs verstehen
• Schritt 03 – Schreiben Sie Ihren ersten Mockito-Test mit Mocks
• Schritt 04 – Vereinfachen von Tests mit Mockito-Annotationen – @Mock, @InjectMocks
• Schritt 05 – Weitere Erkundung von Mocks über die Mocking-List-Schnittstelle

Sichern von Spring Boot-Anwendungen mit Spring Security

• Schritt 00 – Erste Schritte mit Spring Security
• Schritt 01 – Sicherheitsgrundlagen verstehen
• Schritt 02 – Sicherheitsprinzipien verstehen
• Schritt 03 – Erste Schritte mit Spring Security
• Schritt 04 – Erkunden der Standard-Spring-Sicherheitskonfiguration
• Schritt 05 – Erstellen eines Spring Boot-Projekts für Spring Security
• Schritt 06 – Spring Security erkunden – Formularauthentifizierung
• Schritt 07 – Spring Security erkunden – Basisauthentifizierung
• Schritt 08 – Erkundung der Spring-Sicherheit – Cross-Site-Request-Forgery – CSRF
• Schritt 09 – Erkunden von Spring Security – CSRF für die REST-API
• Schritt 10 – Erstellen einer Spring Security-Konfiguration zum Deaktivieren von CSRF
• Schritt 11 – Spring Security erkunden – Erste Schritte mit CORS
• Schritt 12 – Spring Security erkunden – Benutzeranmeldeinformationen im Speicher speichern
• Schritt 13 – Spring Security erkunden – Benutzeranmeldeinformationen mit JDBC speichern
• Schritt 14 – Codierung vs. Hashing vs. Verschlüsselung verstehen
• Schritt 15 – Spring Security erkunden – Bcrypt-verschlüsselte Passwörter speichern
• Schritt 16 – Erste Schritte mit der JWT-Authentifizierung
• Schritt 17 – Einrichten von JWT Auth mit Spring Security und Spring Boot – 1
• Schritt 18 – Einrichten von JWT Auth mit Spring Security und Spring Boot – 2
• Schritt 19 – JWT-Ressource mit Spring Security und Spring Boot einrichten – 1
• Schritt 20 – JWT-Ressource mit Spring Security und Spring Boot einrichten – 2
• Schritt 21 – Grundlegendes zur Spring Security-Authentifizierung
• Schritt 22 – Erkundung der Spring-Sicherheitsautorisierung
• Schritt 23 – Erstellen eines Spring Boot-Projekts für OAuth mit Spring Security
• Schritt 24 – Erste Schritte mit Spring Boot und OAuth2 – Melden Sie sich mit Google an
• Schritt 25 – Kurzübersicht – Sichern von Spring Boot-Apps mit Spring Security

Spring AOP mit Spring Boot lernen

• Schritt 01 – Erste Schritte mit Spring AOP – Ein Überblick
• Schritt 02 – Was ist aspektorientierte Programmierung?
• Schritt 03 – Erstellen eines Spring Boot-Projekts für Spring AOP
• Schritt 04 – Federkomponenten für Spring AOP einrichten
• Schritt 05 – AOP-Protokollierungsaspekt und Pointcut erstellen
• Schritt 06 – AOP-Terminologie verstehen
• Schritt 07 – Erkunden der AOP-Anmerkungen @After, @AfterReturning und @AfterThrowing
• Schritt 08 – Erkunden der Umgebung von AOP-Anmerkungen mit einer Timer-Klasse
• Schritt 09 – AOP Best Practice – Erstellen gemeinsamer Pointcut-Definitionen
• Schritt 10 – Erstellen einer Spurzeitanmerkung
• Schritt 11 – Erste Schritte mit Spring AOP – Vielen Dank

Maven mit Spring und Spring Boot lernen

• Schritt 01 – Einführung in Maven
• Schritt 02 – Erstellen eines Spring Boot-Projekts mit Maven
• Schritt 03 – Erkunden von Maven pom.xml für das Spring Boot-Projekt
• Schritt 04 – Erkundung von Maven Parent Pom für das Spring Boot-Projekt
• Schritt 05 – Maven weiter erkunden
• Schritt 06 – Erkunden des Maven Build-Lebenszyklus mit einem Spring Boot-Projekt
• Schritt 07 – Wie funktioniert Maven?
• Schritt 08 – Spielen mit Maven-Befehlen
• Schritt 09 – Wie werden Spring-Projekte versioniert?

Gradle mit Spring und Spring Boot lernen

• Schritt 01 – Erste Schritte mit Gradle
• Schritt 02 – Erstellen eines Spring Boot-Projekts mit Gradle
• Schritt 03 – Erkunden der Gradle-Build- und Einstellungsdateien
• Schritt 04 – Erkunden der Gradle-Plugins für Java und Spring Boot
• Schritt 05 – Maven oder Gradle – Welches soll für Spring Boot-Projekte verwendet werden?

Docker mit Spring und Spring Boot lernen

• Schritt 01 – Erste Schritte mit Docker
• Schritt 02 – Docker-Grundlagen verstehen
• Schritt 03 – Verstehen, wie Docker funktioniert
• Schritt 04 – Docker-Terminologie verstehen
• Schritt 05 – Docker-Image für ein Spring Boot-Projekt erstellen – Dockerfile
• Schritt 06 – Erstellen eines Spring Boot Docker-Images mithilfe einer mehrstufigen Docker-Datei
• Schritt 07 – Spring Boot Docker Image erstellen – Dockerfile optimieren
• Schritt 08 – Erstellen eines Docker-Images mit dem Spring Boot Maven Plugin
• Schritt 09 – Kurzer Überblick über Docker mit Spring Boot

Erste Schritte mit Cloud und AWS

• Schritt 02 – Einführung in Cloud und AWS – Vorteile
• Schritt 03 – Erstellen Ihres AWS-Kontos
• Schritt 04 – Erstellen Ihres ersten IAM-Benutzers
• Schritt 05 – Den Bedarf an Regionen und Zonen verstehen
• Schritt 06 – Erkunden von Regionen und Verfügbarkeitszonen in AWS

Erste Schritte mit Compute Services in AWS

• Schritt 01 – Erste Schritte mit EC2 – Virtuelle Server in AWS
• Schritt 02 – Demo – Erstellen virtueller Maschinen mit Amazon EC2
• Schritt 02z – Demo – Einrichten eines Webservers in einer Amazon EC2-Instanz
• Schritt 03 – Kurzer Überblick über wichtige EC2-Konzepte
• Schritt 04 – Erkundung von IaaS vs. PaaS – Cloud Computing mit AWS
• Schritt 05 – Erste Schritte mit AWS Elastic Beanstalk
• Schritt 06 – Demo – Einrichten einer Webanwendung mit AWS Elastic Beanstalk
• Schritt 07 – Demo – Spielen mit AWS Elastic Beanstalk
• Schritt 08 – Den Bedarf an Docker und Containern verstehen
• Schritt 09 – Erkunden der Container-Orchestrierung in AWS
• Schritt 10 – Demo – Einrichten eines ECS-Clusters mit AWS Fargate
• Schritt 11 – Demo – Spielen mit Amazon ECS
• Schritt 12 – Erste Schritte mit Serverless in AWS – AWS Lambda
• Schritt 13 – Demo – Erstellen Ihrer ersten Lambda-Funktion
• Schritt 14 – Demo – Spielen mit Lambda-Funktionen
• Schritt 15 – Cloud Computing in AWS – Kurzüberblick über Compute Services

Bereitstellen von Spring Boot-Anwendungen in AWS

• Schritt 01 – Bereitstellen der Hello World Spring Boot-App auf AWS
• Schritt 02 – Erkunden von AWS Elastic Beanstalk – Ihrer ersten Spring Boot-App in AWS
• Schritt 03 – Ausführen der Spring Boot REST API mit MySQL-Datenbank als Docker-Container
• Schritt 04 – Bereitstellen der Spring Boot REST API mit MySQL für AWS Elastic Beanstalk und RDS
• Schritt 05 – Erkundung von AWS Elastic Beanstalk und Amazon RDS – Spring Boot REST API
• Schritt 06 – Erkunden der Spring Boot- und React Full Stack-App
• Schritt 07 – Bereitstellen der Full Stack Spring Boot REST API für AWS Elastic Beanstalk
• Schritt 08 – Bereitstellen der Full Stack React App auf Amazon S3

Einführung in die funktionale Programmierung mit Java

• Schritt 00 – Einführung in die funktionale Programmierung – Übersicht
• Schritt 01 – Erste Schritte mit der funktionalen Programmierung mit Java
• Schritt 02 – Schreiben Ihres ersten Java-Funktionsprogramms
• Schritt 03 – Verbesserung des Java-Funktionsprogramms mit Filter
• Schritt 04 – Verwenden von Lambda Expression zur Verbesserung Ihres Funktionsprogramms
• Schritt 05 – Führen Sie funktionale Programmierübungen mit Streams, Filtern und Lambdas durch
• Schritt 06 – Verwendung der Karte in funktionalen Programmen – mit Übungen
• Schritt 07 – Optionale Klasse in Java verstehen
• Schritt 08 – Kurzer Überblick über die Grundlagen der funktionalen Programmierung

Herzlichen Glückwunsch – Master Spring Framework und Spring Boot

• Herzlichen Glückwunsch – Master Spring Framework und Spring Boot