SpringBoot Reference

This section documents Spring Boot 4.1.x and Spring Framework 7.0.x on the Java 17/21+ baseline, as described by the official Spring Boot reference documentation and each sub-project’s own site (Spring Data, Spring for Apache Kafka, Micrometer, Project Reactor, springdoc-openapi, Spring gRPC, and the others listed in this section’s Bibliography) — which are the references these pages are written and verified against.

This content was generated with the assistance of AI and should be verified against those official docs before being relied on in production. Spring Boot and its ecosystem continue to evolve; the examples here target the current 4.1.x / 7.0.x releases.

This section’s bibliography lists the reference material consulted while preparing these pages.

Welcome to the SpringBoot reference. Spring and Spring Boot are the dominant framework and application runtime for building Java backend services — dependency injection, externalized configuration, opinionated auto-configuration, and a vast, well-integrated ecosystem spanning data access, messaging, caching, and observability. This section documents the current Spring Boot 4.1.x / Spring Framework 7.0.x releases on the Java 17/21+ baseline, written and verified against docs.spring.io and each sub-project’s own site.

If you are new to Spring Boot, start with Getting Started, then Core Concepts and Configuration & Profiles, then work down the list or jump to what you need.

How does this compare to Quarkus? See Quarkus vs. Spring Boot for a concept-by-concept mapping and decision guide against the Kubernetes-native, build-time-augmented Quarkus Reference.

Containerizing and testing these services with Docker — building Spring Boot images (layered Dockerfiles, Cloud Native Buildpacks, Jib), running the local dependency stack with Docker Compose and spring-boot-docker-compose, and running Testcontainers integration tests locally and in GitHub Actions — is covered in the sibling Docker reference.

What’s covered

Getting started

Getting Started — what Spring and Spring Boot are, Spring Initializr, the Java 17/21+ baseline and Maven project layout, @SpringBootApplication, running the app, and Spring Boot 2 → 3 → 4 migration notes.

Core concepts

Core Concepts — the IoC container, beans and dependency injection, component scanning, @Configuration/@Bean, bean scopes and lifecycle callbacks, a short AOP note, and how auto-configuration resolves at startup.
Core Annotations — what @Component, @Service, @Repository, @Controller/@RestController, and @Configuration each add beyond plain component scanning (persistence-exception translation, CGLIB proxying, web dispatch), plus a categorized reference table of every other core annotation used throughout this section.
Java or Kotlin for Spring Boot? — first-class Kotlin support via the kotlin-spring/kotlin-jpa plugins, a pros/cons comparison, a side-by-side REST endpoint, and guidance on which language to choose.
Configuration & Profiles — externalized configuration and precedence, @ConfigurationProperties vs. @Value, profiles, configuration metadata for IDE autocompletion, and runtime configuration changes with @RefreshScope (Spring Cloud Config + Bus, Kubernetes ConfigMaps/Secrets, AWS Secrets Manager/Parameter Store).

Spring Data

Spring Data Overview — the repository abstraction shared by every Spring Data module, @Version optimistic locking, entity inheritance across stores, keyset scrolling with Window<T>/ScrollPosition, and a map of which module to use for which database.
Spring Data JPA (SQL) — entities and JPA mapping, entity inheritance (@Inheritance/@MappedSuperclass), JpaRepository, @Query, Specifications/projections, transactions, @Version optimistic locking, auditing, Window<T> keyset scrolling, plus custom queries with JdbcClient/JdbcTemplate.
Spring Data MongoDB — MongoRepository, document mapping, polymorphic documents (@TypeAlias), indexes, auditing, @Version optimistic locking, transactions, Window<T> keyset scrolling, plus custom queries with MongoTemplate.
Spring Data Couchbase — CouchbaseRepository, N1QL/SQL queries, polymorphic documents, scopes/collections, `@Version`/CAS optimistic locking (no `Window<T>` keyset scrolling support -- see the SQL seek-query alternative), plus custom queries with CouchbaseTemplate.
Spring Data Neo4j — @Node/@Relationship mapping, node inheritance via multiple labels, Neo4jRepository, Cypher queries, transactions, @Version optimistic locking, plus custom queries with Neo4jClient.
Neo4j Use Cases — complete Spring Boot applications on Spring Data Neo4j and Graph Data Science: fraud detection, opportunity detection and recommendations, logistics and supply chain, identity resolution, graph-based access control and dependency/impact analysis, plus calling GDS from Spring, testing with Testcontainers and production considerations.
Transaction Isolation & Locking — the @Transactional isolation attribute and its performance impact, pessimistic locking with @Lock and lock timeouts, and how it compares to @Version optimistic locking across the Spring Data stores.

