Spring Boot

Work with requests, responses, methods, headers, status codes, URLs, cookies, JSON, and REST conventions. Use command-line and graphical HTTP clients to inspect real web traffic.

Create and run a Spring Boot application with the Spring Initializr, Maven or Gradle, an IDE, and the command line. Read the standard project layout, dependency declarations, generated JARs, and application startup logs.

Trace the path from Java EE and the Spring Framework to Spring Boot, embedded servers, convention over configuration, and cloud-native deployment. Connect major Spring Boot releases to Java versions, Jakarta EE, observability, containers, and native compilation.

Use inversion of control, dependency injection, beans, component scanning, scopes, qualifiers, and Java configuration. Design small services whose dependencies are explicit and easy to replace or test.

Follow the startup process from the main method through application context creation, classpath detection, conditional configuration, and embedded server launch. Inspect condition reports and replace default beans when an application needs different behavior.

Manage settings with properties, YAML, environment variables, command-line arguments, profiles, and configuration property classes. Apply precedence rules, validation, secrets handling, and environment-specific configuration without hard-coded values.

Build server-rendered and REST endpoints with controllers, request mappings, parameters, headers, filters, interceptors, and the servlet lifecycle. Trace an incoming request through Spring MVC to its response.

Convert Java objects to and from JSON with Jackson, validate incoming data with Jakarta Bean Validation, and create consistent error responses. Handle malformed requests, business errors, and global exceptions without leaking internal details.

Design resources, URLs, status codes, pagination, filtering, idempotency, and versioning for maintainable HTTP APIs. Publish and test an OpenAPI contract so clients can use the service reliably.

Connect a Spring Boot application to a relational database using JDBC, connection pools, SQL queries, and row mapping. Diagnose common failures involving schemas, connections, indexes, and slow queries.

Model entities, relationships, identifiers, fetching, cascading, and repositories with Spring Data JPA and Hibernate. Detect N+1 queries, manage persistence contexts, and choose when direct SQL is clearer than object-relational mapping.

Define transaction boundaries, propagation, isolation, rollback behavior, and locking. Apply transactions to service operations while avoiding long-running transactions and hidden consistency bugs.

Version database schemas with migration tools such as Flyway or Liquibase. Create repeatable local setups, deploy compatible changes, seed test data, and plan safe rollbacks.

Use Spring Data abstractions with document, key-value, and search-oriented stores when relational modeling is not the best fit. Model data around access patterns and account for consistency, indexing, and operational tradeoffs.

Apply authentication, authorization, password encoding, security filter chains, method security, CSRF protection, CORS rules, and secure headers. Build and test access rules for public, user, and administrative endpoints.

Secure APIs and browser applications with OAuth 2.0, OpenID Connect, JWT access tokens, sessions, resource servers, and identity providers. Choose flows for human users, single-page applications, and service-to-service calls.

Write unit tests with JUnit and Mockito, integration tests with the Spring test context, and HTTP tests with MockMvc or WebTestClient. Keep tests fast while checking configuration, serialization, security, and database behavior.

Use focused test slices and disposable infrastructure to test web, persistence, messaging, and security boundaries. Run real databases and brokers with Testcontainers and Spring Boot service connections instead of relying only on mocks.

Produce useful structured logs with levels, context fields, correlation identifiers, and safe exception details. Configure logging for local diagnosis and centralized production collection without exposing secrets.

Expose health, information, metrics, environment, thread, and diagnostic endpoints through Spring Boot Actuator. Secure management endpoints and create custom health indicators for application dependencies.

Instrument services with Micrometer metrics, distributed traces, and correlation across logs. Define service-level indicators, export telemetry through OpenTelemetry-compatible systems, and diagnose latency across service boundaries.

Reduce repeated work with Spring’s cache abstraction, local caches, and distributed cache stores. Design cache keys, expiration, invalidation, and consistency rules while preventing stampedes and stale-data failures.

