Von Code Sentinel, Technical Project Manager & Security-Experte bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Einsteiger | 🟡 Mittel
Lesezeit: 18 Minuten
Voraussetzungen: Java-Grundkenntnisse, Maven-Basics hilfreich

⚡ Das Wichtigste in 30 Sekunden

Dein Problem: Du hörst „Spring CLI“ und „Spring Shell“ und fragst dich: Ist das dasselbe? Brauche ich das? Was davon hilft mir bei CI/CD?

Die Lösung: Zwei komplett verschiedene Tools mit ähnlichen Namen – und ja, beide haben ihren Platz in modernen DevOps-Workflows.

Heute lernst du:

  • ✅ Warum CLI-Tools im DevOps-Kontext unverzichtbar sind
  • ✅ Was Spring CLI ist (Spoiler: Ein Bootstrap-Tool)
  • ✅ Was Spring Shell ist (Spoiler: Ein Framework für eigene CLIs)
  • ✅ Wann du welches brauchst

Für wen ist dieser Artikel?

  • 🌱 Anfänger: Du verstehst endlich den Unterschied
  • 🌿 Erfahrene: Du siehst den DevOps-Kontext klarer
  • 🌳 Profis: Im Bonus findest du Pipeline-Integration

Zeit-Investment: 18 Minuten (lohnt sich!)

👋 Code Sentinel: „Zwei Namen, null Klarheit – bis jetzt.“

Hey! 👋

Code Sentinel hier. Schön, dass du wieder da bist!

Letzte Woche kam Nova zu mir: „Hey Code, ich soll für unser DevOps-Team ein CLI-Tool bauen. Spring CLI oder Spring Shell – was nehme ich?“

Meine Antwort: „Kommt drauf an, was du bauen willst.“

Ihr Gesicht: 😐

Real talk? Diese Verwirrung ist völlig normal. Die Namen klingen ähnlich, beide haben mit der Kommandozeile zu tun, und Google hilft auch nicht wirklich weiter.

Aber hier ist die Sache: Wenn du den Unterschied einmal verstanden hast, wird vieles klarer – nicht nur die Tools selbst, sondern auch, warum CLI-Automatisierung im DevOps-Bereich so wichtig ist.

Lass uns das gemeinsam angehen! 🚀

🎯 Die große Frage: Warum überhaupt CLI-Tools?

Bevor wir in Spring CLI und Spring Shell eintauchen, müssen wir über das Warum sprechen. Das ist des Pudels Kern.

Das Problem mit GUIs in CI/CD

Stell dir vor, du musst jeden Tag:

  • Ein neues Spring-Boot-Projekt anlegen
  • Dependencies hinzufügen
  • Konfigurationsdateien generieren
  • Deployment-Skripte ausführen

Mit GUI (Weboberfläche):

  1. Browser öffnen
  2. URL eingeben
  3. Formular ausfüllen
  4. Klicken, klicken, klicken…
  5. Download
  6. Entpacken
  7. Manuell in IDE importieren

Mit CLI:

spring init --dependencies=web,data-jpa,security my-app
cd my-app
./mvnw spring-boot:run

Drei Zeilen. Fertig.

Warum das für DevOps kritisch ist

💡 Neu hier? Was ist DevOps?

DevOps verbindet Entwicklung (Dev) und IT-Betrieb (Ops). Das Ziel: Schnellere, zuverlässigere Software-Releases durch Automatisierung.

Kernprinzip: Alles, was automatisierbar ist, wird automatisiert.

→ Mehr zu DevOps in unserem Grundlagen-Artikel

CLI-Tools sind die Grundlage für:

BereichWarum CLI?
CI/CD PipelinesJenkins, GitLab CI, GitHub Actions – alles Skript-basiert
Infrastructure as CodeTerraform, Ansible – keine GUI, nur CLI
Container-OrchestrierungDocker, Kubernetes – kubectl ist dein bester Freund
Automatisierte TestsHeadless, ohne menschliche Interaktion
ReproduzierbarkeitEin Skript, 1000x identisch ausführbar