ORM, search & batch

Hibernate (JPA & ORM) — the object/relational paradigm mismatch, the persistence context and entity lifecycle, lazy loading and the N+1 problem, first/second-level caching, HQL/JPQL/Criteria query options, and how spring-boot-starter-data-jpa wires Hibernate in as the default JPA provider.
Elasticsearch — the inverted index, documents/indices/shards and replicas, analyzers and mappings, the query DSL and BM25 relevance, and Spring Boot + Spring Data Elasticsearch integration (@Document, ElasticsearchRepository/ElasticsearchOperations, the Elasticsearch Java API Client); a dedicated reference section covers it in depth under Elasticsearch Reference.
Apache Solr — cores and collections, schema.xml/managed schema and analysis chains, request handlers and query parsers (DisMax/eDisMax), SolrCloud, and talking to Solr from Spring Boot via SolrJ now that Spring Data Solr is retired; a dedicated reference section covers it in depth under Apache Solr Reference.
MongoDB Atlas Search — the $search/$searchMeta aggregation stages, search index definitions and per-language analyzers, fuzzy matching, faceting, and projection via stored source, compared with Elasticsearch and Apache Solr; a cloud-only Atlas service with no self-hosted equivalent — see MongoDB Reference: Text, wildcard, geospatial & Atlas search for the general Atlas Search/Vector Search outline.
Redis from Spring Boot — caching with @Cacheable/RedisCacheManager, Spring Data Redis repositories and custom queries, and Redis as a vector store for AI/RAG workloads (see Integrating with Spring AI for the vendor-neutral Spring AI vector-store surface); a dedicated reference section covers it in depth under Spring Boot: Redis as a Cache, Spring Data Redis & Custom Queries, and Spring Boot: Redis as a Vector Database.
Spring Batch — finite bulk processing: jobs and steps, chunk-oriented vs. tasklet steps, the JobRepository, Spring Boot auto-configuration, and launching jobs. For the in-depth guide — fault tolerance, readers and writers, scaling and partitioning, observability and testing — see Spring Batch Reference.

Caching

Caching — the Spring Cache abstraction, local caching with Caffeine, and distributed caching with Redis.
Near-Far Caches — layering a local Caffeine near cache in front of a distributed Redis far cache: pros/cons versus a single tier, consistency and invalidation trade-offs, and Spring Boot implementation options (a custom composite CacheManager, Redisson’s RLocalCachedMap).

File Storage

File Storage & Object Stores — why horizontally-scaled, ephemeral pod replicas can’t rely on local/container disk, network-mounted filesystems (Amazon EFS, Google Cloud Filestore, Azure Files) via each cloud’s CSI driver, object storage client libraries (Amazon S3, Google Cloud Storage, Azure Blob Storage), storage access tiers and lifecycle policies, cloud-agnostic abstractions to avoid vendor lock-in — Spring’s Resource/WritableResource abstraction, Apache jclouds' BlobStore, and Spring Content — and integration testing against local emulators (S3Mock, fake-gcs-server, Azurite) now that MinIO and LocalStack are no longer free, no-account defaults.

APIs

