### start

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartup.html

Starts a new startup step with the given name.

```APIDOC
## start(String name)

### Description
Starts a new startup step with the given name.

### Method
`start` in interface `ApplicationStartup`
```

--------------------------------

### start()

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/web/embedded/netty/NettyWebServer.html

Starts the web server. Calling this method on an already started server has no effect.

```APIDOC
## start()

### Description
Starts the web server. Calling this method on an already started server has no effect.

### Method
public void start() throws WebServerException

### Throws
* `WebServerException` - if the server cannot be started
```

--------------------------------

### start

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/buildpack/platform/build/AbstractBuildLog.html

Logs that a build is starting. This method is part of the `BuildLog` interface.

```APIDOC
## start

### Description
Logs that a build is starting.

### Method
`public void start(BuildRequest request)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **request** (`BuildRequest`) - The build request.
```

--------------------------------

### Startup Failure Message Example

Source: https://docs.spring.io/spring-boot/3.5/reference/features/spring-application.html

Example of a startup failure message when a port is already in use. It provides a description of the problem and an action to resolve it.

```text
***************************
APPLICATION FAILED TO START
***************************

Description:

Embedded servlet container failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that is listening on port 8080 or configure this application to listen on another port.
```

--------------------------------

### start()

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/rsocket/netty/NettyRSocketServer.html

Starts the RSocket server. If the server is already running, this method has no effect.

```APIDOC
## start()

### Description
Starts the RSocket server. If the server is already running, this method has no effect.

### Method
POST

### Endpoint
N/A (Instance Method)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
- Not applicable for this method.

### Response
#### Success Response (200)
- No specific response body defined for success.

#### Error Response
- **RSocketServerException** - Thrown if the server cannot be started.
```

--------------------------------

### Start init.d Service on Debian-based Systems

Source: https://docs.spring.io/spring-boot/3.5/how-to/deployment/installing.html

This command starts the 'myapp' service using the init.d system on Debian-based Linux distributions.

```bash
$ service myapp start
```

--------------------------------

### Install Spring Boot CLI with SDKMAN!

Source: https://docs.spring.io/spring-boot/3.5/installing.html

Installs the Spring Boot CLI using SDKMAN!. Use this to manage multiple SDK versions.

```bash
$ sdk install springboot
$ spring --version
```

--------------------------------

### RSocketServerBootstrap

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

Bootstrap an `RSocketServer` and start it with the application context. This class is responsible for bootstrapping and starting RSocket servers.

```APIDOC
## RSocketServerBootstrap

### Description
Bootstrap an `RSocketServer` and start it with the application context. This class is responsible for bootstrapping and starting RSocket servers.

### Class
RSocketServerBootstrap
```

--------------------------------

### Check Gradle Installation

Source: https://docs.spring.io/spring-boot/3.5/tutorial/first-application/index.html

Verify that Gradle is installed and display its version information. Run this command in your terminal.

```bash
$ gradle --version

------------------------------------------------------------
Gradle 8.14.4
------------------------------------------------------------

Build time:    2026-01-23 16:30:23 UTC
Revision:      ad5ff774b4b0e9a8a0cf1a14ca70d7230003c3ad

Kotlin:        2.0.21
Groovy:        3.0.25
Ant:           Apache Ant(TM) version 1.10.15 compiled on August 25 2024
Launcher JVM:  17.0.18 (BellSoft 17.0.18+10-LTS)
Daemon JVM:    /Users/developer/.sdkman/candidates/java/17.0.18-librca (no JDK specified, using current Java home)
OS:            Mac OS X 26.3 aarch64
```

--------------------------------

### Start Ant with -lib Option

Source: https://docs.spring.io/spring-boot/3.5/build-tool-plugin/antlib.html

Ensure Ant is started with the -lib option pointing to the directory containing the spring-boot-antlib JAR.

```bash
$ ant -lib <directory containing spring-boot-antlib-3.5.15.jar>
```

--------------------------------

### Install Spring Boot CLI with Scoop

Source: https://docs.spring.io/spring-boot/3.5/installing.html

Installs the Spring Boot CLI on Windows using Scoop. Ensure your Scoop extras bucket is up-to-date.

```bash
$ scoop bucket add extras
$ scoop install springboot
```

--------------------------------

### Obtain JdkClientHttpConnectorBuilder

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/http/client/reactive/class-use/JdkClientHttpConnectorBuilder.html

Demonstrates how to get a JdkClientHttpConnectorBuilder instance to start configuring a JdkClientHttpConnector.

```APIDOC
## Obtain JdkClientHttpConnectorBuilder

### Description
Use the static `jdk()` method on `ClientHttpConnectorBuilder` to obtain a `JdkClientHttpConnectorBuilder`.

### Method
`static JdkClientHttpConnectorBuilder`

### Usage
```java
ClientHttpConnectorBuilder.jdk()
```
```

--------------------------------

### Retrieve Application Startup Steps Snapshot

Source: https://docs.spring.io/spring-boot/3.5/api/rest/actuator/startup.html

Use this GET request to retrieve the startup steps recorded so far. This provides a snapshot of the initialization process.

```curl
$ curl 'http://localhost:8080/actuator/startup' -i -X GET
```

--------------------------------

### ConnectorStartFailedException

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

A `ConnectorStartFailedException` is thrown when a Tomcat `Connector` fails to start, for example due to a port clash or incorrect SSL configuration.

```APIDOC
## ConnectorStartFailedException

