### start

Source: https://docs.spring.io/spring-boot/4.1.0/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.

### Specified by
`start` in interface `ApplicationStartup`

### Parameters
#### Path Parameters
- **name** (String) - Required - The name of the startup step.
```

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

### getStartTime

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/info/ProcessInfo.html

Gets the instant at which the process started, useful for tracking deployment and restart times.

```APIDOC
## getStartTime

### Description
Retrieves the time at which the process started. This information is valuable for understanding when the process was initiated and for tracking the timing of the last deployment or restart.

### Method
```java
public @Nullable Instant getStartTime()
```

### Returns
An `Instant` object representing the process start time, or `null` if it cannot be determined.

### Since
4.1.0
```

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

### Properties File Example

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

Example of external configuration properties in a .properties file format.

```properties
my.service.enabled=true
my.service.security.username=admin
```

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

### Launch Test Application (Kotlin)

Source: https://docs.spring.io/spring-boot/reference/features/dev-services.html

Create a test application class in `src/test` to launch the main application with test dependencies. This Kotlin example uses `fromApplication<…>()` to start the application.

```kotlin
import org.springframework.boot.fromApplication

fun main(args: Array<String>) {
	fromApplication<MyApplication>().run(*args)
}
```

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

### start

Source: https://docs.spring.io/spring-boot/4.1.0/api/java/org/springframework/boot/reactor/netty/NettyWebServer.html

Starts the web server. If the server is already started, this method has no effect.

```APIDOC
## start

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

### Method
`void start()`

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

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

### Spring Boot Native Application Startup Output

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

Example output indicating a Spring Boot native application has started successfully.

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

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

### JettyWebServer start() Method

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

The JettyWebServer implementation's start method can throw WebServerException.

```APIDOC
## JettyWebServer `start()`

### Description
Starts the Jetty embedded web server. This method may throw a `WebServerException` if the server fails to start.

### Method
`void start()`
```

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

### Basic ApplicationContextRunner Setup

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

Demonstrates how to initialize an ApplicationContextRunner with common properties and user configurations. This setup is shared across multiple tests.

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

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

### YAML File Example

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

Example of external configuration properties in a YAML file format.

```yaml
my:
  service:
    enabled: true
    security:
      username: admin
```

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

### start()

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

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

```APIDOC
## start()

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

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

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

### Install Spring Boot CLI with SDKMAN!

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

Use SDKMAN! to install the Spring Boot CLI. This command installs the latest stable version.

```bash
$ sdk install springboot
$ spring --version
Spring CLI v4.1.0
```

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

### starting

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

Called immediately when the run method has first started. Can be used for very early initialization.

```APIDOC
## starting
default void starting(ConfigurableBootstrapContext bootstrapContext)

### Description
Called immediately when the run method has first started. Can be used for very early initialization.

### Parameters
* `bootstrapContext` (ConfigurableBootstrapContext) - the bootstrap context
```

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

### Install Spring Boot CLI with Scoop

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

Use these commands to add the 'extras' bucket and install the Spring Boot CLI via Scoop.

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

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

### Start Ant with Spring Boot AntLib

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

Use the '-lib' option when starting Ant to include the Spring Boot AntLib JAR.

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

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

### BufferingApplicationStartup Constructor

Source: https://docs.spring.io/spring-boot/4.1.0/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) - Required - the configured capacity; once reached, new steps are not recorded.
```

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

### getInstalledBy

Source: https://docs.spring.io/spring-boot/4.1.0/api/java/org/springframework/boot/flyway/autoconfigure/FlywayProperties.html

Gets the user who installed the migrations.

```APIDOC
## getInstalledBy()

### Description
Gets the user who installed the migrations.

### Method
public

### Endpoint
N/A

### Returns
String - The user who installed the migrations, or null if not set.
```

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

### main

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

The entry point for the PropertiesLauncher application. It accepts command line arguments to configure the launch process.

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

