
Spring Boot 3
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions


Persons
Content
- Cover
- Über den Autor
- Titel
- Impressum
- Inhaltsübersicht
- Inhaltsverzeichnis
- 1 Einleitung
- 1.1 Warum Spring Boot?
- 1.2 Für wen ist dieses Buch?
- 1.3 Aufbau des Buchs
- 1.4 Codebeispiele
- Teil I Grundlagen
- 2 Hallo, Spring Boot
- 2.1 Einleitung
- 2.2 JDK installieren
- 2.3 Kickstart mit dem Spring Initializr
- 2.4 Projektstruktur
- 2.5 Die Anwendung bauen
- 2.6 Die Anwendung starten
- 2.7 Einen REST-Controller bauen
- 3 Spring-Grundlagen
- 3.1 Dependency Injection und Inversion of Control
- 3.1.1 Inversion of Control
- 3.1.2 Dependency Injection
- 3.2 Der Spring Application Context
- 3.3 Application Context mit XML konfigurieren
- 3.4 Java-Konfiguration im Detail
- 3.4.1 @Configuration und @Bean
- 3.4.2 @Component und @ComponentScan
- 3.4.3 @Configuration und @ComponentScan kombinieren
- 3.5 Was haben wir vom Spring Container?
- 4 Spring-Boot-Grundlagen
- 4.1 Bootstrapping
- 4.2 Den Application Context beeinflussen
- 4.3 Embedded Webserver
- 4.4 Dependency Management
- 4.5 Integrationen
- 4.6 Produktionsbetrieb
- 5 Konfiguration
- 5.1 Warum Konfiguration?
- 5.2 Konfigurationsparameter
- 5.2.1 Konfigurationsparameter definieren
- 5.2.2 Parameter als String injizieren
- 5.2.3 Parameter typsicher injizieren
- 5.2.4 Parameter validieren
- 5.2.5 Default-Werte definieren
- 5.3 Profile
- 5.3.1 Konfigurationsparameter für ein Profil definieren
- 5.3.2 Ein Profil aktivieren
- 5.3.3 Konfigurationswerte aus unterschiedlichen Quellen kombinieren
- 5.4 Das Environment-Bean
- 5.5 Best Practices für Konfigurationsmanagement
- 5.5.1 Konfigurationsdateien im JAR
- 5.5.2 Secrets als Umgebungsvariablen definieren
- 5.5.3 Umgebungsvariablen explizit definieren
- 5.5.4 Profile nur für Umgebungen
- 5.5.5 Konfiguration von Default-Werten
- 6 Build Management mit Spring Boot
- 6.1 Überblick
- 6.2 Gradle oder Maven?
- 6.3 Spring Boot »Fat JAR«
- 6.4 Das Gradle Plugin
- 6.5 Das Maven Plugin
- 6.6 Dependency Management mit Spring Boot
- 6.6.1 Spring-Boot-BOM mit Gradle konsumieren
- 6.6.2 Spring-Boot-BOM mit Maven konsumieren
- 7 Einführung ins Testen
- 7.1 Testen - wieso, weshalb, warum?
- 7.2 Spring Boot Starter Test
- 7.3 Unit-Tests
- 7.4 SpringExtension (JUnit 5)
- 7.5 Integrationstests mit Spring
- 7.5.1 @SpringBootTest
- 7.5.2 Ausblick auf Slice-Annotationen
- 8 Troubleshooting einer Spring-Boot-Anwendung
- 8.1 Spring-Boot-Magie
- 8.2 Troubleshooting-Werkzeuge
- 8.2.1 Lokal reproduzieren
- 8.2.2 Debug-Modus
- 8.2.3 Actuator-Endpoints
- 8.2.4 Logging
- 8.2.5 Hooks
- 8.3 Troubleshooting-Anwendungsfälle
- 8.3.1 Welche Beans stehen mir zur Verfügung?
- 8.3.2 Wo kommt eine Bean her?
- 8.3.3 Warum ist meine Bean nicht im Application Context?
- 8.3.4 Warum ist eine Bean doppelt im Application Context?
- 8.3.5 Wie ist meine Anwendung konfiguriert?
- 8.3.6 Welche Konfigurationsparameter werden (nicht) genutzt?
- 8.3.7 Welche Endpoints stellt meine Anwendung zur Verfügung?
- 8.3.8 Warum startet meine Anwendung nicht?
- Teil II Anwendungsfälle
- 9 Einen REST-Service entwickeln
- 9.1 Was ist REST?
- 9.2 Codebeispiel
- 9.3 Endpoints
- 9.4 Request Body und Parameter
- 9.5 Fehlerbehandlung
- 10 Das Reactor-Framework verwenden
- 10.1 Was ist das Reactor-Framework?
- 10.2 Codebeispiel
- 10.3 Andere reaktive Operatoren
- 11 Eine GraphQL-API entwickeln
- 11.1 GraphQL in Kürze
- 11.2 Die Beispielanwendung
- 11.3 Erstellung der Anwendung
- 11.4 Abbildung des Datenmodells in GraphQL
- 11.5 Implementierung des Controllers
- 11.5.1 Query Mapping
- 11.5.2 Schema Mapping
- 11.5.3 Mutation Mapping
- 11.6 Implementierung einer Subscription
- 12 Integration einer SPA mit Spring Boot
- 12.1 Herausforderungen von SPAs
- 12.1.1 Handhabung von URLs
- 12.1.2 Integration unterschiedlicher Toolings
- 12.2 Mögliche Varianten für ein Deployment
- 12.2.1 Integration in das Spring-Boot-JAR
- 12.2.2 Unabhängige Deployments des Frontends und Backends
- 12.3 Ein Spring Boot Backend mit React Frontend
- 12.3.1 Verzeichnisstruktur
- 12.3.2 Konfiguration des Builds
- 12.3.3 Integration einer REST-API in das Frontend
- 12.3.4 Unterstützung von Deep-Links mit der History-API
- 13 Ein serverbasiertes Web-Frontend entwickeln
- 13.1 Warum serverseitig?
- 13.2 Die Beispielanwendung
- 13.3 »Hello World« mit Thymeleaf
- 13.4 Formulardaten verarbeiten
- 13.5 Interaktivität mit HTMX
- 13.6 Spring Boot Developer Tools
- 13.7 Weitere Ressourcen
- 14 Eine Datenbank anbinden
- 14.1 Datenbanken
- 14.2 Codebeispiel
- 14.3 Spring Data Repositories
- 14.4 Transaktionen
- 15 Eine CLI-Anwendung entwickeln
- 15.1 Eine ADR-Management-Anwendung
- 15.2 Erstellen des Projekts
- 15.2.1 Die ADR-API
- 15.3 Ein erstes Kommando
- 15.4 Registrieren von Kommandos
- 15.4.1 Programmatische Registrierung von Kommandos
- 15.4.2 Kommandos mit Annotationen definieren
- 15.4.3 AvailabilityProvider
- 15.4.4 Anzeige eines eigenen Prompts
- 15.5 Ausführung im interaktiven oder Kommando-Modus
- 15.6 Alternativen zu Spring Shell
- 16 Architektur-Governance mit Spring Boot
- 16.1 Warum Architektur-Governance?
- 16.2 Komponentenbasierte Architektur
- 16.3 Komponentenbasierte Architektur mit Spring Boot
- 16.4 Governance mit ArchUnit
- 16.5 Spring Modulith
- Teil III Referenz
- 17 Testing
- 17.1 Überblick
- 17.2 Unit Testing
- 17.2.1 Unit Testing ohne Spring
- 17.2.2 Unit Testing Utilities im Spring Framework
- 17.3 Integration Testing
- 17.3.1 Spring TestContext Framework
- 17.3.2 SpringExtension und SpringRunner
- 17.3.3 TestContextManager und ContextConfiguration
- 17.4 Wichtige Testfunktionalitäten im Überblick
- 17.4.1 @SpringBootTest
- 17.4.2 Context Initializers
- 17.4.3 @TestPropertySource
- 17.4.4 @ActiveProfiles
- 17.4.5 @TestConfiguration
- 17.4.6 @TestExecutionListeners
- 17.5 Testen von einzelnen Schichten mit Test Slices
- 17.5.1 Was sind Test Slices?
- 17.5.2 @WebMvcTest
- 17.5.3 @DataJpaTest
- 17.5.4 @JsonTest
- 17.5.5 Weitere Test Slices
- 18 Spring Reactive
- 18.1 Warum Reactive?
- 18.2 Grundlagen
- 18.2.1 Reactive Streams und Project Reactor
- 18.2.2 Reaktive Datentypen: Mono und Flux
- 18.2.3 Reactive Chaining
- 18.3 Spring WebFlux
- 18.3.1 Annotierte Controller
- 18.3.2 Funktionale Endpoints
- 18.3.3 WebClient statt RestTemplate
- 18.4 Testen von Reactive Streams
- 18.4.1 StepVerifier
- 18.4.2 WebFluxTest
- 19 Spring Web MVC
- 19.1 REST
- 19.1.1 RestController
- 19.1.2 Request-Daten auslesen
- 19.1.3 Reactive RestController
- 19.2 JSON-Mapping mit Jackson
- 19.2.1 Jackson Annotations
- 19.2.2 Custom Serializer
- 19.3 Error Handling
- 19.4 API-Dokumentation mit Spring REST Docs
- 19.4.1 Setup für REST Docs
- 19.4.2 JUnit-Test zur Generierung
- 19.4.3 Nutzen von Snippets
- 19.5 HATEOAS
- 19.5.1 Wieso überhaupt HATEOAS?
- 19.5.2 Repräsentation von Ressourcen
- 19.5.3 Hypermedia Links & Relations
- 19.5.4 Komfortable Links mit dem WebMvcLinkBuilder
- 19.5.5 Affordances
- 19.5.6 Integration mit RestTemplate und WebClient
- 20 HTTP-Clients mit Spring
- 20.1 RestTemplate
- 20.2 RestClient
- 20.3 WebClient
- 20.4 HTTP-Interface
- 21 GraphQL
- 21.1 Einführung
- 21.2 GraphQL in Kürze
- 21.2.1 Das GraphQL-Schema
- 21.2.2 Die Query Language
- 21.2.3 Ein GraphQL-Schema kann noch mehr
- 21.3 Ablauf eines GraphQL-Requests
- 21.3.1 Transportmethoden
- 21.4 Erstellung einer Spring-Boot-Anwendung mit GraphQL-API
- 21.4.1 Verwenden des Spring Initializr
- 21.4.2 Manuelles Hinzufügen der notwendigen Abhängigkeiten
- 21.4.3 Interaktives Testen mit GraphiQL
- 21.5 Implementierung einer GraphQL-API
- 21.5.1 Definieren eines GraphQL-Schemas
- 21.5.2 GraphQL Controller in Spring Boot
- 21.5.3 Optimierte Abfragen mit Batches
- 21.5.4 Definition eigener Skalare
- 21.6 Fehlerbehandlung
- 22 Spring Boot Developer Tools
- 22.1 Warum Developer Tools?
- 22.2 Developer Tools aktivieren
- 22.3 Restart
- 22.4 Live Reload
- 22.5 Einschränkungen der Developer Tools
- 23 Events
- 23.1 Lose Kopplung
- 23.2 Events versenden
- 23.3 Events empfangen
- 23.3.1 ApplicationListener
- 23.3.2 @EventListener
- 23.4 Synchron oder asynchron?
- 23.5 Spring Boot ApplicationEvents
- 24 Caching
- 24.1 Cache-Configuration
- 24.2 Caching-Annotationen
- 24.3 Cache-Implementierungen
- 24.3.1 EhCache
- 24.3.2 Caffeine
- 25 Messaging
- 25.1 Messaging im Überblick
- 25.2 JMS
- 25.2.1 Mit einer JMS-API verbinden
- 25.2.2 Nachrichten senden
- 25.2.3 Nachrichten empfangen
- 25.2.4 Message Converter
- 25.3 AMQP
- 25.3.1 Das AMQP-Protokoll
- 25.3.2 Konfiguration
- 25.3.3 Nachrichten versenden
- 25.3.4 Nachrichten empfangen
- 25.4 Kafka
- 25.4.1 Konfiguration
- 25.4.2 Nachrichten versenden und empfangen
- 25.5 Ausblick: Spring Cloud Stream
- 25.5.1 Konzepte
- 25.5.2 Nachrichten senden und empfangen
- 25.5.3 Vorteile
- 26 Spring Data
- 26.1 Überblick über Spring Data
- 26.2 Spring Data Repositories
- 26.2.1 Das Repository-Interface
- 26.2.2 Query-Methoden
- 26.3 Die DataSource Bean
- 26.4 JPA
- 26.4.1 Welchen Mehrwert bietet Spring Data JPA?
- 26.4.2 JPA-Repositories und -Entities
- 26.4.3 Datenbankinitialisierung mit JPA und Hibernate
- 26.5 R2DBC
- 26.5.1 Datenbankverbindung über ConnectionFactory
- 26.5.2 Datenbankzugriff
- 26.6 NoSQL mit Spring Data MongoDB
- 26.6.1 MongoDatabaseFactory und MongoTemplate
- 26.6.2 Spring Data Repository für MongoDB
- 26.6.3 Integrationstests mit @DataMongoTest
- 26.7 Schema-Migration mit Flyway
- 27 Spring Cloud Config
- 27.1 Warum Spring Cloud Config?
- 27.2 Der Spring Cloud Config-Server
- 27.3 Environment Repository
- 27.4 Spring Cloud Config-Client
- 28 Spring Security
- 28.1 Konzepte
- 28.1.1 Authentication
- 28.1.2 Authorization
- 28.1.3 Auto-Configuration
- 28.2 Absicherung von Methoden
- 28.3 Absicherung von HTTP-Pfaden
- 28.4 Benutzerverwaltung
- 28.5 Security Testing
- 28.6 OAuth
- 28.6.1 Was ist OAuth?
- 28.6.2 OAuth Resource-Server
- 28.6.3 OAuth-Client
- 29 Observability
- 29.1 Warum Observability?
- 29.2 Admin-Endpoints mit Actuator
- 29.2.1 Anwendungs-Metadaten ausgeben
- 29.2.2 Einen eigenen Actuator-Endpoint entwickeln
- 29.3 Logging
- 29.3.1 SLF4J
- 29.3.2 Logging via application.yml konfigurieren
- 29.3.3 Logback und Log4J direkt konfigurieren
- 29.3.4 Kombination der Logging-Konfigurationen
- 29.4 Metriken
- 29.4.1 Standardmetriken exportieren
- 29.4.2 Metriken an ein Observability-Produkt exportieren
- 29.4.3 Eigene Metriken exportieren
- 29.4.4 Tags
- 29.4.5 Metriken programmatisch anpassen
- 29.4.6 Histogramme und Perzentile
- 29.5 Tracing
- 29.5.1 Traces programmatisch auswerten
- 29.5.2 Traces in Log-Events ausgeben
- 29.5.3 Traces exportieren
- 29.5.4 Clients instrumentieren
- 29.5.5 Baggage
- 30 Docker-Images mit Spring Boot
- 30.1 Warum Docker?
- 30.2 Einfaches Docker-Image mit Spring Boot
- 30.3 Optimierte Docker-Images
- 30.4 Optimiertes Docker-Image mit Spring Boot
- 30.5 Docker abstrahieren mit Buildpacks
- 31 Native Images mit Spring Boot
- 31.1 Warum Native?
- 31.2 Was ist ein Native Image?
- 31.3 Anwendungsfälle für Native Images
- 31.4 Ahead-of-Time-Optimierung mit Spring Boot
- 31.5 Ein natives Image erstellen
- 31.6 Ein natives Image testen
- 31.7 Reachability-Metadaten erstellen
- 32 Spring Boot erweitern
- 32.1 Cross-Cutting Concerns
- 32.2 @Configuration und @Import
- 32.3 @Enable.-Annotationen
- 32.4 @AutoConfiguration
- 32.5 Bedingte @Configuration
- 32.6 Testen von @AutoConfigurations
- 32.7 Starter
- 32.8 Fortgeschrittene Erweiterungspunkte
- 32.8.1 FactoryBean
- 32.8.2 BeanPostProcessor
- 32.8.3 BeanDefinitionRegistryPostProcessor
- 32.8.4 EnvironmentPostProcessor
- 33 Coordinated Restore at Checkpoint (CRaC)
- 33.1 Warum CRaC?
- 33.2 Checkpoint und Restore
- 33.3 Checkpoint und Restore mit Spring Boot
- 33.4 Automatische Checkpoints
- 33.5 Checkpoints in Docker
- 33.6 CRaC vs. GraalVM
- 34 Migration von Spring Boot 2 zu Spring Boot 3
- 34.1 Überblick
- 34.2 Schritt 1: Bibliotheken analysieren und aktualisieren
- 34.3 Schritt 2: Auf Java 17 aktualisieren
- 34.4 Schritt 3: Das Spring-Boot-Upgrade vorbereiten
- 34.4.1 WebSecurityConfigurerAdapter durch WebSecurityFilterChain ersetzen
- 34.4.2 @AutoConfiguration
- 34.4.3 @LocalServerPort
- 34.4.4 @EnableWebFluxSecurity
- 34.5 Schritt 4: Spring Boot aktualisieren
- 34.5.1 Spring Boot auf 3.x aktualisieren
- 34.5.2 Bibliotheken aktualisieren
- 34.5.3 javax durch jakarta ersetzen
- 34.5.4 Spring Cloud Sleuth durch Micrometer ersetzen
- 34.5.5 @ConstructorBinding
- 34.5.6 HttpStatusCode
- 34.5.7 Konfigurationsparameter
- 35 Ausblick
- Fußnoten
- Index
System requirements
File format: PDF
Copy protection: Watermark-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Use the free software Adobe Reader, Adobe Digital Editions, or any other PDF viewer of your choice (see eBook Help).
- Tablet/Smartphone (Android; iOS): Install the free app Adobe Digital Editions or another reading app for eBooks, e.g., PocketBook (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Watermark-DRM, a „soft” copy protection. This means that there are no technical restrictions to prevent illegal distribution. However, there is a personalised watermark embedded in the eBook that can be used to identify the purchaser of the eBook in the event of misuse and to provide evidence for legal purposes.
For more information, see our eBook Help page.