### start

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

Logs that a build is starting.

```APIDOC
## start

`public void start(BuildRequest request)`

Logs that a build is starting.

### Parameters

* **request** (BuildRequest) - the build request
```

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

### GET DockerComposeProperties.getStart()

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

Retrieves the start configuration properties for Docker Compose lifecycle management.

```APIDOC
## GET /docker-compose/properties/start

### Description
Retrieves the current DockerComposeProperties.Start configuration used for managing the lifecycle of Docker Compose within a Spring application context.

### Method
GET

### Endpoint
/docker-compose/properties/start

### Response
#### Success Response (200)
- **start** (DockerComposeProperties.Start) - The configuration object defining start behavior for Docker Compose.
```

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

### start()

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/reactor/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.

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

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

### start

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

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

### Spring Boot Native Application Startup Log

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

Example output showing a Spring Boot application started as a native executable. Note the significantly reduced startup time.

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

```

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

### Install Spring Boot CLI with SDKMAN!

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

Installs the latest stable version of the Spring Boot CLI using SDKMAN! and verifies the installation.

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

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

### Basic Neo4j Test Setup (Kotlin)

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

Demonstrates the basic setup for testing Neo4j applications using `@DataNeo4jTest` in Kotlin.

```kotlin
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.data.neo4j.test.autoconfigure.DataNeo4jTest

@DataNeo4jTest
class MyDataNeo4jTests(@Autowired val repository: SomeRepository) {

	// ...

}

```

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

### starting

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/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` - the bootstrap context
```

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

### Install Spring Boot CLI with Scoop

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

Installs the Spring Boot CLI on Windows using Scoop by adding the 'extras' bucket and then installing the springboot app.

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

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

### Basic Redis Test Setup (Kotlin)

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

Demonstrates the basic setup for testing Redis applications using `@DataRedisTest` in Kotlin.

```kotlin
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.data.redis.test.autoconfigure.DataRedisTest

@DataRedisTest
class MyDataRedisTests(@Autowired val repository: SomeRepository) {

	// ...

}

```

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

### DockerCompose.start

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

Run `docker compose start` to start services. Waits until all containers are started and healthy.

```APIDOC
## DockerCompose.start

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

### Method
`void`

### Parameters
#### Path Parameters
- **logLevel** (LogLevel) - Description: the log level used to report progress
- **arguments** (List<String>) - Description: the arguments to pass to the start command (Optional)
```

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

### Basic Neo4j Test Setup (Java)

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

Demonstrates the basic setup for testing Neo4j applications using `@DataNeo4jTest` in Java.

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.neo4j.test.autoconfigure.DataNeo4jTest;

@DataNeo4jTest
class MyDataNeo4jTests {

	@Autowired
	private SomeRepository repository;

	// ...

}

```

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

### Basic Redis Test Setup (Java)

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

Demonstrates the basic setup for testing Redis applications using `@DataRedisTest` in Java.

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.redis.test.autoconfigure.DataRedisTest;

@DataRedisTest
class MyDataRedisTests {

	@Autowired
	private SomeRepository repository;

	// ...

}

```

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

### Start Container

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

Starts a specified Docker container.

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

### Description
Starts a specified Docker container.

### Method
POST

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

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

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

### Spring Boot CLI Installation

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

Instructions for installing the Spring Boot Command Line Interface (CLI).

```APIDOC
## Installing the CLI

### Description

This section details how to install the Spring Boot CLI.

### Endpoint

N/A (CLI installation)

### Usage

Refer to the official Spring Boot documentation for specific installation steps for your operating system and environment.
```

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

### DockerCompose.up

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

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

```APIDOC
## DockerCompose.up

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

### Method
`void`

