From 54ea6479b530e928d690abaafbd8dfc948cb038a Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
<41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 12:36:01 +0000
Subject: [PATCH] chore(catalog): record boot-3.5.4
---
catalog.json | 6 +-
markdown/boot/3.5.4/LICENSE | 201 ++
markdown/boot/3.5.4/NOTICE | 69 +
markdown/boot/3.5.4/_index.md | 148 +
.../appendix/application-properties/index.md | 55 +
.../auto-configuration-classes/index.md | 12 +
.../dependency-versions/coordinates.md | 13 +
.../appendix/dependency-versions/index.md | 10 +
.../dependency-versions/properties.md | 14 +
.../appendix/test-auto-configuration/index.md | 10 +
.../test-auto-configuration/slices.md | 12 +
.../boot/3.5.4/build-tool-plugin/antlib.md | 126 +
.../boot/3.5.4/build-tool-plugin/index.md | 13 +
.../build-tool-plugin/other-build-systems.md | 118 +
markdown/boot/3.5.4/cli/index.md | 10 +
markdown/boot/3.5.4/cli/installation.md | 11 +
markdown/boot/3.5.4/cli/using-the-cli.md | 169 +
markdown/boot/3.5.4/community.md | 24 +
markdown/boot/3.5.4/documentation.md | 148 +
markdown/boot/3.5.4/how-to/actuator.md | 106 +
markdown/boot/3.5.4/how-to/aot.md | 58 +
markdown/boot/3.5.4/how-to/application.md | 187 +
markdown/boot/3.5.4/how-to/batch.md | 92 +
markdown/boot/3.5.4/how-to/build.md | 328 ++
.../boot/3.5.4/how-to/class-data-sharing.md | 36 +
markdown/boot/3.5.4/how-to/data-access.md | 1144 +++++++
.../boot/3.5.4/how-to/data-initialization.md | 318 ++
.../boot/3.5.4/how-to/deployment/cloud.md | 465 +++
.../boot/3.5.4/how-to/deployment/index.md | 13 +
.../3.5.4/how-to/deployment/installing.md | 272 ++
.../deployment/traditional-deployment.md | 339 ++
markdown/boot/3.5.4/how-to/docker-compose.md | 43 +
markdown/boot/3.5.4/how-to/hotswapping.md | 77 +
markdown/boot/3.5.4/how-to/http-clients.md | 90 +
markdown/boot/3.5.4/how-to/index.md | 17 +
markdown/boot/3.5.4/how-to/jersey.md | 61 +
markdown/boot/3.5.4/how-to/logging.md | 214 ++
markdown/boot/3.5.4/how-to/messaging.md | 75 +
.../developing-your-first-application.md | 283 ++
.../boot/3.5.4/how-to/native-image/index.md | 13 +
.../testing-native-applications.md | 114 +
markdown/boot/3.5.4/how-to/nosql.md | 50 +
.../how-to/properties-and-configuration.md | 446 +++
markdown/boot/3.5.4/how-to/security.md | 102 +
markdown/boot/3.5.4/how-to/spring-mvc.md | 312 ++
markdown/boot/3.5.4/how-to/testing.md | 156 +
markdown/boot/3.5.4/how-to/webserver.md | 875 +++++
markdown/boot/3.5.4/index.md | 19 +
markdown/boot/3.5.4/installing.md | 194 ++
markdown/boot/3.5.4/redirect.md | 2342 +++++++++++++
.../boot/3.5.4/reference/actuator/auditing.md | 25 +
.../3.5.4/reference/actuator/cloud-foundry.md | 291 ++
.../boot/3.5.4/reference/actuator/enabling.md | 35 +
.../3.5.4/reference/actuator/endpoints.md | 1487 ++++++++
.../reference/actuator/http-exchanges.md | 24 +
.../boot/3.5.4/reference/actuator/index.md | 12 +
markdown/boot/3.5.4/reference/actuator/jmx.md | 80 +
.../boot/3.5.4/reference/actuator/loggers.md | 94 +
.../boot/3.5.4/reference/actuator/metrics.md | 1822 ++++++++++
.../3.5.4/reference/actuator/monitoring.md | 230 ++
.../3.5.4/reference/actuator/observability.md | 188 ++
.../reference/actuator/process-monitoring.md | 37 +
.../boot/3.5.4/reference/actuator/tracing.md | 311 ++
markdown/boot/3.5.4/reference/data/index.md | 10 +
markdown/boot/3.5.4/reference/data/nosql.md | 1359 ++++++++
markdown/boot/3.5.4/reference/data/sql.md | 1103 ++++++
markdown/boot/3.5.4/reference/features/aop.md | 16 +
.../3.5.4/reference/features/dev-services.md | 742 ++++
.../features/developing-auto-configuration.md | 648 ++++
.../reference/features/external-config.md | 2285 +++++++++++++
.../boot/3.5.4/reference/features/index.md | 12 +
.../features/internationalization.md | 42 +
.../boot/3.5.4/reference/features/json.md | 240 ++
.../boot/3.5.4/reference/features/kotlin.md | 182 +
.../boot/3.5.4/reference/features/logging.md | 842 +++++
.../boot/3.5.4/reference/features/profiles.md | 232 ++
.../reference/features/spring-application.md | 737 ++++
markdown/boot/3.5.4/reference/features/ssl.md | 277 ++
.../features/task-execution-and-scheduling.md | 377 +++
markdown/boot/3.5.4/reference/index.md | 8 +
markdown/boot/3.5.4/reference/io/caching.md | 562 +++
markdown/boot/3.5.4/reference/io/email.md | 56 +
markdown/boot/3.5.4/reference/io/hazelcast.md | 50 +
markdown/boot/3.5.4/reference/io/index.md | 13 +
markdown/boot/3.5.4/reference/io/jta.md | 121 +
markdown/boot/3.5.4/reference/io/quartz.md | 134 +
.../boot/3.5.4/reference/io/rest-client.md | 850 +++++
.../boot/3.5.4/reference/io/validation.md | 59 +
.../boot/3.5.4/reference/io/webservices.md | 152 +
.../boot/3.5.4/reference/messaging/amqp.md | 343 ++
.../boot/3.5.4/reference/messaging/index.md | 14 +
.../boot/3.5.4/reference/messaging/jms.md | 413 +++
.../boot/3.5.4/reference/messaging/kafka.md | 392 +++
.../boot/3.5.4/reference/messaging/pulsar.md | 502 +++
.../boot/3.5.4/reference/messaging/rsocket.md | 153 +
.../reference/messaging/spring-integration.md | 77 +
.../3.5.4/reference/messaging/websockets.md | 22 +
.../boot/3.5.4/reference/packaging/aot.md | 41 +
.../reference/packaging/checkpoint-restore.md | 22 +
.../reference/packaging/class-data-sharing.md | 58 +
.../cloud-native-buildpacks.md | 27 +
.../packaging/container-images/dockerfiles.md | 158 +
.../container-images/efficient-images.md | 54 +
.../packaging/container-images/index.md | 10 +
.../3.5.4/reference/packaging/efficient.md | 40 +
.../boot/3.5.4/reference/packaging/index.md | 12 +
.../packaging/native-image/advanced-topics.md | 337 ++
.../reference/packaging/native-image/index.md | 11 +
.../introducing-graalvm-native-images.md | 205 ++
.../boot/3.5.4/reference/testing/index.md | 33 +
.../reference/testing/spring-applications.md | 20 +
.../testing/spring-boot-applications.md | 3003 +++++++++++++++++
.../testing/test-scope-dependencies.md | 22 +
.../3.5.4/reference/testing/test-utilities.md | 302 ++
.../3.5.4/reference/testing/testcontainers.md | 638 ++++
.../reference/using/auto-configuration.md | 76 +
.../3.5.4/reference/using/build-systems.md | 150 +
.../reference/using/configuration-classes.md | 32 +
.../boot/3.5.4/reference/using/devtools.md | 520 +++
markdown/boot/3.5.4/reference/using/index.md | 15 +
.../using/packaging-for-production.md | 15 +
.../using/running-your-application.md | 102 +
.../spring-beans-and-dependency-injection.md | 112 +
.../reference/using/structuring-your-code.md | 91 +
...ng-the-springbootapplication-annotation.md | 98 +
.../3.5.4/reference/web/graceful-shutdown.md | 65 +
markdown/boot/3.5.4/reference/web/index.md | 15 +
markdown/boot/3.5.4/reference/web/reactive.md | 721 ++++
markdown/boot/3.5.4/reference/web/servlet.md | 1373 ++++++++
.../3.5.4/reference/web/spring-graphql.md | 239 ++
.../3.5.4/reference/web/spring-hateoas.md | 22 +
.../3.5.4/reference/web/spring-security.md | 693 ++++
.../3.5.4/reference/web/spring-session.md | 67 +
.../annotation-processor.md | 296 ++
.../configuration-metadata/format.md | 248 ++
.../configuration-metadata/index.md | 14 +
.../configuration-metadata/manual-hints.md | 338 ++
.../executable-jar/alternatives.md | 15 +
.../specification/executable-jar/index.md | 13 +
.../executable-jar/jarfile-class.md | 40 +
.../specification/executable-jar/launching.md | 45 +
.../executable-jar/nested-jars.md | 152 +
.../executable-jar/property-launcher.md | 49 +
.../executable-jar/restrictions.md | 25 +
markdown/boot/3.5.4/system-requirements.md | 48 +
.../3.5.4/tutorial/first-application/index.md | 526 +++
markdown/boot/3.5.4/tutorial/index.md | 8 +
markdown/boot/3.5.4/upgrading.md | 57 +
148 files changed, 38943 insertions(+), 1 deletion(-)
create mode 100644 markdown/boot/3.5.4/LICENSE
create mode 100644 markdown/boot/3.5.4/NOTICE
create mode 100644 markdown/boot/3.5.4/_index.md
create mode 100644 markdown/boot/3.5.4/appendix/application-properties/index.md
create mode 100644 markdown/boot/3.5.4/appendix/auto-configuration-classes/index.md
create mode 100644 markdown/boot/3.5.4/appendix/dependency-versions/coordinates.md
create mode 100644 markdown/boot/3.5.4/appendix/dependency-versions/index.md
create mode 100644 markdown/boot/3.5.4/appendix/dependency-versions/properties.md
create mode 100644 markdown/boot/3.5.4/appendix/test-auto-configuration/index.md
create mode 100644 markdown/boot/3.5.4/appendix/test-auto-configuration/slices.md
create mode 100644 markdown/boot/3.5.4/build-tool-plugin/antlib.md
create mode 100644 markdown/boot/3.5.4/build-tool-plugin/index.md
create mode 100644 markdown/boot/3.5.4/build-tool-plugin/other-build-systems.md
create mode 100644 markdown/boot/3.5.4/cli/index.md
create mode 100644 markdown/boot/3.5.4/cli/installation.md
create mode 100644 markdown/boot/3.5.4/cli/using-the-cli.md
create mode 100644 markdown/boot/3.5.4/community.md
create mode 100644 markdown/boot/3.5.4/documentation.md
create mode 100644 markdown/boot/3.5.4/how-to/actuator.md
create mode 100644 markdown/boot/3.5.4/how-to/aot.md
create mode 100644 markdown/boot/3.5.4/how-to/application.md
create mode 100644 markdown/boot/3.5.4/how-to/batch.md
create mode 100644 markdown/boot/3.5.4/how-to/build.md
create mode 100644 markdown/boot/3.5.4/how-to/class-data-sharing.md
create mode 100644 markdown/boot/3.5.4/how-to/data-access.md
create mode 100644 markdown/boot/3.5.4/how-to/data-initialization.md
create mode 100644 markdown/boot/3.5.4/how-to/deployment/cloud.md
create mode 100644 markdown/boot/3.5.4/how-to/deployment/index.md
create mode 100644 markdown/boot/3.5.4/how-to/deployment/installing.md
create mode 100644 markdown/boot/3.5.4/how-to/deployment/traditional-deployment.md
create mode 100644 markdown/boot/3.5.4/how-to/docker-compose.md
create mode 100644 markdown/boot/3.5.4/how-to/hotswapping.md
create mode 100644 markdown/boot/3.5.4/how-to/http-clients.md
create mode 100644 markdown/boot/3.5.4/how-to/index.md
create mode 100644 markdown/boot/3.5.4/how-to/jersey.md
create mode 100644 markdown/boot/3.5.4/how-to/logging.md
create mode 100644 markdown/boot/3.5.4/how-to/messaging.md
create mode 100644 markdown/boot/3.5.4/how-to/native-image/developing-your-first-application.md
create mode 100644 markdown/boot/3.5.4/how-to/native-image/index.md
create mode 100644 markdown/boot/3.5.4/how-to/native-image/testing-native-applications.md
create mode 100644 markdown/boot/3.5.4/how-to/nosql.md
create mode 100644 markdown/boot/3.5.4/how-to/properties-and-configuration.md
create mode 100644 markdown/boot/3.5.4/how-to/security.md
create mode 100644 markdown/boot/3.5.4/how-to/spring-mvc.md
create mode 100644 markdown/boot/3.5.4/how-to/testing.md
create mode 100644 markdown/boot/3.5.4/how-to/webserver.md
create mode 100644 markdown/boot/3.5.4/index.md
create mode 100644 markdown/boot/3.5.4/installing.md
create mode 100644 markdown/boot/3.5.4/redirect.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/auditing.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/cloud-foundry.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/enabling.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/endpoints.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/http-exchanges.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/index.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/jmx.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/loggers.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/metrics.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/monitoring.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/observability.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/process-monitoring.md
create mode 100644 markdown/boot/3.5.4/reference/actuator/tracing.md
create mode 100644 markdown/boot/3.5.4/reference/data/index.md
create mode 100644 markdown/boot/3.5.4/reference/data/nosql.md
create mode 100644 markdown/boot/3.5.4/reference/data/sql.md
create mode 100644 markdown/boot/3.5.4/reference/features/aop.md
create mode 100644 markdown/boot/3.5.4/reference/features/dev-services.md
create mode 100644 markdown/boot/3.5.4/reference/features/developing-auto-configuration.md
create mode 100644 markdown/boot/3.5.4/reference/features/external-config.md
create mode 100644 markdown/boot/3.5.4/reference/features/index.md
create mode 100644 markdown/boot/3.5.4/reference/features/internationalization.md
create mode 100644 markdown/boot/3.5.4/reference/features/json.md
create mode 100644 markdown/boot/3.5.4/reference/features/kotlin.md
create mode 100644 markdown/boot/3.5.4/reference/features/logging.md
create mode 100644 markdown/boot/3.5.4/reference/features/profiles.md
create mode 100644 markdown/boot/3.5.4/reference/features/spring-application.md
create mode 100644 markdown/boot/3.5.4/reference/features/ssl.md
create mode 100644 markdown/boot/3.5.4/reference/features/task-execution-and-scheduling.md
create mode 100644 markdown/boot/3.5.4/reference/index.md
create mode 100644 markdown/boot/3.5.4/reference/io/caching.md
create mode 100644 markdown/boot/3.5.4/reference/io/email.md
create mode 100644 markdown/boot/3.5.4/reference/io/hazelcast.md
create mode 100644 markdown/boot/3.5.4/reference/io/index.md
create mode 100644 markdown/boot/3.5.4/reference/io/jta.md
create mode 100644 markdown/boot/3.5.4/reference/io/quartz.md
create mode 100644 markdown/boot/3.5.4/reference/io/rest-client.md
create mode 100644 markdown/boot/3.5.4/reference/io/validation.md
create mode 100644 markdown/boot/3.5.4/reference/io/webservices.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/amqp.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/index.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/jms.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/kafka.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/pulsar.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/rsocket.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/spring-integration.md
create mode 100644 markdown/boot/3.5.4/reference/messaging/websockets.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/aot.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/checkpoint-restore.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/class-data-sharing.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/container-images/cloud-native-buildpacks.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/container-images/dockerfiles.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/container-images/efficient-images.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/container-images/index.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/efficient.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/index.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/native-image/advanced-topics.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/native-image/index.md
create mode 100644 markdown/boot/3.5.4/reference/packaging/native-image/introducing-graalvm-native-images.md
create mode 100644 markdown/boot/3.5.4/reference/testing/index.md
create mode 100644 markdown/boot/3.5.4/reference/testing/spring-applications.md
create mode 100644 markdown/boot/3.5.4/reference/testing/spring-boot-applications.md
create mode 100644 markdown/boot/3.5.4/reference/testing/test-scope-dependencies.md
create mode 100644 markdown/boot/3.5.4/reference/testing/test-utilities.md
create mode 100644 markdown/boot/3.5.4/reference/testing/testcontainers.md
create mode 100644 markdown/boot/3.5.4/reference/using/auto-configuration.md
create mode 100644 markdown/boot/3.5.4/reference/using/build-systems.md
create mode 100644 markdown/boot/3.5.4/reference/using/configuration-classes.md
create mode 100644 markdown/boot/3.5.4/reference/using/devtools.md
create mode 100644 markdown/boot/3.5.4/reference/using/index.md
create mode 100644 markdown/boot/3.5.4/reference/using/packaging-for-production.md
create mode 100644 markdown/boot/3.5.4/reference/using/running-your-application.md
create mode 100644 markdown/boot/3.5.4/reference/using/spring-beans-and-dependency-injection.md
create mode 100644 markdown/boot/3.5.4/reference/using/structuring-your-code.md
create mode 100644 markdown/boot/3.5.4/reference/using/using-the-springbootapplication-annotation.md
create mode 100644 markdown/boot/3.5.4/reference/web/graceful-shutdown.md
create mode 100644 markdown/boot/3.5.4/reference/web/index.md
create mode 100644 markdown/boot/3.5.4/reference/web/reactive.md
create mode 100644 markdown/boot/3.5.4/reference/web/servlet.md
create mode 100644 markdown/boot/3.5.4/reference/web/spring-graphql.md
create mode 100644 markdown/boot/3.5.4/reference/web/spring-hateoas.md
create mode 100644 markdown/boot/3.5.4/reference/web/spring-security.md
create mode 100644 markdown/boot/3.5.4/reference/web/spring-session.md
create mode 100644 markdown/boot/3.5.4/specification/configuration-metadata/annotation-processor.md
create mode 100644 markdown/boot/3.5.4/specification/configuration-metadata/format.md
create mode 100644 markdown/boot/3.5.4/specification/configuration-metadata/index.md
create mode 100644 markdown/boot/3.5.4/specification/configuration-metadata/manual-hints.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/alternatives.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/index.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/jarfile-class.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/launching.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/nested-jars.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/property-launcher.md
create mode 100644 markdown/boot/3.5.4/specification/executable-jar/restrictions.md
create mode 100644 markdown/boot/3.5.4/system-requirements.md
create mode 100644 markdown/boot/3.5.4/tutorial/first-application/index.md
create mode 100644 markdown/boot/3.5.4/tutorial/index.md
create mode 100644 markdown/boot/3.5.4/upgrading.md
diff --git a/catalog.json b/catalog.json
index c8bb10b..906fbe4 100644
--- a/catalog.json
+++ b/catalog.json
@@ -1,9 +1,13 @@
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"version": "1",
- "generated_at": "2026-09-11T19:16:47.638Z",
+ "generated_at": "2026-09-12T12:36:01.635Z",
"projects": {
"boot": {
+ "3.5.4": {
+ "tag": "boot-3.5.4",
+ "released_at": "2026-09-12T12:36:01Z"
+ },
"4.0.8": {
"tag": "boot-4.0.8",
"released_at": "2026-09-11T19:11:35Z"
diff --git a/markdown/boot/3.5.4/LICENSE b/markdown/boot/3.5.4/LICENSE
new file mode 100644
index 0000000..c2f8167
--- /dev/null
+++ b/markdown/boot/3.5.4/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for describing the origin of the Work and
+ reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Support. While redistributing the Work or
+ Derivative Works thereof, You may choose to offer, and charge a
+ fee for, acceptance of support, warranty, indemnity, or other
+ liability obligations and/or rights consistent with this License.
+ However, in accepting such obligations, You may act only on Your
+ own behalf and on Your sole responsibility, not on behalf of any
+ other Contributor, and only if You agree to indemnify, defend,
+ and hold each Contributor harmless for any liability incurred by,
+ or claims asserted against, such Contributor by reason of your
+ accepting any such warranty or support.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 2026 Passion Factory
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ permissions and limitations under the License.
diff --git a/markdown/boot/3.5.4/NOTICE b/markdown/boot/3.5.4/NOTICE
new file mode 100644
index 0000000..734679b
--- /dev/null
+++ b/markdown/boot/3.5.4/NOTICE
@@ -0,0 +1,69 @@
+boot 3.5.4 — converted Spring documentation
+
+This archive contains documentation converted from:
+ Repository: https://github.com/spring-projects/spring-boot
+ Ref: v3.5.4
+ Commit: 925f9bc6ba99f0eaffce1e357282d3672b88e2a5
+
+The documentation is licensed under the Apache License, Version 2.0, by its
+original authors. Conversion changed formatting only; the meaning of the
+content is unmodified. The upstream license and attribution follow.
+
+---
+
+@pleaseai/spring-docs
+Copyright 2026 Passion Factory
+
+This product includes software developed by Passion Factory (https://passionfactory.ai).
+
+================================================================================
+Redistributed Documentation Content
+================================================================================
+
+This repository redistributes documentation generated from the following
+upstream projects. All redistributed content retains its original copyright
+and is licensed under the Apache License, Version 2.0.
+
+The Markdown files in this repository (and in the GitHub Release archives it
+publishes) are mechanical conversions from the original sources. Content
+meaning is unchanged; only the file format differs.
+
+--------------------------------------------------------------------------------
+Spring Framework
+ Copyright (c) 2002-present, the Spring Framework authors.
+ Source: https://github.com/spring-projects/spring-framework
+ License: Apache License, Version 2.0
+ Notice: https://github.com/spring-projects/spring-framework/blob/main/NOTICE.txt
+
+Spring Boot
+ Copyright (c) 2012-present, the Spring Boot authors.
+ Source: https://github.com/spring-projects/spring-boot
+ License: Apache License, Version 2.0
+ Notice: https://github.com/spring-projects/spring-boot/blob/main/NOTICE.txt
+
+Spring Security
+ Copyright (c) 2002-present, the Spring Security authors.
+ Source: https://github.com/spring-projects/spring-security
+ License: Apache License, Version 2.0
+ Notice: https://github.com/spring-projects/spring-security/blob/main/NOTICE.txt
+
+Spring Data (and its sub-projects: JPA, JDBC, MongoDB, Redis, etc.)
+ Copyright (c) 2008-present, the Spring Data authors.
+ Source: https://github.com/spring-projects/spring-data-*
+ License: Apache License, Version 2.0
+
+Spring Cloud (and its sub-projects)
+ Copyright (c) 2013-present, the Spring Cloud authors.
+ Source: https://github.com/spring-cloud/*
+ License: Apache License, Version 2.0
+--------------------------------------------------------------------------------
+
+Per-release attribution:
+ Each GitHub Release archive published from this repository includes a
+ NOTICE file pinned to the exact upstream commit/tag from which the
+ documentation was generated. Consult the archive's NOTICE for the
+ authoritative attribution applicable to that release.
+
+If you are a maintainer of any upstream project listed above and have
+concerns about how this documentation is redistributed, please open an
+issue at https://github.com/pleaseai/spring-docs/issues.
diff --git a/markdown/boot/3.5.4/_index.md b/markdown/boot/3.5.4/_index.md
new file mode 100644
index 0000000..a5e3834
--- /dev/null
+++ b/markdown/boot/3.5.4/_index.md
@@ -0,0 +1,148 @@
+# boot 3.5.4
+
+144 pages, converted from upstream Spring AsciiDoc.
+
+- [appendix/application-properties/index](./appendix/application-properties/index.md)
+- [appendix/auto-configuration-classes/index](./appendix/auto-configuration-classes/index.md)
+- [appendix/dependency-versions/coordinates](./appendix/dependency-versions/coordinates.md)
+- [appendix/dependency-versions/index](./appendix/dependency-versions/index.md)
+- [appendix/dependency-versions/properties](./appendix/dependency-versions/properties.md)
+- [appendix/test-auto-configuration/index](./appendix/test-auto-configuration/index.md)
+- [appendix/test-auto-configuration/slices](./appendix/test-auto-configuration/slices.md)
+- [build-tool-plugin/antlib](./build-tool-plugin/antlib.md)
+- [build-tool-plugin/index](./build-tool-plugin/index.md)
+- [build-tool-plugin/other-build-systems](./build-tool-plugin/other-build-systems.md)
+- [cli/index](./cli/index.md)
+- [cli/installation](./cli/installation.md)
+- [cli/using-the-cli](./cli/using-the-cli.md)
+- [community](./community.md)
+- [documentation](./documentation.md)
+- [how-to/actuator](./how-to/actuator.md)
+- [how-to/aot](./how-to/aot.md)
+- [how-to/application](./how-to/application.md)
+- [how-to/batch](./how-to/batch.md)
+- [how-to/build](./how-to/build.md)
+- [how-to/class-data-sharing](./how-to/class-data-sharing.md)
+- [how-to/data-access](./how-to/data-access.md)
+- [how-to/data-initialization](./how-to/data-initialization.md)
+- [how-to/deployment/cloud](./how-to/deployment/cloud.md)
+- [how-to/deployment/index](./how-to/deployment/index.md)
+- [how-to/deployment/installing](./how-to/deployment/installing.md)
+- [how-to/deployment/traditional-deployment](./how-to/deployment/traditional-deployment.md)
+- [how-to/docker-compose](./how-to/docker-compose.md)
+- [how-to/hotswapping](./how-to/hotswapping.md)
+- [how-to/http-clients](./how-to/http-clients.md)
+- [how-to/index](./how-to/index.md)
+- [how-to/jersey](./how-to/jersey.md)
+- [how-to/logging](./how-to/logging.md)
+- [how-to/messaging](./how-to/messaging.md)
+- [how-to/native-image/developing-your-first-application](./how-to/native-image/developing-your-first-application.md)
+- [how-to/native-image/index](./how-to/native-image/index.md)
+- [how-to/native-image/testing-native-applications](./how-to/native-image/testing-native-applications.md)
+- [how-to/nosql](./how-to/nosql.md)
+- [how-to/properties-and-configuration](./how-to/properties-and-configuration.md)
+- [how-to/security](./how-to/security.md)
+- [how-to/spring-mvc](./how-to/spring-mvc.md)
+- [how-to/testing](./how-to/testing.md)
+- [how-to/webserver](./how-to/webserver.md)
+- [index](./index.md)
+- [installing](./installing.md)
+- [redirect](./redirect.md)
+- [reference/actuator/auditing](./reference/actuator/auditing.md)
+- [reference/actuator/cloud-foundry](./reference/actuator/cloud-foundry.md)
+- [reference/actuator/enabling](./reference/actuator/enabling.md)
+- [reference/actuator/endpoints](./reference/actuator/endpoints.md)
+- [reference/actuator/http-exchanges](./reference/actuator/http-exchanges.md)
+- [reference/actuator/index](./reference/actuator/index.md)
+- [reference/actuator/jmx](./reference/actuator/jmx.md)
+- [reference/actuator/loggers](./reference/actuator/loggers.md)
+- [reference/actuator/metrics](./reference/actuator/metrics.md)
+- [reference/actuator/monitoring](./reference/actuator/monitoring.md)
+- [reference/actuator/observability](./reference/actuator/observability.md)
+- [reference/actuator/process-monitoring](./reference/actuator/process-monitoring.md)
+- [reference/actuator/tracing](./reference/actuator/tracing.md)
+- [reference/data/index](./reference/data/index.md)
+- [reference/data/nosql](./reference/data/nosql.md)
+- [reference/data/sql](./reference/data/sql.md)
+- [reference/features/aop](./reference/features/aop.md)
+- [reference/features/dev-services](./reference/features/dev-services.md)
+- [reference/features/developing-auto-configuration](./reference/features/developing-auto-configuration.md)
+- [reference/features/external-config](./reference/features/external-config.md)
+- [reference/features/index](./reference/features/index.md)
+- [reference/features/internationalization](./reference/features/internationalization.md)
+- [reference/features/json](./reference/features/json.md)
+- [reference/features/kotlin](./reference/features/kotlin.md)
+- [reference/features/logging](./reference/features/logging.md)
+- [reference/features/profiles](./reference/features/profiles.md)
+- [reference/features/spring-application](./reference/features/spring-application.md)
+- [reference/features/ssl](./reference/features/ssl.md)
+- [reference/features/task-execution-and-scheduling](./reference/features/task-execution-and-scheduling.md)
+- [reference/index](./reference/index.md)
+- [reference/io/caching](./reference/io/caching.md)
+- [reference/io/email](./reference/io/email.md)
+- [reference/io/hazelcast](./reference/io/hazelcast.md)
+- [reference/io/index](./reference/io/index.md)
+- [reference/io/jta](./reference/io/jta.md)
+- [reference/io/quartz](./reference/io/quartz.md)
+- [reference/io/rest-client](./reference/io/rest-client.md)
+- [reference/io/validation](./reference/io/validation.md)
+- [reference/io/webservices](./reference/io/webservices.md)
+- [reference/messaging/amqp](./reference/messaging/amqp.md)
+- [reference/messaging/index](./reference/messaging/index.md)
+- [reference/messaging/jms](./reference/messaging/jms.md)
+- [reference/messaging/kafka](./reference/messaging/kafka.md)
+- [reference/messaging/pulsar](./reference/messaging/pulsar.md)
+- [reference/messaging/rsocket](./reference/messaging/rsocket.md)
+- [reference/messaging/spring-integration](./reference/messaging/spring-integration.md)
+- [reference/messaging/websockets](./reference/messaging/websockets.md)
+- [reference/packaging/aot](./reference/packaging/aot.md)
+- [reference/packaging/checkpoint-restore](./reference/packaging/checkpoint-restore.md)
+- [reference/packaging/class-data-sharing](./reference/packaging/class-data-sharing.md)
+- [reference/packaging/container-images/cloud-native-buildpacks](./reference/packaging/container-images/cloud-native-buildpacks.md)
+- [reference/packaging/container-images/dockerfiles](./reference/packaging/container-images/dockerfiles.md)
+- [reference/packaging/container-images/efficient-images](./reference/packaging/container-images/efficient-images.md)
+- [reference/packaging/container-images/index](./reference/packaging/container-images/index.md)
+- [reference/packaging/efficient](./reference/packaging/efficient.md)
+- [reference/packaging/index](./reference/packaging/index.md)
+- [reference/packaging/native-image/advanced-topics](./reference/packaging/native-image/advanced-topics.md)
+- [reference/packaging/native-image/index](./reference/packaging/native-image/index.md)
+- [reference/packaging/native-image/introducing-graalvm-native-images](./reference/packaging/native-image/introducing-graalvm-native-images.md)
+- [reference/testing/index](./reference/testing/index.md)
+- [reference/testing/spring-applications](./reference/testing/spring-applications.md)
+- [reference/testing/spring-boot-applications](./reference/testing/spring-boot-applications.md)
+- [reference/testing/test-scope-dependencies](./reference/testing/test-scope-dependencies.md)
+- [reference/testing/test-utilities](./reference/testing/test-utilities.md)
+- [reference/testing/testcontainers](./reference/testing/testcontainers.md)
+- [reference/using/auto-configuration](./reference/using/auto-configuration.md)
+- [reference/using/build-systems](./reference/using/build-systems.md)
+- [reference/using/configuration-classes](./reference/using/configuration-classes.md)
+- [reference/using/devtools](./reference/using/devtools.md)
+- [reference/using/index](./reference/using/index.md)
+- [reference/using/packaging-for-production](./reference/using/packaging-for-production.md)
+- [reference/using/running-your-application](./reference/using/running-your-application.md)
+- [reference/using/spring-beans-and-dependency-injection](./reference/using/spring-beans-and-dependency-injection.md)
+- [reference/using/structuring-your-code](./reference/using/structuring-your-code.md)
+- [reference/using/using-the-springbootapplication-annotation](./reference/using/using-the-springbootapplication-annotation.md)
+- [reference/web/graceful-shutdown](./reference/web/graceful-shutdown.md)
+- [reference/web/index](./reference/web/index.md)
+- [reference/web/reactive](./reference/web/reactive.md)
+- [reference/web/servlet](./reference/web/servlet.md)
+- [reference/web/spring-graphql](./reference/web/spring-graphql.md)
+- [reference/web/spring-hateoas](./reference/web/spring-hateoas.md)
+- [reference/web/spring-security](./reference/web/spring-security.md)
+- [reference/web/spring-session](./reference/web/spring-session.md)
+- [specification/configuration-metadata/annotation-processor](./specification/configuration-metadata/annotation-processor.md)
+- [specification/configuration-metadata/format](./specification/configuration-metadata/format.md)
+- [specification/configuration-metadata/index](./specification/configuration-metadata/index.md)
+- [specification/configuration-metadata/manual-hints](./specification/configuration-metadata/manual-hints.md)
+- [specification/executable-jar/alternatives](./specification/executable-jar/alternatives.md)
+- [specification/executable-jar/index](./specification/executable-jar/index.md)
+- [specification/executable-jar/jarfile-class](./specification/executable-jar/jarfile-class.md)
+- [specification/executable-jar/launching](./specification/executable-jar/launching.md)
+- [specification/executable-jar/nested-jars](./specification/executable-jar/nested-jars.md)
+- [specification/executable-jar/property-launcher](./specification/executable-jar/property-launcher.md)
+- [specification/executable-jar/restrictions](./specification/executable-jar/restrictions.md)
+- [system-requirements](./system-requirements.md)
+- [tutorial/first-application/index](./tutorial/first-application/index.md)
+- [tutorial/index](./tutorial/index.md)
+- [upgrading](./upgrading.md)
diff --git a/markdown/boot/3.5.4/appendix/application-properties/index.md b/markdown/boot/3.5.4/appendix/application-properties/index.md
new file mode 100644
index 0000000..dbdb3b8
--- /dev/null
+++ b/markdown/boot/3.5.4/appendix/application-properties/index.md
@@ -0,0 +1,55 @@
+---
+title: "Common Application Properties"
+source: "appendix:application-properties/index.adoc"
+---
+
+
+ ...
+
+```
+
+You need to remember to start Ant using the `-lib` option, as shown in the following example:
+
+```shell
+$ ant -lib
+```
+
+> [!TIP]
+> The “Using Spring Boot” section includes a more complete example of [using Apache Ant with `spring-boot-antlib`](../reference/using/build-systems.md#using.build-systems.ant).
+
+
+
+
+
+
+
+```
+
+#### Detect start-class
+
+```xml
+
+
+
+
+```
+
+ getCompileScopeJars() {
+ return ...
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.loader.tools.Library
+import org.springframework.boot.loader.tools.LibraryCallback
+import org.springframework.boot.loader.tools.LibraryScope
+import org.springframework.boot.loader.tools.Repackager
+import java.io.File
+import java.io.IOException
+
+class MyBuildTool {
+
+ @Throws(IOException::class)
+ fun build() {
+ val sourceJarFile: File? = ...
+ val repackager = Repackager(sourceJarFile)
+ repackager.setBackupSource(false)
+ repackager.repackage { callback: LibraryCallback -> getLibraries(callback) }
+ }
+
+ @Throws(IOException::class)
+ private fun getLibraries(callback: LibraryCallback) {
+ // Build system specific implementation, callback for each dependency
+ for (nestedJar in getCompileScopeJars()!!) {
+ callback.library(Library(nestedJar, LibraryScope.COMPILE))
+ }
+ // ...
+ }
+
+ private fun getCompileScopeJars(): List? {
+ return ...
+ }
+
+}
+
+```
diff --git a/markdown/boot/3.5.4/cli/index.md b/markdown/boot/3.5.4/cli/index.md
new file mode 100644
index 0000000..efcb70c
--- /dev/null
+++ b/markdown/boot/3.5.4/cli/index.md
@@ -0,0 +1,10 @@
+---
+title: "Spring Boot CLI"
+source: "cli:index.adoc"
+---
+
+ []
+
+Available commands are:
+
+ init [options] [location]
+ Initialize a new project using Spring Initializr (start.spring.io)
+
+ encodepassword [options]
+ Encode a password for use with Spring Security
+
+ shell
+ Start a nested shell
+
+Common options:
+
+ --debug Verbose mode
+ Print additional status information for the command you are running
+See 'spring help ' for more information on a specific command.
+```
+
+You can type `spring help` to get more details about any of the supported commands, as shown in the following example:
+
+```shell
+$ spring help init
+spring init - Initialize a new project using Spring Initializr (start.spring.io)
+
+usage: spring init [options] [location]
+
+Option Description
+------ -----------
+-a, --artifact-id Project coordinates; infer archive name (for
+ example 'test')
+-b, --boot-version Spring Boot version (for example '1.2.0.RELEASE')
+--build Build system to use (for example 'maven' or
+ 'gradle') (default: maven)
+-d, --dependencies Comma-separated list of dependency identifiers to
+ include in the generated project
+--description Project description
+-f, --force Force overwrite of existing files
+--format Format of the generated content (for example
+ 'build' for a build file, 'project' for a
+ project archive) (default: project)
+-g, --group-id Project coordinates (for example 'org.test')
+-j, --java-version Language level (for example '1.8')
+-l, --language Programming language (for example 'java')
+--list List the capabilities of the service. Use it to
+ discover the dependencies and the types that are
+ available
+-n, --name Project name; infer application name
+-p, --packaging Project packaging (for example 'jar')
+--package-name Package name
+-t, --type Project type. Not normally needed if you use --
+ build and/or --format. Check the capabilities of
+ the service (--list) for more details
+--target URL of the service to use (default: https://start.
+ spring.io)
+-v, --version Project version (for example '0.0.1-SNAPSHOT')
+-x, --extract Extract the project archive. Inferred if a
+ location is specified without an extension
+
+examples:
+
+ To list all the capabilities of the service:
+ $ spring init --list
+
+ To creates a default project:
+ $ spring init
+
+ To create a web my-app.zip:
+ $ spring init -d=web my-app.zip
+
+ To create a web/data-jpa gradle project unpacked:
+ $ spring init -d=web,jpa --build=gradle my-dir
+```
+
+The `version` command provides a quick way to check which version of Spring Boot you are using, as follows:
+
+```shell
+$ spring version
+Spring CLI v{version-spring-boot}
+```
+
+
+ native
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+ process-aot
+
+ profile-a,profile-b
+
+
+
+
+
+
+
+
+```
+
+For Gradle, you need to configure the `ProcessAot` task:
+
+```gradle
+tasks.withType(org.springframework.boot.gradle.tasks.aot.ProcessAot).configureEach {
+ args('--spring.profiles.active=profile-a,profile-b')
+}
+```
+
+Profiles which only change configuration properties that don’t influence conditions are supported without limitations when running ahead-of-time optimized applications.
diff --git a/markdown/boot/3.5.4/how-to/application.md b/markdown/boot/3.5.4/how-to/application.md
new file mode 100644
index 0000000..301e42b
--- /dev/null
+++ b/markdown/boot/3.5.4/how-to/application.md
@@ -0,0 +1,187 @@
+---
+title: "Spring Boot Application"
+source: "how-to:application.adoc"
+---
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+ {version-spring-boot}
+
+
+
+ build-info
+
+
+
+
+
+
+```
+
+> [!TIP]
+> See the [Spring Boot Maven Plugin documentation](https://docs.spring.io/spring-boot/3.5.4/maven-plugin/build-info.html) for more details.
+
+The following example does the same with Gradle:
+
+```gradle
+springBoot {
+ buildInfo()
+}
+```
+
+> [!TIP]
+> See the [Spring Boot Gradle Plugin documentation](https://docs.spring.io/spring-boot/3.5.4/gradle-plugin/integrating-with-actuator.html) for more details.
+
+
+
+
+ io.github.git-commit-id
+ git-commit-id-maven-plugin
+
+
+
+```
+
+Gradle users can achieve the same result by using the [`gradle-git-properties`](https://plugins.gradle.org/plugin/com.gorylenko.gradle-git-properties) plugin, as shown in the following example:
+
+```gradle
+plugins {
+ id "com.gorylenko.gradle-git-properties" version "2.4.1"
+}
+```
+
+Both the Maven and Gradle plugins allow the properties that are included in `git.properties` to be configured.
+
+> [!TIP]
+> The commit time in `git.properties` is expected to match the following format: `yyyy-MM-dd’T’HH:mm:ssZ`.
+> This is the default format for both plugins listed above.
+> Using this format lets the time be parsed into a [`Date`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html) and its format, when serialized to JSON, to be controlled by Jackson’s date serialization configuration settings.
+
+
+
+
+ org.cyclonedx
+ cyclonedx-maven-plugin
+
+
+
+```
+
+Gradle users can achieve the same result by using the [`cyclonedx-gradle-plugin`](https://github.com/CycloneDX/cyclonedx-gradle-plugin) plugin, as shown in the following example:
+
+```gradle
+plugins {
+ id 'org.cyclonedx.bom' version '2.3.0'
+}
+```
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+```
+
+If you do not use the parent POM, you can still use the plugin.
+However, you must additionally add an `` section, as follows:
+
+```xml
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+ {version-spring-boot}
+
+
+
+ repackage
+
+
+
+
+
+
+```
+
+See the [plugin documentation](https://docs.spring.io/spring-boot/3.5.4/maven-plugin/packaging.html#packaging.repackage-goal) for full usage details.
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+ exec
+
+
+
+
+```
+
+
+
+## Extract Specific Libraries When an Executable Jar Runs
+
+Most nested libraries in an executable jar do not need to be unpacked in order to run.
+However, certain libraries can have problems.
+For example, JRuby includes its own nested jar support, which assumes that the `jruby-complete.jar` is always directly available as a file in its own right.
+
+To deal with any problematic libraries, you can flag that specific nested jars should be automatically unpacked when the executable jar first runs.
+Such nested jars are written beneath the temporary directory identified by the `java.io.tmpdir` system property.
+
+> [!WARNING]
+> Care should be taken to ensure that your operating system is configured so that it will not delete the jars that have been unpacked to the temporary directory while the application is still running.
+
+For example, to indicate that JRuby should be flagged for unpacking by using the Maven Plugin, you would add the following configuration:
+
+```xml
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+ org.jruby
+ jruby-complete
+
+
+
+
+
+
+```
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+ maven-jar-plugin
+
+
+ lib
+ package
+
+ jar
+
+
+ lib
+
+ application.yaml
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
diff --git a/markdown/boot/3.5.4/how-to/class-data-sharing.md b/markdown/boot/3.5.4/how-to/class-data-sharing.md
new file mode 100644
index 0000000..1c0bd62
--- /dev/null
+++ b/markdown/boot/3.5.4/how-to/class-data-sharing.md
@@ -0,0 +1,36 @@
+---
+title: "Class Data Sharing"
+source: "how-to:class-data-sharing.adoc"
+---
+
+> jpaPropertiesFactory = (dataSource) -> createJpaProperties(dataSource,
+ jpaProperties.getProperties());
+ return new EntityManagerFactoryBuilder(jpaVendorAdapter, jpaPropertiesFactory, null);
+ }
+
+ private JpaVendorAdapter createJpaVendorAdapter(JpaProperties jpaProperties) {
+ // ... map JPA properties as needed
+ return new HibernateJpaVendorAdapter();
+ }
+
+ private Map createJpaProperties(DataSource dataSource, Map existingProperties) {
+ Map jpaProperties = new LinkedHashMap<>(existingProperties);
+ // ... map JPA properties that require the DataSource (e.g. DDL flags)
+ return jpaProperties;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.beans.factory.annotation.Qualifier
+import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.orm.jpa.JpaVendorAdapter
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter
+import javax.sql.DataSource
+
+@Configuration(proxyBeanMethods = false)
+class MyAdditionalEntityManagerFactoryConfiguration {
+
+ @Qualifier("second")
+ @Bean(defaultCandidate = false)
+ @ConfigurationProperties("app.jpa")
+ fun secondJpaProperties(): JpaProperties {
+ return JpaProperties()
+ }
+
+ @Qualifier("second")
+ @Bean(defaultCandidate = false)
+ fun firstEntityManagerFactory(
+ @Qualifier("second") dataSource: DataSource,
+ @Qualifier("second") jpaProperties: JpaProperties
+ ): LocalContainerEntityManagerFactoryBean {
+ val builder = createEntityManagerFactoryBuilder(jpaProperties)
+ return builder.dataSource(dataSource).packages(Order::class.java).persistenceUnit("second").build()
+ }
+
+ private fun createEntityManagerFactoryBuilder(jpaProperties: JpaProperties): EntityManagerFactoryBuilder {
+ val jpaVendorAdapter = createJpaVendorAdapter(jpaProperties)
+ val jpaPropertiesFactory = { dataSource: DataSource ->
+ createJpaProperties(dataSource, jpaProperties.properties) }
+ return EntityManagerFactoryBuilder(jpaVendorAdapter, jpaPropertiesFactory, null)
+ }
+
+ private fun createJpaVendorAdapter(jpaProperties: JpaProperties): JpaVendorAdapter {
+ // ... map JPA properties as needed
+ return HibernateJpaVendorAdapter()
+ }
+
+ private fun createJpaProperties(dataSource: DataSource, existingProperties: Map): Map {
+ val jpaProperties: Map = LinkedHashMap(existingProperties)
+ // ... map JPA properties that require the DataSource (e.g. DDL flags)
+ return jpaProperties
+ }
+
+}
+
+```
+
+The example above creates an [`EntityManagerFactory`](https://jakarta.ee/specifications/persistence/3.1/apidocs/jakarta.persistence/jakarta/persistence/EntityManagerFactory.html) using the [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html) bean qualified with `@Qualifier("second")`.
+It scans entities located in the same package as `Order`.
+It is possible to map additional JPA properties using the `app.jpa` namespace.
+The use of `@Bean(defaultCandidate=false)` allows the `secondJpaProperties` and `secondEntityManagerFactory` beans to be defined without interfering with auto-configured beans of the same type.
+
+> [!NOTE]
+> The [Spring Framework reference documentation](https://docs.spring.io/spring-framework/reference/6.2/core/beans/dependencies/factory-autowire.html#beans-factory-autowire-candidate) describes this feature in more details.
+
+You should provide a similar configuration for any more additional data sources for which you need JPA access.
+To complete the picture, you need to configure a [`JpaTransactionManager`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/orm/jpa/JpaTransactionManager.html) for each [`EntityManagerFactory`](https://jakarta.ee/specifications/persistence/3.1/apidocs/jakarta.persistence/jakarta/persistence/EntityManagerFactory.html) as well.
+Alternatively, you might be able to use a JTA transaction manager that spans both.
+
+If you use Spring Data, you need to configure [`@EnableJpaRepositories`](https://docs.spring.io/spring-data/jpa/docs/3.5.x/api/org/springframework/data/jpa/repository/config/EnableJpaRepositories.html) accordingly, as shown in the following examples:
+
+#### Java
+
+```java
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@Configuration(proxyBeanMethods = false)
+@EnableJpaRepositories(basePackageClasses = Order.class, entityManagerFactoryRef = "entityManagerFactory")
+public class OrderConfiguration {
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.context.annotation.Configuration
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories
+
+@Configuration(proxyBeanMethods = false)
+@EnableJpaRepositories(basePackageClasses = [Order::class], entityManagerFactoryRef = "firstEntityManagerFactory")
+class OrderConfiguration
+
+```
+
+#### Java
+
+```java
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@Configuration(proxyBeanMethods = false)
+@EnableJpaRepositories(basePackageClasses = Customer.class, entityManagerFactoryRef = "secondEntityManagerFactory")
+public class CustomerConfiguration {
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.context.annotation.Configuration
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories
+
+@Configuration(proxyBeanMethods = false)
+@EnableJpaRepositories(basePackageClasses = [Customer::class], entityManagerFactoryRef = "secondEntityManagerFactory")
+class CustomerConfiguration
+
+```
+
+__.sql` (with `` an underscore-separated version, such as ‘1’ or ‘2\_1’).
+By default, they are in a directory called `classpath:db/migration`, but you can modify that location by setting `spring.flyway.locations`.
+This is a comma-separated list of one or more `classpath:` or `filesystem:` locations.
+For example, the following configuration would search for scripts in both the default classpath location and the `/opt/migration` directory:
+
+#### Properties
+
+```properties
+spring.flyway.locations=classpath:db/migration,filesystem:/opt/migration
+```
+
+#### YAML
+
+```yaml
+spring:
+ flyway:
+ locations: "classpath:db/migration,filesystem:/opt/migration"
+```
+
+You can also add a special `{vendor}` placeholder to use vendor-specific scripts.
+Assume the following:
+
+#### Properties
+
+```properties
+spring.flyway.locations=classpath:db/migration/{vendor}
+```
+
+#### YAML
+
+```yaml
+spring:
+ flyway:
+ locations: "classpath:db/migration/{vendor}"
+```
+
+Rather than using `db/migration`, the preceding configuration sets the directory to use according to the type of the database (such as `db/migration/mysql` for MySQL).
+The list of supported databases is available in [`DatabaseDriver`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jdbc/DatabaseDriver.html).
+
+Migrations can also be written in Java.
+Flyway will be auto-configured with any beans that implement [`JavaMigration`](https://javadoc.io/doc/org.flywaydb/flyway-core/11.7.2/org/flywaydb/core/api/migration/JavaMigration.html).
+
+[`FlywayProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/flyway/FlywayProperties.html) provides most of Flyway’s settings and a small set of additional properties that can be used to disable the migrations or switch off the location checking.
+If you need more control over the configuration, consider registering a [`FlywayConfigurationCustomizer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/flyway/FlywayConfigurationCustomizer.html) bean.
+
+Spring Boot calls `Flyway.migrate()` to perform the database migration.
+If you would like more control, provide a [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) that implements [`FlywayMigrationStrategy`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/flyway/FlywayMigrationStrategy.html).
+
+Flyway supports SQL and Java [callbacks](https://documentation.red-gate.com/fd/callback-concept-184127466.html).
+To use SQL-based callbacks, place the callback scripts in the `classpath:db/migration` directory.
+To use Java-based callbacks, create one or more beans that implement [`Callback`](https://javadoc.io/doc/org.flywaydb/flyway-core/11.7.2/org/flywaydb/core/api/callback/Callback.html).
+Any such beans are automatically registered with [`Flyway`](https://javadoc.io/doc/org.flywaydb/flyway-core/11.7.2/org/flywaydb/core/Flyway.html).
+They can be ordered by using [`@Order`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/annotation/Order.html) or by implementing [`Ordered`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/Ordered.html).
+
+By default, Flyway autowires the (`@Primary`) [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html) in your context and uses that for migrations.
+If you like to use a different [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html), you can create one and mark its [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) as [`@FlywayDataSource`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/flyway/FlywayDataSource.html).
+If you do so and want two data sources (for example by retaining the main auto-configured [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html)), remember to set the `defaultCandidate` attribute of the [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) annotation to `false`.
+Alternatively, you can use Flyway’s native [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html) by setting `spring.flyway.[url,user,password]` in external properties.
+Setting either `spring.flyway.url` or `spring.flyway.user` is sufficient to cause Flyway to use its own [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html).
+If any of the three properties has not been set, the value of its equivalent `spring.datasource` property will be used.
+
+You can also use Flyway to provide data for specific scenarios.
+For example, you can place test-specific migrations in `src/test/resources` and they are run only when your application starts for testing.
+Also, you can use profile-specific configuration to customize `spring.flyway.locations` so that certain migrations run only when a particular profile is active.
+For example, in `application-dev.properties`, you might specify the following setting:
+
+#### Properties
+
+```properties
+spring.flyway.locations=classpath:/db/migration,classpath:/dev/db/migration
+```
+
+#### YAML
+
+```yaml
+spring:
+ flyway:
+ locations: "classpath:/db/migration,classpath:/dev/db/migration"
+```
+
+With that setup, migrations in `dev/db/migration` run only when the `dev` profile is active.
+
+` bean if you want to customize the [`Liquibase`](https://javadoc.io/doc/org.liquibase/liquibase-core/4.31.1/liquibase/Liquibase.html) instance before it is being used.
+
+
+ com.google.cloud.tools
+ appengine-maven-plugin
+ 2.4.4
+
+ myproject
+
+
+```
+
+Then deploy with `mvn appengine:deploy` (you need to authenticate first, otherwise the build fails).
diff --git a/markdown/boot/3.5.4/how-to/deployment/index.md b/markdown/boot/3.5.4/how-to/deployment/index.md
new file mode 100644
index 0000000..36ac210
--- /dev/null
+++ b/markdown/boot/3.5.4/how-to/deployment/index.md
@@ -0,0 +1,13 @@
+---
+title: "Deploying Spring Boot Applications"
+source: "how-to:deployment/index.adoc"
+---
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+ true
+
+
+```
+
+The following example shows the equivalent Gradle configuration:
+
+```gradle
+tasks.named('bootJar') {
+ launchScript()
+}
+```
+
+It can then be symlinked to `init.d` to support the standard `start`, `stop`, `restart`, and `status` commands.
+
+The default launch script that is added to a fully executable jar supports most Linux distributions and is tested on CentOS and Ubuntu.
+Other platforms, such as OS X and FreeBSD, require the use of a custom script.
+The default scripts supports the following features:
+
+- Starts the services as the user that owns the jar file
+- Tracks the application’s PID by using `/var/run//.pid`
+- Writes console logs to `/var/log/.log`
+
+Assuming that you have a Spring Boot application installed in `/var/myapp`, to install a Spring Boot application as an `init.d` service, create a symlink, as follows:
+
+```shell
+$ sudo ln -s /var/myapp/myapp.jar /etc/init.d/myapp
+```
+
+Once installed, you can start and stop the service in the usual way.
+For example, on a Debian-based system, you could start it with the following command:
+
+```shell
+$ service myapp start
+```
+
+> [!TIP]
+> If your application fails to start, check the log file written to `/var/log/.log` for errors.
+
+You can also flag the application to start automatically by using your standard operating system tools.
+For example, on Debian, you could use the following command:
+
+```shell
+$ update-rc.d myapp defaults
+```
+
+.log` by default). |
+| `APP_NAME` | The name of the app. If the jar is run from a symlink, the script guesses the app name. If it is not a symlink or you want to explicitly set the app name, this can be useful. |
+| `RUN_ARGS` | The arguments to pass to the program (the Spring Boot app). |
+| `JAVA_HOME` | The location of the `java` executable is discovered by using the `PATH` by default, but you can set it explicitly if there is an executable file at `$JAVA_HOME/bin/java`. |
+| `JAVA_OPTS` | Options that are passed to the JVM when it is launched. |
+| `JARFILE` | The explicit location of the jar file, in case the script is being used to launch a jar that it is not actually embedded. |
+| `DEBUG` | If not empty, sets the `-x` flag on the shell process, allowing you to see the logic in the script. |
+| `STOP_WAIT_TIME` | The time in seconds to wait when stopping the application before forcing a shutdown (`60` by default). |
+
+> [!NOTE]
+> The `PID_FOLDER`, `LOG_FOLDER`, and `LOG_FILENAME` variables are only valid for an `init.d` service.
+> For `systemd`, the equivalent customizations are made by using the ‘service’ script.
+> See the [service unit configuration man page](https://www.freedesktop.org/software/systemd/man/systemd.service.html) for more details.
+
+) {
+ runApplication(*args)
+}
+
+```
+
+The next step is to update your build configuration such that your project produces a war file rather than a jar file.
+If you use Maven and `spring-boot-starter-parent` (which configures Maven’s war plugin for you), all you need to do is to modify `pom.xml` to change the packaging to war, as follows:
+
+```xml
+war
+```
+
+If you use Gradle, you need to modify `build.gradle` to apply the war plugin to the project, as follows:
+
+```gradle
+apply plugin: 'war'
+```
+
+The final step in the process is to ensure that the embedded servlet container does not interfere with the servlet container to which the war file is deployed.
+To do so, you need to mark the embedded servlet container dependency as being provided.
+
+If you use Maven, the following example marks the servlet container (Tomcat, in this case) as being provided:
+
+```xml
+
+
+
+ org.springframework.boot
+ spring-boot-starter-tomcat
+ provided
+
+
+
+```
+
+If you use Gradle, the following example marks the servlet container (Tomcat, in this case) as being provided:
+
+```gradle
+dependencies {
+ // ...
+ providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
+ // ...
+}
+```
+
+> [!TIP]
+> `providedRuntime` is preferred to Gradle’s `compileOnly` configuration.
+> Among other limitations, `compileOnly` dependencies are not on the test classpath, so any web-based integration tests fail.
+
+If you use the Spring Boot [build-tool-plugin:index.adoc](../../build-tool-plugin/index.md), marking the embedded servlet container dependency as provided produces an executable war file with the provided dependencies packaged in a `lib-provided` directory.
+This means that, in addition to being deployable to a servlet container, you can also run your application by using `java -jar` on the command line.
+
+) {
+ runApplication(*args)
+}
+```
+
+> [!NOTE]
+> If you intend to start your application as a war or as an executable application, you need to share the customizations of the builder in a method that is both available to the [`SpringBootServletInitializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/web/servlet/support/SpringBootServletInitializer.html) callback and in the `main` method in a class similar to the following:
+>
+> #### Java
+>
+> ```java
+> import org.springframework.boot.Banner;
+> import org.springframework.boot.autoconfigure.SpringBootApplication;
+> import org.springframework.boot.builder.SpringApplicationBuilder;
+> import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+>
+> @SpringBootApplication
+> public class MyApplication extends SpringBootServletInitializer {
+>
+> @Override
+> protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
+> return customizerBuilder(builder);
+> }
+>
+> public static void main(String[] args) {
+> customizerBuilder(new SpringApplicationBuilder()).run(args);
+> }
+>
+> private static SpringApplicationBuilder customizerBuilder(SpringApplicationBuilder builder) {
+> return builder.sources(MyApplication.class).bannerMode(Banner.Mode.OFF);
+> }
+>
+> }
+> ```
+>
+> #### Kotlin
+>
+> ```kotlin
+> import org.springframework.boot.Banner
+> import org.springframework.boot.autoconfigure.SpringBootApplication
+> import org.springframework.boot.builder.SpringApplicationBuilder
+> import org.springframework.boot.web.servlet.support.SpringBootServletInitializer
+>
+> @SpringBootApplication
+> class MyApplication : SpringBootServletInitializer() {
+>
+> override fun configure(builder: SpringApplicationBuilder): SpringApplicationBuilder {
+> return customizerBuilder(builder)
+> }
+>
+> companion object {
+>
+> @JvmStatic
+> fun main(args: Array) {
+> customizerBuilder(SpringApplicationBuilder()).run(*args)
+> }
+>
+> private fun customizerBuilder(builder: SpringApplicationBuilder): SpringApplicationBuilder {
+> return builder.sources(MyApplication::class.java).bannerMode(Banner.Mode.OFF)
+> }
+>
+> }
+>
+> }
+>
+> ```
+
+Applications can fall into more than one category:
+
+- Servlet 3.0+ applications with no `web.xml`.
+- Applications with a `web.xml`.
+- Applications with a context hierarchy.
+- Applications without a context hierarchy.
+
+All of these should be amenable to translation, but each might require slightly different techniques.
+
+Servlet 3.0+ applications might translate pretty easily if they already use the Spring Servlet 3.0+ initializer support classes.
+Normally, all the code from an existing [`WebApplicationInitializer`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/web/WebApplicationInitializer.html) can be moved into a [`SpringBootServletInitializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/web/servlet/support/SpringBootServletInitializer.html).
+If your existing application has more than one [`ApplicationContext`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/ApplicationContext.html) (for example, if it uses [`AbstractDispatcherServletInitializer`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/web/servlet/support/AbstractDispatcherServletInitializer.html)) then you might be able to combine all your context sources into a single [`SpringApplication`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/SpringApplication.html).
+The main complication you might encounter is if combining does not work and you need to maintain the context hierarchy.
+See the [entry on building a hierarchy](../application.md#howto.application.context-hierarchy) for examples.
+An existing parent context that contains web-specific features usually needs to be broken up so that all the [`ServletContextAware`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/web/context/ServletContextAware.html) components are in the child context.
+
+Applications that are not already Spring applications might be convertible to Spring Boot applications, and the previously mentioned guidance may help.
+However, you may yet encounter problems.
+In that case, we suggest [asking questions on Stack Overflow with a tag of `spring-boot`](https://stackoverflow.com/questions/tagged/spring-boot).
+
+
+
+
+ org.slf4j
+
+
+
+```
diff --git a/markdown/boot/3.5.4/how-to/docker-compose.md b/markdown/boot/3.5.4/how-to/docker-compose.md
new file mode 100644
index 0000000..d51e2a2
--- /dev/null
+++ b/markdown/boot/3.5.4/how-to/docker-compose.md
@@ -0,0 +1,43 @@
+---
+title: "Docker Compose"
+source: "how-to:docker-compose.adoc"
+---
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+```
+
+Spring Boot has a [`LoggingSystem`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/logging/LoggingSystem.html) abstraction that attempts to configure logging based on the content of the classpath.
+If Logback is available, it is the first choice.
+
+If the only change you need to make to logging is to set the levels of various loggers, you can do so in `application.properties` by using the "logging.level" prefix, as shown in the following example:
+
+#### Properties
+
+```properties
+logging.level.org.springframework.web=debug
+logging.level.org.hibernate=error
+```
+
+#### YAML
+
+```yaml
+logging:
+ level:
+ org.springframework.web: "debug"
+ org.hibernate: "error"
+```
+
+You can also set the location of a file to which the log will be written (in addition to the console) by using `logging.file.name`.
+
+To configure the more fine-grained settings of a logging system, you need to use the native configuration format supported by the [`LoggingSystem`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/logging/LoggingSystem.html) in question.
+By default, Spring Boot picks up the native configuration from its default location for the system (such as `classpath:logback.xml` for Logback), but you can set the location of the config file by using the `logging.config` property.
+
+
+
+
+
+```
+
+Your logback configuration file can also make use of System properties that the [`LoggingSystem`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/logging/LoggingSystem.html) takes care of creating for you:
+
+- `${PID}`: The current process ID.
+- `${LOG_FILE}`: Whether `logging.file.name` was set in Boot’s external configuration.
+- `${LOG_PATH}`: Whether `logging.file.path` (representing a directory for log files to live in) was set in Boot’s external configuration.
+- `${LOG_EXCEPTION_CONVERSION_WORD}`: Whether `logging.exception-conversion-word` was set in Boot’s external configuration.
+- `${ROLLING_FILE_NAME_PATTERN}`: Whether `logging.pattern.rolling-file-name` was set in Boot’s external configuration.
+
+Spring Boot also provides some nice ANSI color terminal output on a console (but not in a log file) by using a custom Logback converter.
+See the `CONSOLE_LOG_PATTERN` in the `defaults.xml` configuration for an example.
+
+If Groovy is on the classpath, you should be able to configure Logback with `logback.groovy` as well.
+If present, this setting is given preference.
+
+> [!NOTE]
+> Spring extensions are not supported with Groovy configuration.
+> Any `logback-spring.groovy` files will not be detected.
+
+
+
+
+
+```
+
+You also need to add `logging.file.name` to your `application.properties` or `application.yaml`, as shown in the following example:
+
+#### Properties
+
+```properties
+logging.file.name=myapplication.log
+```
+
+#### YAML
+
+```yaml
+logging:
+ file:
+ name: "myapplication.log"
+```
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter
+
+
+ org.springframework.boot
+ spring-boot-starter-logging
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+
+```
+
+Gradle provides a few different ways to set up the starters.
+One way is to use a [module replacement](https://docs.gradle.org/current/userguide/resolution_rules.html#sec:module_replacement).
+To do so, declare a dependency on the Log4j 2 starter and tell Gradle that any occurrences of the default logging starter should be replaced by the Log4j 2 starter, as shown in the following example:
+
+```gradle
+dependencies {
+ implementation "org.springframework.boot:spring-boot-starter-log4j2"
+ modules {
+ module("org.springframework.boot:spring-boot-starter-logging") {
+ replacedBy("org.springframework.boot:spring-boot-starter-log4j2", "Use Log4j2 instead of Logback")
+ }
+ }
+}
+```
+
+> [!NOTE]
+> The Log4j starters gather together the dependencies for common logging requirements (such as having Tomcat use `java.util.logging` but configuring the output using Log4j 2).
+
+> [!NOTE]
+> To ensure that debug logging performed using `java.util.logging` is routed into Log4j 2, configure its [JDK logging adapter](https://logging.apache.org/log4j/2.x/log4j-jul.html) by setting the `java.util.logging.manager` system property to `org.apache.logging.log4j.jul.LogManager`.
+
+` section that looks like this:
+
+```xml
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ {version-spring-boot}
+
+```
+
+You additionally should have this in the ` ` section:
+
+```xml
+
+ org.graalvm.buildtools
+ native-maven-plugin
+
+```
+
+The `spring-boot-starter-parent` declares a `native` profile that configures the executions that need to run in order to create a native image.
+You can activate profiles using the `-P` flag on the command line.
+
+> [!TIP]
+> If you don’t want to use `spring-boot-starter-parent` you’ll need to configure executions for the `process-aot` goal from Spring Boot’s plugin and the `add-reachability-metadata` goal from the Native Build Tools plugin.
+
+To build the image, you can run the `spring-boot:build-image` goal with the `native` profile active:
+
+```shell
+$ mvn -Pnative spring-boot:build-image
+```
+
+` section that looks like this:
+
+```xml
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ {version-spring-boot}
+
+```
+
+The `spring-boot-starter-parent` defines a `nativeTest` profile that provides the necessary configuration for the Spring Boot and Native Build Tools plugins.
+First you need to add those two plugin in the module to opt-in for the feature.
+Your tests are executed in native mode only when the `nativeTest` is enabled.
+You can activate profiles using the `-P` flag on the command line.
+
+> [!TIP]
+> If you don’t want to use `spring-boot-starter-parent` you’ll need to configure executions for the `process-test-aot` goal from the Spring Boot plugin and the `test` goal from the Native Build Tools plugin.
+
+To build the image and run the tests, use the `test` goal with the `nativeTest` profile active:
+
+```shell
+$ mvn -PnativeTest test
+```
+
+
+ org.springframework.boot
+ spring-boot-starter-data-redis
+
+
+ io.lettuce
+ lettuce-core
+
+
+
+
+ redis.clients
+ jedis
+
+```
+
+The following example shows how to accomplish this in Gradle:
+
+```gradle
+dependencies {
+ implementation('org.springframework.boot:spring-boot-starter-data-redis') {
+ exclude group: 'io.lettuce', module: 'lettuce-core'
+ }
+ implementation 'redis.clients:jedis'
+ // ...
+}
+```
diff --git a/markdown/boot/3.5.4/how-to/properties-and-configuration.md b/markdown/boot/3.5.4/how-to/properties-and-configuration.md
new file mode 100644
index 0000000..a9bec15
--- /dev/null
+++ b/markdown/boot/3.5.4/how-to/properties-and-configuration.md
@@ -0,0 +1,446 @@
+---
+title: "Properties and Configuration"
+source: "how-to:properties-and-configuration.adoc"
+---
+
+
+
+ src/main/resources
+ true
+
+
+```
+
+You also need to include the following element inside `
+ org.apache.maven.plugins
+ maven-resources-plugin
+ 2.7
+
+
+ @
+
+ false
+
+
+```
+
+> [!NOTE]
+> The `useDefaultDelimiters` property is important if you use standard Spring placeholders (such as `${placeholder}`) in your configuration.
+> If that property is not set to `false`, these may be expanded by the build.
+
+) {
+ val application = SpringApplication(MyApplication::class.java)
+ application.setBannerMode(Banner.Mode.OFF)
+ application.run(*args)
+ }
+
+}
+
+```
+
+Or to `sources(…)` method of a [`SpringApplicationBuilder`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/builder/SpringApplicationBuilder.html):
+
+#### Java
+
+```java
+import org.springframework.boot.Banner;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+
+public class MyApplication {
+
+ public static void main(String[] args) {
+ new SpringApplicationBuilder()
+ .bannerMode(Banner.Mode.OFF)
+ .sources(MyApplication.class)
+ .run(args);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.Banner
+import org.springframework.boot.builder.SpringApplicationBuilder
+
+object MyApplication {
+
+ @JvmStatic
+ fun main(args: Array) {
+ SpringApplicationBuilder()
+ .bannerMode(Banner.Mode.OFF)
+ .sources(MyApplication::class.java)
+ .run(*args)
+ }
+
+}
+
+```
+
+Given the examples above, if we have the following configuration:
+
+#### Properties
+
+```properties
+spring.main.sources=com.example.MyDatabaseConfig,com.example.MyJmsConfig
+spring.main.banner-mode=console
+```
+
+#### YAML
+
+```yaml
+spring:
+ main:
+ sources: "com.example.MyDatabaseConfig,com.example.MyJmsConfig"
+ banner-mode: "console"
+```
+
+The actual application will show the banner (as overridden by configuration) and use three sources for the [`ApplicationContext`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/ApplicationContext.html).
+The application sources are:
+
+1. `MyApplication` (from the code)
+1. `MyDatabaseConfig` (from the external config)
+1. `MyJmsConfig`(from the external config)
+
+` (like a JSON object), and Spring Boot flattens the map so that it is one level deep and has period-separated keys, as many people are used to with [`Properties`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Properties.html) files in Java.
+
+The preceding example YAML corresponds to the following `application.properties` file:
+
+```properties
+spring.application.name=cruncher
+spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.url=jdbc:mysql://localhost/test
+server.port=9000
+```
+
+See [reference:features/external-config.adoc#features.external-config.yaml](../reference/features/external-config.md#features.external-config.yaml) in the “Spring Boot Features” section for more information about YAML.
+
+
+ com.fasterxml.jackson.dataformat
+ jackson-dataformat-xml
+
+```
+
+If Jackson’s XML extension is not available and JAXB is available, XML can be rendered with the additional requirement of having `MyThing` annotated as [`@XmlRootElement`](https://jakarta.ee/specifications/xml-binding/4.0/apidocs/jakarta.xml.bind/jakarta/xml/bind/annotation/XmlRootElement.html), as shown in the following example:
+
+#### Java
+
+```java
+import jakarta.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement
+public class MyThing {
+
+ private String name;
+ public String getName() {
+ return this.name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import jakarta.xml.bind.annotation.XmlRootElement
+
+@XmlRootElement
+class MyThing {
+
+ var name: String? = null
+
+}
+
+```
+
+You will need to ensure that the JAXB library is part of your project, for example by adding:
+
+```xml
+
+ org.glassfish.jaxb
+ jaxb-runtime
+
+```
+
+> [!NOTE]
+> To get the server to render XML instead of JSON, you might have to send an `Accept: text/xml` header (or use a browser).
+
+` | `true`, `false` |
+| [`JsonNodeFeature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/cfg/JsonNodeFeature.html) | `spring.jackson.datatype.json-node.` | `true`, `false` |
+| [`DeserializationFeature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/DeserializationFeature.html) | `spring.jackson.deserialization.` | `true`, `false` |
+| [`JsonGenerator.Feature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.19.2/com/fasterxml/jackson/core/JsonGenerator.Feature.html) | `spring.jackson.generator.` | `true`, `false` |
+| [`MapperFeature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/MapperFeature.html) | `spring.jackson.mapper.` | `true`, `false` |
+| [`JsonParser.Feature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.19.2/com/fasterxml/jackson/core/JsonParser.Feature.html) | `spring.jackson.parser.` | `true`, `false` |
+| [`SerializationFeature`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/SerializationFeature.html) | `spring.jackson.serialization.` | `true`, `false` |
+| [`JsonInclude.Include`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-annotations/2.19.2/com/fasterxml/jackson/annotation/JsonInclude.Include.html) | `spring.jackson.default-property-inclusion` | `always`, `non_null`, `non_absent`, `non_default`, `non_empty` |
+
+For example, to enable pretty print, set `spring.jackson.serialization.indent_output=true`.
+Note that, thanks to the use of [relaxed binding](../reference/features/external-config.md#features.external-config.typesafe-configuration-properties.relaxed-binding), the case of `indent_output` does not have to match the case of the corresponding enum constant, which is `INDENT_OUTPUT`.
+
+This environment-based configuration is applied to the auto-configured [`Jackson2ObjectMapperBuilder`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/http/converter/json/Jackson2ObjectMapperBuilder.html) bean and applies to any mappers created by using the builder, including the auto-configured [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html) bean.
+
+The context’s [`Jackson2ObjectMapperBuilder`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/http/converter/json/Jackson2ObjectMapperBuilder.html) can be customized by one or more [`Jackson2ObjectMapperBuilderCustomizer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/jackson/Jackson2ObjectMapperBuilderCustomizer.html) beans.
+Such customizer beans can be ordered (Boot’s own customizer has an order of 0), letting additional customization be applied both before and after Boot’s customization.
+
+Any beans of type [`Module`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/Module.html) are automatically registered with the auto-configured [`Jackson2ObjectMapperBuilder`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/http/converter/json/Jackson2ObjectMapperBuilder.html) and are applied to any [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html) instances that it creates.
+This provides a global mechanism for contributing custom modules when you add new features to your application.
+
+> [!NOTE]
+> If you wish to register additional modules programmatically using a [`Jackson2ObjectMapperBuilderCustomizer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/jackson/Jackson2ObjectMapperBuilderCustomizer.html), make sure to use the `modulesToInstall` method that takes a consumer as the other variants are not additive.
+
+If you want to replace the default [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html) completely, either define a [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) of that type or, if you prefer the builder-based approach, define a [`Jackson2ObjectMapperBuilder`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/http/converter/json/Jackson2ObjectMapperBuilder.html) [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html).
+When defining an [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html) bean, marking it as [`@Primary`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Primary.html) is recommended as the auto-configuration’s [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html) that it will replace is [`@Primary`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Primary.html).
+Note that, in either case, doing so disables all auto-configuration of the [`ObjectMapper`](https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.19.2/com/fasterxml/jackson/databind/ObjectMapper.html).
+
+If you provide any [`@Beans`](https://docs.oracle.com/en/java/javase/17/docs/api/java.desktop/java/beans/Beans.html) of type [`MappingJackson2HttpMessageConverter`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.html), they replace the default value in the MVC configuration.
+Also, a convenience bean of type [`HttpMessageConverters`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/http/HttpMessageConverters.html) is provided (and is always available if you use the default MVC configuration).
+It has some useful methods to access the default and user-enhanced message converters.
+
+See the [Customize the @ResponseBody Rendering](#howto.spring-mvc.customize-responsebody-rendering) section and the [`WebMvcAutoConfiguration`](https://github.com/spring-projects/spring-boot/tree/v3.5.4/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfiguration.java) source code for more details.
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+
+ org.springframework.boot
+ spring-boot-starter-tomcat
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-jetty
+
+```
+
+The following Gradle example configures the necessary dependencies and a [module replacement](https://docs.gradle.org/current/userguide/resolution_rules.html#sec:module_replacement) to use Undertow in place of Reactor Netty for Spring WebFlux:
+
+```gradle
+dependencies {
+ implementation "org.springframework.boot:spring-boot-starter-undertow"
+ implementation "org.springframework.boot:spring-boot-starter-webflux"
+ modules {
+ module("org.springframework.boot:spring-boot-starter-reactor-netty") {
+ replacedBy("org.springframework.boot:spring-boot-starter-undertow", "Use Undertow instead of Reactor Netty")
+ }
+ }
+}
+```
+
+> [!NOTE]
+> `spring-boot-starter-reactor-netty` is required to use the [`WebClient`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/web/reactive/function/client/WebClient.html) class, so you may need to keep a dependency on Netty even when you need to include a different HTTP server.
+
+` and pull the container out of the event when it is published.
+
+Tests that use `@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)` can also inject the actual port into a field by using the [`@LocalServerPort`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/test/web/server/LocalServerPort.html) annotation, as shown in the following example:
+
+#### Java
+
+```java
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.web.server.LocalServerPort;
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class MyWebIntegrationTests {
+
+ @LocalServerPort
+ int port;
+
+ // ...
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
+import org.springframework.boot.test.web.server.LocalServerPort
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class MyWebIntegrationTests {
+
+ @LocalServerPort
+ var port = 0
+
+ // ...
+
+}
+
+```
+
+> [!NOTE]
+> [`@LocalServerPort`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/test/web/server/LocalServerPort.html) is a meta-annotation for `@Value("${local.server.port}")`.
+> Do not try to inject the port in a regular application.
+> As we just saw, the value is set only after the container has been initialized.
+> Contrary to a test, application code callbacks are processed early (before the value is actually available).
+
+
+```
+
+The following example shows setting SSL properties using PEM-encoded certificate and private key files:
+
+#### Properties
+
+```properties
+server.port=8443
+server.ssl.certificate=classpath:my-cert.crt
+server.ssl.certificate-private-key=classpath:my-cert.key
+server.ssl.trust-certificate=classpath:ca-cert.crt
+```
+
+#### YAML
+
+```yaml
+server:
+ port: 8443
+ ssl:
+ certificate: "classpath:my-cert.crt"
+ certificate-private-key: "classpath:my-cert.key"
+ trust-certificate: "classpath:ca-cert.crt"
+```
+
+..options` properties.
+
+ {
+
+ @Override
+ public void customize(TomcatServletWebServerFactory factory) {
+ // customize the factory here
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory
+import org.springframework.boot.web.server.WebServerFactoryCustomizer
+import org.springframework.stereotype.Component
+
+@Component
+class MyTomcatWebServerCustomizer : WebServerFactoryCustomizer {
+
+ override fun customize(factory: TomcatServletWebServerFactory?) {
+ // customize the factory here
+ }
+
+}
+
+```
+
+> [!NOTE]
+> Spring Boot uses that infrastructure internally to auto-configure the server.
+> Auto-configured [`WebServerFactoryCustomizer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/web/server/WebServerFactoryCustomizer.html) beans have an order of `0` and will be processed before any user-defined customizers, unless it has an explicit order that states otherwise.
+
+Once you have got access to a [`WebServerFactory`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/web/server/WebServerFactory.html) using the customizer, you can use it to configure specific parts, like connectors, server resources, or the server itself - all using server-specific APIs.
+
+In addition Spring Boot provides:
+
+ registration(MyFilter filter) {
+ FilterRegistrationBean registration = new FilterRegistrationBean<>(filter);
+ registration.setEnabled(false);
+ return registration;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.web.servlet.FilterRegistrationBean
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyFilterConfiguration {
+
+ @Bean
+ fun registration(filter: MyFilter): FilterRegistrationBean {
+ val registration = FilterRegistrationBean(filter)
+ registration.isEnabled = false
+ return registration
+ }
+
+}
+
+```
+
+ connectorCustomizer() {
+ return (tomcat) -> tomcat.addAdditionalTomcatConnectors(createConnector());
+ }
+
+ private Connector createConnector() {
+ Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
+ connector.setPort(8081);
+ return connector;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.apache.catalina.connector.Connector
+import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory
+import org.springframework.boot.web.server.WebServerFactoryCustomizer
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyTomcatConfiguration {
+
+ @Bean
+ fun connectorCustomizer(): WebServerFactoryCustomizer {
+ return WebServerFactoryCustomizer { tomcat: TomcatServletWebServerFactory ->
+ tomcat.addAdditionalTomcatConnectors(
+ createConnector()
+ )
+ }
+ }
+
+ private fun createConnector(): Connector {
+ val connector = Connector("org.apache.coyote.http11.Http11NioProtocol")
+ connector.port = 8081
+ return connector
+ }
+
+}
+
+```
+
+ undertowListenerCustomizer() {
+ return (factory) -> factory.addBuilderCustomizers(this::addHttpListener);
+ }
+
+ private Builder addHttpListener(Builder builder) {
+ return builder.addHttpListener(8080, "0.0.0.0");
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import io.undertow.Undertow
+import org.springframework.boot.web.embedded.undertow.UndertowBuilderCustomizer
+import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory
+import org.springframework.boot.web.server.WebServerFactoryCustomizer
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyUndertowConfiguration {
+
+ @Bean
+ fun undertowListenerCustomizer(): WebServerFactoryCustomizer {
+ return WebServerFactoryCustomizer { factory: UndertowServletWebServerFactory ->
+ factory.addBuilderCustomizers(
+ UndertowBuilderCustomizer { builder: Undertow.Builder -> addHttpListener(builder) })
+ }
+ }
+
+ private fun addHttpListener(builder: Undertow.Builder): Undertow.Builder {
+ return builder.addHttpListener(8080, "0.0.0.0")
+ }
+
+}
+
+```
+
+/shell-completion/` and all scripts in that directory are executed when a new shell starts.
+For example, to run the script manually if you have installed by using SDKMAN!, use the following commands:
+
+```shell
+$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
+$ spring
+ encodepassword help init shell version
+```
+
+> [!NOTE]
+> If you install the Spring Boot CLI by using Homebrew or MacPorts, the command-line completion scripts are automatically registered with your shell.
+
+) {
+ super.prepareContext(host, initializers)
+ val child = StandardContext()
+ child.addLifecycleListener(FixContextListener())
+ child.path = "/cloudfoundryapplication"
+ val initializer = getServletContextInitializer(contextPath)
+ child.addServletContainerInitializer(initializer, emptySet())
+ child.crossContext = true
+ host.addChild(child)
+ }
+
+ }
+ }
+
+ private fun getServletContextInitializer(contextPath: String): ServletContainerInitializer {
+ return ServletContainerInitializer { classes: Set?>?, context: ServletContext ->
+ val servlet: Servlet = object : GenericServlet() {
+
+ @Throws(ServletException::class, IOException::class)
+ override fun service(req: ServletRequest, res: ServletResponse) {
+ val servletContext = req.servletContext.getContext(contextPath)
+ servletContext.getRequestDispatcher("/cloudfoundryapplication").forward(req, res)
+ }
+
+ }
+ context.addServlet("cloudfoundry", servlet).addMapping("/*")
+ }
+ }
+}
+
+```
+
+If you’re using a Webflux based application, you can use the following configuration:
+
+#### Java
+
+```java
+import java.util.Map;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.boot.autoconfigure.web.reactive.WebFluxProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.server.reactive.ContextPathCompositeHandler;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.http.server.reactive.ServerHttpResponse;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+
+@Configuration(proxyBeanMethods = false)
+@EnableConfigurationProperties(WebFluxProperties.class)
+public class MyReactiveCloudFoundryConfiguration {
+
+ @Bean
+ public HttpHandler httpHandler(ApplicationContext applicationContext, WebFluxProperties properties) {
+ HttpHandler httpHandler = WebHttpHandlerBuilder.applicationContext(applicationContext).build();
+ return new CloudFoundryHttpHandler(properties.getBasePath(), httpHandler);
+ }
+
+ private static final class CloudFoundryHttpHandler implements HttpHandler {
+
+ private final HttpHandler delegate;
+
+ private final ContextPathCompositeHandler contextPathDelegate;
+
+ private CloudFoundryHttpHandler(String basePath, HttpHandler delegate) {
+ this.delegate = delegate;
+ this.contextPathDelegate = new ContextPathCompositeHandler(Map.of(basePath, delegate));
+ }
+
+ @Override
+ public Mono handle(ServerHttpRequest request, ServerHttpResponse response) {
+ // Remove underlying context path first (e.g. Servlet container)
+ String path = request.getPath().pathWithinApplication().value();
+ if (path.startsWith("/cloudfoundryapplication")) {
+ return this.delegate.handle(request, response);
+ }
+ else {
+ return this.contextPathDelegate.handle(request, response);
+ }
+ }
+
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.autoconfigure.web.reactive.WebFluxProperties
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.context.ApplicationContext
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.http.server.reactive.ContextPathCompositeHandler
+import org.springframework.http.server.reactive.HttpHandler
+import org.springframework.http.server.reactive.ServerHttpRequest
+import org.springframework.http.server.reactive.ServerHttpResponse
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder
+import reactor.core.publisher.Mono
+
+@Configuration(proxyBeanMethods = false)
+@EnableConfigurationProperties(WebFluxProperties::class)
+class MyReactiveCloudFoundryConfiguration {
+
+ @Bean
+ fun httpHandler(applicationContext: ApplicationContext, properties: WebFluxProperties): HttpHandler {
+ val httpHandler = WebHttpHandlerBuilder.applicationContext(applicationContext).build()
+ return CloudFoundryHttpHandler(properties.basePath, httpHandler)
+ }
+
+ private class CloudFoundryHttpHandler(basePath: String, private val delegate: HttpHandler) : HttpHandler {
+ private val contextPathDelegate = ContextPathCompositeHandler(mapOf(basePath to delegate))
+
+ override fun handle(request: ServerHttpRequest, response: ServerHttpResponse): Mono {
+ // Remove underlying context path first (e.g. Servlet container)
+ val path = request.path.pathWithinApplication().value()
+ return if (path.startsWith("/cloudfoundryapplication")) {
+ delegate.handle(request, response)
+ } else {
+ contextPathDelegate.handle(request, response)
+ }
+ }
+ }
+}
+
+```
diff --git a/markdown/boot/3.5.4/reference/actuator/enabling.md b/markdown/boot/3.5.4/reference/actuator/enabling.md
new file mode 100644
index 0000000..f2af472
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/actuator/enabling.md
@@ -0,0 +1,35 @@
+---
+title: "Enabling Production-ready Features"
+source: "reference:actuator/enabling.adoc"
+---
+
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+```
+
+For Gradle, use the following declaration:
+
+```gradle
+dependencies {
+ implementation 'org.springframework.boot:spring-boot-starter-actuator'
+}
+```
diff --git a/markdown/boot/3.5.4/reference/actuator/endpoints.md b/markdown/boot/3.5.4/reference/actuator/endpoints.md
new file mode 100644
index 0000000..778a1db
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/actuator/endpoints.md
@@ -0,0 +1,1487 @@
+---
+title: "Endpoints"
+source: "reference:actuator/endpoints.adoc"
+---
+
+.access` property.
+The following example allows unrestricted access to the `shutdown` endpoint:
+
+#### Properties
+
+```properties
+management.endpoint.shutdown.access=unrestricted
+```
+
+#### YAML
+
+```yaml
+management:
+ endpoint:
+ shutdown:
+ access: unrestricted
+```
+
+If you prefer access to be opt-in rather than opt-out, set the `management.endpoints.access.default` property to `none` and use individual endpoint `access` properties to opt back in.
+The following example allows read-only access to the `loggers` endpoint and denies access to all other endpoints:
+
+#### Properties
+
+```properties
+management.endpoints.access.default=none
+management.endpoint.loggers.access=read-only
+```
+
+#### YAML
+
+```yaml
+management:
+ endpoints:
+ access:
+ default: none
+ endpoint:
+ loggers:
+ access: read-only
+```
+
+> [!NOTE]
+> Inaccessible endpoints are removed entirely from the application context.
+> If you want to change only the technologies over which an endpoint is exposed, use the [`include` and `exclude` properties](#actuator.endpoints.exposing) instead.
+
+` prefix uniquely identifies the endpoint that is being configured.
+
+ health() {
+ return doHealthCheck().onErrorResume((exception) ->
+ Mono.just(new Health.Builder().down(exception).build()));
+ }
+
+ private Mono doHealthCheck() {
+ // perform some specific health check
+ return ...
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.actuate.health.Health
+import org.springframework.boot.actuate.health.ReactiveHealthIndicator
+import org.springframework.stereotype.Component
+import reactor.core.publisher.Mono
+
+@Component
+class MyReactiveHealthIndicator : ReactiveHealthIndicator {
+
+ override fun health(): Mono {
+ return doHealthCheck()!!.onErrorResume { exception: Throwable? ->
+ Mono.just(Health.Builder().down(exception).build())
+ }
+ }
+
+ private fun doHealthCheck(): Mono? {
+ // perform some specific health check
+ return ...
+ }
+
+}
+
+```
+
+> [!TIP]
+> To handle the error automatically, consider extending from [`AbstractReactiveHealthIndicator`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/AbstractReactiveHealthIndicator.html).
+
+` property and specify a list of health indicator IDs to `include` or `exclude`.
+For example, to create a group that includes only database indicators you can define the following:
+
+#### Properties
+
+```properties
+management.endpoint.health.group.custom.include=db
+```
+
+#### YAML
+
+```yaml
+management:
+ endpoint:
+ health:
+ group:
+ custom:
+ include: "db"
+```
+
+You can then check the result by hitting `localhost:8080/actuator/health/custom`.
+
+Similarly, to create a group that excludes the database indicators from the group and includes all the other indicators, you can define the following:
+
+#### Properties
+
+```properties
+management.endpoint.health.group.custom.exclude=db
+```
+
+#### YAML
+
+```yaml
+management:
+ endpoint:
+ health:
+ group:
+ custom:
+ exclude: "db"
+```
+
+By default, startup will fail if a health group includes or excludes a health indicator that does not exist.
+To disable this behavior set `management.endpoint.health.validate-group-membership` to `false`.
+
+By default, groups inherit the same [`StatusAggregator`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/StatusAggregator.html) and [`HttpCodeStatusMapper`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/HttpCodeStatusMapper.html) settings as the system health.
+However, you can also define these on a per-group basis.
+You can also override the `show-details` and `roles` properties if required:
+
+#### Properties
+
+```properties
+management.endpoint.health.group.custom.show-details=when-authorized
+management.endpoint.health.group.custom.roles=admin
+management.endpoint.health.group.custom.status.order=fatal,up
+management.endpoint.health.group.custom.status.http-mapping.fatal=500
+management.endpoint.health.group.custom.status.http-mapping.out-of-service=500
+```
+
+#### YAML
+
+```yaml
+management:
+ endpoint:
+ health:
+ group:
+ custom:
+ show-details: "when-authorized"
+ roles: "admin"
+ status:
+ order: "fatal,up"
+ http-mapping:
+ fatal: 500
+ out-of-service: 500
+```
+
+> [!TIP]
+> You can use `@Qualifier("groupname")` if you need to register custom [`StatusAggregator`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/StatusAggregator.html) or [`HttpCodeStatusMapper`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/HttpCodeStatusMapper.html) beans for use with the group.
+
+A health group can also include/exclude a [`CompositeHealthContributor`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/CompositeHealthContributor.html).
+You can also include/exclude only a certain component of a [`CompositeHealthContributor`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/CompositeHealthContributor.html).
+This can be done using the fully qualified name of the component as follows:
+
+```properties
+management.endpoint.health.group.custom.include="test/primary"
+management.endpoint.health.group.custom.exclude="test/primary/b"
+```
+
+In the example above, the `custom` group will include the [`HealthContributor`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/HealthContributor.html) with the name `primary` which is a component of the composite `test`.
+Here, `primary` itself is a composite and the [`HealthContributor`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/health/HealthContributor.html) with the name `b` will be excluded from the `custom` group.
+
+Health groups can be made available at an additional path on either the main or management port.
+This is useful in cloud environments such as Kubernetes, where it is quite common to use a separate management port for the actuator endpoints for security purposes.
+Having a separate port could lead to unreliable health checks because the main application might not work properly even if the health check is successful.
+The health group can be configured with an additional path as follows:
+
+```properties
+management.endpoint.health.group.live.additional-path="server:/healthz"
+```
+
+This would make the `live` health group available on the main server port at `/healthz`.
+The prefix is mandatory and must be either `server:` (represents the main server port) or `management:` (represents the management port, if configured.)
+The path must be a single path segment.
+
+
+ failureThreshold: ...
+ periodSeconds: ...
+
+readinessProbe:
+ httpGet:
+ path: "/actuator/health/readiness"
+ port:
+ failureThreshold: ...
+ periodSeconds: ...
+```
+
+> [!NOTE]
+> `` should be set to the port that the actuator endpoints are available on.
+> It could be the main web server port or a separate management port if the `"management.server.port"` property has been set.
+
+These health groups are automatically enabled only if the application [runs in a Kubernetes environment](../../how-to/deployment/cloud.md#howto.deployment.cloud.kubernetes).
+You can enable them in any environment by using the `management.endpoint.health.probes.enabled` configuration property.
+
+> [!NOTE]
+> If an application takes longer to start than the configured liveness period, Kubernetes mentions the `"startupProbe"` as a possible solution.
+> Generally speaking, the `"startupProbe"` is not necessarily needed here, as the `"readinessProbe"` fails until all startup tasks are done.
+> This means your application will not receive traffic until it is ready.
+> However, if your application takes a long time to start, consider using a `"startupProbe"` to make sure that Kubernetes won’t kill your application while it is in the process of starting.
+> See the section that describes [how probes behave during the application lifecycle](#actuator.endpoints.kubernetes-probes.lifecycle).
+
+If your Actuator endpoints are deployed on a separate management context, the endpoints do not use the same web infrastructure (port, connection pools, framework components) as the main application.
+In this case, a probe check could be successful even if the main application does not work properly (for example, it cannot accept new connections).
+For this reason, it is a good idea to make the `liveness` and `readiness` health groups available on the main server port.
+This can be done by setting the following property:
+
+```properties
+management.endpoint.health.probes.add-additional-paths=true
+```
+
+This would make the `liveness` group available at `/livez` and the `readiness` group available at `/readyz` on the main server port.
+Paths can be customized using the `additional-path` property on each group, see [health groups](#actuator.endpoints.health.groups) for details.
+
+.enabled` property.
+Different contributors have different defaults for this property, depending on their prerequisites and the nature of the information that they expose.
+
+With no prerequisites to indicate that they should be enabled, the `env`, `java`, `os`, and `process` contributors are disabled by default. The `ssl` contributor has a prerequisite of having an [SSL Bundle](../features/ssl.md#features.ssl.bundles) configured but it is disabled by default.
+Each can be enabled by setting its `management.info..enabled` property to `true`.
+
+The `build` and `git` info contributors are enabled by default.
+Each can be disabled by setting its `management.info..enabled` property to `false`.
+Alternatively, to disable every contributor that is usually enabled by default, set the `management.info.defaults.enabled` property to `false`.
+
+ metricsCommonTags() {
+ return (registry) -> registry.config().commonTags("region", "us-east-1");
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import io.micrometer.core.instrument.MeterRegistry
+import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyMeterRegistryConfiguration {
+
+ @Bean
+ fun metricsCommonTags(): MeterRegistryCustomizer {
+ return MeterRegistryCustomizer { registry ->
+ registry.config().commonTags("region", "us-east-1")
+ }
+ }
+
+}
+
+```
+
+You can apply customizations to particular registry implementations by being more specific about the generic type:
+
+#### Java
+
+```java
+import io.micrometer.core.instrument.Meter;
+import io.micrometer.core.instrument.config.NamingConvention;
+import io.micrometer.graphite.GraphiteMeterRegistry;
+
+import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration(proxyBeanMethods = false)
+public class MyMeterRegistryConfiguration {
+
+ @Bean
+ public MeterRegistryCustomizer graphiteMetricsNamingConvention() {
+ return (registry) -> registry.config().namingConvention(this::name);
+ }
+
+ private String name(String name, Meter.Type type, String baseUnit) {
+ return ...
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import io.micrometer.core.instrument.Meter
+import io.micrometer.core.instrument.config.NamingConvention
+import io.micrometer.graphite.GraphiteMeterRegistry
+import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyMeterRegistryConfiguration {
+
+ @Bean
+ fun graphiteMetricsNamingConvention(): MeterRegistryCustomizer {
+ return MeterRegistryCustomizer { registry: GraphiteMeterRegistry ->
+ registry.config().namingConvention(this::name)
+ }
+ }
+
+ private fun name(name: String, type: Meter.Type, baseUnit: String?): String {
+ return ...
+ }
+
+}
+
+```
+
+Spring Boot also [configures built-in instrumentation](#actuator.metrics.supported) that you can control through configuration or dedicated annotation markers.
+
+
+ io.prometheus
+ prometheus-metrics-exporter-pushgateway
+
+```
+
+When the Prometheus Pushgateway dependency is present on the classpath and the `management.prometheus.metrics.export.pushgateway.enabled` property is set to `true`, a [`PrometheusPushGatewayManager`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusPushGatewayManager.html) bean is auto-configured.
+This manages the pushing of metrics to a Prometheus Pushgateway.
+
+You can tune the [`PrometheusPushGatewayManager`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusPushGatewayManager.html) by using properties under `management.prometheus.metrics.export.pushgateway`.
+For advanced configuration, you can also provide your own [`PrometheusPushGatewayManager`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusPushGatewayManager.html) bean.
+
+`.
+
+ someMethod() {
+ MongoDatabase db = this.mongo.getMongoDatabase();
+ return db.getCollection("users");
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import com.mongodb.client.MongoCollection
+import org.bson.Document
+import org.springframework.data.mongodb.MongoDatabaseFactory
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val mongo: MongoDatabaseFactory) {
+ fun someMethod(): MongoCollection {
+ val db = mongo.mongoDatabase
+ return db.getCollection("users")
+ }
+}
+
+```
+
+If you have defined your own [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html), it will be used to auto-configure a suitable [`MongoDatabaseFactory`](https://docs.spring.io/spring-data/mongodb/docs/4.5.x/api/org/springframework/data/mongodb/MongoDatabaseFactory.html).
+
+The auto-configured [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html) is created using a [`MongoClientSettings`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.html) bean.
+If you have defined your own [`MongoClientSettings`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.html), it will be used without modification and the `spring.data.mongodb` properties will be ignored.
+Otherwise a [`MongoClientSettings`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.html) will be auto-configured and will have the `spring.data.mongodb` properties applied to it.
+In either case, you can declare one or more [`MongoClientSettingsBuilderCustomizer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/mongo/MongoClientSettingsBuilderCustomizer.html) beans to fine-tune the [`MongoClientSettings`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.html) configuration.
+Each will be called in order with the [`MongoClientSettings.Builder`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.Builder.html) that is used to build the [`MongoClientSettings`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-core/com/mongodb/MongoClientSettings.html).
+
+You can set the `spring.data.mongodb.uri` property to change the URL and configure additional settings such as the *replica set*, as shown in the following example:
+
+#### Properties
+
+```properties
+spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
+```
+
+#### YAML
+
+```yaml
+spring:
+ data:
+ mongodb:
+ uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
+```
+
+Alternatively, you can specify connection details using discrete properties.
+For example, you might declare the following settings in your `application.properties`:
+
+#### Properties
+
+```properties
+spring.data.mongodb.host=mongoserver1.example.com
+spring.data.mongodb.port=27017
+spring.data.mongodb.additional-hosts[0]=mongoserver2.example.com:23456
+spring.data.mongodb.database=test
+spring.data.mongodb.username=user
+spring.data.mongodb.password=secret
+```
+
+#### YAML
+
+```yaml
+spring:
+ data:
+ mongodb:
+ host: "mongoserver1.example.com"
+ port: 27017
+ additional-hosts:
+ - "mongoserver2.example.com:23456"
+ database: "test"
+ username: "user"
+ password: "secret"
+```
+
+The auto-configured [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html) can be configured to use SSL for communication with the server by setting the properties as shown in this example:
+
+#### Properties
+
+```properties
+spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
+spring.data.mongodb.ssl.enabled=true
+```
+
+#### YAML
+
+```yaml
+spring:
+ data:
+ mongodb:
+ uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
+ ssl:
+ enabled: true
+```
+
+Custom SSL trust material can be configured in an [SSL bundle](../features/ssl.md) and applied to the [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html) as shown in this example:
+
+#### Properties
+
+```properties
+spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
+spring.data.mongodb.ssl.bundle=example
+```
+
+#### YAML
+
+```yaml
+spring:
+ data:
+ mongodb:
+ uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
+ ssl:
+ bundle: "example"
+```
+
+> [!TIP]
+> If `spring.data.mongodb.port` is not specified, the default of `27017` is used.
+> You could delete this line from the example shown earlier.
+>
+> You can also specify the port as part of the host address by using the `host:port` syntax.
+> This format should be used if you need to change the port of an `additional-hosts` entry.
+
+> [!TIP]
+> If you do not use Spring Data MongoDB, you can inject a [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html) bean instead of using [`MongoDatabaseFactory`](https://docs.spring.io/spring-data/mongodb/docs/4.5.x/api/org/springframework/data/mongodb/MongoDatabaseFactory.html).
+> If you want to take complete control of establishing the MongoDB connection, you can also declare your own [`MongoDatabaseFactory`](https://docs.spring.io/spring-data/mongodb/docs/4.5.x/api/org/springframework/data/mongodb/MongoDatabaseFactory.html) or [`MongoClient`](https://mongodb.github.io/mongo-java-driver/5.5/apidocs/mongodb-driver-sync/com/mongodb/client/MongoClient.html) bean.
+
+> [!NOTE]
+> If you are using the reactive driver, Netty is required for SSL.
+> The auto-configuration configures this factory automatically if Netty is available and the factory to use has not been customized already.
+
+ someMethod() {
+ return this.mongoTemplate.getCollection("users");
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import com.mongodb.client.MongoCollection
+import org.bson.Document
+import org.springframework.data.mongodb.core.MongoTemplate
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val mongoTemplate: MongoTemplate) {
+ fun someMethod(): MongoCollection {
+ return mongoTemplate.getCollection("users")
+ }
+}
+
+```
+
+See the [`MongoOperations`](https://docs.spring.io/spring-data/mongodb/docs/4.5.x/api/org/springframework/data/mongodb/core/MongoOperations.html) API documentation for complete details.
+
+ {
+
+ Page findAll(Pageable pageable);
+
+ City findByNameAndStateAllIgnoringCase(String name, String state);
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.repository.Repository
+
+interface CityRepository :
+ Repository {
+ fun findAll(pageable: Pageable?): Page?
+ fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?
+}
+
+```
+
+Repositories and documents are found through scanning.
+By default, the [auto-configuration packages](../using/auto-configuration.md#using.auto-configuration.packages) are scanned.
+You can customize the locations to look for repositories and documents by using [`@EnableMongoRepositories`](https://docs.spring.io/spring-data/mongodb/docs/4.5.x/api/org/springframework/data/mongodb/repository/config/EnableMongoRepositories.html) and [`@EntityScan`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/domain/EntityScan.html) respectively.
+
+> [!TIP]
+> For complete details of Spring Data MongoDB, including its rich object mapping technologies, see its [reference documentation](https://docs.spring.io/spring-data/mongodb/reference/4.5).
+
+ {
+
+ Optional findOneByNameAndState(String name, String state);
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.data.neo4j.repository.Neo4jRepository
+import java.util.Optional
+
+interface CityRepository : Neo4jRepository {
+
+ fun findOneByNameAndState(name: String?, state: String?): Optional?
+
+}
+
+```
+
+The `spring-boot-starter-data-neo4j` starter enables the repository support as well as transaction management.
+Spring Boot supports both classic and reactive Neo4j repositories, using the [`Neo4jTemplate`](https://docs.spring.io/spring-data/neo4j/docs/7.5.x/api/org/springframework/data/neo4j/core/Neo4jTemplate.html) or [`ReactiveNeo4jTemplate`](https://docs.spring.io/spring-data/neo4j/docs/7.5.x/api/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.html) beans.
+When Project Reactor is available on the classpath, the reactive style is also auto-configured.
+
+Repositories and entities are found through scanning.
+By default, the [auto-configuration packages](../using/auto-configuration.md#using.auto-configuration.packages) are scanned.
+You can customize the locations to look for repositories and entities by using [`@EnableNeo4jRepositories`](https://docs.spring.io/spring-data/neo4j/docs/7.5.x/api/org/springframework/data/neo4j/repository/config/EnableNeo4jRepositories.html) and [`@EntityScan`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/domain/EntityScan.html) respectively.
+
+> [!NOTE]
+> In an application using the reactive style, a [`ReactiveTransactionManager`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/transaction/ReactiveTransactionManager.html) is not auto-configured.
+> To enable transaction management, the following bean must be defined in your configuration:
+>
+> #### Java
+>
+> ```java
+> import org.neo4j.driver.Driver;
+>
+> import org.springframework.context.annotation.Bean;
+> import org.springframework.context.annotation.Configuration;
+> import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;
+> import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;
+>
+> @Configuration(proxyBeanMethods = false)
+> public class MyNeo4jConfiguration {
+>
+> @Bean
+> public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,
+> ReactiveDatabaseSelectionProvider databaseNameProvider) {
+> return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);
+> }
+>
+> }
+> ```
+>
+> #### Kotlin
+>
+> ```kotlin
+> import org.neo4j.driver.Driver
+> import org.springframework.context.annotation.Bean
+> import org.springframework.context.annotation.Configuration
+> import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider
+> import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager
+>
+> @Configuration(proxyBeanMethods = false)
+> class MyNeo4jConfiguration {
+>
+> @Bean
+> fun reactiveTransactionManager(driver: Driver,
+> databaseNameProvider: ReactiveDatabaseSelectionProvider): ReactiveNeo4jTransactionManager {
+> return ReactiveNeo4jTransactionManager(driver, databaseNameProvider)
+> }
+> }
+>
+> ```
+
+ someMethod() {
+ return this.template.findAll(User.class);
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.ldap.core.LdapTemplate
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val template: LdapTemplate) {
+ fun someMethod(): List {
+ return template.findAll(User::class.java)
+ }
+}
+
+```
+
+
+ org.springframework.boot
+ spring-boot-starter-data-jpa
+
+
+ org.hsqldb
+ hsqldb
+ runtime
+
+```
+
+> [!NOTE]
+> You need a dependency on `spring-jdbc` for an embedded database to be auto-configured.
+> In this example, it is pulled in transitively through `spring-boot-starter-data-jpa`.
+
+> [!TIP]
+> If, for whatever reason, you do configure the connection URL for an embedded database, take care to ensure that the database’s automatic shutdown is disabled.
+> If you use H2, you should use `DB_CLOSE_ON_EXIT=FALSE` to do so.
+> If you use HSQLDB, you should ensure that `shutdown=true` is not used.
+> Disabling the database’s automatic shutdown lets Spring Boot control when the database is closed, thereby ensuring that it happens once access to the database is no longer needed.
+
+ {
+
+ Page findAll(Pageable pageable);
+
+ City findByNameAndStateAllIgnoringCase(String name, String state);
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.City
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.repository.Repository
+
+interface CityRepository : Repository {
+
+ fun findAll(pageable: Pageable?): Page?
+
+ fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?
+
+}
+
+```
+
+Spring Data JPA repositories support three different modes of bootstrapping: default, deferred, and lazy.
+To enable deferred or lazy bootstrapping, set the `spring.data.jpa.repositories.bootstrap-mode` property to `deferred` or `lazy` respectively.
+When using deferred or lazy bootstrapping, the auto-configured [`EntityManagerFactoryBuilder`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/orm/jpa/EntityManagerFactoryBuilder.html) will use the context’s [`AsyncTaskExecutor`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/task/AsyncTaskExecutor.html), if any, as the bootstrap executor.
+If more than one exists, the one named `applicationTaskExecutor` will be used.
+
+> [!NOTE]
+> When using deferred or lazy bootstrapping, make sure to defer any access to the JPA infrastructure after the application context bootstrap phase.
+> You can use [`SmartInitializingSingleton`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/SmartInitializingSingleton.html) to invoke any initialization that requires the JPA infrastructure.
+> For JPA components (such as converters) that are created as Spring beans, use [`ObjectProvider`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/ObjectProvider.html) to delay the resolution of dependencies, if any.
+
+> [!TIP]
+> We have barely scratched the surface of Spring Data JPA.
+> For complete details, see the [Spring Data JPA reference documentation](https://docs.spring.io/spring-data/jpa/reference/3.5).
+
+, Repository {
+
+ Page findAll(Pageable pageable);
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.Country
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.repository.Repository
+import org.springframework.data.repository.history.RevisionRepository
+
+interface CountryRepository :
+ RevisionRepository,
+ Repository {
+
+ fun findAll(pageable: Pageable?): Page?
+
+}
+
+```
+
+> [!NOTE]
+> For more details, check the [Spring Data Envers reference documentation](https://docs.spring.io/spring-data/jpa/reference/3.5/envers.html).
+
+` tag.
+You can also use Spring Boot-defined version variables (such as `h2.version`) to declare the plugin’s database dependency.
+The following listing shows an example:
+
+```xml
+
+ org.jooq
+ jooq-codegen-maven
+
+ ...
+
+
+
+ com.h2database
+ h2
+ ${h2.version}
+
+
+
+
+ org.h2.Driver
+ jdbc:h2:~/yourdatabase
+
+
+ ...
+
+
+
+```
+
+ authorsBornAfter1980() {
+ return this.create.selectFrom(AUTHOR)
+ .where(AUTHOR.DATE_OF_BIRTH.greaterThan(new GregorianCalendar(1980, 0, 1)))
+ .fetch(AUTHOR.DATE_OF_BIRTH);
+```
+
+#### Kotlin
+
+```kotlin
+ fun authorsBornAfter1980(): List {
+ return create.selectFrom(Tables.AUTHOR)
+ .where(Tables.AUTHOR?.DATE_OF_BIRTH?.greaterThan(GregorianCalendar(1980, 0, 1)))
+ .fetch(Tables.AUTHOR?.DATE_OF_BIRTH)
+ }
+```
+
+ options = new HashMap<>();
+ options.put("lock_timeout", "30s");
+ options.put("statement_timeout", "60s");
+ return (builder) -> builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider
+import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyPostgresR2dbcConfiguration {
+
+ @Bean
+ fun postgresCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
+ val options: MutableMap = HashMap()
+ options["lock_timeout"] = "30s"
+ options["statement_timeout"] = "60s"
+ return ConnectionFactoryOptionsBuilderCustomizer { builder ->
+ builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options)
+ }
+ }
+
+}
+
+```
+
+When a [`ConnectionFactory`](https://r2dbc.io/spec/1.0.0.RELEASE/api/io/r2dbc/spi/ConnectionFactory.html) bean is available, the regular JDBC [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html) auto-configuration backs off.
+If you want to retain the JDBC [`DataSource`](https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/javax/sql/DataSource.html) auto-configuration, and are comfortable with the risk of using the blocking JDBC API in a reactive application, add `@Import(DataSourceAutoConfiguration.class)` on a [`@Configuration`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Configuration.html) class in your application to re-enable it.
+
+
+ io.r2dbc
+ r2dbc-h2
+ runtime
+
+```
+
+> [!NOTE]
+> If you are using this feature in your tests, you may notice that the same database is reused by your whole test suite regardless of the number of application contexts that you use.
+> If you want to make sure that each context has a separate embedded database, you should set `spring.r2dbc.generate-unique-name` to `true`.
+
+> someMethod() {
+ return this.databaseClient.sql("select * from user").fetch().all();
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.r2dbc.core.DatabaseClient
+import org.springframework.stereotype.Component
+import reactor.core.publisher.Flux
+
+@Component
+class MyBean(private val databaseClient: DatabaseClient) {
+ fun someMethod(): Flux> {
+ return databaseClient.sql("select * from user").fetch().all()
+ }
+}
+
+```
+
+ {
+
+ Mono findByNameAndStateAllIgnoringCase(String name, String state);
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.data.repository.Repository
+import reactor.core.publisher.Mono
+
+interface CityRepository : Repository {
+
+ fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): Mono?
+
+}
+
+```
+
+> [!TIP]
+> We have barely scratched the surface of Spring Data R2DBC. For complete details, see the [Spring Data R2DBC reference documentation](https://docs.spring.io/spring-data/relational/reference/3.5).
diff --git a/markdown/boot/3.5.4/reference/features/aop.md b/markdown/boot/3.5.4/reference/features/aop.md
new file mode 100644
index 0000000..3593f19
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/features/aop.md
@@ -0,0 +1,16 @@
+---
+title: "Aspect-Oriented Programming"
+source: "reference:features/aop.adoc"
+---
+
+
+
+ org.springframework.boot
+ spring-boot-docker-compose
+ true
+
+
+```
+
+#### Gradle
+
+```gradle
+dependencies {
+ developmentOnly("org.springframework.boot:spring-boot-docker-compose")
+}
+```
+
+When this module is included as a dependency Spring Boot will do the following:
+
+- Search for a `compose.yml` and other common compose filenames in your working directory
+- Call `docker compose up` with the discovered `compose.yml`
+- Create service connection beans for each supported container
+- Call `docker compose stop` when the application is shutdown
+
+If the Docker Compose services are already running when starting the application, Spring Boot will only create the service connection beans for each supported container.
+It will not call `docker compose up` again and it will not call `docker compose stop` when the application is shutdown.
+
+> [!TIP]
+> Repackaged archives do not contain Spring Boot’s Docker Compose by default.
+> If you want to use this support, you need to include it.
+> When using the Maven plugin, set the `excludeDockerCompose` property to `false`.
+> When using the Gradle plugin, [configure the task’s classpath to include the `developmentOnly` configuration](https://docs.spring.io/spring-boot/3.5.4/gradle-plugin/packaging.html#packaging-executable.configuring.including-development-only-dependencies).
+
+) {
+ fromApplication().run(*args)
+}
+
+```
+
+You’ll also need to define the [`Container`](https://javadoc.io/doc/org.testcontainers/testcontainers/1.21.3/org/testcontainers/containers/Container.html) instances that you want to start along with your application.
+To do this, you need to make sure that the `spring-boot-testcontainers` module has been added as a `test` dependency.
+Once that has been done, you can create a [`@TestConfiguration`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/test/context/TestConfiguration.html) class that declares [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) methods for the containers you want to start.
+
+You can also annotate your [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) methods with [`@ServiceConnection`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/testcontainers/service/connection/ServiceConnection.html) in order to create [`ConnectionDetails`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/service/connection/ConnectionDetails.html) beans.
+See [the service connections](../testing/testcontainers.md#testing.testcontainers.service-connections) section for details of the supported technologies.
+
+A typical Testcontainers configuration would look like this:
+
+#### Java
+
+```java
+import org.testcontainers.containers.Neo4jContainer;
+
+import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
+import org.springframework.context.annotation.Bean;
+
+@TestConfiguration(proxyBeanMethods = false)
+public class MyContainersConfiguration {
+
+ @Bean
+ @ServiceConnection
+ public Neo4jContainer neo4jContainer() {
+ return new Neo4jContainer<>("neo4j:5");
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.test.context.TestConfiguration
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection
+import org.springframework.context.annotation.Bean
+import org.testcontainers.containers.Neo4jContainer
+
+@TestConfiguration(proxyBeanMethods = false)
+class MyContainersConfiguration {
+
+ @Bean
+ @ServiceConnection
+ fun neo4jContainer(): Neo4jContainer<*> {
+ return Neo4jContainer("neo4j:5")
+ }
+
+}
+
+```
+
+> [!NOTE]
+> The lifecycle of [`Container`](https://javadoc.io/doc/org.testcontainers/testcontainers/1.21.3/org/testcontainers/containers/Container.html) beans is automatically managed by Spring Boot.
+> Containers will be started and stopped automatically.
+
+> [!TIP]
+> You can use the `spring.testcontainers.beans.startup` property to change how containers are started.
+> By default `sequential` startup is used, but you may also choose `parallel` if you wish to start multiple containers in parallel.
+
+Once you have defined your test configuration, you can use the `with(…)` method to attach it to your test launcher:
+
+#### Java
+
+```java
+import org.springframework.boot.SpringApplication;
+
+public class TestMyApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.from(MyApplication::main).with(MyContainersConfiguration.class).run(args);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.fromApplication
+import org.springframework.boot.with
+
+fun main(args: Array) {
+ fromApplication().with(MyContainersConfiguration::class).run(*args)
+}
+
+```
+
+You can now launch `TestMyApplication` as you would any regular Java `main` method application to start your application and the containers that it needs to run.
+
+> [!TIP]
+> You can use the Maven goal `spring-boot:test-run` or the Gradle task `bootTestRun` to do this from the command line.
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+
+ org.springframework.boot
+ spring-boot-autoconfigure-processor
+
+
+
+
+
+
+
+```
+
+With Gradle, the dependency should be declared in the `annotationProcessor` configuration, as shown in the following example:
+
+```gradle
+dependencies {
+ annotationProcessor "org.springframework.boot:spring-boot-autoconfigure-processor"
+}
+```
+
+)).
+1. [`@PropertySource`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/PropertySource.html) annotations on your [`@Configuration`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Configuration.html) classes.
+Please note that such property sources are not added to the [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html) until the application context is being refreshed.
+This is too late to configure certain properties such as `logging.*` and `spring.main.*` which are read before refresh begins.
+1. Config data (such as `application.properties` files).
+1. A [`RandomValuePropertySource`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/env/RandomValuePropertySource.html) that has properties only in `random.*`.
+1. OS environment variables.
+1. Java System properties (`System.getProperties()`).
+1. JNDI attributes from `java:comp/env`.
+1. [`ServletContext`](https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta.servlet/jakarta/servlet/ServletContext.html) init parameters.
+1. [`ServletConfig`](https://jakarta.ee/specifications/servlet/6.0/apidocs/jakarta.servlet/jakarta/servlet/ServletConfig.html) init parameters.
+1. Properties from `SPRING_APPLICATION_JSON` (inline JSON embedded in an environment variable or system property).
+1. Command line arguments.
+1. `properties` attribute on your tests.
+Available on [`@SpringBootTest`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/test/context/SpringBootTest.html) and the [test annotations for testing a particular slice of your application](../testing/spring-boot-applications.md#testing.spring-boot-applications.autoconfigured-tests).
+1. [`@DynamicPropertySource`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/test/context/DynamicPropertySource.html) annotations in your tests.
+1. [`@TestPropertySource`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/test/context/TestPropertySource.html) annotations on your tests.
+1. [Devtools global settings properties](../using/devtools.md#using.devtools.globalsettings) in the `$HOME/.config/spring-boot` directory when devtools is active.
+
+Config data files are considered in the following order:
+
+1. [Application properties](#features.external-config.files) packaged inside your jar (`application.properties` and YAML variants).
+1. [Profile-specific application properties](#features.external-config.files.profile-specific) packaged inside your jar (`application-{profile}.properties` and YAML variants).
+1. [Application properties](#features.external-config.files) outside of your packaged jar (`application.properties` and YAML variants).
+1. [Profile-specific application properties](#features.external-config.files.profile-specific) outside of your packaged jar (`application-{profile}.properties` and YAML variants).
+
+> [!NOTE]
+> It is recommended to stick with one format for your entire application.
+> If you have configuration files with both `.properties` and YAML format in the same location, `.properties` takes precedence.
+
+> [!NOTE]
+> If you use environment variables rather than system properties, most operating systems disallow period-separated key names, but you can use underscores instead (for example, `SPRING_CONFIG_NAME` instead of `spring.config.name`).
+> See [Binding From Environment Variables](#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables) for details.
+
+> [!NOTE]
+> If your application runs in a servlet container or application server, then JNDI properties (in `java:comp/env`) or servlet context initialization parameters can be used instead of, or as well as, environment variables or system properties.
+
+To provide a concrete example, suppose you develop a [`@Component`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/stereotype/Component.html) that uses a `name` property, as shown in the following example:
+
+#### Java
+
+```java
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MyBean {
+
+ @Value("${name}")
+ private String name;
+
+ // ...
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean {
+
+ @Value("\${name}")
+ private val name: String? = null
+
+ // ...
+
+}
+
+```
+
+On your application classpath (for example, inside your jar) you can have an `application.properties` file that provides a sensible default property value for `name`.
+When running in a new environment, an `application.properties` file can be provided outside of your jar that overrides the `name`.
+For one-off testing, you can launch with a specific command line switch (for example, `java -jar app.jar --name="Spring"`).
+
+> [!TIP]
+> The `env` and `configprops` endpoints can be useful in determining why a property has a particular value.
+> You can use these two endpoints to diagnose unexpected property values.
+> See the [Production ready features](../actuator/endpoints.md) section for details.
+
+.properties` files are loaded.
+
+In most situations, each `spring.config.location` item you add will reference a single file or directory.
+Locations are processed in the order that they are defined and later ones can override the values of earlier ones.
+
+` for search locations that are files.
+> Locations with wildcards are sorted alphabetically based on the absolute path of the file names.
+
+> [!TIP]
+> Wildcard locations only work with external directories.
+> You cannot use a wildcard in a `classpath:` location.
+
+.properties` variants.
+
+> [!TIP]
+> Spring Boot includes pluggable API that allows various different location addresses to be supported.
+> By default you can import Java Properties, YAML and [configuration trees](#features.external-config.files.configtree).
+>
+> Third-party jars can offer support for additional technologies (there is no requirement for files to be local).
+> For example, you can imagine config data being from external stores such as Consul, Apache ZooKeeper or Netflix Archaius.
+>
+> If you want to support your own locations, see the [`ConfigDataLocationResolver`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/config/ConfigDataLocationResolver.html) and [`ConfigDataLoader`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/config/ConfigDataLoader.html) classes in the `org.springframework.boot.context.config` package.
+
+ roles = new ArrayList<>(Collections.singleton("USER"));
+ public String getUsername() {
+ return this.username;
+ }
+
+ public void setUsername(String username) {
+ this.username = username;
+ }
+
+ public String getPassword() {
+ return this.password;
+ }
+
+ public void setPassword(String password) {
+ this.password = password;
+ }
+
+ public List getRoles() {
+ return this.roles;
+ }
+
+ public void setRoles(List roles) {
+ this.roles = roles;
+ }
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+import java.net.InetAddress
+
+@ConfigurationProperties("my.service")
+class MyProperties {
+
+ var isEnabled = false
+
+ var remoteAddress: InetAddress? = null
+
+ val security = Security()
+
+ class Security {
+
+ var username: String? = null
+
+ var password: String? = null
+
+ var roles: List = ArrayList(setOf("USER"))
+
+ }
+
+}
+
+```
+
+The preceding POJO defines the following properties:
+
+- `my.service.enabled`, with a value of `false` by default.
+- `my.service.remote-address`, with a type that can be coerced from [`String`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html).
+- `my.service.security.username`, with a nested "security" object whose name is determined by the name of the property.
+In particular, the type is not used at all there and could have been [`SecurityProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/autoconfigure/security/SecurityProperties.html).
+- `my.service.security.password`.
+- `my.service.security.roles`, with a collection of [`String`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html) that defaults to `USER`.
+
+> [!TIP]
+> To use a reserved keyword in the name of a property, such as `my.service.import`, use the [`@Name`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/Name.html) annotation on the property’s field.
+
+> [!NOTE]
+> The properties that map to [`@ConfigurationProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/ConfigurationProperties.html) classes available in Spring Boot, which are configured through properties files, YAML files, environment variables, and other mechanisms, are public API but the accessors (getters/setters) of the class itself are not meant to be used directly.
+
+> [!NOTE]
+> Such arrangement relies on a default empty constructor and getters and setters are usually mandatory, since binding is through standard Java Beans property descriptors, just like in Spring MVC.
+> A setter may be omitted in the following cases:
+>
+> - Maps, as long as they are initialized, need a getter but not necessarily a setter, since they can be mutated by the binder.
+> - Collections and arrays can be accessed either through an index (typically with YAML) or by using a single comma-separated value (properties).
+> In the latter case, a setter is mandatory.
+> We recommend to always add a setter for such types.
+> If you initialize a collection, make sure it is not immutable (as in the preceding example).
+> - If nested POJO properties are initialized (like the `Security` field in the preceding example), a setter is not required.
+> If you want the binder to create the instance on the fly by using its default constructor, you need a setter.
+>
+> Some people use Project Lombok to add getters and setters automatically.
+> Make sure that Lombok does not generate any particular constructor for such a type, as it is used automatically by the container to instantiate the object.
+>
+> Finally, only standard Java Bean properties are considered and binding on static properties is not supported.
+
+ roles;
+ public Security(String username, String password, @DefaultValue("USER") List roles) {
+ this.username = username;
+ this.password = password;
+ this.roles = roles;
+ }
+ public String getUsername() {
+ return this.username;
+ }
+
+ public String getPassword() {
+ return this.password;
+ }
+
+ public List getRoles() {
+ return this.roles;
+ }
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.boot.context.properties.bind.DefaultValue
+import java.net.InetAddress
+
+@ConfigurationProperties("my.service")
+class MyProperties(val enabled: Boolean, val remoteAddress: InetAddress,
+ val security: Security) {
+
+ class Security(val username: String, val password: String,
+ @param:DefaultValue("USER") val roles: List)
+
+}
+
+```
+
+In this setup, the presence of a single parameterized constructor implies that constructor binding should be used.
+This means that the binder will find a constructor with the parameters that you wish to have bound.
+If your class has multiple constructors, the [`@ConstructorBinding`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/ConstructorBinding.html) annotation can be used to specify which constructor to use for constructor binding.
+
+To opt-out of constructor binding for a class, the parameterized constructor must be annotated with [`@Autowired`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/annotation/Autowired.html) or made `private`.
+Kotlin developers can use an empty primary constructor to opt-out of constructor binding.
+
+For example:
+
+#### Java
+
+```java
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties("my")
+public class MyProperties {
+ final MyBean myBean;
+
+ private String name;
+ @Autowired
+ public MyProperties(MyBean myBean) {
+ this.myBean = myBean;
+ }
+ public String getName() {
+ return this.name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("my")
+class MyProperties() {
+
+ constructor(name: String) : this() {
+ this.name = name
+ }
+ var name: String? = null
+}
+
+```
+
+Constructor binding can be used with records.
+Unless your record has multiple constructors, there is no need to use [`@ConstructorBinding`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/ConstructorBinding.html).
+
+Nested members of a constructor bound class (such as `Security` in the example above) will also be bound through their constructor.
+
+Default values can be specified using [`@DefaultValue`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/DefaultValue.html) on constructor parameters and record components.
+The conversion service will be applied to coerce the annotation’s [`String`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html) value to the target type of a missing property.
+
+Referring to the previous example, if no properties are bound to `Security`, the `MyProperties` instance will contain a `null` value for `security`.
+To make it contain a non-null instance of `Security` even when no properties are bound to it (when using Kotlin, this will require the `username` and `password` parameters of `Security` to be declared as nullable as they do not have default values), use an empty [`@DefaultValue`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/DefaultValue.html) annotation:
+
+#### Java
+
+```java
+ public MyProperties(boolean enabled, InetAddress remoteAddress, @DefaultValue Security security) {
+ this.enabled = enabled;
+ this.remoteAddress = remoteAddress;
+ this.security = security;
+ }
+```
+
+#### Kotlin
+
+```kotlin
+class MyProperties(val enabled: Boolean, val remoteAddress: InetAddress,
+ @DefaultValue val security: Security) {
+
+ class Security(val username: String?, val password: String?,
+ @param:DefaultValue("USER") val roles: List)
+
+}
+```
+
+> [!NOTE]
+> To use constructor binding the class must be enabled using [`@EnableConfigurationProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/EnableConfigurationProperties.html) or configuration property scanning.
+> You cannot use constructor binding with beans that are created by the regular Spring mechanisms (for example [`@Component`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/stereotype/Component.html) beans, beans created by using [`@Bean`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Bean.html) methods or beans loaded by using [`@Import`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Import.html))
+
+> [!NOTE]
+> To use constructor binding the class must be compiled with `-parameters`.
+> This will happen automatically if you use Spring Boot’s Gradle plugin or if you use Maven and `spring-boot-starter-parent`.
+
+> [!NOTE]
+> The use of [`Optional`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html) with [`@ConfigurationProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/ConfigurationProperties.html) is not recommended as it is primarily intended for use as a return type.
+> As such, it is not well-suited to configuration property injection.
+> For consistency with properties of other types, if you do declare an [`Optional`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html) property and it has no value, `null` rather than an empty [`Optional`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html) will be bound.
+
+> [!TIP]
+> To use a reserved keyword in the name of a property, such as `my.service.import`, use the [`@Name`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/bind/Name.html) annotation on the constructor parameter.
+
+-`, where `` is the environment key prefix specified in the [`@ConfigurationProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/ConfigurationProperties.html) annotation and `` is the fully qualified name of the bean.
+> If the annotation does not provide any prefix, only the fully qualified name of the bean is used.
+>
+> Assuming that it is in the `com.example.app` package, the bean name of the `SomeProperties` example above is `some.properties-com.example.app.SomeProperties`.
+
+We recommend that [`@ConfigurationProperties`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/properties/ConfigurationProperties.html) only deal with the environment and, in particular, does not inject other beans from the context.
+For corner cases, setter injection can be used or any of the `*Aware` interfaces provided by the framework (such as [`EnvironmentAware`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/EnvironmentAware.html) if you need access to the [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html)).
+If you still want to inject other beans using the constructor, the configuration properties bean must be annotated with [`@Component`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/stereotype/Component.html) and use JavaBean-based property binding.
+
+`:
+
+#### Properties
+
+```properties
+my.map[/key1]=value1
+my.map[/key2]=value2
+my.map./key3=value3
+```
+
+#### YAML
+
+```yaml
+my:
+ map:
+ "[/key1]": "value1"
+ "[/key2]": "value2"
+ "/key3": "value3"
+```
+
+> [!NOTE]
+> For YAML files, the brackets need to be surrounded by quotes for the keys to be parsed properly.
+
+The properties above will bind to a [`Map`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html) with `/key1`, `/key2` and `key3` as the keys in the map.
+The slash has been removed from `key3` because it was not surrounded by square brackets.
+
+When binding to scalar values, keys with `.` in them do not need to be surrounded by `[]`.
+Scalar values include enums and all types in the `java.lang` package except for [`Object`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html).
+Binding `a.b=c` to `Map` will preserve the `.` in the key and return a Map with the entry `{"a.b"="c"}`.
+For any other types you need to use the bracket notation if your `key` contains a `.`.
+For example, binding `a.b=c` to `Map` will return a Map with the entry `{"a"={"b"="c"}}` whereas `[a.b]=c` will return a Map with the entry `{"a.b"="c"}`.
+
+ values = new HashMap<>();
+
+ public Map getValues() {
+ return this.values;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("my.props")
+class MyMapsProperties {
+
+ val values: Map = HashMap()
+
+}
+
+```
+
+When setting `MY_PROPS_VALUES_KEY=value`, the `values` [`Map`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html) contains a `{"key"="value"}` entry.
+
+Only the environment variable **name** is lower-cased, not the value.
+When setting `MY_PROPS_VALUES_KEY=VALUE`, the `values` [`Map`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html) contains a `{"key"="VALUE"}` entry.
+
+ list = new ArrayList<>();
+
+ public List getList() {
+ return this.list;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("my")
+class MyProperties {
+
+ val list: List = ArrayList()
+
+}
+
+```
+
+Consider the following configuration:
+
+#### Properties
+
+```properties
+my.list[0].name=my name
+my.list[0].description=my description
+#---
+spring.config.activate.on-profile=dev
+my.list[0].name=my another name
+```
+
+#### YAML
+
+```yaml
+my:
+ list:
+ - name: "my name"
+ description: "my description"
+---
+spring:
+ config:
+ activate:
+ on-profile: "dev"
+my:
+ list:
+ - name: "my another name"
+```
+
+If the `dev` profile is not active, `MyProperties.list` contains one `MyPojo` entry, as previously defined.
+If the `dev` profile is enabled, however, the `list` *still* contains only one entry (with a name of `my another name` and a description of `null`).
+This configuration *does not* add a second `MyPojo` instance to the list, and it does not merge the items.
+
+When a [`List`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html) is specified in multiple profiles, the one with the highest priority (and only that one) is used.
+Consider the following example:
+
+#### Properties
+
+```properties
+my.list[0].name=my name
+my.list[0].description=my description
+my.list[1].name=another name
+my.list[1].description=another description
+#---
+spring.config.activate.on-profile=dev
+my.list[0].name=my another name
+```
+
+#### YAML
+
+```yaml
+my:
+ list:
+ - name: "my name"
+ description: "my description"
+ - name: "another name"
+ description: "another description"
+---
+spring:
+ config:
+ activate:
+ on-profile: "dev"
+my:
+ list:
+ - name: "my another name"
+```
+
+In the preceding example, if the `dev` profile is active, `MyProperties.list` contains *one* `MyPojo` entry (with a name of `my another name` and a description of `null`).
+For YAML, both comma-separated lists and YAML lists can be used for completely overriding the contents of the list.
+
+For [`Map`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html) properties, you can bind with property values drawn from multiple sources.
+However, for the same property in multiple sources, the one with the highest priority is used.
+The following example exposes a `Map` from `MyProperties`:
+
+#### Java
+
+```java
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties("my")
+public class MyProperties {
+
+ private final Map map = new LinkedHashMap<>();
+
+ public Map getMap() {
+ return this.map;
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties("my")
+class MyProperties {
+
+ val map: Map = LinkedHashMap()
+
+}
+
+```
+
+Consider the following configuration:
+
+#### Properties
+
+```properties
+my.map.key1.name=my name 1
+my.map.key1.description=my description 1
+#---
+spring.config.activate.on-profile=dev
+my.map.key1.name=dev name 1
+my.map.key2.name=dev name 2
+my.map.key2.description=dev description 2
+```
+
+#### YAML
+
+```yaml
+my:
+ map:
+ key1:
+ name: "my name 1"
+ description: "my description 1"
+---
+spring:
+ config:
+ activate:
+ on-profile: "dev"
+my:
+ map:
+ key1:
+ name: "dev name 1"
+ key2:
+ name: "dev name 2"
+ description: "dev description 2"
+```
+
+If the `dev` profile is not active, `MyProperties.map` contains one entry with key `key1` (with a name of `my name 1` and a description of `my description 1`).
+If the `dev` profile is enabled, however, `map` contains two entries with keys `key1` (with a name of `dev name 1` and a description of `my description 1`) and `key2` (with a name of `dev name 2` and a description of `dev description 2`).
+
+> [!NOTE]
+> The preceding merging rules apply to properties from all property sources, and not just files.
+
+)
+- A more readable format where the value and the unit are coupled (`10s` means 10 seconds)
+
+Consider the following example:
+
+#### Java
+
+```java
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.convert.DurationUnit;
+
+@ConfigurationProperties("my")
+public class MyProperties {
+
+ @DurationUnit(ChronoUnit.SECONDS)
+ private Duration sessionTimeout = Duration.ofSeconds(30);
+
+ private Duration readTimeout = Duration.ofMillis(1000);
+ public Duration getSessionTimeout() {
+ return this.sessionTimeout;
+ }
+
+ public void setSessionTimeout(Duration sessionTimeout) {
+ this.sessionTimeout = sessionTimeout;
+ }
+
+ public Duration getReadTimeout() {
+ return this.readTimeout;
+ }
+
+ public void setReadTimeout(Duration readTimeout) {
+ this.readTimeout = readTimeout;
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.boot.convert.DurationUnit
+import java.time.Duration
+import java.time.temporal.ChronoUnit
+
+@ConfigurationProperties("my")
+class MyProperties {
+
+ @DurationUnit(ChronoUnit.SECONDS)
+ var sessionTimeout = Duration.ofSeconds(30)
+
+ var readTimeout = Duration.ofMillis(1000)
+
+}
+
+```
+
+To specify a session timeout of 30 seconds, `30`, `PT30S` and `30s` are all equivalent.
+A read timeout of 500ms can be specified in any of the following form: `500`, `PT0.5S` and `500ms`.
+
+You can also use any of the supported units.
+These are:
+
+- `ns` for nanoseconds
+- `us` for microseconds
+- `ms` for milliseconds
+- `s` for seconds
+- `m` for minutes
+- `h` for hours
+- `d` for days
+
+The default unit is milliseconds and can be overridden using [`@DurationUnit`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/convert/DurationUnit.html) as illustrated in the sample above.
+
+If you prefer to use constructor binding, the same properties can be exposed, as shown in the following example:
+
+#### Java
+
+```java
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.context.properties.bind.DefaultValue;
+import org.springframework.boot.convert.DurationUnit;
+
+@ConfigurationProperties("my")
+public class MyProperties {
+ private final Duration sessionTimeout;
+
+ private final Duration readTimeout;
+ public MyProperties(@DurationUnit(ChronoUnit.SECONDS) @DefaultValue("30s") Duration sessionTimeout,
+ @DefaultValue("1000ms") Duration readTimeout) {
+ this.sessionTimeout = sessionTimeout;
+ this.readTimeout = readTimeout;
+ }
+ public Duration getSessionTimeout() {
+ return this.sessionTimeout;
+ }
+
+ public Duration getReadTimeout() {
+ return this.readTimeout;
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.boot.context.properties.bind.DefaultValue
+import org.springframework.boot.convert.DurationUnit
+import java.time.Duration
+import java.time.temporal.ChronoUnit
+
+@ConfigurationProperties("my")
+class MyProperties(@param:DurationUnit(ChronoUnit.SECONDS) @param:DefaultValue("30s") val sessionTimeout: Duration,
+ @param:DefaultValue("1000ms") val readTimeout: Duration)
+
+```
+
+> [!TIP]
+> If you are upgrading a [`Long`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html) property, make sure to define the unit (using [`@DurationUnit`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/convert/DurationUnit.html)) if it is not milliseconds.
+> Doing so gives a transparent upgrade path while supporting a much richer format.
+
+)
+- A simpler format where the value and the unit pairs are coupled (`1y3d` means 1 year and 3 days)
+
+The following units are supported with the simple format:
+
+- `y` for years
+- `m` for months
+- `w` for weeks
+- `d` for days
+
+> [!NOTE]
+> The [`Period`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Period.html) type never actually stores the number of weeks, it is a shortcut that means “7 days”.
+
+ {
+
+ @Override
+ public void serialize(MyObject value, JsonGenerator jgen, SerializerProvider serializers) throws IOException {
+ jgen.writeStartObject();
+ jgen.writeStringField("name", value.getName());
+ jgen.writeNumberField("age", value.getAge());
+ jgen.writeEndObject();
+ }
+
+ }
+
+ public static class Deserializer extends JsonDeserializer {
+
+ @Override
+ public MyObject deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException {
+ ObjectCodec codec = jsonParser.getCodec();
+ JsonNode tree = codec.readTree(jsonParser);
+ String name = tree.get("name").textValue();
+ int age = tree.get("age").intValue();
+ return new MyObject(name, age);
+ }
+
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.JsonProcessingException
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JsonDeserializer
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.JsonSerializer
+import com.fasterxml.jackson.databind.SerializerProvider
+import org.springframework.boot.jackson.JsonComponent
+import java.io.IOException
+
+@JsonComponent
+class MyJsonComponent {
+
+ class Serializer : JsonSerializer() {
+ @Throws(IOException::class)
+ override fun serialize(value: MyObject, jgen: JsonGenerator, serializers: SerializerProvider) {
+ jgen.writeStartObject()
+ jgen.writeStringField("name", value.name)
+ jgen.writeNumberField("age", value.age)
+ jgen.writeEndObject()
+ }
+ }
+
+ class Deserializer : JsonDeserializer() {
+ @Throws(IOException::class, JsonProcessingException::class)
+ override fun deserialize(jsonParser: JsonParser, ctxt: DeserializationContext): MyObject {
+ val codec = jsonParser.codec
+ val tree = codec.readTree(jsonParser)
+ val name = tree["name"].textValue()
+ val age = tree["age"].intValue()
+ return MyObject(name, age)
+ }
+ }
+
+}
+
+```
+
+All [`@JsonComponent`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonComponent.html) beans in the [`ApplicationContext`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/ApplicationContext.html) are automatically registered with Jackson.
+Because [`@JsonComponent`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonComponent.html) is meta-annotated with [`@Component`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/stereotype/Component.html), the usual component-scanning rules apply.
+
+Spring Boot also provides [`JsonObjectSerializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectSerializer.html) and [`JsonObjectDeserializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectDeserializer.html) base classes that provide useful alternatives to the standard Jackson versions when serializing objects.
+See [`JsonObjectSerializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectSerializer.html) and [`JsonObjectDeserializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectDeserializer.html) in the API documentation for details.
+
+The example above can be rewritten to use [`JsonObjectSerializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectSerializer.html) and [`JsonObjectDeserializer`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/jackson/JsonObjectDeserializer.html) as follows:
+
+#### Java
+
+```java
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.ObjectCodec;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.SerializerProvider;
+
+import org.springframework.boot.jackson.JsonComponent;
+import org.springframework.boot.jackson.JsonObjectDeserializer;
+import org.springframework.boot.jackson.JsonObjectSerializer;
+
+@JsonComponent
+public class MyJsonComponent {
+
+ public static class Serializer extends JsonObjectSerializer {
+
+ @Override
+ protected void serializeObject(MyObject value, JsonGenerator jgen, SerializerProvider provider)
+ throws IOException {
+ jgen.writeStringField("name", value.getName());
+ jgen.writeNumberField("age", value.getAge());
+ }
+
+ }
+
+ public static class Deserializer extends JsonObjectDeserializer {
+
+ @Override
+ protected MyObject deserializeObject(JsonParser jsonParser, DeserializationContext context, ObjectCodec codec,
+ JsonNode tree) throws IOException {
+ String name = nullSafeValue(tree.get("name"), String.class);
+ int age = nullSafeValue(tree.get("age"), Integer.class);
+ return new MyObject(name, age);
+ }
+
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import org.springframework.boot.jackson.JsonComponent
+import org.springframework.boot.jackson.JsonObjectDeserializer
+import org.springframework.boot.jackson.JsonObjectSerializer
+import java.io.IOException
+
+@JsonComponent
+class MyJsonComponent {
+
+ class Serializer : JsonObjectSerializer() {
+ @Throws(IOException::class)
+ override fun serializeObject(value: MyObject, jgen: JsonGenerator, provider: SerializerProvider) {
+ jgen.writeStringField("name", value.name)
+ jgen.writeNumberField("age", value.age)
+ }
+ }
+
+ class Deserializer : JsonObjectDeserializer() {
+ @Throws(IOException::class)
+ override fun deserializeObject(jsonParser: JsonParser, context: DeserializationContext,
+ codec: ObjectCodec, tree: JsonNode): MyObject {
+ val name = nullSafeValue(tree["name"], String::class.java)
+ val age = nullSafeValue(tree["age"], Int::class.java)
+ return MyObject(name, age)
+ }
+ }
+
+}
+
+```
+
+(*args)` as shown in the following example:
+
+```kotlin
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.runApplication
+
+@SpringBootApplication
+class MyApplication
+
+fun main(args: Array) {
+ runApplication(*args)
+}
+```
+
+This is a drop-in replacement for `SpringApplication.run(MyApplication::class.java, *args)`.
+It also allows customization of the application as shown in the following example:
+
+```kotlin
+runApplication(*args) {
+ setBannerMode(OFF)
+}
+```
+
+=` where `level` is one of TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF.
+The `root` logger can be configured by using `logging.level.root`.
+
+The following example shows potential logging settings in `application.properties`:
+
+#### Properties
+
+```properties
+logging.level.root=warn
+logging.level.org.springframework.web=debug
+logging.level.org.hibernate=error
+```
+
+#### YAML
+
+```yaml
+logging:
+ level:
+ root: "warn"
+ org.springframework.web: "debug"
+ org.hibernate: "error"
+```
+
+It is also possible to set logging levels using environment variables.
+For example, `LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=DEBUG` will set `org.springframework.web` to `DEBUG`.
+
+> [!NOTE]
+> The above approach will only work for package level logging.
+> Since relaxed binding [always converts environment variables to lowercase](external-config.md#features.external-config.typesafe-configuration-properties.relaxed-binding.maps-from-environment-variables), it is not possible to configure logging for an individual class in this way.
+> If you need to configure logging for a class, you can use [the `SPRING_APPLICATION_JSON`](external-config.md#features.external-config.application-json) variable.
+
+
+ ${CONSOLE_LOG_STRUCTURED_FORMAT}
+ ${CONSOLE_LOG_CHARSET}
+
+```
+
+You can also refer to the default configurations included in Spring Boot:
+
+- [Logback Structured Console Appender](https://github.com/spring-projects/spring-boot/tree/v3.5.4/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback/structured-console-appender.xml)
+- [Logback Structured File Appender](https://github.com/spring-projects/spring-boot/tree/v3.5.4/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback/structured-file-appender.xml)
+
+#### Log4j2
+
+```xml
+
+) method.
+
+The `service` values can be customized using `logging.structured.ecs.service` properties:
+
+#### Properties
+
+```properties
+logging.structured.ecs.service.name=MyService
+logging.structured.ecs.service.version=1
+logging.structured.ecs.service.environment=Production
+logging.structured.ecs.service.node-name=Primary
+```
+
+#### YAML
+
+```yaml
+logging:
+ structured:
+ ecs:
+ service:
+ name: MyService
+ version: 1.0
+ environment: Production
+ node-name: Primary
+```
+
+> [!NOTE]
+> `logging.structured.ecs.service.name` will default to `spring.application.name` if not specified.
+
+> [!NOTE]
+> `logging.structured.ecs.service.version` will default to `spring.application.version` if not specified.
+
+) method.
+
+Several fields can be customized using `logging.structured.gelf` properties:
+
+#### Properties
+
+```properties
+logging.structured.gelf.host=MyService
+logging.structured.gelf.service.version=1
+```
+
+#### YAML
+
+```yaml
+logging:
+ structured:
+ gelf:
+ host: MyService
+ service:
+ version: 1.0
+```
+
+> [!NOTE]
+> `logging.structured.gelf.host` will default to `spring.application.name` if not specified.
+
+> [!NOTE]
+> `logging.structured.gelf.service.version` will default to `spring.application.version` if not specified.
+
+) method.
+
+If you add [markers](https://www.slf4j.org/api/org/slf4j/Marker.html), these will show up in a `tags` string array in the JSON.
+
+ {
+
+ @Override
+ public String format(ILoggingEvent event) {
+ return "time=" + event.getInstant() + " level=" + event.getLevel() + " message=" + event.getMessage() + "\n";
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import ch.qos.logback.classic.spi.ILoggingEvent
+import org.springframework.boot.logging.structured.StructuredLogFormatter
+
+class MyCustomFormat : StructuredLogFormatter {
+
+ override fun format(event: ILoggingEvent): String {
+ return "time=${event.instant} level=${event.level} message=${event.message}\n"
+ }
+
+}
+```
+
+As you can see in the example, you can return any format, it doesn’t have to be JSON.
+
+To enable your custom format, set the property `logging.structured.format.console` or `logging.structured.format.file` to the fully qualified class name of your implementation.
+
+Your implementation can use some constructor parameters, which are injected automatically.
+Please see the JavaDoc of [`StructuredLogFormatter`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/logging/structured/StructuredLogFormatter.html) for more details.
+
+` tag lets you optionally include or exclude sections of configuration based on the active Spring profiles.
+Profile sections are supported anywhere within the `` element.
+Use the `name` attribute to specify which profile accepts the configuration.
+The `` tag can contain a profile name (for example `staging`) or a profile expression.
+A profile expression allows for more complicated profile logic to be expressed, for example `production & (eu-central | eu-west)`.
+Check the [Spring Framework reference guide](https://docs.spring.io/spring-framework/reference/6.2/core/beans/environment.html#beans-definition-profiles-java) for more details.
+The following listing shows three sample profiles:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+` tag lets you expose properties from the Spring [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html) for use within Logback.
+Doing so can be useful if you want to access values from your `application.properties` file in your Logback configuration.
+The tag works in a similar way to Logback’s standard `` tag.
+However, rather than specifying a direct `value`, you specify the `source` of the property (from the [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html)).
+If you need to store the property somewhere other than in `local` scope, you can use the `scope` attribute.
+If you need a fallback value (in case the property is not set in the [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html)), you can use the `defaultValue` attribute.
+The following example shows how to expose properties for use within Logback:
+
+```xml
+
+ ${fluentHost}
+ ...
+
+```
+
+> [!NOTE]
+> The `source` must be specified in kebab case (such as `my.property-name`).
+> However, properties can be added to the [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html) by using the relaxed rules.
+
+` tag lets you optionally include or exclude sections of configuration based on the active Spring profiles.
+Profile sections are supported anywhere within the `` element.
+Use the `name` attribute to specify which profile accepts the configuration.
+The `` tag can contain a profile name (for example `staging`) or a profile expression.
+A profile expression allows for more complicated profile logic to be expressed, for example `production & (eu-central | eu-west)`.
+Check the [Spring Framework reference guide](https://docs.spring.io/spring-framework/reference/6.2/core/beans/environment.html#beans-definition-profiles-java) for more details.
+The following listing shows three sample profiles:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+ ${spring:spring.application.name}
+ ${spring:spring.application.group}
+
+```
+
+> [!NOTE]
+> The lookup key should be specified in kebab case (such as `my.property-name`).
+
+) method, as shown in the following example:
+
+#### Java
+
+```java
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MyApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(MyApplication.class, args);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.runApplication
+@SpringBootApplication
+class MyApplication
+
+fun main(args: Array) {
+ runApplication(*args)
+}
+
+```
+
+When your application starts, you should see something similar to the following output:
+
+```
+Unresolved include directive in modules/reference/pages/features/spring-application.adoc - include::ROOT:partial$application/spring-application.txt[]
+```
+
+By default, `INFO` logging messages are shown, including some relevant startup details, such as the user that launched the application.
+If you need a log level other than `INFO`, you can set it, as described in [features/logging.adoc#features.logging.log-levels](logging.md#features.logging.log-levels).
+The application version is determined using the implementation version from the main application class’s package.
+Startup information logging can be turned off by setting `spring.main.log-startup-info` to `false`.
+This will also turn off logging of the application’s active profiles.
+
+> [!TIP]
+> To add additional logging during startup, you can override `logStartupInfo(boolean)` in a subclass of [`SpringApplication`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/SpringApplication.html).
+
+ `
+> or running your application as a native image.
+>
+> To use the `application.*` properties, launch your application as a packed jar using `java -jar` or as an unpacked jar using `java org.springframework.boot.loader.launch.JarLauncher`.
+> This will initialize the `application.*` banner properties before building the classpath and launching your app.
+
+) {
+ runApplication(*args) {
+ setBannerMode(Banner.Mode.OFF)
+ }
+}
+
+```
+
+> [!NOTE]
+> The constructor arguments passed to [`SpringApplication`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/SpringApplication.html) are configuration sources for Spring beans.
+> In most cases, these are references to [`@Configuration`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Configuration.html) classes, but they could also be direct references [`@Component`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/stereotype/Component.html) classes.
+
+It is also possible to configure the [`SpringApplication`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/SpringApplication.html) by using an `application.properties` file.
+See [features/external-config.adoc](external-config.md) for details.
+
+For a complete list of the configuration options, see the [`SpringApplication`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/SpringApplication.html) API documentation.
+
+ event) {
+ switch (event.getState()) {
+ case ACCEPTING_TRAFFIC -> {
+ // create file /tmp/healthy
+ }
+ case REFUSING_TRAFFIC -> {
+ // remove file /tmp/healthy
+ }
+ }
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.availability.AvailabilityChangeEvent
+import org.springframework.boot.availability.ReadinessState
+import org.springframework.context.event.EventListener
+import org.springframework.stereotype.Component
+
+@Component
+class MyReadinessStateExporter {
+
+ @EventListener
+ fun onStateChange(event: AvailabilityChangeEvent) {
+ when (event.state) {
+ ReadinessState.ACCEPTING_TRAFFIC -> {
+ // create file /tmp/healthy
+ }
+ ReadinessState.REFUSING_TRAFFIC -> {
+ // remove file /tmp/healthy
+ }
+ else -> {
+ // ...
+ }
+ }
+ }
+
+}
+
+```
+
+We can also update the state of the application, when the application breaks and cannot recover:
+
+#### Java
+
+```java
+import org.springframework.boot.availability.AvailabilityChangeEvent;
+import org.springframework.boot.availability.LivenessState;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MyLocalCacheVerifier {
+
+ private final ApplicationEventPublisher eventPublisher;
+
+ public MyLocalCacheVerifier(ApplicationEventPublisher eventPublisher) {
+ this.eventPublisher = eventPublisher;
+ }
+
+ public void checkLocalCache() {
+ try {
+ // ...
+ }
+ catch (CacheCompletelyBrokenException ex) {
+ AvailabilityChangeEvent.publish(this.eventPublisher, ex, LivenessState.BROKEN);
+ }
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.availability.AvailabilityChangeEvent
+import org.springframework.boot.availability.LivenessState
+import org.springframework.context.ApplicationEventPublisher
+import org.springframework.stereotype.Component
+
+@Component
+class MyLocalCacheVerifier(private val eventPublisher: ApplicationEventPublisher) {
+
+ fun checkLocalCache() {
+ try {
+ // ...
+ } catch (ex: CacheCompletelyBrokenException) {
+ AvailabilityChangeEvent.publish(eventPublisher, ex, LivenessState.BROKEN)
+ }
+ }
+
+}
+
+```
+
+Spring Boot provides [Kubernetes HTTP probes for "Liveness" and "Readiness" with Actuator Health Endpoints](../actuator/endpoints.md#actuator.endpoints.kubernetes-probes).
+You can get more guidance about [deploying Spring Boot applications on Kubernetes in the dedicated section](../../how-to/deployment/cloud.md#howto.deployment.cloud.kubernetes).
+
+ files = args.getNonOptionArgs();
+ if (debug) {
+ System.out.println(files);
+ }
+ // if run with "--debug logfile.txt" prints ["logfile.txt"]
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.ApplicationArguments
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(args: ApplicationArguments) {
+
+ init {
+ val debug = args.containsOption("debug")
+ val files = args.nonOptionArgs
+ if (debug) {
+ println(files)
+ }
+ // if run with "--debug logfile.txt" prints ["logfile.txt"]
+ }
+
+}
+
+```
+
+> [!TIP]
+> Spring Boot also registers a [`CommandLinePropertySource`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/CommandLinePropertySource.html) with the Spring [`Environment`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/env/Environment.html).
+> This lets you also inject single application arguments by using the [`@Value`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/annotation/Value.html) annotation.
+
+) {
+ exitProcess(SpringApplication.exit(
+ runApplication(*args)))
+}
+
+```
+
+Also, the [`ExitCodeGenerator`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/ExitCodeGenerator.html) interface may be implemented by exceptions.
+When such an exception is encountered, Spring Boot returns the exit code provided by the implemented `getExitCode()` method.
+
+If there is more than one [`ExitCodeGenerator`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/ExitCodeGenerator.html), the first non-zero exit code that is generated is used.
+To control the order in which the generators are called, additionally implement the [`Ordered`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/Ordered.html) interface or use the [`Order`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/annotation/Order.html) annotation.
+
+) {
+ runApplication(*args) {
+ applicationStartup = BufferingApplicationStartup(2048)
+ }
+}
+
+```
+
+The first available implementation, [`FlightRecorderApplicationStartup`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/metrics/jfr/FlightRecorderApplicationStartup.html) is provided by Spring Framework.
+It adds Spring-specific startup events to a Java Flight Recorder session and is meant for profiling applications and correlating their Spring context lifecycle with JVM events (such as allocations, GCs, class loading…).
+Once configured, you can record data by running the application with the Flight Recorder enabled:
+
+```shell
+$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jar
+```
+
+Spring Boot ships with the [`BufferingApplicationStartup`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartup.html) variant; this implementation is meant for buffering the startup steps and draining them into an external metrics system.
+Applications can ask for the bean of type [`BufferingApplicationStartup`](https://docs.spring.io/spring-boot/3.5.4/api/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartup.html) in any component.
+
+Spring Boot can also be configured to expose a [`startup` endpoint](https://docs.spring.io/spring-boot/3.5.4/api/rest/actuator/startup.html) that provides this information as a JSON document.
+
+ cacheManagerCustomizer() {
+ return (cacheManager) -> cacheManager.setAllowNullValues(false);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizer
+import org.springframework.cache.concurrent.ConcurrentMapCacheManager
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration(proxyBeanMethods = false)
+class MyCacheManagerConfiguration {
+
+ @Bean
+ fun cacheManagerCustomizer(): CacheManagerCustomizer {
+ return CacheManagerCustomizer { cacheManager ->
+ cacheManager.isAllowNullValues = false
+ }
+ }
+
+}
+
+```
+
+> [!NOTE]
+> In the preceding example, an auto-configured [`ConcurrentMapCacheManager`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/cache/concurrent/ConcurrentMapCacheManager.html) is expected.
+> If that is not the case (either you provided your own config or a different cache provider was auto-configured), the customizer is not invoked at all.
+> You can have as many customizers as you want, and you can also order them by using [`@Order`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/annotation/Order.html) or [`Ordered`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/core/Ordered.html).
+
+`.
+The auto-configuration ignores any other generic type.
+
+ someRestCall(String name) {
+ return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.stereotype.Service
+import org.springframework.web.reactive.function.client.WebClient
+import reactor.core.publisher.Mono
+
+@Service
+class MyService(webClientBuilder: WebClient.Builder) {
+
+ private val webClient: WebClient
+
+ init {
+ webClient = webClientBuilder.baseUrl("https://example.org").build()
+ }
+
+ fun someRestCall(name: String?): Mono {
+ return webClient.get().uri("/{name}/details", name)
+ .retrieve().bodyToMono(Details::class.java)
+ }
+
+}
+
+```
+
+ someRestCall(String name) {
+ return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientSsl
+import org.springframework.stereotype.Service
+import org.springframework.web.reactive.function.client.WebClient
+import reactor.core.publisher.Mono
+
+@Service
+class MyService(webClientBuilder: WebClient.Builder, ssl: WebClientSsl) {
+
+ private val webClient: WebClient
+
+ init {
+ webClient = webClientBuilder.baseUrl("https://example.org")
+ .apply(ssl.fromBundle("mybundle")).build()
+ }
+
+ fun someRestCall(name: String?): Mono {
+ return webClient.get().uri("/{name}/details", name)
+ .retrieve().bodyToMono(Details::class.java)
+ }
+
+}
+
+```
+
+ kafkaTemplate;
+
+ public MyBean(KafkaTemplate kafkaTemplate) {
+ this.kafkaTemplate = kafkaTemplate;
+ }
+ public void someMethod() {
+ this.kafkaTemplate.send("someTopic", "Hello");
+ }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.kafka.core.KafkaTemplate
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val kafkaTemplate: KafkaTemplate) {
+ fun someMethod() {
+ kafkaTemplate.send("someTopic", "Hello")
+ }
+}
+
+```
+
+> [!NOTE]
+> If the property `spring.kafka.producer.transaction-id-prefix` is defined, a [`KafkaTransactionManager`](https://docs.spring.io/spring-kafka/docs/3.3.x/api/org/springframework/kafka/transaction/KafkaTransactionManager.html) is automatically configured.
+> Also, if a [`RecordMessageConverter`](https://docs.spring.io/spring-kafka/docs/3.3.x/api/org/springframework/kafka/support/converter/RecordMessageConverter.html) bean is defined, it is automatically associated to the auto-configured [`KafkaTemplate`](https://docs.spring.io/spring-kafka/docs/3.3.x/api/org/springframework/kafka/core/KafkaTemplate.html).
+
+ kStream(StreamsBuilder streamsBuilder) {
+ KStream stream = streamsBuilder.stream("ks1In");
+ stream.map(this::uppercaseValue).to("ks1Out", Produced.with(Serdes.Integer(), new JsonSerde<>()));
+ return stream;
+ }
+
+ private KeyValue uppercaseValue(Integer key, String value) {
+ return new KeyValue<>(key, value.toUpperCase(Locale.getDefault()));
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.apache.kafka.common.serialization.Serdes
+import org.apache.kafka.streams.KeyValue
+import org.apache.kafka.streams.StreamsBuilder
+import org.apache.kafka.streams.kstream.KStream
+import org.apache.kafka.streams.kstream.Produced
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.kafka.annotation.EnableKafkaStreams
+import org.springframework.kafka.support.serializer.JsonSerde
+
+@Configuration(proxyBeanMethods = false)
+@EnableKafkaStreams
+class MyKafkaStreamsConfiguration {
+
+ @Bean
+ fun kStream(streamsBuilder: StreamsBuilder): KStream {
+ val stream = streamsBuilder.stream("ks1In")
+ stream.map(this::uppercaseValue).to("ks1Out", Produced.with(Serdes.Integer(), JsonSerde()))
+ return stream
+ }
+
+ private fun uppercaseValue(key: Int, value: String): KeyValue {
+ return KeyValue(key, value.uppercase())
+ }
+
+}
+
+```
+
+By default, the streams managed by the [`StreamsBuilder`](https://kafka.apache.org/39/javadoc/org/apache/kafka/streams/StreamsBuilder.html) object are started automatically.
+You can customize this behavior using the `spring.kafka.streams.auto-startup` property.
+
+:`.
+
+If you need more control over the configuration, consider registering one or more [`PulsarAdminBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/PulsarAdminBuilderCustomizer.html) beans.
+
+ pulsarTemplate;
+
+ public MyBean(PulsarTemplate pulsarTemplate) {
+ this.pulsarTemplate = pulsarTemplate;
+ }
+
+ public void someMethod() {
+ this.pulsarTemplate.send("someTopic", "Hello");
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.apache.pulsar.client.api.PulsarClientException
+import org.springframework.pulsar.core.PulsarTemplate
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val pulsarTemplate: PulsarTemplate) {
+
+ @Throws(PulsarClientException::class)
+ fun someMethod() {
+ pulsarTemplate.send("someTopic", "Hello")
+ }
+
+}
+
+```
+
+The [`PulsarTemplate`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/PulsarTemplate.html) relies on a [`PulsarProducerFactory`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/PulsarProducerFactory.html) to create the underlying Pulsar producer.
+Spring Boot auto-configuration also provides this producer factory, which by default, caches the producers that it creates.
+You can configure the producer factory and cache settings by specifying any of the `spring.pulsar.producer.*` and `spring.pulsar.producer.cache.*` prefixed application properties.
+
+If you need more control over the producer factory configuration, consider registering one or more [`ProducerBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/ProducerBuilderCustomizer.html) beans.
+These customizers are applied to all created producers.
+You can also pass in a [`ProducerBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/ProducerBuilderCustomizer.html) when sending a message to only affect the current producer.
+
+If you need more control over the message being sent, you can pass in a [`TypedMessageBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/core/TypedMessageBuilderCustomizer.html) when sending a message.
+
+ pulsarTemplate;
+
+ public MyBean(ReactivePulsarTemplate pulsarTemplate) {
+ this.pulsarTemplate = pulsarTemplate;
+ }
+
+ public void someMethod() {
+ this.pulsarTemplate.send("someTopic", "Hello").subscribe();
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.pulsar.reactive.core.ReactivePulsarTemplate
+import org.springframework.stereotype.Component
+
+@Component
+class MyBean(private val pulsarTemplate: ReactivePulsarTemplate) {
+
+ fun someMethod() {
+ pulsarTemplate.send("someTopic", "Hello").subscribe()
+ }
+
+}
+
+```
+
+The [`ReactivePulsarTemplate`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactivePulsarTemplate.html) relies on a [`ReactivePulsarSenderFactory`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactivePulsarSenderFactory.html) to actually create the underlying sender.
+Spring Boot auto-configuration also provides this sender factory, which by default, caches the producers that it creates.
+You can configure the sender factory and cache settings by specifying any of the `spring.pulsar.producer.*` and `spring.pulsar.producer.cache.*` prefixed application properties.
+
+If you need more control over the sender factory configuration, consider registering one or more [`ReactiveMessageSenderBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageSenderBuilderCustomizer.html) beans.
+These customizers are applied to all created senders.
+You can also pass in a [`ReactiveMessageSenderBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageSenderBuilderCustomizer.html) when sending a message to only affect the current sender.
+
+If you need more control over the message being sent, you can pass in a [`MessageSpecBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/MessageSpecBuilderCustomizer.html) when sending a message.
+
+>` beans.
+
+ processMessage(String content) {
+ // ...
+ return Mono.empty();
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.pulsar.reactive.config.annotation.ReactivePulsarListener
+import org.springframework.stereotype.Component
+import reactor.core.publisher.Mono
+
+@Component
+class MyBean {
+
+ @ReactivePulsarListener(topics = ["someTopic"])
+ fun processMessage(content: String?): Mono {
+ // ...
+ return Mono.empty()
+ }
+
+}
+
+```
+
+Spring Boot auto-configuration provides all the components necessary for [`ReactivePulsarListener`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/config/annotation/ReactivePulsarListener.html), such as the [`ReactivePulsarListenerContainerFactory`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/config/ReactivePulsarListenerContainerFactory.html) and the consumer factory it uses to construct the underlying reactive Pulsar consumers.
+You can configure these components by specifying any of the `spring.pulsar.listener.*` and `spring.pulsar.consumer.*` prefixed application properties.
+
+If you need more control over the configuration of the consumer factory, consider registering one or more [`ReactiveMessageConsumerBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageConsumerBuilderCustomizer.html) beans.
+These customizers are applied to all consumers created by the factory, and therefore all [`@ReactivePulsarListener`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/config/annotation/ReactivePulsarListener.html) instances.
+You can also customize a single listener by setting the `consumerCustomizer` attribute of the [`@ReactivePulsarListener`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/config/annotation/ReactivePulsarListener.html) annotation.
+
+If you need more control over the actual container factory configuration, consider registering one or more `PulsarContainerFactoryCustomizer>` beans.
+
+>` beans.
+
+ pulsarReaderFactory;
+
+ public MyBean(ReactivePulsarReaderFactory pulsarReaderFactory) {
+ this.pulsarReaderFactory = pulsarReaderFactory;
+ }
+
+ public void someMethod() {
+ ReactiveMessageReaderBuilderCustomizer readerBuilderCustomizer = (readerBuilder) -> readerBuilder
+ .topic("someTopic")
+ .startAtSpec(StartAtSpec.ofInstant(Instant.now().minusSeconds(5)));
+ Mono> message = this.pulsarReaderFactory
+ .createReader(Schema.STRING, List.of(readerBuilderCustomizer))
+ .readOne();
+ // ...
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.apache.pulsar.client.api.Schema
+import org.apache.pulsar.reactive.client.api.ReactiveMessageReaderBuilder
+import org.apache.pulsar.reactive.client.api.StartAtSpec
+import org.springframework.pulsar.reactive.core.ReactiveMessageReaderBuilderCustomizer
+import org.springframework.pulsar.reactive.core.ReactivePulsarReaderFactory
+import org.springframework.stereotype.Component
+import java.time.Instant
+
+@Component
+class MyBean(private val pulsarReaderFactory: ReactivePulsarReaderFactory) {
+
+ fun someMethod() {
+ val readerBuilderCustomizer = ReactiveMessageReaderBuilderCustomizer {
+ readerBuilder: ReactiveMessageReaderBuilder ->
+ readerBuilder
+ .topic("someTopic")
+ .startAtSpec(StartAtSpec.ofInstant(Instant.now().minusSeconds(5)))
+ }
+ val message = pulsarReaderFactory
+ .createReader(Schema.STRING, listOf(readerBuilderCustomizer))
+ .readOne()
+ // ...
+ }
+
+}
+
+```
+
+Spring Boot auto-configuration provides this reader factory which can be customized by setting any of the `spring.pulsar.reader.*` prefixed application properties.
+
+If you need more control over the reader factory configuration, consider passing in one or more [`ReactiveMessageReaderBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageReaderBuilderCustomizer.html) instances when using the factory to create a reader.
+
+If you need more control over the reader factory configuration, consider registering one or more [`ReactiveMessageReaderBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageReaderBuilderCustomizer.html) beans.
+These customizers are applied to all created readers.
+You can also pass one or more [`ReactiveMessageReaderBuilderCustomizer`](https://docs.spring.io/spring-pulsar/docs/1.2.x/api/org/springframework/pulsar/reactive/core/ReactiveMessageReaderBuilderCustomizer.html) when creating a reader to only apply the customizations to the created reader.
+
+> [!TIP]
+> For more details on any of the above components and to discover other available features, see the Spring for Apache Pulsar [reference documentation](https://docs.spring.io/spring-pulsar/docs/1.2.x/reference).
+
+ someRSocketCall(String name) {
+ return this.rsocketRequester.route("user").data(name).retrieveMono(User.class);
+ }
+
+}
+```
+
+#### Kotlin
+
+```kotlin
+import org.springframework.messaging.rsocket.RSocketRequester
+import org.springframework.stereotype.Service
+import reactor.core.publisher.Mono
+
+@Service
+class MyService(rsocketRequesterBuilder: RSocketRequester.Builder) {
+
+ private val rsocketRequester: RSocketRequester
+
+ init {
+ rsocketRequester = rsocketRequesterBuilder.tcp("example.org", 9898)
+ }
+
+ fun someRSocketCall(name: String): Mono {
+ return rsocketRequester.route("user").data(name).retrieveMono(
+ User::class.java
+ )
+ }
+
+}
+
+```
diff --git a/markdown/boot/3.5.4/reference/messaging/spring-integration.md b/markdown/boot/3.5.4/reference/messaging/spring-integration.md
new file mode 100644
index 0000000..53ce731
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/messaging/spring-integration.md
@@ -0,0 +1,77 @@
+---
+title: "Spring Integration"
+source: "reference:messaging/spring-integration.adoc"
+---
+
+
+ jakarta.websocket
+ jakarta.websocket-api
+
+```
diff --git a/markdown/boot/3.5.4/reference/packaging/aot.md b/markdown/boot/3.5.4/reference/packaging/aot.md
new file mode 100644
index 0000000..5f3e5d3
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/packaging/aot.md
@@ -0,0 +1,41 @@
+---
+title: "Ahead-of-Time Processing With the JVM"
+source: "reference:packaging/aot.adoc"
+---
+
+
+- "snapshot-dependencies":
+ - BOOT-INF/lib/library3-SNAPSHOT.jar
+- "application":
+ - META-INF/MANIFEST.MF
+ - BOOT-INF/classes/a/b/C.class
+```
+
+This layering is designed to separate code based on how likely it is to change between application builds.
+Library code is less likely to change between builds, so it is placed in its own layers to allow tooling to re-use the layers from cache.
+Application code is more likely to change between builds so it is isolated in a separate layer.
+
+Spring Boot also supports layering for war files with the help of a `layers.idx`.
+
+For Maven, see the [packaging layered jar or war section](https://docs.spring.io/spring-boot/3.5.4/maven-plugin/packaging.html#packaging.layers) for more details on adding a layer index to the archive.
+For Gradle, see the [packaging layered jar or war section](https://docs.spring.io/spring-boot/3.5.4/gradle-plugin/packaging.html#packaging-executable.configuring.layered-archives) of the Gradle plugin documentation.
diff --git a/markdown/boot/3.5.4/reference/packaging/container-images/index.md b/markdown/boot/3.5.4/reference/packaging/container-images/index.md
new file mode 100644
index 0000000..c2a15ca
--- /dev/null
+++ b/markdown/boot/3.5.4/reference/packaging/container-images/index.md
@@ -0,0 +1,10 @@
+---
+title: "Container Images"
+source: "reference:packaging/container-images/index.adoc"
+---
+
+ getMyBeanInstanceSupplier() {
+ return BeanInstanceSupplier.forFactoryMethod(MyConfiguration.class, "myBean")
+ .withGenerator((registeredBean) -> registeredBean.getBeanFactory().getBean(MyConfiguration.class).myBean());
+ }
+
+ /**
+ * Get the bean definition for 'myBean'.
+ */
+ public static BeanDefinition getMyBeanBeanDefinition() {
+ Class beanType = MyBean.class;
+ RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
+ beanDefinition.setInstanceSupplier(getMyBeanInstanceSupplier());
+ return beanDefinition;
+ }
+
+}
+```
+
+> [!NOTE]
+> The exact code generated may differ depending on the nature of your bean definitions.
+
+You can see above that the generated code creates equivalent bean definitions to the [`@Configuration`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/annotation/Configuration.html) class, but in a direct way that can be understood by GraalVM.
+
+There is a bean definition for the `myConfiguration` bean, and one for `myBean`.
+When a `myBean` instance is required, a [`BeanInstanceSupplier`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/aot/BeanInstanceSupplier.html) is called.
+This supplier will invoke the `myBean()` method on the `myConfiguration` bean.
+
+> [!NOTE]
+> During Spring AOT processing, your application is started up to the point that bean definitions are available.
+> Bean instances are not created during the AOT processing phase.
+
+Spring AOT will generate code like this for all your bean definitions.
+It will also generate code when bean post-processing is required (for example, to call [`@Autowired`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/beans/factory/annotation/Autowired.html) methods).
+An [`ApplicationContextInitializer`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/ApplicationContextInitializer.html) will also be generated which will be used by Spring Boot to initialize the [`ApplicationContext`](https://docs.spring.io/spring-framework/docs/6.2.x/javadoc-api/org/springframework/context/ApplicationContext.html) when an AOT processed application is actually run.
+
+> [!TIP]
+> Although AOT generated source code can be verbose, it is quite readable and can be helpful when debugging an application.
+> Generated source files can be found in `target/spring-aot/main/sources` when using Maven and `build/generated/aotSources` with Gradle.
+
+
+> org.junit.vintage
+> junit-vintage-engine
+> test
+>
+>