### Description
Entry point for the PropertiesLauncher. Launches the application based on provided arguments and properties.

### Parameters
* `args` (String[]) - Command line arguments.

### Throws
* `Exception` - if an error occurs during launch.
```

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

### getInstalledRank()

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

Get the rank of the installed Flyway migration.

```APIDOC
## getInstalledRank()

### Description
Get the rank of the installed Flyway migration.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### getInstalledOn()

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

Get the timestamp when the Flyway migration was installed.

```APIDOC
## getInstalledOn()

### Description
Get the timestamp when the Flyway migration was installed.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### Retrieve Application Startup Steps Snapshot

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

Use a GET request to retrieve a snapshot of the application startup steps recorded so far. This is useful for inspecting the startup sequence without clearing the buffer.

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

```json
{
  "springBootVersion" : "4.1.0",
  "timeline" : {
    "events" : [ { 
      "duration" : "PT0.000006111S",
      "endTime" : "2026-06-10T16:30:25.192381171Z",
      "startTime" : "2026-06-10T16:30:25.192375060Z",
      "startupStep" : {
        "id" : 3,
        "name" : "spring.beans.instantiate",
        "parentId" : 2,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ]
      }
    }, { 
      "duration" : "PT0.000019807S",
      "endTime" : "2026-06-10T16:30:25.192386471Z",
      "startTime" : "2026-06-10T16:30:25.192366664Z",
      "startupStep" : {
        "id" : 2,
        "name" : "spring.boot.application.starting",
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ],
    "startTime" : "2026-06-10T16:30:24.965022372Z"
  }
}
```

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

### getInstalledBy() - FlywayMigrationDescriptor

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

Get the identifier of who installed the Flyway migration.

```APIDOC
## getInstalledBy() - FlywayMigrationDescriptor

### Description
Get the identifier of who installed the Flyway migration.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### from

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

Create an application from an existing main method.

```APIDOC
## from

### Description
Create an application from an existing main method that can run with additional @Configuration or bean classes.

### Parameters
- **main** (ThrowingConsumer<String[]>) - Required - The main method entry point

### Response
- **Augmented** (SpringApplication.Augmented) - An instance used to add configuration and run the application
```

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

### getInstalledBy() - FlywayProperties

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

Get the identifier of who installed the Flyway migration from properties.

```APIDOC
## getInstalledBy() - FlywayProperties

### Description
Get the identifier of who installed the Flyway migration from properties.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### initialize

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

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

```APIDOC
## initialize Method

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

### Description
Fully initialize the logging system.

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
```

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

### initialize

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

Fully initializes the logging system with optional configuration and log file.

```APIDOC
## Method: initialize

### Description
Fully initialize the logging system.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method
`initialize`

### Endpoint
N/A (Method call)

### 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

### Returns
None
```

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

### Example Response for Configuration Properties

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

This is an example of the JSON response received when querying for configuration properties. It details the contexts, beans, their properties, and constraints.

```json
HTTP/1.1 200 OK
Content-Disposition: inline;filename=f.txt
Content-Type: application/vnd.spring-boot.actuator.v3+json
Content-Length: 2332

{
  "contexts" : {
    "application" : {
      "beans" : {
        "spring.jackson-org.springframework.boot.jackson.autoconfigure.JacksonProperties" : {
          "inputs" : {
            "findAndAddModules" : { },
            "serialization" : { },
            "factory" : {
              "constraints" : {
                "read" : {
                  "maxDocumentLength" : { },
                  "maxNameLength" : { },
                  "maxNestingDepth" : { },
                  "maxNumberLength" : { },
                  "maxStringLength" : { },
                  "maxTokenCount" : { }
                },
                "write" : {
                  "maxNestingDepth" : { }
                }
              }
            },
            "read" : { },
            "visibility" : { },
            "constructorDetector" : { },
            "datatype" : {
              "datetime" : { },
              "enum" : { },
              "jsonNode" : { }
            },
            "deserialization" : { },
            "json" : {
              "read" : { },
              "write" : { }
            },
            "mapper" : { },
            "write" : { },
            "useJackson2Defaults" : { }
          },
          "prefix" : "spring.jackson",
          "properties" : {
            "findAndAddModules" : true,
            "serialization" : { },
            "factory" : {
              "constraints" : {
                "read" : {
                  "maxDocumentLength" : -1,
                  "maxNameLength" : 50000,
                  "maxNestingDepth" : 500,
                  "maxNumberLength" : 1000,
                  "maxStringLength" : 100000000,
                  "maxTokenCount" : -1
                },
                "write" : {
                  "maxNestingDepth" : 500
                }
              }
            },
            "read" : { },
            "visibility" : { },
            "constructorDetector" : "DEFAULT",
            "datatype" : {
              "datetime" : { },
              "enum" : { },
              "jsonNode" : { }
            },
            "deserialization" : { },
            "json" : {
              "read" : { },
              "write" : { }
            },
            "mapper" : { },
            "write" : { },
            "useJackson2Defaults" : false
          }
        }
      }
    }
  }
}
```

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

### Get Startup Failure

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/test/context/assertj/ApplicationContextAssert.html

Asserts on the failure that prevented the application context from starting. Use when expecting the context to fail.

```java
assertThat(context).getFailure().hasMessageContaining("missing bean");
```

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

### loadOnStartup

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/tomcat/TomcatEmbeddedContext.html

Loads components on startup.

```APIDOC
## loadOnStartup

### Description
Loads components on startup.

### Method
`public boolean loadOnStartup(Container[] children)`

### Overrides
`loadOnStartup` in class `StandardContext`
```

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

### Implementing CommandLineRunner

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

Example of how to implement the CommandLineRunner interface to execute custom logic when the Spring Boot application starts.

```APIDOC
## Example Implementation

### Description
This example demonstrates how to create a Spring bean that implements `CommandLineRunner` to execute a specific task upon application startup.

### Method
`run(String... args)`

### Endpoint
N/A (This is a startup hook, not an HTTP endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
N/A

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

#### Response Example
N/A

### Code Example (Java)
```java
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.Arrays;

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Application started with arguments: " + Arrays.toString(args));
        // Your custom startup logic here
    }
}
```
```

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

### ConnectorStartFailedException

Source: https://docs.spring.io/spring-boot/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
## Class ConnectorStartFailedException

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

### Details
An exception indicating a failure during the startup of a Tomcat `Connector`.
```

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

### List Available Capabilities

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

Lists all available dependencies and project types supported by the start.spring.io service. This helps in understanding the options for project initialization.

```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!

```

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

### Create a Gradle Project with Web and JPA

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

Initialize a Gradle project with `web` and `jpa` dependencies in the `my-dir` directory, unpacked.

```bash
$ spring init -d=web,jpa --build=gradle my-dir
```

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

### Generated Security Password Example

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

This example shows the WARN level log message when an application starts with Spring Security, revealing the randomly generated password for the default user. Ensure the 'org.springframework.boot.security.autoconfigure' category is set to log WARN messages to see this output.

```text
Using generated security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35

This generated password is for development use only. Your security configuration must be updated before running your application in production.
```

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

### applicationStartup(ApplicationStartup applicationStartup)

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

Configures the ApplicationStartup for collecting startup metrics.

```APIDOC
## applicationStartup(ApplicationStartup applicationStartup)

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

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

### Returns
* the current builder

Since:
    2.4.0
```

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

### Filter Scanned Entities with ManagedClassNameFilter (Java)

Source: https://docs.spring.io/spring-boot/how-to/data-access.html

Implement a ManagedClassNameFilter bean to include only specific entities during scanning. This example filters for entities starting with 'com.example.app.customer.'

```java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.persistenceunit.ManagedClassNameFilter;

@Configuration(proxyBeanMethods = false)
public class MyEntityScanConfiguration {

	@Bean
	public ManagedClassNameFilter entityScanFilter() {
		return (className) -> className.startsWith("com.example.app.customer.");
	}

}
```

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

### Filter Scanned Entities with ManagedClassNameFilter (Kotlin)

Source: https://docs.spring.io/spring-boot/how-to/data-access.html

Implement a ManagedClassNameFilter bean in Kotlin to include only specific entities during scanning. This example filters for entities starting with 'com.example.app.customer.'

```kotlin
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.orm.jpa.persistenceunit.ManagedClassNameFilter

@Configuration(proxyBeanMethods = false)
class MyEntityScanConfiguration {

	@Bean
	fun entityScanFilter() : ManagedClassNameFilter {
		return ManagedClassNameFilter { className ->
			className.startsWith("com.example.app.customer.")
		}
	}
}
```

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

### SpringApplication.logStartupInfo(ConfigurableApplicationContext)

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

Called to log startup information, subclasses may override to add additional logging.

```APIDOC
## logStartupInfo(ConfigurableApplicationContext)

### Description
Called to log startup information, subclasses may override to add additional logging.

### Method
```
logStartupInfo(ConfigurableApplicationContext)
```

### Endpoint
N/A (SDK method)

### Parameters
- **context** (ConfigurableApplicationContext) - The application context.

### Request Example
N/A

### Response
N/A
```

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

### MyApplication Java Example

Source: https://docs.spring.io/spring-boot/reference/actuator/tracing.html

A basic 'Hello World!' Spring Boot application in Java, including a logger statement in the home method.

```java
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication
public class MyApplication {

	private static final Log logger = LogFactory.getLog(MyApplication.class);

	@RequestMapping("/")
	String home() {
		logger.info("home() has been called");
		return "Hello World!";
	}

	public static void main(String[] args) {
		SpringApplication.run(MyApplication.class, args);
	}

}
```

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

### Create and Use WebClient in Kotlin

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

Inject WebClient.Builder to create a configured WebClient instance for making REST calls. This example demonstrates a typical setup for a reactive service.

```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)
	}

}
```

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

### launch(String[] args)

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

Launches 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
```

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

### Create and Use WebClient in Java

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

Inject WebClient.Builder to create a configured WebClient instance for making REST calls. This example demonstrates a typical setup for a reactive service.

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

}
```

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

### MyApplication Kotlin Example

Source: https://docs.spring.io/spring-boot/reference/actuator/tracing.html

A basic 'Hello World!' Spring Boot application in Kotlin, including a logger statement in the home method.

```kotlin
import org.apache.commons.logging.Log
import org.apache.commons.logging.LogFactory
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
@SpringBootApplication
class MyApplication {

	private val logger: Log = LogFactory.getLog(MyApplication::class.java)

	@RequestMapping("/")
	fun home(): String {
		logger.info("home() has been called")
		return "Hello, World!"
	}

}

fun main(args: Array<String>) {
	runApplication<MyApplication>(*args)
}
```

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

### Run Remote Spring Application Client

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

Example output of the remote client application when launched. It shows the application starting, connecting to the remote server, and activating the LiveReload server.

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

2026-06-10T16:33:47.783Z  INFO 54045 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication v4.1.0 using Java 25.0.3 with PID 54045 (/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/4.1.0/spring-boot-devtools-4.1.0.jar started by myuser in /opt/apps/)
2026-06-10T16:33:47.793Z  INFO 54045 --- [           main] o.s.b.devtools.RemoteSpringApplication   : No active profile set, falling back to 1 default profile: "default"
2026-06-10T16:33:48.836Z  INFO 54045 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2026-06-10T16:33:48.936Z  INFO 54045 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 2.321 seconds (process running for 3.912)
```

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

### Spring Boot Startup Log Output

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

This is an example of the default INFO level logging output when a Spring Boot application starts. It includes banner, version, and startup details.

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

 :: Spring Boot ::                (v4.1.0)

2026-06-10T16:33:51.740Z  INFO 54551 --- [           main] o.s.b.d.f.logexample.MyApplication       : Starting MyApplication using Java 25.0.3 with PID 54551 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
2026-06-10T16:33:51.747Z  INFO 54551 --- [           main] o.s.b.d.f.logexample.MyApplication       : No active profile set, falling back to 1 default profile: "default"
2026-06-10T16:33:55.110Z  INFO 54551 --- [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat initialized with port 8080 (http)
2026-06-10T16:33:55.196Z  INFO 54551 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2026-06-10T16:33:55.205Z  INFO 54551 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/11.0.22]
2026-06-10T16:33:55.376Z  INFO 54551 --- [           main] b.w.c.s.WebApplicationContextInitializer : Root WebApplicationContext: initialization completed in 3421 ms
2026-06-10T16:33:56.597Z  INFO 54551 --- [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat started on port 8080 (http) with context path '/'
2026-06-10T16:33:56.628Z  INFO 54551 --- [           main] o.s.b.d.f.logexample.MyApplication       : Started MyApplication in 6.318 seconds (process running for 7.637)
2026-06-10T16:33:56.668Z  INFO 54551 --- [ionShutdownHook] o.s.boot.tomcat.GracefulShutdown         : Commencing graceful shutdown. Waiting for active requests to complete
2026-06-10T16:33:56.709Z  INFO 54551 --- [tomcat-shutdown] o.s.boot.tomcat.GracefulShutdown         : Graceful shutdown complete
```

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

### Launch Test Application (Java)

Source: https://docs.spring.io/spring-boot/reference/features/dev-services.html

Create a test application class in `src/test` to launch the main application with test dependencies. This example uses `SpringApplication.from(…)` to start the application.

```java
import org.springframework.boot.SpringApplication;

public class TestMyApplication {

	public static void main(String[] args) {
		SpringApplication.from(MyApplication::main).run(args);
	}

}
```

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

### Constructor Details

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/util/Instantiator.html

Details on how to create an Instantiator instance.

```APIDOC
## Constructor Details

### Instantiator

`public Instantiator(Class<?> type, Consumer<Instantiator.AvailableParameters> availableParameters)`

Create a new `Instantiator` instance for the given type.

Parameters:
* `type` - the type to instantiate
* `availableParameters` - consumer used to register available parameters

### Instantiator

`public Instantiator(Class<?> type, Consumer<Instantiator.AvailableParameters> availableParameters, Instantiator.FailureHandler failureHandler)`

Create a new `Instantiator` instance for the given type.

Parameters:
* `type` - the type to instantiate
* `availableParameters` - consumer used to register available parameters
* `failureHandler` - a `Instantiator.FailureHandler` that will be called in case of failure when instantiating objects

Since:
2.7.0
```

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

### Retrieve HTTP Exchanges using curl

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

Make a GET request to the `/actuator/httpexchanges` endpoint to fetch information about recorded HTTP exchanges. This example uses curl to demonstrate the request.

```bash
$ curl 'http://localhost:8080/actuator/httpexchanges' -i -X GET
Copied!

```

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

### startRecording

Source: https://docs.spring.io/spring-boot/4.1.0/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 reset 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.
```

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

### Retrieve Application Beans using curl

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

Make a GET request to the /actuator/beans endpoint to retrieve information about the application's beans. This example uses curl to demonstrate the request.

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

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

### buildInfo Method (with configurer)

Source: https://docs.spring.io/spring-boot/gradle-plugin/api/java/org/springframework/boot/gradle/dsl/SpringBootExtension.html

Creates a new BuildInfo task named bootBuildInfo and adds its output as a source directory of the main source set's resources, passing the task to a configurer.

```APIDOC
## buildInfo(Action<BuildInfo> configurer)

### Description
Creates a new `BuildInfo` task named `bootBuildInfo` and adds its output as a `source directory` of the main source set's `resources`. The task is passed to the given `configurer` for further configuration.
By default, the task's project artifact will be the archive base name of the `bootWar` or `bootJar` task.

### Parameters
#### Path Parameters
- **configurer** (Action<BuildInfo>) - Required - The task configurer.

### Method
POST

### Endpoint
N/A (Method call)
```

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

### Retrieve Part of the Log File

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

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

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

```http
HTTP/1.1 206 Partial Content
Accept-Ranges: bytes
Content-Type: text/plain;charset=UTF-8
Content-Range: bytes 0-1023/4707
Content-Length: 1024

  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \/  ___)| |_)| | | | | || (_| | ) ) ) )
  '  |____| .__|_| |_|_| |_\[__ /=/_/_/_/
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::