### Parameters
#### Path Parameters
- **logLevel** (LogLevel) - Description: the log level used to report progress
- **arguments** (List<String>) - Description: the arguments to pass to the up command (Optional)
```

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

### Retrieve Application Startup Steps Snapshot

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

Make a GET request to the /actuator/startup endpoint to retrieve the steps recorded so far during application startup.

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

```json
{
  "springBootVersion" : "4.0.8-SNAPSHOT",
  "timeline" : {
    "events" : [ { 
      "duration" : "PT0.000007253S",
      "endTime" : "2026-06-10T21:13:45.281166462Z",
      "startTime" : "2026-06-10T21:13:45.281159209Z",
      "startupStep" : {
        "id" : 3,
        "name" : "spring.beans.instantiate",
        "parentId" : 2,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ]
      }
    }, { 
      "duration" : "PT0.000023564S",
      "endTime" : "2026-06-10T21:13:45.281172664Z",
      "startTime" : "2026-06-10T21:13:45.281149100Z",
      "startupStep" : {
        "id" : 2,
        "name" : "spring.boot.application.starting",
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ],
    "startTime" : "2026-06-10T21:13:44.759504542Z"
  }
}
```

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

### Start Ant with -lib Option

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/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-4.0.8-SNAPSHOT.jar>
```

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

### get

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/test/http/server/LocalTestWebServer.html

Returns the LocalTestWebServer instance provided from the ApplicationContext, or null if no local server is started or could be provided.

```APIDOC
## get

### Description
Return the `LocalTestWebServer` instance provided from the `ApplicationContext` or `null` of no local server is started or could be provided.

### Method
public static @Nullable LocalTestWebServer get(ApplicationContext applicationContext)

### Parameters
#### Path Parameters
- **applicationContext** (ApplicationContext) - Required - the application context

### Returns
the local test web server or `null`
```

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

### BufferingApplicationStartup Constructor

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

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

### Java @PulsarReader Example

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

Consumes messages from a Pulsar topic using the @PulsarReader annotation. 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) {
		// ...
	}

}
```

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

### Create a Spring Boot Project with Specific Dependencies and Name

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

Initialize a project with the 'web' dependency and package it as 'my-app.zip'.

```bash
$ spring init -d=web my-app.zip
```

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

### DockerProcessStartException Class

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

Details the DockerProcessStartException, which extends DockerException and is thrown when a Docker process fails to start. It typically signifies that Docker is not installed on the system.

```APIDOC
## Class: DockerProcessStartException

### Description
`DockerProcessStartException` is thrown if the docker process cannot be started. This usually indicates that docker is not installed.

### Class Hierarchy
`java.lang.Object` -> `java.lang.Throwable` -> `java.lang.Exception` -> `java.lang.RuntimeException` -> `org.springframework.boot.docker.compose.core.DockerException` -> `org.springframework.boot.docker.compose.core.DockerProcessStartException`

### Implemented Interfaces
`Serializable`

### Since
3.1.0

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

### See Also
* Serialized Form
```

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

### BuildLog.start

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/buildpack/platform/build/class-use/BuildRequest.html

Logs the initiation of a build process.

```APIDOC
## BuildLog.start

### Description
Logs that a build is starting.

### Parameters
#### Request Body
- **request** (BuildRequest) - Required - The build request object associated with the start event.
```

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

### Kotlin @PulsarReader Example

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

Consumes messages from a Pulsar topic using the @PulsarReader annotation in Kotlin. Starts reading 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?) {
		// ...
	}

}
```

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

### RestTestClient Example in Java

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

Demonstrates how to use RestTestClient to make a GET request and assert the response status and body. Requires @SpringBootTest with WebEnvironment.RANDOM_PORT and @AutoConfigureRestTestClient.

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

}
```

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

### initialize

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

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

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

### Description
Fully initializes the logging system.

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

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

### Retrieve Entire Environment using curl

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/rest/actuator/env.html

Make a GET request to the /actuator/env endpoint to retrieve all environment properties. This example uses curl for demonstration.

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

```

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

### Disable Remote Example Metrics (Properties)

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/reference/actuator/metrics.html

Use this property to disable meters with IDs starting with 'example.remote'. This is applied via Spring Boot's PropertiesMeterFilter.

```properties
management.metrics.enable.example.remote=false
```

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

### applicationStartup

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

Configures the ApplicationStartup for collecting startup metrics.

```APIDOC
## applicationStartup

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

### Method
`public SpringApplicationBuilder applicationStartup(ApplicationStartup applicationStartup)`

### Parameters
#### Path Parameters
- **applicationStartup** (ApplicationStartup) - Required - The application startup to use.

### Returns
- the current builder

### Since
- 2.4.0
```

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

### logStartupInfo

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

