Eine kuratierte Sammlung essentieller Tools für moderne Java-Entwicklung – von den Experten bei Java Fleet Systems Consulting

Seiteninhalt

0.1 🎯 Überblick
0.2 📚 Wichtige Abkürzungen & Begriffe

1 🔍 Security & Vulnerability Scanning
2 🏛️ Legacy Code & Migration
3 🔧 Build & Dependency Management
4 🧪 Testing & Quality Assurance
5 📊 Monitoring & Performance
- 5.1 Micrometer
  - 5.1.1 Beschreibung:
  - 5.1.2 Verwendung:
- 5.2 JProfiler / YourKit
  - 5.2.1 Beschreibung:
  - 5.2.2 Kostenlose Alternativen:
6 🚀 Development & IDE Tools
7 🛠️ Utility Libraries
- 7.1 Apache Commons
  - 7.1.1 Beschreibung:
  - 7.1.2 Verwendung:
- 7.2 Guava
  - 7.2.1 Beschreibung:
  - 7.2.2 Verwendung:
8 📚 Zusammenfassung & Quick-Start

🎯 Überblick

Diese Seite sammelt die wichtigsten Tools und Libraries, die in der Java-Entwicklung regelmäßig benötigt werden. Jedes Tool wird mit Charakterisierung, Beschreibung, Download/Installation und praktischer Verwendung erklärt.

📚 Wichtige Abkürzungen & Begriffe

Security & Vulnerability

CVE = Common Vulnerabilities and Exposures (öffentlich dokumentierte Sicherheitslücken)
SBOM = Software Bill of Materials (Stückliste aller Software-Komponenten)
OWASP = Open Web Application Security Project (Non-Profit für Web-Security)
CVSS = Common Vulnerability Scoring System (Bewertungssystem für Schwachstellen, 0-10)

Development & Testing

API = Application Programming Interface (Schnittstelle zwischen Software-Komponenten)
REST = Representational State Transfer (Architekturstil für Web-APIs)
JSON = JavaScript Object Notation (Datenformat für API-Kommunikation)
XML = eXtensible Markup Language (strukturiertes Datenformat)
YAML = YAML Ain’t Markup Language (menschenlesbares Datenformat)
IDE = Integrated Development Environment (Entwicklungsumgebung)
CLI = Command Line Interface (Kommandozeilen-Schnittstelle)
CI/CD = Continuous Integration/Continuous Deployment (automatisierte Build-Pipeline)
TDD = Test-Driven Development (testgetriebene Entwicklung)
BDD = Behavior-Driven Development (verhaltensgetriebene Entwicklung)

Architecture & Patterns

JVM = Java Virtual Machine (Laufzeitumgebung für Java)
JDK = Java Development Kit (Entwicklungskit mit Compiler, Tools, etc.)
JRE = Java Runtime Environment (Laufzeitumgebung ohne Entwicklungstools)
JAR = Java ARchive (gepackte Java-Anwendung)
WAR = Web Application Archive (gepackte Web-Anwendung)
ORM = Object-Relational Mapping (Objektrelationale Abbildung für Datenbanken)
MVC = Model-View-Controller (Architekturmuster für UI-Anwendungen)
DI = Dependency Injection (Entwurfsmuster für lose Kopplung)
AOP = Aspect-Oriented Programming (aspektorientierte Programmierung)

Data & Persistence

JDBC = Java Database Connectivity (Standard-API für Datenbankzugriff)
JPA = Java Persistence API (Standard für ORM in Java)
SQL = Structured Query Language (Datenbankabfragesprache)
NoSQL = Not Only SQL (nicht-relationale Datenbanken)
CRUD = Create, Read, Update, Delete (Grundoperationen für Daten)

Web & Networking

HTTP = HyperText Transfer Protocol (Web-Übertragungsprotokoll)
HTTPS = HTTP Secure (verschlüsselte Variante von HTTP)
SSL/TLS = Secure Sockets Layer/Transport Layer Security (Verschlüsselungsprotokolle)
JWT = JSON Web Token (Standard für sichere Datenübertragung)
CORS = Cross-Origin Resource Sharing (Browser-Sicherheitsfeature)
URL = Uniform Resource Locator (Webadresse)
URI = Uniform Resource Identifier (eindeutige Ressourcenkennung)

Build & Deployment

Maven = Build-Automation-Tool für Java (Project Object Model – POM)
Gradle = Build-Automation-Tool (Groovy/Kotlin-basiert)
Docker = Container-Virtualisierungsplattform
K8s = Kubernetes (Container-Orchestrierungsplattform)
VM = Virtual Machine (virtuelle Maschine)

Performance & Monitoring

GC = Garbage Collection (automatische Speicherverwaltung in Java)
JMX = Java Management Extensions (Monitoring- und Management-API)
APM = Application Performance Monitoring (Anwendungsleistungsüberwachung)
SLA = Service Level Agreement (Dienstgütevereinbarung)
SLO = Service Level Objective (Dienstgüteziel)

Standards & Specifications

JSR = Java Specification Request (Java-Standardisierungsprozess)
RFC = Request for Comments (Internet-Standards)
W3C = World Wide Web Consortium (Web-Standards-Organisation)
ISO = International Organization for Standardization (Internationale Normungsorganisation)

Kategorien:

🔍 Security & Vulnerability Scanning
🏛️ Legacy Code & Migration
🔧 Build & Dependency Management
🧪 Testing & Quality Assurance
📊 Monitoring & Performance
🚀 Development & IDE Tools

🔍 Security & Vulnerability Scanning

Trivy

Charakterisierung: Container- und Dependency-Vulnerability-Scanner
Typ: Security-Tool, Open Source

Beschreibung:

Trivy scannt Container-Images, Dateisysteme und Git-Repositories nach bekannten CVE (Common Vulnerabilities and Exposures) – das sind öffentlich dokumentierte Sicherheitslücken mit eindeutiger ID. Unterstützt Java, Python, Node.js, Go und viele weitere Sprachen. Bewertet Schwachstellen nach CVSS (Common Vulnerability Scoring System) von 0-10.

Download & Installation:

# macOS (Homebrew)
brew install trivy

# Linux (apt - Ubuntu/Debian)
sudo apt-get install wget apt-transport-https gnupg lsb-release
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy

# Windows (Chocolatey)
choco install trivy