2017-08-08 17:12:30.910  INFO 19866 --- [           main] s.f.SampleWebFreeMarkerApplication       : Starting SampleWebFreeMarkerApplication with PID 19866
2017-08-08 17:12:30.913  INFO 19866 --- [           main] s.f.SampleWebFreeMarkerApplication       : No active profile set, falling back to default profiles: default
2017-08-08 17:12:30.952  INFO 19866 --- [           main] ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@76b10754: startup date [Tue Aug 08 17:12:30 BST 2017]; root of context hierarchy
2017-08-08 17:12:31.878  INFO 19866 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
20
```

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

### Native Application Startup Output

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

Example output showing the startup of a Spring Boot application compiled into a native executable. Note the significantly faster startup time compared to a JVM-based application.

```text
  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \/  ___)| |_)| | | | | |\__, | ) ) ) )
  '  |____| .__|_| |_|_| |\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v4.1.0) 
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.08 seconds (process running for 0.095)
```

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

### Initialize JsonbTester Fields

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

Utility method to initialize JsonbTester fields within a test instance. This is typically called in a setup method before tests run. See class-level documentation for example usage.

```java
public static void initFields(Object testInstance, Jsonb jsonb)
```

```java
public static void initFields(Object testInstance, ObjectFactory<Jsonb> jsonb)
```

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

### Display Help Screen

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

Run `spring` without arguments to display the main help screen, showing available commands and common options.

```bash
$ spring
```

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

### DockerProcessStartException Class

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

The `DockerProcessStartException` is a specific exception type within the Spring Boot Docker Compose integration, signaling an issue with starting the Docker process. It typically suggests that Docker might not be installed on the system.

```APIDOC
## Class: DockerProcessStartException