Flag to indicate the startup information should be logged. Defaults to 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
```

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

### Retrieve Specific Metric Details

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/rest/actuator/metrics.html

Fetch detailed information for a specific metric by appending its name to the /actuator/metrics endpoint. This example shows how to get details for 'jvm.memory.max'.

```curl
$ curl 'http://localhost:8080/actuator/metrics/jvm.memory.max' -i -X GET
```

```json
{
  "availableTags" : [ {
    "tag" : "area",
    "values" : [ "heap", "nonheap" ]
  }, {
    "tag" : "id",
    "values" : [ "CodeHeap 'profiled nmethods'", "G1 Old Gen", "CodeHeap 'non-profiled nmethods'", "G1 Survivor Space", "Compressed Class Space", "Metaspace", "G1 Eden Space", "CodeHeap 'non-nmethods'" ]
  } ],
  "baseUnit" : "bytes",
  "description" : "The maximum amount of memory in bytes that can be used for memory management",
  "measurements" : [ {
    "statistic" : "VALUE",
    "value" : 2.936016893E9
  } ],
  "name" : "jvm.memory.max"
}
```

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

### Disable Remote Example Metrics (YAML)

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/reference/actuator/metrics.html

Use this YAML configuration to disable meters with IDs starting with 'example.remote'. This is applied via Spring Boot's PropertiesMeterFilter.

```yaml
management:
  metrics:
    enable:
      example:
        remote: false
```

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

### Getting Startup Failure Information

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

Returns the Throwable that caused the application context to fail during startup, or null if the context started without any issues. This is crucial for diagnosing startup problems.

```java
@Nullable Throwable
getStartupFailure()
```

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

### from(ThrowingConsumer<String[]> main)

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

Create an application from an existing main method that can run with additional configuration.

```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
- **SpringApplication.Augmented** - An instance used to add configuration and run the application
```

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

### initialize Method

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/web/server/context/ServerPortInfoApplicationContextInitializer.html

Initializes the application context by setting environment properties for the server port.

```APIDOC
## initialize(ConfigurableApplicationContext applicationContext)

### Description
Initializes the application context by setting environment properties for the server port. This method is part of the `ApplicationContextInitializer` interface.

### Method Signature
`void initialize(ConfigurableApplicationContext applicationContext)`

### Parameters
* **applicationContext** (ConfigurableApplicationContext) - The application context to initialize.
```

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

### Configure JDK Client with Custom ProxySelector (Kotlin)

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

Kotlin example for configuring a JDK HTTP client with a specific ProxySelector via ClientHttpConnectorBuilder, suitable for advanced proxy setups.

```kotlin
import org.springframework.boot.http.client.reactive.ClientHttpConnectorBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.net.ProxySelector

@Configuration(proxyBeanMethods = false)
class MyConnectorHttpConfiguration {

	@Bean
	fun clientHttpConnectorBuilder(proxySelector: ProxySelector): ClientHttpConnectorBuilder<*> {
		return ClientHttpConnectorBuilder.jdk().withHttpClientCustomizer { builder -> builder.proxy(proxySelector) }
	}

}
```

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

### Configure Second EntityManagerFactory (Kotlin)

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

This Kotlin example demonstrates configuring a secondary `EntityManagerFactory` using `LocalContainerEntityManagerFactoryBean`. It highlights the setup for a distinct persistence unit, datasource, and JPA properties.

```kotlin
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.jpa.EntityManagerFactoryBuilder
import org.springframework.boot.jpa.autoconfigure.JpaProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.orm.jpa.JpaVendorAdapter
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter
import javax.sql.DataSource

@Configuration(proxyBeanMethods = false)
class MyAdditionalEntityManagerFactoryConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.jpa")
	fun secondJpaProperties(): JpaProperties {
		return JpaProperties()
	}

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	fun secondEntityManagerFactory(
		@Qualifier("second") dataSource: DataSource,
		@Qualifier("second") jpaProperties: JpaProperties
	): LocalContainerEntityManagerFactoryBean {
		val builder = createEntityManagerFactoryBuilder(jpaProperties)
		return builder.dataSource(dataSource).packages(Order::class.java).persistenceUnit("second").build()
	}

	private fun createEntityManagerFactoryBuilder(jpaProperties: JpaProperties): EntityManagerFactoryBuilder {
		val jpaVendorAdapter = createJpaVendorAdapter(jpaProperties)
		val jpaPropertiesFactory = { dataSource: DataSource ->
				createJpaProperties(dataSource, jpaProperties.properties) }
		return EntityManagerFactoryBuilder(jpaVendorAdapter, jpaPropertiesFactory, null)
	}

	private fun createJpaVendorAdapter(jpaProperties: JpaProperties): JpaVendorAdapter {
		// ... map JPA properties as needed
		return HibernateJpaVendorAdapter()
	}

	private fun createJpaProperties(dataSource: DataSource, existingProperties: Map<String, *>): Map<String, *> {
		val jpaProperties: Map<String, *> = LinkedHashMap(existingProperties)
		// ... map JPA properties that require the DataSource (e.g. DDL flags)
		return jpaProperties
	}

}
```

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

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

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

Lists all available dependencies and project types from the start.spring.io service using the `--list` flag.

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

```

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

### Remote Client Application Output

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/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. The `spring.devtools.remote.secret` property is read for authentication.

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

2026-06-10T21:16:04.137Z  INFO 23577 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication v4.0.8-SNAPSHOT using Java 25.0.3 with PID 23577 (/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/4.0.8-SNAPSHOT/spring-boot-devtools-4.0.8-SNAPSHOT.jar started by myuser in /opt/apps/)
2026-06-10T21:16:04.157Z  INFO 23577 --- [           main] o.s.b.devtools.RemoteSpringApplication   : No active profile set, falling back to 1 default profile: "default"
2026-06-10T21:16:05.413Z  INFO 23577 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2026-06-10T21:16:05.520Z  INFO 23577 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 2.889 seconds (process running for 3.975)
Copied!

```

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

### Initialize a New Project with Dependencies

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

Creates a new Maven-based project with specified dependencies using the `init` command.

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

```

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

### initialize Method

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

Initialize the given application context.

```APIDOC
## initialize(ConfigurableApplicationContext applicationContext)

### Description
Initialize the given application context.

### Method
`public void initialize(ConfigurableApplicationContext applicationContext)`

### Implements
`ApplicationContextInitializer<ConfigurableApplicationContext>.initialize(ConfigurableApplicationContext)`
```

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

### Retrieve Part of the Log File

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

Use a GET request to the /actuator/logfile endpoint 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'
```

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

### Enable SSL for Redis Container

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

This example demonstrates how to enable SSL for a Redis container using PEM-based keystore and truststore configurations via Docker Compose labels. It also shows the necessary secrets and command to start Redis with SSL.

```yaml
services:
  redis:
    image: 'redis:latest'
    ports:
      - '6379'
    secrets:
      - ssl-ca
      - ssl-key
      - ssl-cert
    command: 'redis-server --tls-port 6379 --port 0 --tls-cert-file /run/secrets/ssl-cert --tls-key-file /run/secrets/ssl-key --tls-ca-cert-file /run/secrets/ssl-ca'
    labels:
      - 'org.springframework.boot.sslbundle.pem.keystore.certificate=client.crt'
      - 'org.springframework.boot.sslbundle.pem.keystore.private-key=client.key'
      - 'org.springframework.boot.sslbundle.pem.truststore.certificate=ca.crt'
secrets:
  ssl-ca:
    file: 'ca.crt'
  ssl-key:
    file: 'server.key'
  ssl-cert:
    file: 'server.crt'
```

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

### POST /docker/containers/{reference}/start

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/buildpack/platform/docker/type/class-use/ContainerReference.html

Starts a specific container.

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

### Description
Start a specific container.

### Method
POST

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

### Parameters
#### Path Parameters
- **reference** (ContainerReference) - Required - The reference identifier of the container.
```

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

### Enable BufferingApplicationStartup in Java

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

Configure `SpringApplication` to use `BufferingApplicationStartup` for buffering startup steps. This is useful for collecting startup data for profiling or external metrics systems.

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

}
```

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

### YAML Configuration

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

Demonstrates setting the same configuration properties ('server.port', 'server.address') using YAML syntax.

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

```

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

### SpringApplication.from

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/class-use/SpringApplication.Augmented.html

Creates an application from an existing main method with optional configuration.

```APIDOC
## static SpringApplication.Augmented from(ThrowingConsumer<String[]> main)

### 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 to execute.
```

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

### Constructor

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/bootstrap/DefaultBootstrapContext.html

Initializes a new instance of the DefaultBootstrapContext class.

```APIDOC
## Constructor

### DefaultBootstrapContext

```java
public DefaultBootstrapContext()
```

Initializes a new instance of the DefaultBootstrapContext class.
```

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

### Install Spring Boot CLI with Homebrew

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

Installs the Spring Boot CLI on macOS using Homebrew by tapping the spring-io repository and then installing the package.

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

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

### Retrieve Application Startup Steps Snapshot

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

Retrieves a snapshot of the steps recorded during the application startup phase. This is done via a GET request to the `/actuator/startup` endpoint.

```APIDOC
## GET /actuator/startup

### Description
Retrieves a snapshot of the application's startup steps recorded so far.

### Method
GET

### Endpoint
/actuator/startup

### Response
#### Success Response (200)
- **springBootVersion** (string) - The Spring Boot version.
- **timeline** (object) - Contains the startup events.
  - **events** (array) - A 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.0.8-SNAPSHOT",
  "timeline" : {
    "events" : [ {
      "duration" : "PT0.000007253S",
      "endTime" : "2026-06-10T21:13:45.281166462Z",
      "startTime" : "2026-06-10T21:13:45.281159209Z",
      "startupStep" : {
        "id" : 3,
        "name" : "spring.beans.instantiate",
        "parentId" : 2,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ]
      }
    }, {
      "duration" : "PT0.000023564S",
      "endTime" : "2026-06-10T21:13:45.281172664Z",
      "startTime" : "2026-06-10T21:13:45.281149100Z",
      "startupStep" : {
        "id" : 2,
        "name" : "spring.boot.application.starting",
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ],
    "startTime" : "2026-06-10T21:13:44.759504542Z"
  }
}
```

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

### Application Starting Event

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/serialized-form.html

Represents the event when the application is starting.

```APIDOC
## Class org.springframework.boot.context.event.ApplicationStartingEvent

### Description
This class extends `SpringApplicationEvent` and is `Serializable`. It is triggered at the very beginning of the application startup process.

### Serialized Fields
* **bootstrapContext** (`ConfigurableBootstrapContext`) - The bootstrap context.
```

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

### Drain Application Startup Steps

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

Make a POST request to the /actuator/startup endpoint to drain and return the steps recorded so far during application startup.

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

```json
{
  "springBootVersion" : "4.0.8-SNAPSHOT",
  "timeline" : {
    "events" : [ { 
      "duration" : "PT0.000372618S",
      "endTime" : "2026-06-10T21:13:45.122205461Z",
      "startTime" : "2026-06-10T21:13:45.121832843Z",
      "startupStep" : {
        "id" : 1,
        "name" : "spring.beans.instantiate",
        "parentId" : 0,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ]
      }
    }, { 
      "duration" : "PT0.013953638S",
      "endTime" : "2026-06-10T21:13:45.122242761Z",
      "startTime" : "2026-06-10T21:13:45.108289123Z",
      "startupStep" : {
        "id" : 0,
        "name" : "spring.boot.application.starting",
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ],
    "startTime" : "2026-06-10T21:13:44.759504542Z"
  }
}
```

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

### Application Started Event

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/serialized-form.html

Represents the event when the application has started.

```APIDOC
## Class org.springframework.boot.context.event.ApplicationStartedEvent

### Description
This class extends `SpringApplicationEvent` and is `Serializable`. It is triggered after the application context has been refreshed and the application has started.

### Serialized Fields
* **context** (`ConfigurableApplicationContext`) - The application context.
* **timeTaken** (`@Nullable Duration`) - The time taken for the application to start.
```

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

### startRecording

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

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

### Start Mojo API

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/maven-plugin/api/java/org/springframework/boot/maven/StartMojo.html

Details about the Start Mojo, its purpose, and its methods.

```APIDOC
## Start Mojo

### Description
Start a spring application. Contrary to the `run` goal, this does not block and allows other goals to operate on the application. This goal is typically used in integration test scenario where the application is started before a test suite and stopped after.

Since: 1.3.0

Author: Stephane Nicoll

See Also:
* `StopMojo`

### Method Summary

#### `execute`
```java
public <T> T execute(long wait, int maxAttempts, Callable<@Nullable T> callback) throws Exception
```
Execute a task, retrying it on failure.

Parameters:
* `wait` (long) - the wait time
* `maxAttempts` (int) - the maximum number of attempts
* `callback` (Callable<@Nullable T>) - the task to execute (possibly multiple times). The callback should return `null` to indicate that another attempt should be made

Returns:
* `T` - the result

Throws:
* `Exception` - in case of execution errors

#### `isUseTestClasspath`
```java
protected boolean isUseTestClasspath()
```
Specified by: `isUseTestClasspath` in class `AbstractRunMojo`

#### `run`
```java
protected void run(org.springframework.boot.maven.JavaProcessExecutor processExecutor, File workingDirectory, List<String> args, Map<String,String> environmentVariables) throws org.apache.maven.plugin.MojoExecutionException, org.apache.maven.plugin.MojoFailureException
```
Run the application.

Specified by: `run` in class `AbstractRunMojo`

Parameters:
* `processExecutor` (JavaProcessExecutor) - the `JavaProcessExecutor` to use
* `workingDirectory` (File) - the working directory of the forked JVM
* `args` (List<String>) - the arguments (JVM arguments and application arguments)
* `environmentVariables` (Map<String,String>) - the environment variables

Throws:
* `org.apache.maven.plugin.MojoExecutionException` - in case of MOJO execution errors
* `org.apache.maven.plugin.MojoFailureException` - in case of MOJO failures

#### `resolveApplicationArguments`
```java
protected org.springframework.boot.maven.RunArguments resolveApplicationArguments()
```
Resolve the application arguments to use.

Overrides: `resolveApplicationArguments` in class `AbstractRunMojo`

Returns:
* `RunArguments` - a `RunArguments` defining the application arguments

#### `resolveJvmArguments`
```java
protected org.springframework.boot.maven.RunArguments resolveJvmArguments()
```
Resolve the JVM arguments to use.

Overrides: `resolveJvmArguments` in class `AbstractRunMojo`

Returns:
* `RunArguments` - a `RunArguments` defining the JVM arguments
```

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

### Launch Spring Application with runApplication

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/kotlin/core/spring-boot/org.springframework.boot/run-application.html

Use this shortcut to launch a Spring Boot application with basic configuration. It's a direct replacement for `SpringApplication.run(MyApplication::class.java, *args)`.

```kotlin
inline fun <T : Any> runApplication(vararg args: String): ConfigurableApplicationContext
Top-level function acting as a Kotlin shortcut allowing to write `runApplication<MyApplication>(arg1, arg2)` instead of `SpringApplication.run(MyApplication::class.java, arg1, arg2)`.
```

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

### started

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

The context has been refreshed and the application has started but CommandLineRunners and ApplicationRunners have not been called.

```APIDOC
## started
default void started(ConfigurableApplicationContext context, @Nullable Duration timeTaken)

### Description
The context has been refreshed and the application has started but `CommandLineRunners` and `ApplicationRunners` have not been called.

### Parameters
* `context` - the application context.
* `timeTaken` - the time taken to start the application or `null` if unknown

Since: 2.6.0
```

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

### Get Environment Variable

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/buildpack/platform/system/Environment.html

Gets the value of the specified environment variable.

```APIDOC
## Get Environment Variable

### Description
Gets the value of the specified environment variable.

### Method
`get`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **name** (String) - The name of the environment variable.

### Request Example
```java
Environment env = Environment.SYSTEM;
String value = env.get("MY_VARIABLE");
```

### Response
#### Success Response (String)
- The string value of the environment variable, or `null` if the variable is not defined.

#### Response Example
```
"some_value"
```
```

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

### Create a Default Spring Boot Project

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

Run 'spring init' without arguments to create a default Spring Boot project structure.

```bash
$ spring init
```

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

### Create Test Application Class (Java)

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

Create a test application class in `src/test` to launch the main application with test dependencies. This example shows the Java version.

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

public class TestMyApplication {

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

}
```

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

### get(PemSslBundleProperties)

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

Gets an SslBundle for the given PemSslBundleProperties. This is a static method in the PropertiesSslBundle class.

```APIDOC
## get(PemSslBundleProperties)

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

### Method
Static Factory Method

### Endpoint
N/A

### Parameters
* **properties** (PemSslBundleProperties) - The PEM SSL bundle properties.

### Response
* **Success Response** (SslBundle) - The SslBundle created from the properties.
```

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

### get(JksSslBundleProperties)

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

Gets an SslBundle for the given JksSslBundleProperties. This is a static method in the PropertiesSslBundle class.

```APIDOC
## get(JksSslBundleProperties)

### Description
Get an `SslBundle` for the given `JksSslBundleProperties`.

### Method
Static Factory Method

### Endpoint
N/A

### Parameters
* **properties** (JksSslBundleProperties) - The JKS SSL bundle properties.

### Response
* **Success Response** (SslBundle) - The SslBundle created from the properties.
```

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

### Basic Application Response

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

When accessing `localhost:8080` in a web browser, the application should display 'Hello World!'.

```text
Hello World!

```

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

### Example Usage of AnyNestedCondition

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/autoconfigure/condition/AnyNestedCondition.html

An example demonstrating how to create a composite condition using AnyNestedCondition.

```APIDOC
## Example Usage

```java
static class OnJndiOrProperty extends AnyNestedCondition {

   OnJndiOrProperty() {
       super(ConfigurationPhase.PARSE_CONFIGURATION);
   }

   @ConditionalOnJndi()
   static class OnJndi {
   }

   @ConditionalOnProperty("something")
   static class OnProperty {
   }

}
```

This example shows a composite condition `OnJndiOrProperty` that matches if either `@ConditionalOnJndi` or `@ConditionalOnProperty("something")` matches.
```

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

### Basic jOOQ Test Setup in Kotlin

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

Shows the equivalent basic setup for a jOOQ test using the @JooqTest annotation in Kotlin, leveraging constructor injection for DSLContext.

```kotlin
import org.jooq.DSLContext
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.jooq.test.autoconfigure.JooqTest

@JooqTest
class MyJooqTests(@Autowired val dslContext: DSLContext) {

	// ...

}
```

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

### Get Root MappedObject from Proxy

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/buildpack/platform/json/MappedObject.html

Static method to get the root MappedObject from a proxy object.

```java
protected static <T extends MappedObject>
T getRoot(Object proxy)
```

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

### Initialize a Gradle Project with Specific Java Version and Packaging

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

Creates a Gradle project with Java 17, WebSocket dependency, and WAR packaging, saving the output to a zip file.

```bash
$ spring init --build=gradle --java-version=17 --dependencies=websocket --packaging=war sample-app.zip
Using service at https://start.spring.io
Content saved to 'sample-app.zip'
Copied!

```

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

### TestcontainersStartup.start(Startable startable)

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/testcontainers/lifecycle/TestcontainersStartup.html

Starts the provided `Startable` instance. This method checks if the `Startable` is already running before initiating the startup process, ensuring idempotency.

```APIDOC
## Method: start

`public static void start(org.testcontainers.lifecycle.Startable startable)`

Start the given `Startable` unless is's detected as already running.

### Parameters
* `startable` (org.testcontainers.lifecycle.Startable) - the startable to start
```

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

### VCAP_APPLICATION Metadata Example

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/api/java/org/springframework/boot/cloud/CloudFoundryVcapEnvironmentPostProcessor.html

Example of the VCAP_APPLICATION environment variable content, containing application metadata.

```json
VCAP_APPLICATION: {"instance_id":"2ce0ac627a6c8e47e936d829a3a47b5b","instance_index":0,
  "version":"0138c4a6-2a73-416b-aca0-572c09f7ca53","name":"foo",
  "uris":["foo.cfapps.io"], ...}
```

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

### Configure PropertiesLauncher Main-Class (Kotlin)

Source: https://docs.spring.io/spring-boot/4.0-SNAPSHOT/gradle-plugin/packaging.html

Configure the bootWar task's manifest to use PropertiesLauncher as the main class using Kotlin.

```kotlin
tasks.named<BootWar>("bootWar") {
	manifest {
		attributes("Main-Class" to "org.springframework.boot.loader.launch.PropertiesLauncher")
	}
}
```

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

### Install Spring Boot CLI with MacPorts

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

Installs the Spring Boot CLI on macOS using MacPorts.

```bash
$ sudo port install spring-boot-cli
```

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

### Enable BufferingApplicationStartup in Kotlin

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

Configure `runApplication` to use `BufferingApplicationStartup` for buffering startup steps in Kotlin applications. This allows for collecting startup data.

```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup
import org.springframework.boot.runApplication

@SpringBootApplication
class MyApplication

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