# Windows (Manual Download)
# Download trivy_x.xx.x_windows-64bit.zip from GitHub Releases
# Unzip und trivy.exe in PATH-Verzeichnis kopieren

# Windows (Scoop)
scoop install trivy

# Docker (alle Plattformen)
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest

Offizielle Website: https://trivy.dev/ GitHub Releases: https://github.com/aquasecurity/trivy/releases

Praktische Verwendung:

# Java-Projekt scannen
trivy fs . 

# Container-Image scannen
trivy image myapp:latest

# Nur High/Critical Vulnerabilities
trivy image --severity HIGH,CRITICAL myapp:latest

# JSON-Report generieren
trivy image --format json --output result.json myapp:latest

# CI/CD: Exit-Code bei Critical Findings
trivy image --exit-code 1 --severity CRITICAL myapp:latest

Warum wichtig: Automatische Erkennung von Sicherheitslücken in Dependencies und Container-Images.

Syft

Charakterisierung: SBOM (Software Bill of Materials) Generator
Typ: Security-Tool, Open Source von Anchore
SBOM = Software Bill of Materials

Beschreibung:

Syft analysiert Container-Images und Projekte und erstellt eine vollständige SBOM – eine „Stückliste“ aller Software-Komponenten, Dependencies und Libraries. Dies ist die Basis für Vulnerability-Management und Compliance-Anforderungen. Unterstützt Standards wie SPDX und CycloneDX.

Download & Installation:

# macOS (Homebrew)
brew install syft

# Linux (Curl)
curl -sSfL https://raw.githubusercontent.com/anchore/syft/main/install.sh | sh -s -- -b /usr/local/bin

# Windows (Chocolatey)
choco install syft

# Windows (Scoop)
scoop install syft

# Windows (Manual Download)
# Download syft_x.xx.x_windows_amd64.zip from GitHub Releases
# Unzip und syft.exe in PATH-Verzeichnis kopieren

# Python (alle Plattformen)
pip install anchore-syft

# Go Install (alle Plattformen)
go install github.com/anchore/syft/cmd/syft@latest

Offizielle Website: https://github.com/anchore/syft GitHub Releases: https://github.com/anchore/syft/releases

Praktische Verwendung:

# SBOM für Java-Projekt erstellen
syft .

# Container-Image analysieren
syft myapp:latest

# JSON-Format (Standard)
syft myapp:latest -o cyclonedx-json > sbom.json

# SPDX-Format (für Compliance)
syft myapp:latest -o spdx-json > sbom-spdx.json

# Nur Java-Dependencies
syft . -o table --select-catalogers java-archive

Warum wichtig: Transparenz über alle verwendeten Komponenten, Grundlage für Security-Scans und Compliance.

OWASP Dependency-Check

Charakterisierung: Maven/Gradle Plugin für Dependency-Vulnerability-Scanning
Typ: Security-Plugin, OWASP Project
OWASP = Open Web Application Security Project

Beschreibung:

OWASP ist eine Non-Profit-Organisation, die sich der Verbesserung der Software-Sicherheit widmet. Das OWASP Top 10 ist die bekannteste Liste der kritischsten Web-Anwendungs-Sicherheitsrisiken.

Das OWASP Dependency-Check Plugin analysiert Projekt-Dependencies auf bekannte Schwachstellen aus der CVE-Datenbank (Common Vulnerabilities and Exposures). Integriert sich nahtlos in Maven/Gradle-Builds.

Download & Installation:

Maven (pom.xml):

<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>8.4.0</version>
    <configuration>
        <failBuildOnCVSS>7</failBuildOnCVSS>
    </configuration>
</plugin>

Gradle (build.gradle):

plugins {
    id 'org.owasp.dependencycheck' version '8.4.0'
}

dependencyCheck {
    failBuildOnCVSS = 7
}

Offizielle Website: https://owasp.org/www-project-dependency-check/

Praktische Verwendung:

# Maven
mvn org.owasp:dependency-check-maven:check

# Gradle
./gradlew dependencyCheckAnalyze

# Report in target/dependency-check-report.html

Warum wichtig: Automatische Integration in Build-Pipeline, findet vulnerable Dependencies vor Production-Deployment.

🏛️ Legacy Code & Migration

jdeps

Charakterisierung: JDK-Tool für Dependency-Analyse
Typ: Built-in JDK-Tool
JDK = Java Development Kit

Beschreibung:

Analysiert Java-Bytecode und zeigt Abhängigkeiten zwischen Packages, Classes und JDK-Modulen. Essential für JDK-Migrationen (z.B. von Java 8 → 11 → 17). Findet problematische Internal APIs, die in neueren JDK-Versionen entfernt wurden.

Download & Installation:

Im JDK enthalten (seit JDK 8) – funktioniert auf Windows, Linux, macOS.

# Verfügbarkeit prüfen (alle Plattformen)
jdeps --version

# Windows (PowerShell/CMD)
jdeps --jdk-internals target\classes\

# Linux/macOS (Bash)
jdeps --jdk-internals target/classes/

Praktische Verwendung:

# JDK-Internal-APIs finden (wichtig für JDK 9+ Migration)
jdeps --jdk-internals target/classes/

# Alle Dependencies anzeigen
jdeps -verbose target/classes/

# Module-Dependencies (JDK 9+)
jdeps --module-path target/dependency target/classes/

# Summary-Report
jdeps --summary target/classes/

Warum wichtig: Unverzichtbar für JDK-Migrationen, findet problematische Dependencies vor Breaking Changes.

ArchUnit

Charakterisierung: Java-Architecture-Testing-Framework
Typ: Testing-Library

Beschreibung:

Ermöglicht automatisierte Tests der Code-Architektur. Perfekt für Legacy-Refactoring und Architectural Governance.

Download & Installation:

Maven:

<dependency>
    <groupId>com.tngtech.archunit</groupId>
    <artifactId>archunit-junit5</artifactId>
    <version>1.2.1</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://www.archunit.org/

Praktische Verwendung:

@Test
void layeredArchitecture() {
    layeredArchitecture()
        .layer("Controller").definedBy("..controller..")
        .layer("Service").definedBy("..service..")
        .layer("Repository").definedBy("..repository..")
        .whereLayer("Controller").mayNotBeAccessedByAnyLayer()
        .whereLayer("Service").mayOnlyBeAccessedByLayers("Controller")
        .whereLayer("Repository").mayOnlyBeAccessedByLayers("Service");
}