### Description
`DockerException` thrown if the docker process cannot be started. Usually indicates that docker is not installed.

### Since
3.1.0

### Author
Moritz Halbritter, Andy Wilkinson, Phillip Webb

### See Also
* Serialized Form
```

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

### RestTestClient Example with Standard Assertions (Kotlin)

Source: https://docs.spring.io/spring-boot/reference/testing/spring-boot-applications.html

Shows how to use RestTestClient in Kotlin to perform a GET request and assert the response. This is an alternative to the Java version for testing REST APIs in Spring Boot applications.

```kotlin
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.test.web.servlet.client.RestTestClient
import org.springframework.test.web.servlet.client.expectBody

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
class MyRandomPortRestTestClientTests {

	@Test
	fun exampleTest(@Autowired webClient: RestTestClient) {
		webClient
			.get().uri("/")
			.exchange()
			.expectStatus().isOk
			.expectBody<String>().isEqualTo("Hello World")
	}

}
```

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

### build

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

Returns a fully configured SpringApplication that is ready to run.

```APIDOC
## Method build

### Description
Returns a fully configured `SpringApplication` that is ready to run.

### Returns
The fully configured `SpringApplication`.

### Signature
`public SpringApplication build()`
```

```APIDOC
## Method build

### Description
Returns a fully configured `SpringApplication` that is ready to run. Any parent that has been configured will be run with the given `args`.