### Description
Thrown when a Tomcat `Connector` fails to start. This can occur due to issues like port clashes or incorrect SSL configuration.

### Exception
`ConnectorStartFailedException`
```

--------------------------------

### BufferingApplicationStartup Constructor

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartup.html

Creates a new buffered ApplicationStartup with a limited capacity and starts the recording of steps.

```APIDOC
## BufferingApplicationStartup(int capacity)

### Description
Create a new buffered `ApplicationStartup` with a limited capacity and starts the recording of steps.

### Parameters
#### Path Parameters
- **capacity** (int) - The configured capacity; once reached, new steps are not recorded.
```

--------------------------------

### Spring CLI Help for 'init' command

Source: https://docs.spring.io/spring-boot/3.5/cli/using-the-cli.html

Shows detailed usage, options, and examples for the 'spring init' command, which initializes a new Spring Boot project.

```bash
$ 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 <String>   Project coordinates; infer archive name (for
                               example 'test')
-b, --boot-version <String>  Spring Boot version (for example '1.2.0.RELEASE')
--build <String>             Build system to use (for example 'maven' or
                               'gradle') (default: maven)
-d, --dependencies <String>  Comma-separated list of dependency identifiers to
                               include in the generated project
--description <String>       Project description
-f, --force                  Force overwrite of existing files
--format <String>            Format of the generated content (for example
                               'build' for a build file, 'project' for a
                               project archive) (default: project)
-g, --group-id <String>      Project coordinates (for example 'org.test')
-j, --java-version <String>  Language level (for example '1.8')
-l, --language <String>      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 <String>          Project name; infer application name
-p, --packaging <String>     Project packaging (for example 'jar')
--package-name <String>      Package name
-t, --type <String>          Project type. Not normally needed if you use --
                               build and/or --format. Check the capabilities of
                               the service (--list) for more details
--target <String>            URL of the service to use (default: https://start.
                               spring.io)
-v, --version <String>       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

```

--------------------------------

### WebClient Example in Java

Source: https://docs.spring.io/spring-boot/3.5/reference/io/rest-client.html

Demonstrates how to inject and use a pre-configured WebClient.Builder to create a WebClient instance for making GET requests.

```java
import reactor.core.publisher.Mono;

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class MyService {

	private final WebClient webClient;

	public MyService(WebClient.Builder webClientBuilder) {
		this.webClient = webClientBuilder.baseUrl("https://example.org").build();
	}

	public Mono<Details> someRestCall(String name) {
		return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
	}

}
```

--------------------------------

### getStartLogMessage Method

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/web/embedded/undertow/UndertowServletWebServer.html

Protected method to get the log message displayed when the server starts. Overrides the method from the parent UndertowWebServer class.

```APIDOC
## getStartLogMessage()

### Description
Gets the log message displayed when the server starts. This method overrides the `getStartLogMessage` method in the `UndertowWebServer` class.

### Method
protected String

### Overrides
`getStartLogMessage` in class `UndertowWebServer`
```

--------------------------------

### Application Startup Steps Snapshot Response

Source: https://docs.spring.io/spring-boot/3.5/api/rest/actuator/startup.html

The response to a GET request to /actuator/startup contains detailed information about the application's startup timeline and events.

```json
HTTP/1.1 200 OK
Content-Type: application/vnd.spring-boot.actuator.v3+json
Content-Length: 890

{
  "springBootVersion" : "3.5.15",
  "timeline" : {
    "startTime" : "2026-06-10T17:21:35.778332712Z",
    "events" : [ { 
      "endTime" : "2026-06-10T17:21:35.974801069Z",
      "duration" : "PT0.000006051S",
      "startTime" : "2026-06-10T17:21:35.974795018Z",
      "startupStep" : {
        "name" : "spring.beans.instantiate",
        "id" : 3,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ],
        "parentId" : 2
      }
    }, { 
      "endTime" : "2026-06-10T17:21:35.974810877Z",
      "duration" : "PT0.000022913S",
      "startTime" : "2026-06-10T17:21:35.974787964Z",
      "startupStep" : {
        "name" : "spring.boot.application.starting",
        "id" : 2,
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ]
  }
}
```

--------------------------------

### List Available Capabilities of start.spring.io

Source: https://docs.spring.io/spring-boot/3.5/cli/using-the-cli.html

Lists all available dependencies, project types, and other capabilities offered by the start.spring.io service. This helps in understanding the options for project generation.

```bash
$ spring init --list
=======================================
Capabilities of https://start.spring.io
=======================================

Available dependencies:
-----------------------
actuator - Actuator: Production ready features to help you monitor and manage your application
...
web - Web: Support for full-stack web development, including Tomcat and spring-webmvc
websocket - Websocket: Support for WebSocket development
ws - WS: Support for Spring Web Services

Available project types:
------------------------
gradle-build -  Gradle Config [format:build, build:gradle]
gradle-project -  Gradle Project [format:project, build:gradle]
maven-build -  Maven POM [format:build, build:maven]
maven-project -  Maven Project [format:project, build:maven] (default)

...
Copied!

```

--------------------------------

### WebClient Example in Kotlin

Source: https://docs.spring.io/spring-boot/3.5/reference/io/rest-client.html

Shows how to inject and use a pre-configured WebClient.Builder to create a WebClient instance for making GET requests in a Kotlin application.

```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<Details> {
		return webClient.get().uri("/{name}/details", name)
				.retrieve().bodyToMono(Details::class.java)
	}

}
```

--------------------------------

### Remote Spring Application Output

Source: https://docs.spring.io/spring-boot/3.5/reference/using/devtools.html

This is an example of the console output when the `RemoteSpringApplication` is running. It shows the application starting, active profiles, and the LiveReload server status.

```log
  .   ____          _                                              __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
 \/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
  '  |____| .__|_| |_|_| |_\[__ /===================================/_/_/_/
 :: Spring Boot Remote ::  (v3.5.15) 