@Test
void noCyclesInPackages() {
    slices().matching("com.company.(*)..").should().beFreeOfCycles();
}

Warum wichtig: Verhindert Architectural Drift, macht Code-Regeln testbar.

Characterization Testing Tools

ApprovalTests

Charakterisierung: Golden Master Testing Framework
Typ: Testing-Library

Beschreibung:

Vereinfacht Characterization Testing durch automatische „Golden Master“ Comparison.

Maven:

<dependency>
    <groupId>com.approvaltests</groupId>
    <artifactId>approvaltests</artifactId>
    <version>22.2.0</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://approvaltests.com/

Verwendung:

@Test
void characterizeLegacyMethod() {
    LegacyClass legacy = new LegacyClass();
    String result = legacy.complexMethod(input);
    Approvals.verify(result);
}

Warum wichtig: Macht Legacy-Code-Testing einfach und sicher.

🔧 Build & Dependency Management

Maven Wrapper

Charakterisierung: Build-Tool-Versionierung
Typ: Build-Wrapper

Beschreibung:

Stellt sicher, dass alle Entwickler die gleiche Maven-Version verwenden.

Installation:

# In bestehendem Maven-Projekt (alle Plattformen)
mvn wrapper:wrapper

# Mit spezifischer Version
mvn wrapper:wrapper -Dmaven=3.9.4

Verwendung:

# Linux/macOS
./mvnw clean install

# Windows (PowerShell/CMD)
mvnw.cmd clean install
# oder in PowerShell
.\mvnw.cmd clean install

Warum wichtig: Konsistente Builds unabhängig von lokaler Maven-Installation.

Gradle Wrapper

Charakterisierung: Build-Tool-Versionierung für Gradle
Typ: Build-Wrapper

Beschreibung:

Gradle-Pendant zum Maven Wrapper.

Verwendung:

# Linux/macOS
./gradlew build
./gradlew test

# Windows (PowerShell/CMD)
gradlew.bat build
gradlew.bat test

# PowerShell (alternative Syntax)
.\gradlew.bat build

Warum wichtig: Reproduzierbare Builds, keine lokale Gradle-Installation nötig.

Maven Versions Plugin

Charakterisierung: Dependency-Update-Management
Typ: Maven Plugin

Beschreibung:

Hilft beim Management von Dependency- und Plugin-Versionen.

Configuration:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>versions-maven-plugin</artifactId>
    <version>2.16.1</version>
</plugin>

Verwendung:

# Veraltete Dependencies finden
mvn versions:display-dependency-updates

# Plugin-Updates anzeigen
mvn versions:display-plugin-updates

# Alle Dependencies auf neueste Version
mvn versions:use-latest-releases

Warum wichtig: Hält Dependencies aktuell, reduziert Security-Vulnerabilities.

🧪 Testing & Quality Assurance

jqwik

Charakterisierung: Property-Based Testing Framework für Java
Typ: Testing-Framework

Beschreibung:

Ermöglicht Property-Based Testing – generiert automatisch Test-Daten und findet Edge Cases.

Maven:

<dependency>
    <groupId>net.jqwik</groupId>
    <artifactId>jqwik</artifactId>
    <version>1.7.4</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://jqwik.net/

Verwendung:

@Property
boolean absoluteValueIsNeverNegative(@ForAll int number) {
    return Math.abs(number) >= 0;
}

@Property
void sortingDoesNotChangeListSize(@ForAll List<Integer> list) {
    List<Integer> sorted = new ArrayList<>(list);
    Collections.sort(sorted);
    assertThat(sorted).hasSameSizeAs(list);
}

Warum wichtig: Findet Edge Cases, die Example-Based Testing übersieht.

TestContainers

Charakterisierung: Integration-Testing mit echten Services
Typ: Testing-Framework

Beschreibung:

Startet echte Services (Datenbanken, Message Brokers, etc.) in Docker-Containern für Integration-Tests. Eliminiert Mocking zugunsten echter Services. Unterstützt PostgreSQL, MySQL, MongoDB, Kafka, Redis und viele andere. Tests laufen mit echten Dependencies statt Mock-Objekten.

Maven:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>1.19.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>postgresql</artifactId>
    <version>1.19.0</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://www.testcontainers.org/

Verwendung:

@Testcontainers
class DatabaseTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @Test
    void contextLoads() {
        String jdbcUrl = postgres.getJdbcUrl();
        // Test mit echter PostgreSQL-Datenbank
    }
}

Warum wichtig: Echte Integration-Tests ohne Mocking, hohe Test-Confidence.

Mockito

Charakterisierung: Mocking-Framework für Java
Typ: Testing-Library

Beschreibung:

Standard-Mocking-Framework für Java-Unit-Tests.

Maven:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.5.0</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://mockito.org/

Verwendung:

@Mock
private UserRepository userRepository;

@Test
void shouldReturnUser() {
    User mockUser = new User("John");
    when(userRepository.findById(1L)).thenReturn(mockUser);
    
    User result = userService.getUser(1L);
    
    assertThat(result.getName()).isEqualTo("John");
    verify(userRepository).findById(1L);
}

Warum wichtig: Isolierte Unit-Tests, unabhängig von externen Dependencies.

AssertJ

Charakterisierung: Fluent Assertion Library
Typ: Testing-Library

Beschreibung:

Moderne, lesbare Assertions für Java-Tests.

Maven:

<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.24.2</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://assertj.github.io/doc/

Verwendung:

@Test
void fluentAssertions() {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    
    assertThat(names)
        .hasSize(3)
        .contains("Alice", "Bob")
        .doesNotContain("Dave")
        .allMatch(name -> name.length() > 2);
}

Warum wichtig: Bessere Lesbarkeit, aussagekräftige Error-Messages.

📊 Monitoring & Performance

Micrometer

Charakterisierung: Metrics-Abstraction für JVM-Anwendungen
Typ: Monitoring-Library

Beschreibung:

Vendor-neutrale Metrics-API, integriert sich in Prometheus, Grafana, etc.

Maven (Spring Boot):

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Offizielle Website: https://micrometer.io/

Verwendung:

@RestController
public class MetricsController {
    
    private final Counter requestCounter;
    private final Timer requestTimer;
    
