Glossar

Jeder Java-Begriff, dem du begegnest - in verständlicher Sprache.

Abstraction: Exposing what an object does while hiding how it does it, via interfaces and abstract classes.
Actuator: Spring Boot's production-ready endpoints - health, metrics, info - for monitoring and managing a running application.
Advice: In AOP, the code an aspect runs at a matched join point - before, after, or around a method.
Annotation: Metadata attached to code (e.g. @Override) that tools and frameworks read to alter behavior.
AOP: Aspect-Oriented Programming: factoring cross-cutting concerns (logging, transactions) into reusable aspects.
API: Application Programming Interface - the set of methods a class or library exposes for others to use.
Application Server: A runtime (WildFly, Open Liberty, Payara) that hosts Jakarta EE applications and provides implementations of the EE specs; modern apps often embed the server instead.
ApplicationContext: Spring's IoC container interface: it creates, wires, and manages beans for the application's lifetime.
ArrayList: A resizable, index-based list backed by an array; the default List implementation.
Aspect: A module bundling a cross-cutting concern together with the advice and pointcut that apply it.
Autoboxing: Automatic conversion between primitives (int) and their wrapper objects (Integer).
Autowiring: Spring automatically supplying a bean's dependencies from the container, e.g. via a constructor.
BCrypt: A deliberately slow, salted password-hashing function; the standard way to store passwords so a database leak doesn't expose them.
Bean: Any object the Spring container instantiates, wires, and manages.
Bytecode: The portable, intermediate instructions produced by the Java compiler and run by the JVM.
CDI: Contexts and Dependency Injection - the Jakarta EE standard for dependency injection and contextual lifecycles (@Inject, scopes), analogous to Spring's container.
Checked exception: An exception the compiler forces you to handle or declare with 'throws' (e.g. IOException).
Circuit Breaker: A resilience pattern (Resilience4j) that stops calling a failing service for a while, failing fast with a fallback to prevent cascading outages.
Class: A blueprint that defines the fields and methods of objects created from it.
Collection: A data structure holding multiple elements - List, Set, Map, or Queue.
Component Scanning: Spring discovering stereotype-annotated classes (@Component, @Service…) in a package and registering them as beans.
Composition: Building objects from other objects (has-a), favored over inheritance for flexibility.
Constructor: A special method that initializes a new object, run when you use 'new'.
Dependency Injection: Supplying a class's dependencies from outside rather than creating them internally.
DTO: A Data Transfer Object - a simple carrier for API request/response data, kept separate from JPA entities so the contract and the model can evolve independently.
Encapsulation: Bundling data with methods and hiding internals behind a controlled interface.
Enum: A type with a fixed, type-safe set of named constant values.
Exception: An object representing an error or unusual condition that interrupts normal flow.
Flyway: A database migration tool that applies versioned SQL scripts in order, so the schema is explicit, reviewable, and reproducible instead of auto-generated.
Functional interface: An interface with exactly one abstract method, implementable by a lambda.
Garbage Collection: Automatic reclamation of memory used by objects no longer reachable by the program.
Generics: Type parameters (like List<String>) that give compile-time type safety without casting.
Generics erasure: The removal of generic type information at compile time, leaving raw types at runtime.
HashMap: A collection storing key-value pairs with fast, average O(1) lookup via hashing.
Heap dump: A snapshot of all objects on the heap, used to diagnose memory leaks.
Immutability: The property of an object whose state cannot change after creation.
Immutable: An object whose state cannot change after construction (e.g. String, records).
Inheritance: A class reusing and extending another's fields and methods (an is-a relationship).
Interface: A contract of methods a class promises to implement, with no (required) implementation.
IoC Container: The Spring engine that inverts control of object creation - instantiating and injecting beans so you don't use new.
Jakarta EE: The Eclipse-stewarded successor to Java EE: a suite of enterprise specifications (JPA, Servlet, CDI, JAX-RS, Bean Validation) whose packages live under jakarta.*.
JAR: Java ARchive - a zip of compiled classes; a 'fat JAR' also bundles dependencies.
JAX-RS: The Jakarta RESTful Web Services specification for building REST APIs with annotations (@Path, @GET); Jersey and RESTEasy implement it.
JDBC: Java Database Connectivity - the standard API for talking to relational databases.
JDK: Java Development Kit - the compiler and tools needed to develop Java, including the JRE.
JIT: Just-In-Time compiler - converts hot bytecode into optimized native code at runtime.
JIT warm-up: The early period where code runs interpreted before the JIT optimizes hot paths.
JPA: Jakarta Persistence API - the standard for object-relational mapping, often via Hibernate.
JRE: Java Runtime Environment - the JVM plus core libraries needed to run (not build) Java apps.
JVM: Java Virtual Machine - the engine that runs bytecode on any platform.
JWT: A JSON Web Token: a signed, self-contained token carrying a user's identity and claims, used for stateless authentication.
Lambda: A concise, passable piece of behavior: (params) -> body, implementing a functional interface.
LTS: Long-Term Support - a Java release (8, 11, 17, 21, 25) with years of updates.
Method: A named, reusable block of code that may take parameters and return a value.
Method reference: A shorthand for a lambda that just calls one existing method, written Class::method.
Micrometer: A vendor-neutral metrics facade ('SLF4J for metrics') that records measurements and exports them to systems like Prometheus.
MicroProfile: Specifications extending Jakarta EE for cloud-native microservices (config, health, metrics, fault tolerance, JWT), implemented by runtimes like Quarkus and Open Liberty.
N+1 problem: An ORM anti-pattern: one query loads N rows, then N more queries load their relations.
NullPointerException: The runtime error from using a reference that points to null.
Object: A concrete instance created from a class, with its own field values.
Optional: A container representing a value or its absence, used to avoid null.
ORM: Object-Relational Mapping - mapping Java objects to database tables (e.g. JPA/Hibernate).
Overloading: Multiple methods sharing a name but differing in parameters.
Overriding: A subclass providing its own version of an inherited method (@Override).
Package: A namespace grouping related classes, named in reverse-domain style (com.myapp.orders).
Pattern matching: Testing a value's shape and binding its parts in one step (instanceof / switch patterns).
Pointcut: An expression selecting which join points (method executions) an aspect's advice applies to.
Polymorphism: One method call behaving differently depending on the actual object type.
PreparedStatement: A parameterized SQL statement that prevents SQL injection.
ProblemDetail: The RFC 9457 standard error body (type, title, status, detail) Spring returns for failures, giving APIs a consistent, machine-readable error shape.
Profile: A named set of beans and properties activated per environment via spring.profiles.active.
Proxy: A stand-in object Spring wraps around a bean to apply AOP advice like @Transactional before delegating.
Record: A concise, immutable data class that auto-generates constructor, accessors, equals, hashCode, and toString.
Record pattern: Destructuring a record directly in instanceof or switch (Java 21+).
Reflection: Inspecting and manipulating classes, methods, and fields at runtime.
REST: An architectural style for web APIs using HTTP methods (GET/POST/PUT/DELETE) over resources.
Sealed class: A class or interface that restricts which types may extend or implement it.
Serialization: Converting an object into bytes for storage or transmission; deserialization reverses it.
Spring Boot: A framework that auto-configures Spring so you can build apps with minimal setup.
Spring Framework: The core Spring library: the IoC container, dependency injection, and AOP that the whole ecosystem builds on.
Stack & Heap: Memory areas: the stack holds method calls and local variables; the heap holds objects.
Starter: A curated Spring Boot dependency (e.g. spring-boot-starter-web) that pulls in everything needed for a feature.
Stereotype: An annotation marking a class as a bean and documenting its role: @Component, @Service, @Repository, @Controller.
Stream: A pipeline for processing sequences of data declaratively (filter, map, reduce).
String pool: A cache of String literals the JVM reuses to save memory.
Testcontainers: A library that runs real dependencies (like PostgreSQL) in throwaway Docker containers during integration tests, for higher fidelity than in-memory fakes.
Text block: A multi-line string literal delimited by triple quotes (""").
Thread: A single path of execution within a process; multiple threads share memory.
try-with-resources: A try statement that automatically closes AutoCloseable resources when it ends.
Unchecked exception: A RuntimeException the compiler doesn't force you to handle; usually signals a bug.
Varargs: A method parameter accepting a variable number of arguments, written Type... name.
Virtual thread: An ultra-lightweight thread (Java 21+) enabling millions of concurrent tasks.
volatile: A keyword guaranteeing that reads/writes of a field are visible across threads.
Wildcard: The ? in generics representing an unknown type, refined with extends or super (PECS).