2026-06-10T17:33:34.518Z  INFO 66691 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication v3.5.15 using Java 17.0.19 with PID 66691 (/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/3.5.15/spring-boot-devtools-3.5.15.jar started by myuser in /opt/apps/)
2026-06-10T17:33:34.541Z  INFO 66691 --- [           main] o.s.b.devtools.RemoteSpringApplication   : No active profile set, falling back to 1 default profile: "default"
2026-06-10T17:33:36.148Z  INFO 66691 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2026-06-10T17:33:36.368Z  INFO 66691 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 4.036 seconds (process running for 5.111)
Copied!

```

--------------------------------

### Retrieve a snapshot of Application Startup Steps

Source: https://docs.spring.io/spring-boot/3.5/api/rest/actuator/startup.html

Fetches the recorded steps during the application startup phase as a snapshot. This is done via a GET request.

```APIDOC
## GET /actuator/startup

### Description
Retrieves a snapshot of the steps recorded so far during the application startup phase.

### Method
GET

### Endpoint
/actuator/startup

### Response
#### Success Response (200)
- **springBootVersion** (string) - The version of Spring Boot.
- **timeline** (object) - Contains startup events.
  - **startTime** (string) - The timestamp when the startup process began.
  - **events** (array) - A list of startup events.
    - **endTime** (string) - The timestamp when the event ended.
    - **duration** (string) - The duration of the event in ISO 8601 format.
    - **startTime** (string) - The timestamp when the event started.
    - **startupStep** (object) - Details about the startup step.
      - **name** (string) - The name of the startup step.
      - **id** (integer) - The unique identifier for the startup step.
      - **tags** (array) - Optional tags associated with the startup step.
        - **key** (string) - The key of the tag.
        - **value** (string) - The value of the tag.
      - **parentId** (integer) - The ID of the parent startup step, if any.

### Response Example
{
  "springBootVersion" : "3.5.15",
  "timeline" : {
    "startTime" : "2026-06-10T17:21:35.778332712Z",
    "events" : [ {
      "endTime" : "2026-06-10T17:21:35.974801069Z",
      "duration" : "PT0.000006051S",
      "startTime" : "2026-06-10T17:21:35.974795018Z",
      "startupStep" : {
        "name" : "spring.beans.instantiate",
        "id" : 3,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ],
        "parentId" : 2
      }
    }, {
      "endTime" : "2026-06-10T17:21:35.974810877Z",
      "duration" : "PT0.000022913S",
      "startTime" : "2026-06-10T17:21:35.974787964Z",
      "startupStep" : {
        "name" : "spring.boot.application.starting",
        "id" : 2,
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ]
  }
}
```

--------------------------------

### Basic ApplicationContextRunner Setup

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/test/context/runner/AbstractApplicationContextRunner.html

Demonstrates how to initialize an ApplicationContextRunner with property values and user configurations for use in tests.

```java
public class MyContextTests {
    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
            .withPropertyValues("spring.foo=bar")
            .withUserConfiguration(MyConfiguration.class);
}
```

--------------------------------

### Kotlin @PulsarReader Example

Source: https://docs.spring.io/spring-boot/3.5/reference/messaging/pulsar.html

This Kotlin component demonstrates how to use the @PulsarReader annotation to consume messages from the 'someTopic' topic, starting from the earliest available message.

```kotlin
import org.springframework.pulsar.annotation.PulsarReader
import org.springframework.stereotype.Component

@Component
class MyBean {

	@PulsarReader(topics = ["someTopic"], startMessageId = "earliest")
	fun processMessage(content: String?) {
		// ...
	}

}
```

--------------------------------

### Java @PulsarReader Example

Source: https://docs.spring.io/spring-boot/3.5/reference/messaging/pulsar.html

This Java component demonstrates how to use the @PulsarReader annotation to consume messages from the 'someTopic' topic, starting from the earliest available message.

```java
import org.springframework.pulsar.annotation.PulsarReader;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	@PulsarReader(topics = "someTopic", startMessageId = "earliest")
	public void processMessage(String content) {
		// ...
	}

}
```

--------------------------------

### Creating an UP Health Status

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/actuate/health/Health.html

Provides a basic example of creating an UP health status using the Health.Builder. This is a common starting point for reporting healthy components.

```java
return Health.up().build();
```

--------------------------------

### GsonTester Initialization Example

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/test/json/GsonTester.html

Demonstrates how to initialize GsonTester fields within a test class using a Gson instance. This setup is typically done in a @Before method.

```java
public class ExampleObjectJsonTests {

