Die Spring Boot CLI (Command Line Interface) ist ein leistungsfähiges Werkzeug, das Entwicklern ermöglicht, Spring Boot-Anwendungen schnell und effizient über die Kommandozeile zu erstellen, zu testen und auszuführen. Besonders in der Contract-First-Entwicklung kann die Spring Boot CLI den Entwicklungsprozess beschleunigen, indem sie die Einrichtung und Verwaltung von Projekten vereinfacht. In diesem Kapitel werden wir die Grundlagen der Spring Boot CLI erläutern, ihre Installation und Konfiguration beschreiben und praxisnahe Beispiele für die Nutzung in der Contract-First-Entwicklung mit Spring Boot und OpenAPI vorstellen. Zudem werden wir Best Practices und nützliche Tipps für den effektiven Einsatz der CLI diskutieren.
Die Spring Boot CLI ist ein Kommandozeilenwerkzeug, das es ermöglicht, Spring Boot-Anwendungen ohne umfangreiche Projektkonfiguration schnell zu erstellen und auszuführen. Sie unterstützt die Entwicklung mit Groovy-Skripten, bietet integrierte Unterstützung für Dependency Management und ermöglicht die schnelle Integration von Bibliotheken und Frameworks.
Hauptmerkmale der Spring Boot CLI:
Die Installation der Spring Boot CLI ist einfach und plattformübergreifend möglich. Hier sind die Schritte zur Installation auf verschiedenen Betriebssystemen:
JAVA_HOME korrekt gesetzt ist.SDKMAN! ist ein plattformübergreifendes Tool zur Verwaltung von SDKs, einschließlich der Spring Boot CLI.
Installation von SDKMAN!:
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"Installation der Spring Boot CLI:
sdk install springbootHomebrew (macOS):
brew tap spring-io/tap
brew install spring-bootChocolatey (Windows):
choco install springbootManuelle Installation:
Laden Sie das Spring Boot CLI ZIP-Archiv von der offiziellen Spring Boot Webseite herunter,
entpacken Sie es und fügen Sie das bin-Verzeichnis zu Ihrem
PATH hinzu.
Nach der Installation können Sie die erfolgreiche Einrichtung überprüfen, indem Sie den folgenden Befehl ausführen:
spring --versionSpring Boot v3.3.0Die Spring Boot CLI bietet eine Reihe von Befehlen, die den Entwicklungsprozess unterstützen. Hier sind einige der wichtigsten:
| Befehl | Beschreibung |
|---|---|
spring init |
Erstellt ein neues Spring Boot-Projekt mit angegebenen Optionen. |
spring run |
Führt ein Spring Boot-Anwendungsskript (Groovy) direkt aus. |
spring help |
Zeigt eine Hilfeseite mit allen verfügbaren Befehlen. |
spring jar |
Paketiert eine Anwendung in eine ausführbare JAR-Datei. |
spring test |
Führt Tests für eine Spring Boot-Anwendung aus. |
Neues Projekt erstellen:
spring init --dependencies=web,data-jpa,postgresql --build=maven --java-version=11 buchverwaltungErläuterung:
--dependencies: Listet die benötigten Abhängigkeiten
auf (hier: web, data-jpa,
postgresql).--build: Wählt das Build-Tool (hier:
maven).--java-version: Gibt die Java-Version an (hier:
11).buchverwaltung: Name des Projekts.Anwendung aus einem Groovy-Skript ausführen:
Erstellen Sie eine Datei namens app.groovy:
@RestController
class HelloController {
@RequestMapping("/")
String home() {
"Hello, Spring Boot CLI!"
}
}Führen Sie das Skript aus:
spring run app.groovyProjekt bauen und ausführen:
Wechseln Sie in das erstellte Projektverzeichnis und führen Sie:
./mvnw spring-boot:runoder, falls das Projekt mit Gradle erstellt wurde:
./gradlew bootRunIn der Contract-First-Entwicklung kann die Spring Boot CLI den Prozess der Projektinitialisierung und der schnellen Prototypenerstellung erheblich beschleunigen. Hier sind einige Anwendungsfälle und Vorgehensweisen:
Die Spring Boot CLI ermöglicht es Entwicklern, schnell Prototypen von APIs zu erstellen, die auf einer vorab definierten Spezifikation basieren. Dies ist besonders nützlich, um die Implementierung der Geschäftslogik zu testen und erste Feedbacks einzuholen.
spring init --dependencies=web,data-jpa,openapi --build=maven --java-version=11 buchverwaltung
cd buchverwaltung
spring run src/main/java/com/example/BuchverwaltungApplication.javaDie Spring Boot CLI kann in Kombination mit Springdoc OpenAPI verwendet werden, um die API-Dokumentation automatisch zu generieren und zu pflegen. Dies unterstützt die Synchronisation zwischen der API-Spezifikation und der Implementierung.
Abhängigkeit hinzufügen:
Fügen Sie die folgende Abhängigkeit zu Ihrer pom.xml
hinzu:
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-ui</artifactId>
<version>1.6.14</version>
</dependency>Konfiguration der OpenAPI-Spezifikation:
Platzieren Sie Ihre api.yaml oder api.json
im Verzeichnis src/main/resources/api/.
Automatisierte Code-Generierung:
Nutzen Sie den OpenAPI Generator in Kombination mit der Spring Boot CLI, um Server-Stubs und Modelle zu generieren, die strikt der Spezifikation entsprechen.
Die Spring Boot CLI kann in Shell-Skripten oder Automatisierungswerkzeugen eingebunden werden, um wiederkehrende Aufgaben wie das Erstellen von Projekten, das Ausführen von Tests oder das Deployen von Anwendungen zu automatisieren.
Erstellen Sie ein Skript namens start.sh:
#!/bin/bash
# Projekt initialisieren
spring init --dependencies=web,data-jpa,openapi --build=maven --java-version=11 buchverwaltung
cd buchverwaltung
# OpenAPI Generator ausführen
mvn clean install
# Anwendung starten
./mvnw spring-boot:runFühren Sie das Skript aus:
chmod +x start.sh
./start.shProjekt initialisieren:
spring init --dependencies=web --build=maven --java-version=11 einfache-api
cd einfache-apiErstellen eines Controllers:
Erstellen Sie die Datei
src/main/java/com/example/einfacheapi/HelloController.java:
package com.example.einfacheapi;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/hello")
public String sayHello() {
return "Hallo, Spring Boot CLI!";
}
}Anwendung ausführen:
./mvnw spring-boot:runTesten der API:
Öffnen Sie einen Browser oder nutzen Sie curl:
curl http://localhost:8080/helloAntwort:
Hallo, Spring Boot CLI!Projekt initialisieren mit OpenAPI-Abhängigkeit:
spring init --dependencies=web,openapi --build=maven --java-version=11 buchverwaltung
cd buchverwaltungHinzufügen von Springdoc OpenAPI zur
pom.xml:
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-ui</artifactId>
<version>1.6.14</version>
</dependency>Erstellen der OpenAPI-Spezifikation
(api.yaml):
Platzieren Sie die Datei im Verzeichnis
src/main/resources/api/:
openapi: 3.0.1
info:
title: Bücher API
description: Eine API zur Verwaltung von Büchern.
version: 1.0.0
servers:
- url: http://localhost:8080/api/v1
paths:
/books:
get:
summary: Liste aller Bücher abrufen
responses:
'200':
description: Erfolgreiche Antwort
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/Book'
post:
summary: Ein neues Buch erstellen
requestBody:
description: Buchdaten
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Book'
responses:
'201':
description: Buch erstellt
content:
application/json:
schema:
$ref: '#/components/schemas/Book'
/books/{id}:
get:
summary: Ein Buch anhand der ID abrufen
parameters:
- $ref: '#/components/parameters/BookId'
responses:
'200':
description: Erfolgreiche Antwort
content:
application/json:
schema:
$ref: '#/components/schemas/Book'
'404':
description: Buch nicht gefunden
content:
application/json:
schema:
$ref: '#/components/schemas/Error'
components:
parameters:
BookId:
name: id
in: path
required: true
schema:
type: integer
format: int64
description: Die ID des Buches
schemas:
Book:
type: object
properties:
id:
type: integer
format: int64
example: 1
title:
type: string
example: Spring Boot in Action
author:
type: string
example: Craig Walls
required:
- title
- author
Error:
type: object
properties:
code:
type: integer
example: 404
message:
type: string
example: Buch nicht gefunden
required:
- code
- messageHinzufügen des OpenAPI Generators zum
pom.xml:
<build>
<plugins>
<!-- OpenAPI Generator Plugin -->
<plugin>
<groupId>org.openapitools</groupId>
<artifactId>openapi-generator-maven-plugin</artifactId>
<version>6.3.0</version>
<executions>
<execution>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<inputSpec>${project.basedir}/src/main/resources/api/api.yaml</inputSpec>
<generatorName>spring</generatorName>
<output>${project.build.directory}/generated-sources/openapi</output>
<configOptions>
<interfaceOnly>true</interfaceOnly>
<delegatePattern>true</delegatePattern>
</configOptions>
</configuration>
</execution>
</executions>
</plugin>
<!-- Maven Compiler Plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>11</source>
<target>11</target>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
</plugins>
<sourceDirectory>src/main/java</sourceDirectory>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>${project.build.directory}/generated-sources/openapi</directory>
</resource>
</resources>
</build>
<dependencies>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Springdoc OpenAPI UI -->
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-ui</artifactId>
<version>1.6.14</version>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>
</dependencies>
<pluginRepositories>
<pluginRepository>
<id>openapitools</id>
<url>https://plugins.gradle.org/m2/</url>
</pluginRepository>
</pluginRepositories>Code-Generierung ausführen:
mvn clean installImplementierung der Geschäftslogik:
Füllen Sie die generierten Controller-Stubs aus. Beispiel für
BookControllerImpl.java:
package com.example.generated.api;
import com.example.generated.model.Book;
import com.example.generated.repository.BookRepository;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import java.util.List;
import java.util.Optional;
@Controller
public class BookControllerImpl implements BookController {
private final BookRepository bookRepository;
public BookControllerImpl(BookRepository bookRepository) {
this.bookRepository = bookRepository;
}
@Override
public ResponseEntity<List<Book>> getBooks() {
List<Book> books = bookRepository.findAll();
return ResponseEntity.ok(books);
}
@Override
public ResponseEntity<Book> getBookById(Long id) {
Optional<Book> book = bookRepository.findById(id);
return book.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}
@Override
public ResponseEntity<Book> createBook(Book book) {
Book savedBook = bookRepository.save(book);
return ResponseEntity.status(201).body(savedBook);
}
// Implementieren Sie weitere Methoden (updateBook, deleteBook etc.)
}Erstellung des Datenmodells und Repository:
Book.java
package com.example.generated.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
private Long id;
private String title;
private String author;
}BookRepository.java
package com.example.generated.repository;
import com.example.generated.model.Book;
import org.springframework.stereotype.Repository;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
@Repository
public class BookRepository {
private final Map<Long, Book> bookStore = new ConcurrentHashMap<>();
private final AtomicLong idGenerator = new AtomicLong();
public Book save(Book book) {
if (book.getId() == null) {
book.setId(idGenerator.incrementAndGet());
}
bookStore.put(book.getId(), book);
return book;
}
public Optional<Book> findById(Long id) {
return Optional.ofNullable(bookStore.get(id));
}
public List<Book> findAll() {
return new ArrayList<>(bookStore.values());
}
public boolean deleteById(Long id) {
return bookStore.remove(id) != null;
}
}Anwendung ausführen und testen:
Starten Sie die Anwendung:
./mvnw spring-boot:runGreifen Sie auf die Swagger UI zu unter:
http://localhost:8080/swagger-ui.html
Beispielhafte cURL-Anfragen:
Alle Bücher abrufen:
curl -X GET "http://localhost:8080/api/v1/books" -H "accept: application/json"Ein neues Buch erstellen:
curl -X POST "http://localhost:8080/api/v1/books" \
-H "Content-Type: application/json" \
-d '{"title": "Spring Boot in Action", "author": "Craig Walls"}'Antwort:
{
"id": 1,
"title": "Spring Boot in Action",
"author": "Craig Walls"
}Erstellen eines Groovy-Skripts für die API:
Erstellen Sie eine Datei namens app.groovy:
@RestController
class BookController {
@GetMapping("/api/v1/books")
List<Book> getBooks() {
return [
new Book(id: 1, title: "Spring Boot in Action", author: "Craig Walls"),
new Book(id: 2, title: "Java Concurrency in Practice", author: "Brian Goetz")
]
}
@PostMapping("/api/v1/books")
Book createBook(@RequestBody Book book) {
book.id = 3
return book
}
}
class Book {
Long id
String title
String author
}Anwendung ausführen:
spring run app.groovyTesten der API:
Alle Bücher abrufen:
curl -X GET "http://localhost:8080/api/v1/books" -H "accept: application/json"Antwort:
[
{
"id": 1,
"title": "Spring Boot in Action",
"author": "Craig Walls"
},
{
"id": 2,
"title": "Java Concurrency in Practice",
"author": "Brian Goetz"
}
]Ein neues Buch erstellen:
curl -X POST "http://localhost:8080/api/v1/books" \
-H "Content-Type: application/json" \
-d '{"title": "Effective Java", "author": "Joshua Bloch"}'Antwort:
{
"id": 3,
"title": "Effective Java",
"author": "Joshua Bloch"
}Die Spring Boot CLI ist ein mächtiges Kommandozeilenwerkzeug, das die schnelle Erstellung, Verwaltung und Ausführung von Spring Boot-Anwendungen ermöglicht. Besonders in der Contract-First-Entwicklung unterstützt die CLI die schnelle Initialisierung von Projekten, die Integration mit OpenAPI und die automatisierte Generierung von Server-Stubs und Modellen. Durch die Nutzung von Tools wie OpenAPI Generator und Springdoc OpenAPI kann die Spring Boot CLI die Konsistenz zwischen API-Spezifikation und Implementierung sicherstellen, den Entwicklungsprozess beschleunigen und die Wartbarkeit der Anwendungen erhöhen. Best Practices wie die konsistente Projektstruktur, automatisierte Tests, klare Versionierungsstrategien und die Integration in CI/CD-Pipelines tragen dazu bei, dass die Spring Boot CLI effektiv eingesetzt wird, um robuste, gut dokumentierte und skalierbare APIs zu entwickeln.