Code Sentinel’s Real Talk:

„Eine GUI ist toll zum Lernen. Aber in Production zählt nur, was sich automatisieren lässt. Punkt.“

Spring CLI

Abbildung 1: Jeder Schritt in der CI/CD-Pipeline ist ein CLI-Befehl – keine Mausklicks, keine Browser

Die zwei Seiten der CLI-Medaille

Jetzt wird’s interessant. Es gibt zwei grundverschiedene Anwendungsfälle:

1. CLI-Tools NUTZEN (als Anwender)

  • Du rufst ein fertiges Tool auf
  • Beispiel: git commit, docker build, mvn clean install
  • Spring CLI fällt in diese Kategorie

2. CLI-Tools BAUEN (als Entwickler)

  • Du erstellst ein eigenes interaktives Tool
  • Beispiel: Admin-Konsole, Datenbank-Migration-Tool
  • Spring Shell ist dafür da

Diese Unterscheidung ist entscheidend. Lass uns beide Seiten anschauen.

Abbildung 2: Spring CLI nutzen vs. Spring Shell bauen – zwei komplett verschiedene Aufgaben

🟢 GRUNDLAGEN

💡 Neu hier? Spring vs. Spring Boot – Was ist der Unterschied?

Diese Frage kommt in jedem Kurs. Hier die kurze Antwort:

Spring FrameworkSpring Boot
Seit20032014
Was ist es?Das Fundament – ein riesiges Framework für Enterprise JavaEine „opinionated“ Schicht auf Spring – macht vieles automatisch
KonfigurationXML oder Java-Config, viel manuellAuto-Configuration, fast nichts manuell
ServerExterner Tomcat/Jetty nötigEingebetteter Server inklusive
StartenWAR bauen, deployen, konfigurieren…java -jar app.jar – fertig

Die Analogie: Spring Framework ist wie ein Baukasten mit 10.000 Teilen. Spring Boot ist derselbe Baukasten, aber mit Anleitung und vorsortiert – du kannst sofort loslegen.

Warum das wichtig ist: Wenn jemand „Spring“ sagt, meint er heute meist „Spring Boot“. Der klassische Spring-Framework-Weg (XML-Config, externe Server) ist in neuen Projekten selten geworden.

Merksatz: Spring Boot ist Spring mit Starthilfe.

Was ist Spring CLI?

Kurzfassung: Spring CLI ist ein Kommandozeilen-Tool zum schnellen Erstellen und Verwalten von Spring-Projekten – und existiert seit Spring Boot 1.0 (2014).

Langfassung: Der Spring Boot CLI ist ein Veteran im Spring-Ökosystem. Mit spring init konntest du schon 2014 Projekte von der Kommandozeile aus erstellen – Spring Initializr für’s Terminal.

⚠️ Achtung: Namensverwirrung!

Seit 2023 gibt es zusätzlich ein separates Projekt namens „Spring CLI“ (ohne „Boot“) auf GitHub. Dieses neue Tool fokussiert sich auf AI-Features und Projekt-Transformationen. Nicht verwechseln mit dem klassischen Spring Boot CLI!

# Spring-Projekt erstellen (klassisch, seit 2014)
spring init --dependencies=web,actuator --build=maven my-service

# Verfügbare Dependencies anzeigen
spring init --list

# Mit bestimmter Spring Boot Version
spring init --boot-version=3.3.6 --dependencies=web my-service

Wann brauchst du Spring CLI?

  • Wenn du schnell neue Projekte bootstrappen willst
  • Wenn du in CI/CD automatisiert Projekte generieren musst
  • Wenn du Spring Initializr ohne Browser nutzen willst

Was ist Spring Shell?

Kurzfassung: Spring Shell ist ein Framework, mit dem du eigene interaktive CLI-Anwendungen in Java baust.

Langfassung: Es gibt dir alles, was eine professionelle Shell braucht: Command-Parsing, Tab-Completion, History, Help-System – und das Ganze integriert in Spring Boot.

@ShellComponent
public class AdminCommands {

    @ShellMethod("Zeigt System-Status an")
    public String status() {
        return "System läuft ✓";
    }
    
    @ShellMethod("Führt Datenbank-Backup durch")
    public String backup(@ShellOption String targetPath) {
        // Backup-Logik hier
        return "Backup nach " + targetPath + " erstellt";
    }
}

Wann brauchst du Spring Shell?

  • Wenn du ein Admin-Tool für deine Anwendung brauchst
  • Wenn du eine interaktive Konsole für Batch-Jobs willst
  • Wenn du DevOps-Automation mit Java-Logik verbinden willst

Der Unterschied auf einen Blick

AspektSpring CLISpring Shell
Was ist es?Ein fertiges ToolEin Framework
Wer nutzt es?Du als EntwicklerDeine Endnutzer
ZweckProjekte erstellenEigene CLIs bauen
InstallationDownload/SDKMANMaven-Dependency
OutputSpring-ProjekteDeine eigene Anwendung

💡 Du kennst die Basics schon? → Spring direkt zu PROFESSIONALS

🟡 PROFESSIONALS

Spring CLI in der Praxis

Installation

Der klassische Spring Boot CLI wird über SDKMAN oder Homebrew installiert:

Option 1: SDKMAN (empfohlen für Linux/macOS)

sdk install springboot
spring --version

Option 2: Homebrew (macOS)

brew tap spring-io/tap
brew install spring-boot

Option 3: Manuell Download von spring.io/tools → Spring Boot CLI ZIP entpacken → bin/ zum PATH hinzufügen.

Hinweis: Das separate „Spring CLI“ Projekt (2023) hat eine eigene Installation über github.com/spring-projects/spring-cli. Für spring init brauchst du das aber nicht.

Wichtige Befehle

# Neues Projekt mit Web und JPA
spring init \
  --dependencies=web,data-jpa,validation \
  --java-version=21 \
  --build=maven \
  --packaging=jar \
  my-api

# Mit Kotlin statt Java
spring init --language=kotlin --dependencies=webflux my-reactive-app

# Projekt-Info anzeigen
spring init --list

# Verfügbare Dependencies
spring init --list | grep security

CI/CD-Integration (GitHub Actions)

name: Generate Service
on:
  workflow_dispatch:
    inputs:
      service_name:
        description: 'Name des neuen Services'
        required: true

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - name: Install Spring CLI
        run: |
          sdk install springboot
          
      - name: Generate Project
        run: |
          spring init \
            --dependencies=web,actuator,prometheus \
            --java-version=21 \
            ${{ github.event.inputs.service_name }}
            
      - name: Commit to Repository
        run: |
          git add .
          git commit -m "feat: Add ${{ github.event.inputs.service_name }}"
          git push

Spring Shell in der Praxis

Maven-Setup

<dependency>
    <groupId>org.springframework.shell</groupId>
    <artifactId>spring-shell-starter</artifactId>
    <version>3.3.3</version>
</dependency>

Einfaches Beispiel: DevOps-Admin-Tool

@ShellComponent
public class DevOpsCommands {

    @ShellMethod(value = "Prüft Health aller Services", key = "health-check")
    public String healthCheck() {
        // Hier würdest du tatsächlich Services pingen
        return """
            ✓ user-service: healthy
            ✓ order-service: healthy
            ✗ payment-service: unhealthy (timeout)
            """;
    }
    
    @ShellMethod(value = "Deployed einen Service", key = "deploy")
    public String deploy(
            @ShellOption(help = "Service-Name") String service,
            @ShellOption(defaultValue = "latest", help = "Version") String version) {
        
        return String.format("Deploying %s:%s...", service, version);
    }
    