    public MetricsController(MeterRegistry meterRegistry) {
        this.requestCounter = Counter.builder("api.requests.total")
                .description("Total API requests")
                .register(meterRegistry);
        this.requestTimer = Timer.builder("api.request.duration")
                .description("API request duration")
                .register(meterRegistry);
    }
}

Warum wichtig: Einheitliche Metrics unabhängig vom Monitoring-System.

JProfiler / YourKit

Charakterisierung: Java-Performance-Profiler
Typ: Profiling-Tools (Commercial)

Beschreibung:

Professionelle Tools für Memory-Leak-Detection, Performance-Analyse und Thread-Debugging.

JProfiler: https://www.ej-technologies.com/products/jprofiler/overview.html
YourKit: https://www.yourkit.com/

Kostenlose Alternativen:

VisualVM: Im JDK enthalten
JConsole: Im JDK enthalten
Eclipse MAT: https://www.eclipse.org/mat/

Warum wichtig: Unverzichtbar für Performance-Optimierung und Memory-Leak-Hunting.

🚀 Development & IDE Tools

Lombok

Charakterisierung: Boilerplate-Code-Reduktion
Typ: Annotation-Processor

Beschreibung:

Reduziert Java-Boilerplate durch Annotations (@Getter, @Setter, @Data, etc.).

Maven:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

Offizielle Website: https://projectlombok.org/

Verwendung:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private int age;
    private String email;
    // Getter, Setter, toString, equals, hashCode automatisch generiert
}

Warum wichtig: Weniger Code, bessere Lesbarkeit, weniger Fehlerquellen.

MapStruct

Charakterisierung: Type-Safe Bean Mapping
Typ: Annotation-Processor

Beschreibung:

Generiert typisierte Mapping-Code zwischen Java-Beans zur Compile-Time.

Maven:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>1.5.5.Final</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.5.5.Final</version>
    <scope>provided</scope>
</dependency>

Offizielle Website: https://mapstruct.org/

Verwendung:

@Mapper
public interface PersonMapper {
    PersonDto toDto(Person person);
    Person toEntity(PersonDto dto);
    
    @Mapping(source = "fullName", target = "name")
    PersonDto toDtoWithMapping(Person person);
}

Warum wichtig: Type-Safe Mapping, Performance, keine Reflection.

Spotbugs

Charakterisierung: Static Code Analysis
Typ: Code-Quality-Tool

Beschreibung:

Findet potentielle Bugs durch statische Code-Analyse.

Maven:

<plugin>
    <groupId>com.github.spotbugs</groupId>
    <artifactId>spotbugs-maven-plugin</artifactId>
    <version>4.7.3.6</version>
</plugin>

Offizielle Website: https://spotbugs.github.io/

Verwendung:

# SpotBugs-Analyse ausführen
mvn spotbugs:spotbugs

# Report anzeigen
mvn spotbugs:gui

Warum wichtig: Findet potentielle Bugs vor Production-Deployment.

Checkstyle

Charakterisierung: Code-Style-Checker
Typ: Code-Quality-Tool

Beschreibung:

Überprüft Code-Formatierung und Style-Guidelines.

Maven:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.3.0</version>
    <configuration>
        <configLocation>checkstyle.xml</configLocation>
    </configuration>
</plugin>

Offizielle Website: https://checkstyle.sourceforge.io/

Verwendung:

# Checkstyle-Check
mvn checkstyle:check

# Report generieren
mvn checkstyle:checkstyle

Warum wichtig: Konsistenter Code-Style im Team.

DataFaker

Charakterisierung: Test-Data-Generation
Typ: Testing-Utility

Beschreibung:

Generiert realistische Test-Daten für verschiedene Anwendungsfälle.

Maven:

<dependency>
    <groupId>net.datafaker</groupId>
    <artifactId>datafaker</artifactId>
    <version>2.0.2</version>
    <scope>test</scope>
</dependency>

Offizielle Website: https://www.datafaker.net/

Verwendung:

Faker faker = new Faker();

String name = faker.name().fullName();
String email = faker.internet().emailAddress();
String address = faker.address().fullAddress();
LocalDate birthday = faker.timeAndDate().birthday();

// Für Property-Based Testing mit jqwik
@Provide
Arbitrary<Person> persons() {
    return Arbitraries.randomValue(random -> {
        Faker faker = new Faker(random);
        return new Person(
            faker.name().firstName(),
            faker.name().lastName(),
            faker.internet().emailAddress()
        );
    });
}

Warum wichtig: Realistische Test-Daten, keine manuellen Dummy-Daten.

🛠️ Utility Libraries

Apache Commons

Charakterisierung: Utility-Library-Collection
Typ: Utility-Libraries

Beschreibung:

Sammlung nützlicher Utility-Classes für häufige Programmier-Tasks.

Wichtigste Module:

<!-- String-Utilities -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.13.0</version>
</dependency>

<!-- Collection-Utilities -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

<!-- IO-Utilities -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.13.0</version>
</dependency>

Offizielle Website: https://commons.apache.org/

Verwendung:

// String-Utilities
StringUtils.isBlank("  "); // true
StringUtils.capitalize("hello"); // "Hello"

// Collection-Utilities
CollectionUtils.isNotEmpty(list);
CollectionUtils.intersection(list1, list2);

// IO-Utilities
FileUtils.readFileToString(file, StandardCharsets.UTF_8);

Warum wichtig: Battle-tested Utilities, weniger eigene Utility-Methods nötig.

Guava

Charakterisierung: Google’s Core Libraries für Java
Typ: Utility-Library

Beschreibung:

Google’s Collection von Utility-Classes und funktionalen Programmier-Helfern.

Maven:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

Offizielle Website: https://github.com/google/guava

Verwendung:

// Immutable Collections
List<String> list = ImmutableList.of("a", "b", "c");
Map<String, Integer> map = ImmutableMap.of("key1", 1, "key2", 2);

// String-Utilities
Strings.isNullOrEmpty(null); // true
Strings.padStart("7", 3, '0'); // "007"

// Preconditions
Preconditions.checkNotNull(object, "Object cannot be null");
Preconditions.checkArgument(age >= 0, "Age cannot be negative");

Warum wichtig: Hochwertige, performante Utilities von Google.

📚 Zusammenfassung & Quick-Start

Essential-Tools für jeden Java-Entwickler:

🚀 Sofort installieren:

Maven/Gradle Wrapper – Reproduzierbare Builds
Trivy – Security-Scanning
jdeps – JDK-Migration-Analyse
TestContainers – Integration-Testing

📊 Für Legacy-Code-Warrior:

Syft – SBOM-Generation
ArchUnit – Architecture-Testing
ApprovalTests – Characterization-Testing
OWASP Dependency-Check – Vulnerability-Scanning

🧪 Für Testing-Enthusiasten:

jqwik – Property-Based Testing
AssertJ – Fluent Assertions
Mockito – Mocking
DataFaker – Test-Data-Generation

⚡ Für Performance-Optimierung:

Micrometer – Metrics
VisualVM – Profiling (kostenlos)
JConsole – JVM-Monitoring

Installation-Checkliste:

# Security-Tools
brew install trivy syft

# Java-Analysis
java -version  # jdeps ist im JDK enthalten

# Maven-Projekt-Setup
mvn wrapper:wrapper

# Optional: Global Tools
npm install -g @cyclonedx/cyclonedx-npm  # Für Node.js-Projekte

Team-Setup-Empfehlung:

In jedes neue Java-Projekt gehört:

<!-- pom.xml essentials -->
<dependencies>
    <!-- Testing -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.assertj</groupId>
        <artifactId>assertj-core</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <scope>test</scope>
    </dependency>
    
    <!-- Utilities -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- Security -->
        <plugin>
            <groupId>org.owasp</groupId>
            <artifactId>dependency-check-maven</artifactId>
        </plugin>
        
        <!-- Code Quality -->
        <plugin>
            <groupId>com.github.spotbugs</groupId>
            <artifactId>spotbugs-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Diese Tool-Liste wird regelmäßig aktualisiert basierend auf Community-Feedback und neuen Entwicklungen in der Java-Welt.

🔥 Advanced Tools für Spezialisten

Performance & JVM Tuning

JProfiler

Charakterisierung: Premium Java Performance Profiler
Typ: Commercial Profiling Tool

Beschreibung:

Professioneller Profiler für Memory-Leak-Detection, CPU-Profiling und Thread-Analyse.

Website: https://www.ej-technologies.com/products/jprofiler/
Lizenz: Commercial (Trial verfügbar)

Verwendung:

# JVM-Agent aktivieren
java -agentpath:/path/to/jprofiler/bin/agent.jar myapp.jar

# Remote Profiling
java -agentpath:jprofiler_agent.jar=port=8849 myapp.jar

Alternativen (kostenlos):

VisualVM: jvisualvm (im JDK enthalten)
JConsole: jconsole (im JDK enthalten)
Eclipse MAT: Memory Analyzer Tool

GCEasy

Charakterisierung: Online GC-Log-Analyzer
Typ: Web-Service (kostenlos)

Beschreibung:

Analysiert Garbage Collection Logs und gibt Performance-Empfehlungen.

Website: https://gceasy.io/

Verwendung:

# GC-Logs aktivieren
java -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log myapp.jar

# Log zu GCEasy hochladen für Analyse

Warum wichtig: Identifiziert GC-Performance-Probleme, Memory-Leaks.

Code Generation & Templates

JHipster

Charakterisierung: Full-Stack-Anwendungs-Generator
Typ: Yeoman-Generator für Spring Boot + Frontend

Beschreibung:

Generiert moderne Full-Stack-Anwendungen mit Spring Boot Backend, Angular/React/Vue Frontend, JWT-Authentication, JPA-Entities und Docker-Configuration. Basiert auf Yeoman (Node.js-Generator-Framework) und befolgt moderne Full-Stack-Best-Practices.

Installation:

npm install -g generator-jhipster

Website: https://www.jhipster.tech/

Verwendung:

# Neue Anwendung erstellen
jhipster

# Entity generieren
jhipster entity Customer

Warum wichtig: Rapid Prototyping, Best-Practice-Setup, moderne Tech-Stacks.

OpenAPI Generator

Charakterisierung: API-Client- und Server-Code-Generator
Typ: Code-Generation-Tool

Beschreibung:

Generiert API-Client- und Server-Code aus OpenAPI/Swagger-Spezifikationen.

Installation:

# Via npm
npm install @openapitools/openapi-generator-cli -g

# Via Homebrew
brew install openapi-generator

Website: https://openapi-generator.tech/

Verwendung:

# Java-Client generieren
openapi-generator generate -i api.yaml -g java -o client/

# Spring Boot Server generieren
openapi-generator generate -i api.yaml -g spring -o server/

Maven Plugin:

<plugin>
    <groupId>org.openapitools</groupId>
    <artifactId>openapi-generator-maven-plugin</artifactId>
    <version>7.0.1</version>
    <executions>
        <execution>
            <goals>
                <goal>generate</goal>
            </goals>
            <configuration>
                <inputSpec>src/main/resources/api.yaml</inputSpec>
                <generatorName>java</generatorName>
                <output>${project.build.directory}/generated-sources</output>
            </configuration>
        </execution>
    </executions>
</plugin>

Warum wichtig: API-First-Development, Type-Safety, konsistente Clients.

Database & Migration Tools

Flyway

Charakterisierung: Database Version Control
Typ: Database Migration Tool

Beschreibung:

Versioniert und migriert Datenbank-Schemas automatisch.

Maven:

<plugin>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-maven-plugin</artifactId>
    <version>9.22.3</version>
    <configuration>
        <url>jdbc:postgresql://localhost:5432/mydb</url>
        <user>user</user>
        <password>password</password>
    </configuration>
</plugin>

Website: https://flywaydb.org/

Verwendung:

-- V1__Create_person_table.sql
CREATE TABLE person (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL
);

-- V2__Add_age_column.sql  
ALTER TABLE person ADD COLUMN age INTEGER;

# Migration ausführen
mvn flyway:migrate

# Status prüfen
mvn flyway:info

Warum wichtig: Reproduzierbare Database-Deployments, Versionskontrolle für Schema.

Liquibase

Charakterisierung: Database Change Management
Typ: Database Migration Tool (XML/YAML-basiert)

Beschreibung:

Alternative zu Flyway mit XML/YAML-basierter Konfiguration.

Maven:

<plugin>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-maven-plugin</artifactId>
    <version>4.24.0</version>
</plugin>