    private GsonTester<ExampleObject> json;

    @Before
    public void setup() {
        Gson gson = new GsonBuilder().create();
        GsonTester.initFields(this, gson);
    }

    @Test
    public void testWriteJson() throws IOException {
        ExampleObject object = //...
        assertThat(json.write(object)).isEqualToJson("expected.json");
    }

 }
```

--------------------------------

### initialize

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/logging/AbstractLoggingSystem.html

Fully initializes the logging system with the provided context, configuration location, and log file.

```APIDOC
## initialize

### Description
Fully initialize the logging system.

### Signature
`public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)`

### Overrides
`initialize` in class `LoggingSystem`

### Parameters
* `initializationContext` (LoggingInitializationContext) - the logging initialization context
* `configLocation` (String) - a log configuration location or `null` if default initialization is required
* `logFile` (LogFile) - the log output file that should be written or `null` for console only output
```

--------------------------------

### Global CORS Configuration (Kotlin)

Source: https://docs.spring.io/spring-boot/3.5/reference/web/servlet.html

Configure global CORS mappings using Kotlin by registering a WebMvcConfigurer bean. This example maps all requests starting with /api/**.

```kotlin
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.web.servlet.config.annotation.CorsRegistry
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer

@Configuration(proxyBeanMethods = false)
class MyCorsConfiguration {

	@Bean
	fun corsConfigurer(): WebMvcConfigurer {
		return object : WebMvcConfigurer {
			override fun addCorsMappings(registry: CorsRegistry) {
				registry.addMapping("/api/**")
			}
		}
	}

}
```

--------------------------------

### Handling Context Startup Failures

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/test/context/runner/AbstractApplicationContextRunner.html

Illustrates how to run the context when startup is expected to fail and assert the nature of the failure using getFailure().

```java
@Test
public someTest() {
    this.context.withPropertyValues("spring.foo=fails").run((loaded) -> {
        assertThat(loaded).getFailure().hasCauseInstanceOf(BadPropertyException.class);
        // other assertions
    });
}
```

--------------------------------

### Global CORS Configuration (Java)

Source: https://docs.spring.io/spring-boot/3.5/reference/web/servlet.html

Configure global CORS mappings by registering a WebMvcConfigurer bean with a customized addCorsMappings method. This example maps all requests starting with /api/**.

```java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration(proxyBeanMethods = false)
public class MyCorsConfiguration {

	@Bean
	public WebMvcConfigurer corsConfigurer() {
		return new WebMvcConfigurer() {

			@Override
			public void addCorsMappings(CorsRegistry registry) {
				registry.addMapping("/api/**");
			}

		};
	}

}
```

--------------------------------

### Spring Boot Startup Log Output

Source: https://docs.spring.io/spring-boot/3.5/reference/features/spring-application.html

Example of the INFO level logging output when a Spring Boot application starts. This includes application details and server initialization.

```log
  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\[__] | / / / /
 =========|_|==============|___/=/_/_/_/

 :: Spring Boot ::               (v3.5.15)

2026-06-10T17:33:39.253Z  INFO 66769 --- [           main] o.s.b.d.f.logexample.MyApplication       : Starting MyApplication using Java 17.0.19 with PID 66769 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2026-06-10T17:33:39.277Z  INFO 66769 --- [           main] o.s.b.d.f.logexample.MyApplication       : No active profile set, falling back to 1 default profile: "default"
2026-06-10T17:33:43.135Z  INFO 66769 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2026-06-10T17:33:43.163Z  INFO 66769 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2026-06-10T17:33:43.164Z  INFO 66769 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.55]
2026-06-10T17:33:43.222Z  INFO 66769 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2026-06-10T17:33:43.224Z  INFO 66769 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3557 ms
2026-06-10T17:33:44.884Z  INFO 66769 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2026-06-10T17:33:44.957Z  INFO 66769 --- [           main] o.s.b.d.f.logexample.MyApplication       : Started MyApplication in 7.241 seconds (process running for 8.527)
2026-06-10T17:33:44.996Z  INFO 66769 --- [ionShutdownHook] o.s.b.w.e.tomcat.GracefulShutdown        : Commencing graceful shutdown. Waiting for active requests to complete
2026-06-10T17:33:45.069Z  INFO 66769 --- [tomcat-shutdown] o.s.b.w.e.tomcat.GracefulShutdown        : Graceful shutdown complete
```

--------------------------------

### launch(String[] args)

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/loader/launch/Launcher.html

Launch the application. This method is the initial entry point that should be called by a subclass public static void main(String[] args) method.

```APIDOC
## launch(String[] args)

### Description
Launch the application. This method is the initial entry point that should be called by a subclass `public static void main(String[] args)` method.

### Method
protected void launch(String[] args)

### Parameters
#### Path Parameters
- **args** (String[]) - the incoming arguments

### Throws
- `Exception` - if the application fails to launch

```

--------------------------------

### Retrieve Part of the Log File

Source: https://docs.spring.io/spring-boot/3.5/api/rest/actuator/logfile.html

Use a GET request to `/actuator/logfile` with the `Range` header to fetch a specific portion of the log file. This example retrieves the first 1024 bytes.

```bash
$ curl 'http://localhost:8080/actuator/logfile' -i -X GET \
    -H 'Range: bytes=0-1023'
```

--------------------------------

### Method: initialize

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/web/servlet/support/ServletContextApplicationContextInitializer.html

Initializes the provided ConfigurableWebApplicationContext with the configured servlet context.

```APIDOC
## Method: initialize

### Description
Initializes the given application context by applying the servlet context configuration.

### Parameters
#### Request Body
- **applicationContext** (ConfigurableWebApplicationContext) - Required - The application context to initialize.
```

--------------------------------

### applicationStartup(ApplicationStartup applicationStartup)

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/builder/SpringApplicationBuilder.html

Configures the `ApplicationStartup` to be used with the `ApplicationContext` for collecting startup metrics.

```APIDOC
## applicationStartup(ApplicationStartup applicationStartup)

### Description
Configures the `ApplicationStartup` to be used with the `ApplicationContext` for collecting startup metrics.

### Method
SpringApplicationBuilder

### Parameters
#### Path Parameters
- **applicationStartup** (ApplicationStartup) - the application startup to use

### Response
#### Success Response (200)
- **builder** (SpringApplicationBuilder) - the current builder

### Since
2.4.0
```

--------------------------------

### Define Router Functions for WebFlux

Source: https://docs.spring.io/spring-boot/3.5/reference/web/reactive.html

Example of defining router functions for handling HTTP requests in Spring WebFlux. This snippet shows how to map GET and DELETE requests to specific handler methods.

```kotlin
import org.springframework.context.annotation.Bean
import org.springframework.http.MediaType.APPLICATION_JSON
import org.springframework.web.reactive.function.server.*

@Configuration
class MyRouter { 

	@Bean
	fun router(userHandler: MyUserHandler): RouterFunction<ServerResponse> {
		return route(
			GET("{user}/customers").and(ACCEPT_JSON), userHandler::getUserCustomers).andRoute(
			DELETE("{user}").and(ACCEPT_JSON), userHandler::deleteUser)
	}

	companion object {
		private val ACCEPT_JSON = accept(APPLICATION_JSON)
	}

}
```

--------------------------------

### DockerComposeProperties.getStart()

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/docker/compose/lifecycle/class-use/DockerComposeProperties.Start.html

Retrieves the start configuration for Docker Compose.

```APIDOC
## DockerComposeProperties.getStart()

### Description
Returns the `DockerComposeProperties.Start` configuration, which defines how Docker Compose services should be started.

### Method
`DockerComposeProperties.Start` `getStart()`

### Returns
- `DockerComposeProperties.Start` - The start configuration object.
```

--------------------------------

### DockerCompose.start

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/docker/compose/core/DockerCompose.html

Runs `docker compose start` to start services. It waits until all containers are started and healthy.

```APIDOC
## start

### Description
Runs `docker compose start` to start services. Waits until all containers are started and healthy.

### Method
`void start(LogLevel logLevel)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## start

### Description
Runs `docker compose start` to start services. Waits until all containers are started and healthy.

### Method
`void start(LogLevel logLevel, List<String> arguments)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Start Container

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/buildpack/platform/docker/DockerApi.ContainerApi.html

Starts a specific Docker container.

```APIDOC
## POST /containers/{reference}/start

### Description
Starts a specific Docker container.

### Method
POST

### Endpoint
/containers/{reference}/start

### Parameters
#### Path Parameters
- **reference** (ContainerReference) - Required - The container reference to start.

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

### Throws
- `IOException` - on IO error
```

--------------------------------

### Enable init.d Service on Boot on Debian

Source: https://docs.spring.io/spring-boot/3.5/how-to/deployment/installing.html

Use this command on Debian systems to flag the 'myapp' service to start automatically during the system boot process. Replace <priority> with the desired startup order.

```bash
$ update-rc.d myapp defaults <priority>
```

--------------------------------

### Usage Example

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/test/system/OutputCaptureRule.html

Example of how to use the OutputCaptureRule in a JUnit test.

```APIDOC
## Usage Example

To use `OutputCaptureRule`, add it as a `@Rule` in your test class:

```java
import org.junit.Rule;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;

public class MyTest {

    @Rule
    public OutputCaptureRule output = new OutputCaptureRule();

    @Test
    public void test() {
        System.out.println("ok");
        assertThat(output.getOut()).contains("ok");
    }

}
```
```

--------------------------------

### Kotlin Spring Boot Web Application Setup

Source: https://docs.spring.io/spring-boot/3.5/how-to/deployment/traditional-deployment.html

This Kotlin code demonstrates setting up a Spring Boot web application by extending SpringBootServletInitializer and annotating with @SpringBootApplication. It's designed for creating a deployable WAR file.

```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.builder.SpringApplicationBuilder
import org.springframework.boot.runApplication
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer

@SpringBootApplication
class MyApplication : SpringBootServletInitializer() {

	override fun configure(application: SpringApplicationBuilder): SpringApplicationBuilder {
		// Customize the application or call application.sources(...) to add sources
		// Since our example is itself a @Configuration class (through @SpringBootApplication)
		// we actually do not need to override this method.
		return application
	}

}
```

--------------------------------

### logStartupInfo

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/builder/SpringApplicationBuilder.html

Flags to indicate if the startup information should be logged. Default is true.

```APIDOC
## logStartupInfo

### Description
Flag to indicate the startup information should be logged.

### Method
public SpringApplicationBuilder logStartupInfo(boolean logStartupInfo)

### Parameters
#### Path Parameters
- **logStartupInfo** (boolean) - Required - the flag to set. Default true.

### Returns
the current builder
```

--------------------------------

### StartCommand

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

Command used to start Docker Compose.

```APIDOC
## StartCommand

### Description
Command used to start Docker Compose.

### Class
StartCommand
```

--------------------------------

### WebServerSslBundle get

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/web/server/class-use/Ssl.html

Get the SslBundle that should be used for the given Ssl instance.

```APIDOC
## WebServerSslBundle get (Ssl ssl)

### Description
Get the `SslBundle` that should be used for the given `Ssl` instance.

### Method
`static SslBundle`

### Signature
`WebServerSslBundle.get(Ssl ssl)`

### Parameters
#### Path Parameters
- **ssl** (Ssl) - Required - The Ssl instance.
```

--------------------------------

### BufferingApplicationStartup

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

`ApplicationStartup` implementation that buffers `steps` and records their timestamp as well as their processing time.

```APIDOC
## BufferingApplicationStartup

### Description
`ApplicationStartup` implementation that buffers `steps` and records their timestamp as well as their processing time.

### Method
N/A

### Endpoint
N/A
```

--------------------------------

### onStartup Method

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/actuate/endpoint/web/ServletEndpointRegistrar.html

Configures the ServletContext for initialization. This method is deprecated and subject to removal.

```APIDOC
## onStartup Method

### Description
Deprecated, for removal: This API element is subject to removal in a future version.
Configure the given `ServletContext` with any servlets, filters, listeners context-params and attributes necessary for initialization.

### Signature
`void onStartup(ServletContext servletContext) throws ServletException`

### Parameters
* **servletContext** (ServletContext) - The `ServletContext` to initialize.

### Throws
* **ServletException** - if any call against the given `ServletContext` throws a `ServletException`.
```

--------------------------------

### Kotlin ConfigurationProperties Example

Source: https://docs.spring.io/spring-boot/3.5/specification/configuration-metadata/manual-hints.html

Example of a Kotlin class annotated with @ConfigurationProperties for a map.

```kotlin
import org.springframework.boot.context.properties.ConfigurationProperties

@ConfigurationProperties("my")
class MyProperties(val contexts: Map<String, Int>)
```

--------------------------------

### Enable FlightRecorderApplicationStartup

Source: https://docs.spring.io/spring-boot/3.5/reference/features/spring-application.html

Starts a Java Flight Recorder session to profile the application and correlate Spring context lifecycle with JVM events. The recording is saved to `recording.jfr` and lasts for 10 seconds.

```bash
$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jar
```

--------------------------------

### Java ConfigurationProperties Example

Source: https://docs.spring.io/spring-boot/3.5/specification/configuration-metadata/manual-hints.html

Example of a Java class annotated with @ConfigurationProperties for a map.

```java
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("my")
public class MyProperties {

	private Map<String, Integer> contexts;

	// getters/setters ...

	public Map<String, Integer> getContexts() {
		return this.contexts;
	}

	public void setContexts(Map<String, Integer> contexts) {
		this.contexts = contexts;
	}

}
```

--------------------------------

### Kotlin @ConfigurationProperties Example

Source: https://docs.spring.io/spring-boot/3.5/reference/features/external-config.html

Example of a Kotlin class annotated with @ConfigurationProperties for external configuration.

```kotlin
import org.springframework.boot.context.properties.ConfigurationProperties

@ConfigurationProperties("my.main-project.person")
class MyPersonProperties {

	var firstName: String? = null

}
```

--------------------------------

### StartupTimeline

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

Represents the timeline of steps recorded by BufferingApplicationStartup.

```APIDOC
## StartupTimeline

### Description
Represent the timeline of `steps` recorded by `BufferingApplicationStartup`.

### Class
StartupTimeline
```

--------------------------------

### Java @ConfigurationProperties Example

Source: https://docs.spring.io/spring-boot/3.5/reference/features/external-config.html

Example of a Java class annotated with @ConfigurationProperties for external configuration.

```java
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("my.main-project.person")
public class MyPersonProperties {

	private String firstName;

	public String getFirstName() {
		return this.firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

}
```

--------------------------------

### SpringApplication Bootstrap and Run

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/SpringApplication.html

Demonstrates the basic usage of SpringApplication.run() to bootstrap a Spring application from a Java main method.

```APIDOC
## SpringApplication Bootstrap and Run

### Description
This example shows how to bootstrap and launch a Spring application using the static `run` method of the `SpringApplication` class. This is the most common way to start a Spring Boot application.

### Method
`public static void run(Class<?> primarySource, String... args)`

### Endpoint
N/A (This is a static method call within a Java application)

### Request Example
```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);
  }
}
```

### Response
N/A (The application context is refreshed and beans are initialized.)

### Success Response (200)
N/A
```

--------------------------------

### WebServerSslBundle get with SslBundles

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/web/server/class-use/Ssl.html

Get the SslBundle that should be used for the given Ssl instance and SslBundles.

```APIDOC
## WebServerSslBundle get (Ssl ssl, SslBundles sslBundles)

### Description
Get the `SslBundle` that should be used for the given `Ssl` instance and `SslBundles`.

### Method
`static SslBundle`

### Signature
`WebServerSslBundle.get(Ssl ssl, SslBundles sslBundles)`

### Parameters
#### Path Parameters
- **ssl** (Ssl) - Required - The Ssl instance.
- **sslBundles** (SslBundles) - Required - The SslBundles instance.
```

--------------------------------

### GET - WebEndpointHttpMethod

Source: https://docs.spring.io/spring-boot/3.5/api/java/index-files/index-7.html

Represents an HTTP GET request. This is an enum constant in the WebEndpointHttpMethod enum.

```APIDOC
## GET - WebEndpointHttpMethod

### Description
An HTTP GET request.

### Enum Constant
org.springframework.boot.actuate.endpoint.web.WebEndpointHttpMethod

### Value
GET
```

--------------------------------

### StartupEndpoint.StartupDescriptor

Source: https://docs.spring.io/spring-boot/3.5/api/java/allclasses-index.html

Description of an application startup.

```APIDOC
## StartupEndpoint.StartupDescriptor

### Description
Description of an application startup.

### Class
StartupEndpoint.StartupDescriptor
```

--------------------------------

### Initialize a New Project with Dependencies

Source: https://docs.spring.io/spring-boot/3.5/cli/using-the-cli.html

Creates a new Maven-based project with specified dependencies like web and data-jpa. The project is extracted to a given directory.

```bash
$ spring init --dependencies=web,data-jpa my-project
Using service at https://start.spring.io
Project extracted to '/Users/developer/example/my-project'
Copied!

```

--------------------------------

### DockerCompose.up

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/docker/compose/core/DockerCompose.html

Runs `docker compose up` to create and start services. It waits until all containers are started and healthy.

```APIDOC
## up

### Description
Runs `docker compose up` to create and start services. Waits until all containers are started and healthy.

### Method
`void up(LogLevel logLevel)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## up

### Description
Runs `docker compose up` to create and start services. Waits until all containers are started and healthy.

### Method
`void up(LogLevel logLevel, List<String> arguments)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### get(PropertyResolver)

Source: https://docs.spring.io/spring-boot/3.5/api/java/index-files/index-7.html

Get a LogFile from the given Spring Environment. This is a static method in the LogFile class.

```APIDOC
## get(PropertyResolver)

### Description
Get a `LogFile` from the given Spring `Environment`.

### Method
Static method

### Class
org.springframework.boot.logging.LogFile

### Parameters
- **propertyResolver** (PropertyResolver) - Description not available
```

--------------------------------

### startRecording

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartup.html

Starts the recording of steps and marks the beginning of the StartupTimeline. This can be called to reset recording if no steps have been recorded yet.

```APIDOC
## startRecording()

### Description
Start the recording of steps and mark the beginning of the `StartupTimeline`. The class constructor already implicitly calls this, but it is possible to reset it as long as steps have not been recorded already.

### Throws
- IllegalStateException - if called and `StartupStep` have been recorded already.
```

--------------------------------

### BasicJsonTester Initialization Methods

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/test/json/BasicJsonTester.html

Details on how to initialize the BasicJsonTester with specific resource loading configurations.

```APIDOC
## Method Details

### initialize
protected final void initialize(Class<?> resourceLoadClass)
Initialize the marshal tester for use, configuring it to load JSON resources as UTF-8. 

Parameters:
    `resourceLoadClass` - the source class used when loading relative classpath resources

### initialize
protected final void initialize(Class<?> resourceLoadClass, Charset charset)
Initialize the marshal tester for use. 

Parameters:
    `resourceLoadClass` - the source class used when loading relative classpath resources     `charset` - the charset used when loading relative classpath resources 

Since:
    1.4.1
```

--------------------------------

### get(Environment)

Source: https://docs.spring.io/spring-boot/3.5/api/java/index-files/index-7.html

Get for all configuration property sources in the environment. This is a static method in the ConfigurationPropertyCaching interface.

```APIDOC
## get(Environment)

### Description
Get for all configuration property sources in the environment.

### Method
Static method

### Interface
org.springframework.boot.context.properties.source.ConfigurationPropertyCaching

### Parameters
- **environment** (Environment) - Description not available
```

--------------------------------

### Check Maven Installation

Source: https://docs.spring.io/spring-boot/3.5/tutorial/first-application/index.html

Confirm that Maven is installed and check its version. This command is executed in the terminal.

```bash
$ mvn -v
Apache Maven 3.9.12 (848fbb4bf2d427b72bdb2471c22fced7ebd9a7a1)
Maven home: /Users/developer/.sdkman/candidates/maven/current
Java version: 17.0.18, vendor: BellSoft, runtime: /Users/developer/.sdkman/candidates/java/17.0.18-librca
```

--------------------------------

### void initialize(BootstrapRegistry registry)

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/BootstrapRegistryInitializer.html

Initializes the provided BootstrapRegistry with required registrations.

```APIDOC
## void initialize(BootstrapRegistry registry)

### Description
Initialize the given BootstrapRegistry with any required registrations.

### Parameters
#### Method Parameters
- **registry** (BootstrapRegistry) - Required - The registry to initialize
```

--------------------------------

### Spring Boot Native Image Startup Log

Source: https://docs.spring.io/spring-boot/3.5/how-to/native-image/developing-your-first-application.html

Example output showing a fast startup time for a Spring Boot application compiled to a native image.

```text
  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\[__] | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v{version-spring-boot}) 
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.08 seconds (process running for 0.095)
```

--------------------------------

### Retrieve Conditions Report

Source: https://docs.spring.io/spring-boot/3.5/api/rest/actuator/conditions.html

Make a GET request to the /actuator/conditions endpoint to get the conditions evaluation report.

```APIDOC
## GET /actuator/conditions

### Description
Retrieves a report detailing the evaluation of conditions on configuration and auto-configuration classes.

### Method
GET

### Endpoint
/actuator/conditions

### Response
#### Success Response (200)
- **contexts** (object) - Contains the evaluation results for different application contexts.
  - **application** (object) - Results for the main application context.
    - **positiveMatches** (object) - Conditions that were met.
    - **negativeMatches** (object) - Conditions that were not met.
    - **unconditionalClasses** (array) - List of classes that were included unconditionally.

### Response Example
```json
{
  "contexts" : {
    "application" : {
      "positiveMatches" : {
        "EndpointAutoConfiguration#propertiesEndpointAccessResolver" : [
          {
            "condition" : "OnBeanCondition",
            "message" : "@ConditionalOnMissingBean (types: org.springframework.boot.actuate.endpoint.EndpointAccessResolver; SearchStrategy: all) did not find any beans"
          }
        ]
      },
      "negativeMatches" : {
        "WebFluxEndpointManagementContextConfiguration" : {
          "notMatched" : [
            {
              "condition" : "OnWebApplicationCondition",
              "message" : "not a reactive web application"
            }
          ],
          "matched" : [
            {
              "condition" : "OnClassCondition",
              "message" : "@ConditionalOnClass found required classes 'org.springframework.web.reactive.DispatcherHandler', 'org.springframework.http.server.reactive.HttpHandler'"
            }
          ]
        }
      },
      "unconditionalClasses" : [
        "org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration",
        "org.springframework.boot.actuate.autoconfigure.endpoint.EndpointAutoConfiguration"
      ]
    }
  }
}
```
```

--------------------------------

### HttpTransport GET Operation

Source: https://docs.spring.io/spring-boot/3.5/api/java/org/springframework/boot/buildpack/platform/docker/transport/class-use/HttpTransport.Response.html

Performs an HTTP GET operation on the specified URI. Returns an HttpTransport.Response object.

```APIDOC
## GET

### Description
Performs an HTTP GET operation.

### Method
GET

### Endpoint
`uri`

### Parameters
#### Path Parameters
- **uri** (URI) - Required - The URI to perform the GET operation on.

### Response
#### Success Response (200)
- **HttpTransport.Response** - The response from the GET operation.
```

--------------------------------

### YAML Configuration

Source: https://docs.spring.io/spring-boot/3.5/specification/configuration-metadata/format.html

Demonstrates the equivalent configuration of server port and address using YAML syntax.

```yaml
server:
  port: 9090
  address: 127.0.0.1
```

--------------------------------

### WarLauncher Manifest Example

Source: https://docs.spring.io/spring-boot/3.5/specification/executable-jar/launching.html

A typical MANIFEST.MF configuration for an executable war file using WarLauncher.

```java
Main-Class: org.springframework.boot.loader.launch.WarLauncher
Start-Class: com.mycompany.project.MyApplication
```

--------------------------------

### get(PropertySource<?>, String)

Source: https://docs.spring.io/spring-boot/3.5/api/java/index-files/index-7.html

Get an Origin for the given PropertySource and propertyName. This is a static method in the PropertySourceOrigin class.

```APIDOC
## get(PropertySource<?>, String)

### Description
Get an `Origin` for the given `PropertySource` and `propertyName`.

### Method
Static method

### Class
org.springframework.boot.origin.PropertySourceOrigin

### Parameters
- **propertySource** (PropertySource<?>) - Description not available
- **propertyName** (String) - Description not available
```