Run background work with task executors, scheduled jobs, and asynchronous methods. Control thread pools, preserve context, handle failures, and prevent duplicate scheduled execution in multi-instance deployments.

Publish and consume messages through broker-backed Spring applications. Work with delivery acknowledgments, ordering, retries, dead-letter queues, idempotent consumers, and serialization contracts.

Coordinate database changes and messages with domain events, transactional event listeners, and the transactional outbox pattern. Design consumers and producers that remain correct when delivery is delayed or repeated.

Call remote HTTP services with RestClient, WebClient, and declarative HTTP interfaces. Configure serialization, authentication, connection pools, timeouts, and test doubles for external dependencies.

Protect remote calls with deadlines, retries, rate limits, bulkheads, and circuit breakers. Decide which failures are safe to retry and combine resilience policies without causing retry storms.

Build non-blocking HTTP applications with Spring WebFlux, Reactor publishers, backpressure, and reactive data access. Compare reactive and servlet-based designs so WebFlux is used only where its complexity has a real payoff.

Create typed query and mutation APIs with Spring for GraphQL. Design schemas, validate operations, solve N+1 data loading, apply security, and test resolver behavior.

Process large data sets with jobs, steps, readers, processors, writers, checkpoints, and restartable execution. Add validation, skip and retry policies, scheduling, and operational metadata with Spring Batch.

Separate business rules from controllers, repositories, and infrastructure using layered, hexagonal, and domain-centered designs. Set clear package and module boundaries that keep a growing codebase maintainable.

Build verifiable application modules with Spring Modulith, module events, architecture tests, and generated documentation. Use modular-monolith patterns to gain strong boundaries without immediately adopting distributed services.

Apply Java 17+ language and runtime features, Jakarta namespace changes, revised configuration practices, and dependency compatibility rules used by Spring Boot 3 and later generations. Plan and validate migrations from older Spring Boot applications.

Manage shared configuration and locate changing service instances in distributed deployments. Apply centralized configuration, service discovery, and client-side load balancing while recognizing when platform-native facilities make them unnecessary.

Route external traffic with Spring Cloud Gateway using predicates, filters, authentication, rate limits, and request transformation. Design gateway boundaries without moving business logic into the edge layer.

Package applications as executable JARs, layered container images, and Cloud Native Buildpack images. Create small, secure images and use Docker Compose with Spring Boot service connections for repeatable local environments.

Deploy Spring Boot services to Kubernetes with configuration, secrets, resource limits, rolling updates, health probes, and graceful shutdown. Diagnose startup failures, traffic routing, scaling behavior, and pod termination issues.

Build automated pipelines that compile, test, scan, package, sign, and release Spring Boot applications. Manage dependency updates, software bills of materials, artifact provenance, and vulnerability response.

Measure startup time, throughput, latency, memory, garbage collection, database behavior, and thread usage before tuning. Apply profiling, load testing, connection-pool sizing, virtual threads, and JVM settings based on evidence.

Use ahead-of-time processing and GraalVM native images to reduce startup time and memory use. Handle reflection metadata, resource inclusion, testing, build cost, and compatibility limits when choosing native deployment.

Connect Spring applications to language models with Spring AI using portable model clients, prompts, structured output, tools, embeddings, and vector stores. Build retrieval-augmented features with evaluation, guardrails, cost controls, and protection against prompt injection.

Operate production services with readiness and liveness checks, graceful shutdown, backups, alerts, dashboards, incident response, and capacity planning. Use logs, metrics, traces, and runtime diagnostics to investigate realistic failures.

Take a service from requirements through API and data design, implementation, security, testing, migration, packaging, deployment, and monitoring. Deliver a documented production-style application with automated checks and a clear operational runbook.

Map Spring Boot skills to backend, platform, integration, and cloud engineering roles. Build proof-of-skill projects, evaluate Spring certifications where useful, contribute to the ecosystem, and follow release notes, security advisories, and supported-version policies.