Website: https://www.liquibase.org/

Verwendung:

<!-- changelog.xml -->
<databaseChangeLog>
    <changeSet id="1" author="developer">
        <createTable tableName="person">
            <column name="id" type="bigint" autoIncrement="true">
                <constraints primaryKey="true"/>
            </column>
            <column name="name" type="varchar(100)">
                <constraints nullable="false"/>
            </column>
        </createTable>
    </changeSet>
</databaseChangeLog>

Warum wichtig: Database-agnostische Migrations, Rollback-Support.

Documentation & API Tools

SpringDoc OpenAPI

Charakterisierung: OpenAPI 3 Integration für Spring Boot
Typ: Documentation-Library
API = Application Programming Interface

Beschreibung:

Generiert automatisch OpenAPI/Swagger-Dokumentation für Spring Boot REST APIs. OpenAPI (früher Swagger) ist der Standard zur Beschreibung von REST-Schnittstellen. Erstellt interaktive API-Dokumentation mit Test-Interface (Swagger UI) unter /swagger-ui.html.

Maven:

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.2.0</version>
</dependency>

Website: https://springdoc.org/

Verwendung:

@RestController
@Tag(name = "Person", description = "Person management API")
public class PersonController {
    
    @GetMapping("/persons")
    @Operation(summary = "Get all persons")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "Found persons"),
        @ApiResponse(responseCode = "404", description = "No persons found")
    })
    public List<Person> getAllPersons() {
        return personService.findAll();
    }
}

Swagger UI verfügbar unter: http://localhost:8080/swagger-ui.html

Warum wichtig: Automatische API-Dokumentation, interaktive API-Explorer.

AsciiDoctor

Charakterisierung: Dokumentations-Tool
Typ: Markup-Processor

Beschreibung:

Erstellt professionelle Dokumentation aus AsciiDoc-Files.

Maven:

<plugin>
    <groupId>org.asciidoctor</groupId>
    <artifactId>asciidoctor-maven-plugin</artifactId>
    <version>2.2.4</version>
    <executions>
        <execution>
            <id>generate-docs</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>process-asciidoc</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Website: https://asciidoctor.org/

Verwendung:

= Java Fleet Systems API Documentation
:toc:
:numbered:

== Introduction

This document describes the REST API endpoints.

== Endpoints

=== GET /persons
Returns all persons in the system.

[source,bash]

—- curl -X GET http://localhost:8080/api/persons —-

Warum wichtig: Professionelle Dokumentation, PDF/HTML-Export, Versionierung.

Containerization & Cloud Tools

Jib

Charakterisierung: Container-Image-Builder für Java
Typ: Build-Tool-Plugin

Beschreibung:

Erstellt Container-Images direkt aus Maven/Gradle ohne Dockerfile.

Maven:

<plugin>
    <groupId>com.google.cloud.tools</groupId>
    <artifactId>jib-maven-plugin</artifactId>
    <version>3.4.0</version>
    <configuration>
        <to>
            <image>gcr.io/my-project/my-app</image>
        </to>
    </configuration>
</plugin>

Website: https://github.com/GoogleContainerTools/jib

Verwendung:

# Image bauen und zu Registry pushen
mvn jib:build

# Image bauen zu lokaler Docker Registry
mvn jib:dockerBuild

# Tar-Archiv erstellen
mvn jib:buildTar

Warum wichtig: Optimierte Container-Images, kein Docker-Daemon nötig, Layer-Caching.

Fabric8 Docker Maven Plugin

Charakterisierung: Docker-Integration für Maven
Typ: Build-Plugin

Beschreibung:

Integriert Docker-Builds und -Container-Management in Maven-Lifecycle.

Maven:

<plugin>
    <groupId>io.fabric8</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.43.4</version>
    <configuration>
        <images>
            <image>
                <name>my-app:latest</name>
                <build>
                    <dockerFile>Dockerfile</dockerFile>
                    <contextDir>${project.basedir}</contextDir>
                </build>
            </image>
        </images>
    </configuration>
</plugin>

Website: https://dmp.fabric8.io/

Verwendung:

# Docker-Image bauen
mvn docker:build

# Container starten
mvn docker:start

# Container stoppen
mvn docker:stop

Warum wichtig: Docker-Integration in Maven, Integration-Tests mit Containern.

Security & Compliance Tools

Cosign

Charakterisierung: Container-Image-Signing-Tool
Typ: Security-Tool (CNCF)

Beschreibung:

Signiert und verifiziert Container-Images für Supply-Chain-Security.

Installation:

# macOS (Homebrew)
brew install cosign

# Linux (Curl)
curl -O -L "https://github.com/sigstore/cosign/releases/latest/download/cosign-linux-amd64"
sudo mv cosign-linux-amd64 /usr/local/bin/cosign
sudo chmod +x /usr/local/bin/cosign

# Windows (Winget)
winget install sigstore.cosign

# Windows (Chocolatey)
choco install cosign

# Windows (Manual)
# Download cosign-windows-amd64.exe from GitHub Releases

Website: https://docs.sigstore.dev/cosign/overview

Verwendung:

# Keypair generieren
cosign generate-key-pair

# Image signieren
cosign sign --key cosign.key my-app:latest

# Signatur verifizieren
cosign verify --key cosign.pub my-app:latest

Warum wichtig: Supply-Chain-Security, Image-Authentizität, Compliance.

Snyk

Charakterisierung: Developer-Security-Platform
Typ: Security-as-a-Service

Beschreibung:

Findet und behebt Vulnerabilities in Dependencies, Container-Images und Code.

Installation:

npm install -g snyk

Website: https://snyk.io/

Verwendung:

# Auth (benötigt Account)
snyk auth

# Projekt scannen
snyk test

# Automatische Fixes anwenden
snyk fix

# Container-Image scannen
snyk container test my-app:latest

# Code-Analyse
snyk code test

Warum wichtig: Kontinuierliche Security-Überwachung, automatische Fixes, Developer-Integration.

Message Queues & Event Streaming

Testcontainers – Kafka Module

Charakterisierung: Integration Testing für Apache Kafka
Typ: Testing-Framework-Extension

Beschreibung:

Ermöglicht Integration-Tests mit echtem Kafka-Cluster.

Maven:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>kafka</artifactId>
    <version>1.19.0</version>
    <scope>test</scope>
</dependency>