    @ShellMethod(value = "Zeigt Logs eines Services", key = "logs")
    public String logs(
            @ShellOption String service,
            @ShellOption(defaultValue = "100") int lines) {
        
        return String.format("Letzte %d Zeilen von %s:", lines, service);
    }
}

Interaktion:

shell:> health-check
✓ user-service: healthy
✓ order-service: healthy  
✗ payment-service: unhealthy (timeout)

shell:> deploy user-service --version 2.1.0
Deploying user-service:2.1.0...

shell:> help deploy
NAME
    deploy - Deployed einen Service

SYNOPSIS
    deploy --service String [--version String]

OPTIONS
    --service String
        Service-Name
    --version String
        Version
        [Optional, default = latest]

Wann was? Die Entscheidungsmatrix

Abbildung 3: Der Entscheidungsbaum – Spring CLI zum Konsumieren, Spring Shell zum Produzieren

💡 Du willst mehr? → Im BONUS findest du Advanced-Themen

🔵 BONUS

Spring Shell für Pipeline-Automation

Ein häufiger Use-Case: Du willst komplexe DevOps-Aufgaben in einer einzigen Anwendung bündeln.

@ShellComponent
public class PipelineCommands {

    private final DockerService docker;
    private final KubernetesService k8s;
    private final SlackNotifier slack;

    @ShellMethod("Vollständiger Release-Prozess")
    public void release(
            @ShellOption String version,
            @ShellOption(defaultValue = "staging") String environment) {
        
        System.out.println("🚀 Starting release " + version);
        
        // 1. Build
        docker.build("my-app:" + version);
        
        // 2. Push
        docker.push("registry.example.com/my-app:" + version);
        
        // 3. Deploy
        k8s.deploy(environment, "my-app", version);
        
        // 4. Notify
        slack.notify("#releases", 
            "✅ " + version + " deployed to " + environment);
    }
    
    @ShellMethod("Rollback zu vorheriger Version")
    public void rollback(@ShellOption String environment) {
        String previousVersion = k8s.getPreviousVersion(environment);
        k8s.deploy(environment, "my-app", previousVersion);
        slack.notify("#releases", 
            "⚠️ Rollback to " + previousVersion);
    }
}

Das „neue“ Spring CLI (2023) – Custom Commands

Das separate Projekt Spring CLI (nicht Boot CLI!) unterstützt benutzerdefinierte Befehle über Action Files:

# .spring/commands/setup-dev.yml
command:
  name: setup-dev
  description: Richtet lokale Entwicklungsumgebung ein
  
actions:
  - exec:
      command: docker-compose up -d
  - exec:
      command: ./mvnw flyway:migrate
  - print:
      message: "✅ Dev-Umgebung bereit!"

spring setup-dev

Hinweis: Diese Features sind Teil des neuen Spring CLI Projekts (github.com/spring-projects/spring-cli), nicht des klassischen Spring Boot CLI. Für die meisten Teams ist der klassische spring init völlig ausreichend.

Security-Perspektive (weil ich’s bin 😉)

Spring Boot CLI:

  • ⚠️ spring init lädt Templates von start.spring.io → Netzwerk-Policies prüfen
  • ⚠️ Kann in Pipelines sensible Daten exponieren → Secrets-Management!
  • ✅ Etabliert, gut getestet, vertrauenswürdig

Spring Shell:

  • ⚠️ Deine Commands könnten Schaden anrichten → Input-Validierung!
  • ⚠️ Shell-Anwendung = potentieller Angriffsvektor → Least Privilege!
  • ✅ Volle Kontrolle über Security-Context

Code Sentinel’s Tipp:

„Jedes CLI-Tool in der Pipeline ist ein potenzieller Injection-Point. Validiere Inputs. Immer.“

💡 Praxis-Tipps

Für Einsteiger 🌱

  1. Starte mit Spring Initializr im Browser: Verstehe erst, was generiert wird, bevor du zur CLI wechselst.
  2. Spring CLI ist optional: Die meisten Teams nutzen die Weboberfläche oder IDE-Plugins – und das ist völlig okay.

Für den Alltag 🌿

  1. Kombiniere beide Tools: Nutze Spring CLI zum Bootstrappen, Spring Shell für Admin-Tools.
  2. Dokumentiere deine Commands: Spring Shell generiert automatisch Help-Texte – nutze das!

Für Profis 🌳

  1. Spring Shell als Ops-Interface: Baue eine zentrale Konsole für alle DevOps-Tasks.
  2. Idempotenz ist King: Jeder Command sollte mehrfach ausführbar sein, ohne Schaden.

🛠️ Tools & Ressourcen

Für Einsteiger 🌱

ToolWarum?Link
Spring InitializrVisuell verstehen, was CLI generiertstart.spring.io
SDKMANEinfache Installation von Spring CLIsdkman.io

Für den Alltag 🌿

ToolWarum?Link
Spring Shell DocsOffizielle Dokumentationdocs.spring.io/spring-shell
JLine 3Die Engine hinter Spring Shellgithub.com/jline/jline3

Für Profis 🌳

ToolWarum?Link
PicocliAlternative zu Spring Shellpicocli.info
GraalVM NativeCLI als native Binarygraalvm.org

❓ FAQ

Frage 1: Brauche ich Spring CLI, wenn ich IntelliJ nutze?

Antwort: Nein. IntelliJ hat Spring Initializr eingebaut. Spring CLI ist vor allem für Automatisierung und CI/CD interessant.

Frage 2: Kann ich mit Spring Shell eine TUI (Text User Interface) bauen?

Antwort: Ja! Spring Shell 3.x unterstützt Views und Components für komplexere Interfaces. Aber für echte TUIs schau dir auch Lanterna oder JCurses an.

Frage 3: Wie ist die Performance von Spring Shell?

Antwort: Startup-Zeit ist typisches Spring Boot – 2-5 Sekunden. Für schnelle Skripte ist das zu langsam. Lösung: GraalVM Native Image reduziert auf <100ms.

Frage 4: Spring CLI vs. Spring Boot CLI – ist das dasselbe?

Antwort: Jein. Der Spring Boot CLI mit spring init existiert seit 2014 – das ist der Klassiker, den die meisten meinen. Seit 2023 gibt es zusätzlich ein separates Projekt namens „Spring CLI“ (ohne „Boot“) mit Fokus auf AI-Features und Projekt-Transformationen. Die Verwirrung ist real – im Alltag meinen die meisten Leute den klassischen Spring Boot CLI.

Frage 5: Kann ich Spring Shell ohne Spring Boot nutzen?

Antwort: Technisch ja, aber warum? Spring Boot bringt die Auto-Configuration mit. Ohne wird’s umständlich.

Frage 6: Wie debugge ich eine Spring Shell Anwendung?

Antwort: Starte mit --spring.shell.interactive.enabled=false für Non-Interactive Mode, dann normales Remote-Debugging via IDE.

Frage 7: Was macht ihr bei zwischenmenschlichen Problemen im Team?

Antwort: Gute Frage… das gehört eher zu private logs. Ein anderes Kapitel. 🔒

Frage 8: Gibt es Alternativen zu Spring Shell?

Antwort: Ja! Picocli ist leichtgewichtiger, Quarkus hat auch CLI-Support. Spring Shell punktet bei Spring-Integration.

Frage 9: Ich höre immer „Spring“ und „Spring Boot“ – ist das dasselbe?

Antwort: Nein, aber sie gehören zusammen. Spring Framework (seit 2003) ist das riesige Fundament mit Dependency Injection, AOP, etc. Spring Boot (seit 2014) ist eine Schicht darüber, die Auto-Configuration und eingebettete Server mitbringt. Heute meinen die meisten Leute mit „Spring“ eigentlich „Spring Boot“. Der Unterschied: Mit purem Spring Framework schreibst du viel Konfiguration selbst, mit Spring Boot startest du in Minuten.

👥 Real Talk: Nova fragt, Code erklärt

Nova: „Okay, ich hab’s kapiert. Spring CLI = Projekte generieren, Spring Shell = eigene Tools bauen. Aber… warum baut man überhaupt CLI-Tools, wenn es doch REST-APIs gibt?“

Code Sentinel: „Gute Frage! Stell dir vor, du musst nachts um 3 Uhr einen Rollback machen. Willst du dafür durch drei Browser-Tabs klicken? Oder lieber ./admin rollback --env=prod tippen?“

Nova: „Okay, fair. Aber kann ich nicht einfach ein Shell-Skript schreiben?“

Code Sentinel: „Klar. Und dann noch eins. Und noch eins. Irgendwann hast du 47 Skripte, die keiner dokumentiert hat, und die Hälfte funktioniert nur auf Bernds Rechner.“

Nova: „…“

Code Sentinel: „Spring Shell gibt dir: Einheitliche Struktur, Auto-Dokumentation, Tab-Completion, Testing, und alles in einer Sprache, die du eh kannst – Java. Das ist der Unterschied.“

Nova: „Verstanden. Also für einmalige Sachen: Bash-Skript. Für wiederkehrende Ops-Tasks: Spring Shell.“

Code Sentinel: „Exakt. Und jetzt zeig ich dir in Teil 2, wie du dein erstes Shell-Tool baust.“ 😊

📦 Downloads

Was du bekommst

DateiInhalt
spring-cli-demo/Beispiel-Projekt mit Spring CLI generiert
spring-shell-starter/Maven-Projekt für Teil 2
grafiken/SVG-Diagramme aus diesem Artikel

Quick Start

# Download und entpacken
unzip spring-cli-shell-teil1.zip
cd spring-cli-shell-teil1

# Spring CLI Demo anschauen
cd spring-cli-demo
./mvnw spring-boot:run

# Oder: Spring Shell Starter für Teil 2 vorbereiten
cd ../spring-shell-starter
./mvnw clean package

Download: spring-cli-shell-teil1.zip (kommt mit Teil 2)

🔗 Weiterführende Links

Offizielle Dokumentation

Für Einsteiger

DevOps-Kontext

🎉 Geschafft!

Was du heute gelernt hast:

✅ CLI-Tools sind die Grundlage für DevOps-Automatisierung
✅ Spring Boot CLI = Bewährtes Bootstrap-Tool seit 2014
✅ Spring Shell = Framework für eigene CLI-Anwendungen
✅ Beide haben ihren Platz – aber für völlig unterschiedliche Zwecke

Egal ob du gerade erst von diesen Tools gehört hast oder dein Wissen vertieft hast – du hast den wichtigsten Unterschied verstanden. Das zählt!

Fragen? Schreib uns:

  • Code Sentinel: code.sentinel@java-developer.online

Nächster Teil: Spring Shell Deep-Dive – Wir bauen ein vollständiges DevOps-Admin-Tool! 🚀

Keep learning, keep automating! 💚

📚 Das könnte dich auch interessieren

Tags: #SpringCLI #SpringShell #DevOps #CICD #Java #Automatisierung

© 2025 Java Fleet Systems Consulting | java-developer.online

Autor

  • Code Sentinel

    32 Jahre alt, Technical Project Manager und Security-Experte bei Java Fleet Systems Consulting. Code ist ein erfahrener Entwickler, der in die Projektleitung aufgestiegen ist, aber immer noch tief in der Technik verwurzelt bleibt. Seine Mission: Sicherstellen, dass Projekte termingerecht, sicher und wartbar geliefert werden.

Tags:

CI/CD
← Vorheriger Artikel Die Desktop-Ära verstehen – Warum GUIs und wo sie heute stehen