REST APIs — Spring MVC @RestController`s, exception handling with `ProblemDetail, and Spring WebFlux for reactive REST.
gRPC APIs — gRPC service definitions, the official Spring gRPC project’s @GrpcService/@ImportGrpcClients, interceptors, and error mapping.
Spring Boot MCP Servers — exposing tools, resources and prompts to LLM hosts with the Spring AI MCP server starters (@McpTool, @McpResource, @McpPrompt), in the AI section.
Spring AI — building LLM features into a Spring Boot 4 service with Spring AI 2.0: ChatClient, advisors, structured output, tool calling, chat memory, streaming, MCP clients and servers, voice and images, observability, evaluation, testing and security, in the AI section.

GraphQL is covered in its own GraphQL Reference, including dedicated Spring for GraphQL integration pages.

Security

Spring Security — the filter-chain model, the method-security annotations (@PreAuthorize and friends), how the SecurityContext works for the servlet and reactive stacks, and how it is built from a username/password credential or from a bearer JWT (OAuth2 Resource Server).
Authorization Server & Social Login — building an OAuth2/OIDC authorization server with Spring Authorization Server (login/logout, token issuance), and "Sign in with Google / Microsoft / Apple" with oauth2Login() — interfaces, database model, REST controller and REST clients. For the OAuth 2.0 / OpenID Connect protocol these two pages implement — grant types, tokens, the Security BCP, and passwordless and multi-factor authentication methods — see the OAuth Reference.

Server-side web UI frameworks

Server-Side Web UI Frameworks — Thymeleaf, Vaadin (linking out to the Vaadin Reference), and legacy JSF via JoinFaces, with a closing decision table. Thymeleaf has its own Thymeleaf section.

Messaging

Messaging with Kafka — producing with KafkaTemplate, consuming with @KafkaListener, serializers, and error handling with dead-letter topics.

Scheduling

Scheduling & ShedLock — in-process scheduling with @Scheduled, the multi-instance duplicate-execution problem, and distributed locking with ShedLock.
Scheduling — advanced scheduling with Quartz, compared with @Scheduled: persistent and clustered schedules, misfire handling, calendars and runtime-defined jobs.

Observability

Logging — Logback defaults, log levels, structured JSON logging, and routing logs to stdout vs. a file.
Metrics & Observability — Micrometer and Actuator, distributed tracing with OpenTelemetry, and Prometheus/Grafana.

Reactive programming

Reactive Programming — Mono/Flux, operators, backpressure, testing with StepVerifier, how reactive transactions ride the Reactor Context rather than a ThreadLocal, safely bridging to blocking code, and a link to a hands-on Reactor workshop.

Concurrency Alternatives

Concurrency Alternatives — Project Reactor, Java Virtual Threads, and Kotlin Coroutines side by side: execution model, pros/cons, code examples, how each handles transaction management, and setting up a mixed Java+Kotlin Maven/Gradle project.

Resilience

Resilience has its own section under Backend Development.

Resilience — making a service that calls other services fault tolerant with Resilience4j 2.4.0: CircuitBreaker, Retry, RateLimiter, Bulkhead and TimeLimiter, fallbacks, Spring Boot configuration and aspect order, observability, Spring Cloud CircuitBreaker, Gateway and OpenFeign, Spring Framework 7 @Retryable and @ConcurrencyLimit, testing, production tuning, and a cheat sheet; and Bucket4j 8.21.0: local and distributed token-bucket rate limiting, API quotas per client, Spring Boot integration (manual, the community bucket4j-spring-boot-starter, Spring Cloud Gateway) and a Resilience4j-vs-Bucket4j comparison, with its own cheat sheet.

Developer productivity tools

Lombok & MapStruct — Lombok’s boilerplate-reduction annotations and MapStruct’s generated DTO ↔ entity mappers, used together.

Testing

Unit & Integration Testing — JUnit 5 and Mockito, Spring Boot’s test slices, and @SpringBootTest with Testcontainers.
Performance Testing with JMeter — test-plan structure, parameterization, and correlating results with Actuator/Prometheus metrics.

API-first development

API-First: REST & gRPC — contract-first REST with OpenAPI and contract-first gRPC with Protocol Buffers.
API-First: Messaging — contract-first Kafka messaging with Avro schemas and describing topics with AsyncAPI.

Build & quality

Maven Quality Plugins — JaCoCo coverage, Surefire vs. Failsafe, and static analysis with Checkstyle, SpotBugs, and PMD.

Architecture

Architectural Patterns — SOLID, hexagonal (ports & adapters) architecture, core DDD vocabulary, the transactional outbox pattern, listen-to-yourself, and sagas.
Distributed ID Generation — the coordination problem behind database-generated primary keys once multiple instances insert concurrently, Twitter’s Snowflake bit-packed ID layout and its ULID/TSID/UUIDv7 relatives, and wiring a Snowflake-style generator into Spring Boot as a custom Hibernate IdentifierGenerator or a plain bean.

Reference

Cheat Sheet — a one-page, downloadable PDF summary of the essentials above for quick memorization.
Quarkus Reference — the Kubernetes-native alternative Java framework built around build-time augmentation and the closed-world assumption; see Quarkus vs. Spring Boot for the concept-by-concept comparison and Spring API Compatibility Extensions for the migration path.
Docker Reference — the Docker platform and its architecture, images and builds, Compose and container security, applied to Spring Boot: building Spring Boot images, running the local dependency stack with Docker Compose, and Testcontainers integration tests locally and in GitHub Actions.

Bibliography

Official documentation (primary source for every page)

spring.io — the Spring project family home.
spring.io/projects/spring-boot and docs.spring.io/spring-boot/reference — Spring Boot 4.1.x reference documentation (getting started, core features, web, data, IO, messaging, testing, packaging, Actuator, how-to guides, build tool plugins).
docs.spring.io/spring-framework/reference — Spring Framework 7.0.x reference (IoC container, AOP, data access, web MVC/WebFlux).
Spring Data JPA, Spring Data MongoDB, Spring Data Couchbase, Spring Data Neo4j, and Spring Data Redis — the per-store Spring Data reference guides.
Quartz Scheduler documentation — the scheduling library behind Scheduling; every source for that section is listed in its Bibliography.
Resilience4j documentation — the fault-tolerance library behind Resilience; every source for that section is listed in its Bibliography.
Caffeine wiki, Redis Pub/Sub, Redis keyspace notifications, and Redisson wiki — Local Cache — the local (Caffeine), Redis invalidation, and Redisson near-cache references used by the near-far caching page.
aws-efs-csi-driver, GKE Filestore CSI driver, and AKS azurefile-csi-driver — the Kubernetes CSI drivers mounting Amazon EFS, Google Cloud Filestore, and Azure Files, used by File Storage & Object Stores.
Spring Cloud GCP reference documentation and Spring Cloud Azure Storage reference documentation — the Google Cloud Storage and Azure Blob Storage client starters (the Spring Cloud AWS reference below already covers its S3 integration).
Apache jclouds BlobStore guide — the provider-agnostic BlobStore API covering Amazon S3, Azure Blob Storage, Google Cloud Storage, and roughly thirty other backends through one common API.
Spring Content — its GitHub repository is the primary documentation source for this Spring-Data-style ContentStore/Store abstraction over JPA/MongoDB entity content; a community-maintained project, not an official Spring/Pivotal one.
Adobe S3Mock, fake-gcs-server, and Azurite — the actively-maintained, no-account local emulators for S3, Google Cloud Storage, and Azure Blob Storage respectively, each usable as a Testcontainers module, used by File Storage & Object Stores's integration-testing section.
Spring Framework — Data Access with JDBC and the JdbcClient/JdbcTemplate API docs — low-level SQL access without JPA.
Spring Framework — Transaction Management, declarative transaction management, and Spring Data JPA — Locking — transaction isolation levels, the Isolation enum, and pessimistic locking with @Lock.
Spring Framework — Programmatic Transaction Management and Reactive Transactions with Spring — TransactionalOperator, ReactiveTransactionManager, and why reactive transaction state lives in the Reactor Context.
Spring Cloud Commons — @RefreshScope, Spring Cloud Config Client, Spring Cloud Config Server, Spring Cloud Bus endpoints, Spring Cloud Kubernetes — PropertySource reload, and Spring Cloud AWS reference — runtime configuration change providers.
MongoTemplate API and template query operations — MongoTemplate low-level queries.
Spring Data Couchbase — Template & direct operations — CouchbaseTemplate and direct operations.
Spring Data Neo4j — Custom queries and the Neo4jClient API docs — low-level Cypher queries.
Spring Data Neo4j — Repositories, Neo4j Client, metadata-based mapping, auditing and query creation — the deep Spring Data Neo4j references behind Neo4j Use Cases.
Spring Boot — NoSQL (Neo4j), Docker Compose support and Testcontainers support (including service connections) — Neo4j auto-configuration and the development and test containers.
Neo4j Cypher Manual, Neo4j Graph Data Science manual, APOC documentation and Neo4j Java Driver manual — the Cypher, GDS, APOC and driver references behind the Neo4j use-case pages; the algorithm theory lives in the Neo4j Reference bibliography.
Testcontainers — Neo4j module — Neo4jContainer, used with the GDS and APOC plugins by the Neo4j use-case pages.
Neo4j Operations Manual — server configuration (db.transaction.timeout), query logging and authentication and authorization, behind the Neo4j use-case production considerations and fraud detection pages.
Neo4j Aura — Graph Analytics — the managed analytics sessions mentioned as the alternative to an in-database GDS plugin.
Spring Data Commons — Paging and sorting and Spring Data Neo4j — Defining query methods — Pageable/Page and derived finders in the Neo4j use-case pages.
Spring Boot — Externalized Configuration, Spring Boot — Configure two DataSources and Spring Framework — Using the @Bean annotation — @ConfigurationProperties records with defaults, and secondary beans declared with defaultCandidate = false.
Java — Record classes — compact constructors that normalise incoming events.
AssertJ documentation — the fluent assertions used by the integration tests of the Neo4j use-case pages.
Neo4j-Migrations — a third-party (community) schema migration tool, mentioned by the Neo4j use-case production considerations; it is not an official Neo4j or Spring project.
Neo4j Developer Center and Neo4j use cases — vendor guides: product-oriented introductions published by Neo4j, consulted for context only and not the primary source for any page.
Spring Framework — Thymeleaf integration and thymeleaf.org documentation — Thymeleaf and its Spring integration.
JoinFaces reference and joinfaces.org — JoinFaces (JSF on Spring Boot).
Spring Boot — Task Execution and Scheduling and Spring Framework — Task Execution and Scheduling — Spring scheduling.
ShedLock — its README is the only documentation source; no separate docs site exists.
Spring for Apache Kafka reference and Spring Boot — Apache Kafka Support.
Spring gRPC reference — the official Spring gRPC project reference.
Spring Boot — Actuator (including the "Observability", "Metrics", and "Tracing" pages) and Micrometer reference — Actuator and Micrometer.
OpenTelemetry Java documentation.
Prometheus documentation and Grafana documentation.
Project Reactor 3 reference guide, in particular Threading and Schedulers — the Scheduler factories, boundedElastic sizing, and where block() throws.
JEP 444: Virtual Threads — the JDK Enhancement Proposal defining virtual threads' execution model, mounting/unmounting, and carrier-thread pinning.
the Kotlin Coroutines guide and the Spring Framework reference — Coroutines — suspend functions, structured concurrency, and TransactionalOperator.executeAndAwait for reactive transaction management under coroutines.
Kotlin docs — Configure a Maven project — the kotlin-maven-plugin ordering, compiler plugins, and dependencies for mixed Java+Kotlin Maven builds.
Project Lombok feature reference.
MapStruct reference guide.
JUnit 5 User Guide.
Mockito.
Testcontainers and Testcontainers for Java.
Apache JMeter User’s Manual.
springdoc-openapi.
the OpenAPI Specification.
OpenAPI Generator (openapi-generator-maven-plugin).
Protocol Buffers documentation.
protobuf-maven-plugin.
the AsyncAPI specification.
Apache Avro documentation.
Confluent Schema Registry.
JaCoCo documentation.
Maven Surefire and Maven Failsafe.
Checkstyle, SpotBugs, and PMD — static analysis.
Alistair Cockburn’s own hexagonal-architecture page.
Transactional Outbox, Saga, and Domain Event — Chris Richardson’s microservices.io pattern catalog.
Listen to Yourself — Oded Shopen’s original write-up of the pattern (no more official source exists for this specific pattern name).
the Reactor workshop — the user’s own hands-on Reactor workshop, linked from Reactive Programming for exercises.
Spring Batch reference and Spring Boot — Batch Applications — jobs, steps, chunk vs. tasklet processing, the JobRepository, and Spring Boot auto-configuration.
Hibernate ORM documentation (User Guide + Javadoc) and the Jakarta Persistence specification — Hibernate as the default JPA provider behind spring-boot-starter-data-jpa; see also Spring Boot — JPA and Spring Data.
Hibernate Search documentation — keeping full-text indexes (Lucene, Elasticsearch, OpenSearch back ends) in sync with Hibernate ORM entities.
Spring Data Elasticsearch reference, the Elasticsearch Java API Client, and the Elasticsearch documentation — @Document mapping, ElasticsearchRepository/ElasticsearchOperations, and the query DSL.
Apache Solr Reference Guide and the SolrJ API documentation (Http2SolrClient, SolrQuery, SolrInputDocument) — Solr’s own integration path now that Spring Data for Apache Solr is discontinued (moved to the Spring Attic; not compatible with Spring Boot 3+/4).
MongoDB Atlas Search documentation and Spring Data MongoDB — Aggregation Framework Support — search index definitions, analyzers, $search/$searchMeta, and the general custom-AggregationOperation extensibility mechanism used to reach the native driver’s typed $search builders.
Spring Security reference (architecture, authentication, method security, reactive, OAuth2 login / client / resource server, testing) and the 6.x → 7.0 migration guide — the primary source for Spring Security.
Spring Authorization Server reference (core model, configuration model, protocol endpoints, JDBC persistence) — the primary source for Authorization Server & Social Login; Spring Authorization Server is now part of Spring Security 7 (announcement).
Twitter Engineering — "Announcing Snowflake" (archived; the original blog post and the twitter-archive/snowflake project itself are no longer maintained), Instagram Engineering — "Sharding & IDs at Instagram", the ULID specification, and IETF RFC 9562 — Universally Unique IDentifiers (UUIDs) (defines UUIDv7) — the primary sources for Distributed ID Generation.

Local books (bibliography only — consulted while preparing these pages, not the primary source for any page; most predate Spring Boot 3/4, so on any discrepancy the official documentation above wins)

Rajput, Dinesh. Mastering Spring Boot 2.0. Packt Publishing, 2018. ISBN 978-1-78712-756-2 (paperback) / 978-1-78712-514-8 (eBook). Consulted as part of the bibliography for this section — see the publisher’s book page, packtpub.com, and the code bundle at PacktPublishing/Mastering-Spring-Boot-2.0.
Turnquist, Greg L. Learning Spring Boot 2.0, 2nd ed. Packt Publishing, 2018. ISBN 978-1-78646-378-4 (paperback) / 978-1-78646-820-8 (eBook). Consulted as part of the bibliography for this section — see the publisher’s book page and packtpub.com.
Mińkowski, Piotr. Mastering Spring Cloud. Packt Publishing, 2018. ISBN 978-1-78847-543-3 (paperback) / 978-1-78847-724-6 (eBook). Cited only for its distributed-systems vocabulary used as motivating context for sagas in Architectural Patterns — not as a source for a dedicated Spring Cloud page (out of scope for this section). See the publisher’s book page, packtpub.com, and the code bundle at PacktPublishing/Mastering-Spring-Cloud.
Davis, Adam L. Reactive Streams in Java: Concurrency with RxJava, Reactor, and Akka Streams. Apress, 2018. Consulted as part of the bibliography for this section — see the publisher’s book page, apress.com, and the code bundle at Apress/reactive-streams-in-java.
Rajput, Dinesh. Spring 5 Design Patterns. Packt Publishing, 2017. ISBN 978-1-78829-945-9 (paperback) / 978-1-78829-959-6 (eBook). Consulted as part of the bibliography for this section — see the publisher’s book page, packtpub.com, and the code bundle at PacktPublishing/Spring5-Design-Patterns.
Walls, Craig. Spring Boot in Action. Manning Publications, 2016. ISBN 9781617292545. Consulted as part of the bibliography for this section — see the publisher’s book page and manning.com.
Gutierrez, Felipe. Spring Boot Messaging: Messaging APIs for Enterprise and Integration Solutions. Apress (2017). Consulted as part of the bibliography for this section — see the publisher’s book page, apress.com, and the code bundle at Apress/spring-boot-messaging.
Walls, Craig. Spring in Action, 4th ed. (covers Spring 4). Manning Publications, 2015. ISBN 9781617291203. Consulted as part of the bibliography for this section — see the publisher’s book page and manning.com.
Minella, Michael T. The Definitive Guide to Spring Batch: Modern Finite Batch Processing in the Cloud, 2nd ed. Apress, 2019. ISBN 978-1-4842-3723-6 (paperback) / 978-1-4842-3724-3 (eBook). Consulted while preparing this section’s Spring Batch page — predates Spring Batch 5 (JobBuilder replaced JobBuilderFactory, javax. moved to jakarta.), so the official reference above wins on any discrepancy. See the publisher’s book page and apress.com.
Bauer, Christian, Gavin King, and Gary Gregory. Java Persistence with Hibernate, 2nd ed. Manning Publications, 2016. ISBN 9781617290459. Consulted while preparing this section’s Hibernate page and Spring Data JPA (SQL) — covers JPA 2.1 / javax.persistence, so it predates Jakarta Persistence 3.2 and Hibernate ORM 6/7. See the publisher’s book page and manning.com.
Peak, Patrick, and Nick Heudecker. Hibernate Quickly. Manning Publications, 2006. ISBN 978-1-932394-41-2. Consulted as part of the bibliography for this section’s Hibernate page — covers Hibernate 3 with XML (hbm.xml) mapping; retained only for its conceptual treatment of the ORM paradigm mismatch and the DAO pattern. See the publisher’s book page and manning.com.
Bernard, Emmanuel, and John Griffin. Hibernate Search in Action. Manning Publications, 2009. ISBN 978-1-933988-64-1. Consulted for the full-text-search background behind this section’s Hibernate and Elasticsearch pages — predates modern Hibernate Search 6/7 (Elasticsearch back end, jakarta.*). See the publisher’s book page and manning.com.
Gheorghe, Radu, Matthew Lee Hinman, and Roy Russo. Elasticsearch in Action. Manning Publications, 2016. ISBN 9781617291623. Consulted while preparing this section’s Elasticsearch page — targets Elasticsearch 1.x/2.x (mapping types, TransportClient), so the current Elasticsearch documentation and Java API Client above win on any discrepancy. See the publisher’s book page and manning.com.
Grainger, Trey, and Timothy Potter. Solr in Action. Manning Publications, 2014. ISBN 9781617291029. Consulted while preparing this section’s Apache Solr page — targets Solr 4 / early SolrCloud, so the Apache Solr Reference Guide and SolrJ documentation above win on any discrepancy. See the publisher’s book page and manning.com.
Boyd, Ryan. Getting Started with OAuth 2.0. O’Reilly Media, 2012. ISBN 978-1-4493-1160-5. Consulted for the protocol-level OAuth 2.0 vocabulary behind Authorization Server & Social Login — predates OAuth 2.1, PKCE, and mature OIDC, so the Spring Security / Spring Authorization Server references above win on any discrepancy. See the publisher’s book page.