Verwendung:

@Testcontainers
class KafkaIntegrationTest {
    
    @Container
    static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.4.0"));
    
    @Test
    void shouldProduceAndConsumeMessage() {
        String bootstrapServers = kafka.getBootstrapServers();
        
        // Producer und Consumer mit echtem Kafka testen
        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        
        // Test Implementation...
    }
}

Warum wichtig: Realistische Integration-Tests für Event-Streaming-Anwendungen.

Embedded Kafka (Spring)

Charakterisierung: Embedded Kafka für Spring-Tests
Typ: Testing-Utility

Beschreibung:

Eingebetteter Kafka-Server für Spring-Integration-Tests.

Maven:

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka-test</artifactId>
    <scope>test</scope>
</dependency>

Verwendung:

@SpringBootTest
@EmbeddedKafka(partitions = 1, topics = {"test-topic"})
class KafkaProducerTest {
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    @Test
    void shouldSendMessage() {
        kafkaTemplate.send("test-topic", "test-message");
        // Assertions...
    }
}

Warum wichtig: Schnelle Kafka-Tests ohne externe Dependencies.

JSON & Data Processing

Jackson

Charakterisierung: JSON-Processing-Library
Typ: Data-Binding-Framework
JSON = JavaScript Object Notation

Beschreibung:

Standard-JSON-Library für Java, integriert in Spring Boot. Konvertiert zwischen Java-Objekten und JSON (JavaScript Object Notation) – dem Standard-Datenformat für REST APIs und Web-Services. Unterstützt auch XML, YAML und andere Formate.

Maven:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

Website: https://github.com/FasterXML/jackson

Verwendung:

ObjectMapper mapper = new ObjectMapper();

// Serialization
Person person = new Person("John", "Doe");
String json = mapper.writeValueAsString(person);

// Deserialization
Person deserializedPerson = mapper.readValue(json, Person.class);

// Custom Configuration
ObjectMapper customMapper = JsonMapper.builder()
    .addModule(new JavaTimeModule())
    .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
    .build();

Warum wichtig: Standard für JSON in Java, hochperformant, flexibel konfigurierbar.

JSON Path

Charakterisierung: JSON-Query-Language
Typ: JSON-Processing-Utility

Beschreibung:

XPath-ähnliche Syntax für JSON-Dokumente.

Maven:

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.8.0</version>
</dependency>

Website: https://github.com/json-path/JsonPath

Verwendung:

String json = "{'persons':[{'name':'John','age':30},{'name':'Jane','age':25}]}";

// Einfache Queries
List<String> names = JsonPath.read(json, "$.persons[*].name");
Integer firstPersonAge = JsonPath.read(json, "$.persons[0].age");

// Mit Filtern
List<String> adultsNames = JsonPath.read(json, "$.persons[?(@.age >= 18)].name");

Warum wichtig: Einfache JSON-Queries, nützlich für Tests und Data-Processing.

Configuration Management

Spring Boot Configuration Processor

Charakterisierung: Configuration Metadata Generator
Typ: Annotation Processor

Beschreibung:

Generiert Metadata für Type-Safe Configuration Properties.

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

Verwendung:

@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    
    /**
     * Application name
     */
    private String name = "MyApp";
    
    /**
     * Security settings
     */
    private Security security = new Security();
    
    @Data
    public static class Security {
        /**
         * Enable JWT authentication
         */
        private boolean jwtEnabled = false;
        
        /**
         * JWT secret key
         */
        private String jwtSecret;
    }
}

application.yml:

app:
  name: PersonApp
  security:
    jwt-enabled: true
    jwt-secret: ${JWT_SECRET:default-secret}

Warum wichtig: Type-Safe Configuration, IDE-Unterstützung, Dokumentation.

Owner (Configuration Library)

Charakterisierung: Type-Safe Property Loading
Typ: Configuration-Framework

Beschreibung:

Alternative zu Spring’s @ConfigurationProperties mit mehr Features.

Maven:

<dependency>
    <groupId>org.aeonbits.owner</groupId>
    <artifactId>owner</artifactId>
    <version>1.0.12</version>
</dependency>

Website: http://owner.aeonbits.org/

Verwendung:

@Config.Sources({
    "classpath:application.properties",
    "system:properties",
    "system:env"
})
public interface AppConfig extends Config {
    
    @DefaultValue("localhost")
    String hostname();
    
    @Key("server.port")
    @DefaultValue("8080")
    int port();
    
    @Key("database.url")
    String databaseUrl();
    
    @Key("feature.enabled")
    @DefaultValue("false")
    boolean isFeatureEnabled();
}

// Usage
AppConfig config = ConfigFactory.create(AppConfig.class);
String host = config.hostname();

Warum wichtig: Type-Safety, Multiple Property-Sources, Default-Values.

HTTP Clients & Web Services

OkHttp

Charakterisierung: HTTP-Client-Library
Typ: Networking-Library

Beschreibung:

Moderner, effizienter HTTP-Client mit Connection-Pooling und Interceptors.

Maven:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>

Website: https://square.github.io/okhttp/

Verwendung:

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .addInterceptor(new LoggingInterceptor())
    .build();

Request request = new Request.Builder()
    .url("https://api.example.com/users")
    .header("Authorization", "Bearer " + token)
    .build();

try (Response response = client.newCall(request).execute()) {
    String responseBody = response.body().string();
    // Process response
}

Warum wichtig: Performance, Connection-Pooling, Interceptor-Pattern.

Feign

Charakterisierung: Declarative HTTP Client
Typ: HTTP-Client-Framework

Beschreibung:

Deklarativer HTTP-Client, integriert sich gut in Spring Cloud.

Maven (Spring Cloud):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Website: https://github.com/OpenFeign/feign

Verwendung:

@FeignClient(name = "person-service", url = "https://api.example.com")
public interface PersonClient {
    
    @GetMapping("/persons")
    List<Person> getAllPersons();
    
    @GetMapping("/persons/{id}")
    Person getPersonById(@PathVariable Long id);
    
    @PostMapping("/persons")
    Person createPerson(@RequestBody PersonCreateRequest request);
}

// Usage in Service
@Service
public class PersonService {
    
    private final PersonClient personClient;
    
    public List<Person> getPersons() {
        return personClient.getAllPersons();
    }
}