### Parameters
#### Path Parameters
- **args** (String...) - The parent's args.

### Returns
The fully configured `SpringApplication`.

### Signature
`public SpringApplication build(String... args)`
```

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

### exec

Source: https://docs.spring.io/spring-boot/gradle-plugin/api/java/org/springframework/boot/gradle/tasks/run/BootRun.html

Executes the BootRun task.

```APIDOC
## POST exec

### Description
Executes the task. Overrides the exec method in the JavaExec class.
```

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

### Java Pulsar Reader Configuration

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

Java example demonstrating how to configure a component to read messages from a Pulsar topic using the `@PulsarReader` annotation. It specifies the topic name and starts reading 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) {
		// ...
	}

}
```

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

### Customize JMX Port for Spring Boot Plugin

Source: https://docs.spring.io/spring-boot/maven-plugin/integration-tests.html

This example demonstrates how to customize the JMX port used by the spring-boot-maven-plugin for communication with the Spring Boot application. Ensure the JMX port is configured in the global configuration to be shared by both 'start' and 'stop' goals.

```xml
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<configuration>
				<jmxPort>9009</jmxPort>
			</configuration>
			<executions>
				<execution>
					<id>pre-integration-test</id>
					<goals>
						<goal>start</goal>
					</goals>
				</execution>
				<execution>
					<id>post-integration-test</id>
					<goals>
						<goal>stop</goal>
					</goals>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>
```

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

### RestTestClient Example with Standard Assertions (Java)

Source: https://docs.spring.io/spring-boot/reference/testing/spring-boot-applications.html

Demonstrates using RestTestClient to make a GET request to the root URI and verify the response status and body. This snippet is useful for basic REST API testing in a Spring Boot application running with random ports.

```java
import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.web.servlet.client.RestTestClient;

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
class MyRandomPortRestTestClientTests {

	@Test
	void exampleTest(@Autowired RestTestClient restClient) {
		restClient
			.get().uri("/")
			.exchange()
			.expectStatus().isOk()
			.expectBody(String.class).isEqualTo("Hello World");
	}

}
```

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

### logStartupInfo(boolean logStartupInfo)

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

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

```APIDOC
## logStartupInfo(boolean 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
```

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

### main

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

Basic main method to launch an application.

```APIDOC
## main

### Description
A basic main that can be used to launch an application. Useful when sources are defined through --spring.main.sources command line argument.

### Parameters
- **args** (String[]) - Required - Command line arguments

### Throws
- **Exception** - If the application cannot be started
```

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

### Startup Endpoint

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/actuate/endpoint/annotation/class-use/ReadOperation.html

Retrieves a snapshot of the application's startup.

```APIDOC
## GET /actuator/startup

### Description
Retrieves a snapshot of the application's startup information.

### Method
GET

### Endpoint
/actuator/startup

### Response
#### Success Response (200)
- **body** (StartupDescriptor) - A descriptor containing startup information.
```

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

### Start Container

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

Starts a specific Docker container.

```APIDOC
## start Container

### Description
Start a specific 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
```json
{
  "reference": "container-id-123"
}
```

### Response
#### Success Response (200 OK)
None (void)

#### Response Example
None
```

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

### Configure BufferingApplicationStartup in Java

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

Sets up `BufferingApplicationStartup` with a buffer size of 2048 for tracking application startup events in a Spring Boot application.

```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;

@SpringBootApplication
public class MyApplication {

	public static void main(String[] args) {
		SpringApplication application = new SpringApplication(MyApplication.class);
		application.setApplicationStartup(new BufferingApplicationStartup(2048));
		application.run(args);
	}

}
```

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

### StartCommand Enum Constants

Source: https://docs.spring.io/spring-boot/api/java/org/springframework/boot/docker/compose/lifecycle/StartCommand.html

Defines the available commands for starting Docker Compose. 'START' uses 'docker compose start' and 'UP' uses 'docker compose up'.

```APIDOC
## Enum Constants

### START
Start using `docker compose start`.

### UP
Start using `docker compose up`.
```

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

### SpringApplicationBuilder.logStartupInfo(boolean)

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

Flag to indicate the startup information should be logged.

```APIDOC
## logStartupInfo(boolean)

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

### Method
```
logStartupInfo(boolean)
```

### Endpoint
N/A (SDK method)

### Parameters
- **logStartupInfo** (boolean) - true to log startup information, false otherwise.

### Request Example
N/A

### Response
N/A
```

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

### Retrieve Application Startup Steps Snapshot

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

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

```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 Spring Boot version.
- **timeline** (object) - Contains the startup events.
  - **events** (array) - List of startup events.
    - **duration** (string) - The duration of the event.
    - **endTime** (string) - The end time of the event.
    - **startTime** (string) - The start time of the event.
    - **startupStep** (object) - Details about the startup step.
      - **id** (integer) - The ID of the startup step.
      - **name** (string) - The name of the startup step.
      - **parentId** (integer) - The parent ID of the startup step.
      - **tags** (array) - Tags associated with the startup step.
  - **startTime** (string) - The overall start time of the timeline.

### Response Example
{
  "springBootVersion": "4.1.0",
  "timeline": {
    "events": [
      {
        "duration": "PT0.000006111S",
        "endTime": "2026-06-10T16:30:25.192381171Z",
        "startTime": "2026-06-10T16:30:25.192375060Z",
        "startupStep": {
          "id": 3,
          "name": "spring.beans.instantiate",
          "parentId": 2,
          "tags": [
            {
              "key": "beanName",
              "value": "homeController"
            }
          ]
        }
      },
      {
        "duration": "PT0.000019807S",
        "endTime": "2026-06-10T16:30:25.192386471Z",
        "startTime": "2026-06-10T16:30:25.192366664Z",
        "startupStep": {
          "id": 2,
          "name": "spring.boot.application.starting",
          "tags": [
            {
              "key": "mainApplicationClass",
              "value": "com.example.startup.StartupApplication"
            }
          ]
        }
      }
    ],
    "startTime": "2026-06-10T16:30:24.965022372Z"
  }
}
```

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

### Any Provider Example

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

This snippet demonstrates the 'any' provider, which allows any additional values to be provided for a property. It auto-completes 'on' and 'off' for 'system.state' while permitting other values.

```json
{
	"hints": [
		{
			"name": "system.state",
			"values": [
				{
					"value": "on"
				},
				{
					"value": "off"
				}
			],
			"providers": [
				{
					"name": "any"
				}
			]
		}
	]
}
```

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

### get(PemSslBundleProperties) - PropertiesSslBundle

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

Gets an SslBundle for the given PemSslBundleProperties.

```APIDOC
## get(PemSslBundleProperties pemSslBundleProperties)

### Description
Gets an `SslBundle` for the given `PemSslBundleProperties`.

### Method
`get`

### Parameters
#### Path Parameters
- `pemSslBundleProperties` (PemSslBundleProperties) - Required - The properties for the PEM SSL bundle.

### Response
#### Success Response (SslBundle)
- Returns an `SslBundle` instance.
```

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

### Access Running Application via Browser (Maven)

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

After starting the application with Maven, access `localhost:8080` in a web browser to see the 'Hello World!' output.

```text
Hello World!

```

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

### Install Spring Boot CLI with Homebrew

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

Install the Spring Boot CLI on macOS using Homebrew. This command taps the Spring IO repository and installs the CLI.

```bash
$ brew tap spring-io/tap
$ brew install spring-boot
```