Warum wichtig: Deklarative API-Calls, Spring-Integration, Load-Balancing.

Caching & Performance

Caffeine

Charakterisierung: High-Performance Caching Library
Typ: In-Memory-Cache

Beschreibung:

Moderner Ersatz für Guava Cache mit besserer Performance.

Maven:

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

Website: https://github.com/ben-manes/caffeine

Verwendung:

// Einfacher Cache
Cache<String, Person> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build();

// Verwendung
Person person = cache.get(key, k -> personService.findById(k));

// LoadingCache
LoadingCache<String, Person> loadingCache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build(key -> personService.findById(key));

Person person = loadingCache.get(personId);

Spring Boot Integration:

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .initialCapacity(100)
            .maximumSize(1000)
            .expireAfterAccess(10, TimeUnit.MINUTES));
        return cacheManager;
    }
}

Warum wichtig: High-Performance, Memory-Efficient, Spring-Integration.

Redis (Jedis/Lettuce)

Charakterisierung: Distributed Caching
Typ: NoSQL-Database/Cache

Beschreibung:

In-Memory-Datenbank für Caching, Sessions, Message-Queues.

Maven (Spring Boot):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Verwendung:

@Service
public class PersonCacheService {
    
    private final RedisTemplate<String, Person> redisTemplate;
    
    @Cacheable(value = "persons", key = "#id")
    public Person getPersonById(Long id) {
        return personService.findById(id);
    }
    
    @CacheEvict(value = "persons", key = "#person.id")
    public Person updatePerson(Person person) {
        return personService.save(person);
    }
}

Configuration:

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 2000ms
    lettuce:
      pool:
        max-active: 8
        max-idle: 8

Warum wichtig: Distributed Caching, Session-Storage, High-Performance.

📋 Tool-Matrix: Wann welches Tool?

🔍 Security-Scanning-Entscheidung:

Use Case	Tool	Warum
Container-Images scannen	Trivy	Schnell, genau, findet CVEs in allen Layern
SBOM generieren	Syft	Standard-konform (SPDX, CycloneDX), viele Outputs
Dependencies in Build	OWASP Dependency-Check	Maven/Gradle-Integration, CVSS-Bewertung
Commercial-Grade	Snyk	Developer-Experience, Auto-Fix, SaaS

🏛️ Legacy-Code-Modernisierung:

Phase	Tool	Zweck
Analysis	jdeps	JDK-Compatibility prüfen, Internal APIs finden
Testing	ApprovalTests	Behavior dokumentieren (Golden Master)
Architecture	ArchUnit	Architecture-Regeln durchsetzen (DSL)
Migration	Charakterisierung	Sicherheitsnetz für Refactoring aufbauen

🧪 Testing-Strategie:

Test-Typ	Tool	Wann einsetzen
Unit Tests	JUnit 5 + Mockito	Basis für TDD, isolierte Tests
Property-Based	jqwik	Complex Logic, Edge Cases finden
Integration	TestContainers	Echte Services (Docker-basiert) testen
Legacy Code	ApprovalTests	Existing Behavior capture (Characterization)

⚡ Performance-Optimierung:

Problem	Tool	Lösung
Memory Leaks	VisualVM/JProfiler	Heap-Analyse, GC-Monitoring
GC-Probleme	GCEasy	GC-Log-Analyse, Tuning-Empfehlungen
Slow Methods	JProfiler	CPU-Profiling, Hotspot-Detection
Caching	Caffeine	High-Performance In-Memory-Cache

🚀 Windows-Installationsleitfaden für Java-Tools

📋 Windows Package Manager – Empfohlene Optionen:

1. Chocolatey (am meisten unterstützt):

# Chocolatey installieren (einmalig)
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# Tools installieren
choco install trivy syft cosign

2. Scoop (modern, sauber):

# Scoop installieren (einmalig)
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

# Tools installieren
scoop install trivy syft

3. Winget (Windows 10/11 integriert):

winget install sigstore.cosign
# Nicht alle Tools verfügbar

⚠️ Wichtige Windows-spezifische Hinweise:

PowerShell vs. CMD:

Die meisten Beispiele funktionieren in PowerShell und CMD
PowerShell ist empfohlen (bessere Syntax, Unicode-Support)

Path-Trenner:

Windows: \ (Backslash)
Linux/Mac: / (Forward Slash)
Java-Tools verstehen meist beide

Beispiel Windows-Pfade:

# jdeps auf Windows
jdeps --jdk-internals target\classes\

# Trivy auf Windows  
trivy fs C:\path\to\project

# Maven Wrapper auf Windows
.\mvnw.cmd clean install

Wichtige Tools und Libraries für Java-Entwicklung

🎯 Überblick

📚 Wichtige Abkürzungen & Begriffe

Security & Vulnerability

Development & Testing

Architecture & Patterns

Data & Persistence

Web & Networking

Build & Deployment

Performance & Monitoring

Standards & Specifications

🔍 Security & Vulnerability Scanning

Trivy

Beschreibung:

Download & Installation:

Praktische Verwendung:

Syft

Beschreibung:

Download & Installation:

Praktische Verwendung:

OWASP Dependency-Check

Beschreibung:

Download & Installation:

Praktische Verwendung:

🏛️ Legacy Code & Migration

jdeps

Beschreibung:

Download & Installation:

Praktische Verwendung:

ArchUnit

Beschreibung:

Download & Installation:

Praktische Verwendung:

Characterization Testing Tools

ApprovalTests

Beschreibung:

🔧 Build & Dependency Management

Maven Wrapper

Beschreibung:

Installation:

Verwendung:

Gradle Wrapper

Beschreibung:

Verwendung:

Maven Versions Plugin

Beschreibung:

Verwendung:

🧪 Testing & Quality Assurance

jqwik

Beschreibung:

Verwendung:

TestContainers

Beschreibung:

Verwendung:

Mockito

Beschreibung:

Verwendung:

AssertJ

Beschreibung:

Verwendung:

📊 Monitoring & Performance

Micrometer

Beschreibung:

Verwendung:

JProfiler / YourKit

Beschreibung:

Kostenlose Alternativen:

🚀 Development & IDE Tools

Lombok

Beschreibung:

Verwendung:

MapStruct

Beschreibung:

Verwendung:

Spotbugs

Beschreibung:

Verwendung:

Checkstyle

Beschreibung:

Verwendung: