Spring Boot

https://docs.spring.io/spring-boot/3.4/
Admin
Spring Boot helps developers create stand-alone, production-grade Spring-based applications with...
Tokens:2,259,702
Snippets:34,792
Trust Score:10
Update:59 minutes ago
Show doc for...
Tokens:
Raw
### Example response for POST /actuator/startup

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

Example HTTP response showing the drained startup steps, with the same structure as the GET response but with different event details.

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

{
  "springBootVersion" : "3.4.13",
  "timeline" : {
    "startTime" : "2025-12-18T07:13:26.071231143Z",
    "events" : [ {
      "endTime" : "2025-12-18T07:13:26.573051399Z",
      "duration" : "PT0.000264666S",
      "startTime" : "2025-12-18T07:13:26.572786733Z",
      "startupStep" : {
        "name" : "spring.beans.instantiate",
        "id" : 1,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ],
        "parentId" : 0
      }
    }, {
      "endTime" : "2025-12-18T07:13:26.573081125Z",
      "duration" : "PT0.001350654S",
      "startTime" : "2025-12-18T07:13:26.571730471Z",
      "startupStep" : {
        "name" : "spring.boot.application.starting",
        "id" : 0,
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ]
  }
}
```

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

### Example response for GET /actuator/startup

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

Example HTTP response showing the structure of the startup steps snapshot, including springBootVersion, timeline startTime, and events with startupStep details.

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

{
  "springBootVersion" : "3.4.13",
  "timeline" : {
    "startTime" : "2025-12-18T07:13:26.071231143Z",
    "events" : [ {
      "endTime" : "2025-12-18T07:13:26.657897941Z",
      "duration" : "PT0.000006613S",
      "startTime" : "2025-12-18T07:13:26.657891328Z",
      "startupStep" : {
        "name" : "spring.beans.instantiate",
        "id" : 3,
        "tags" : [ {
          "key" : "beanName",
          "value" : "homeController"
        } ],
        "parentId" : 2
      }
    }, {
      "endTime" : "2025-12-18T07:13:26.657904212Z",
      "duration" : "PT0.000022071S",
      "startTime" : "2025-12-18T07:13:26.657882141Z",
      "startupStep" : {
        "name" : "spring.boot.application.starting",
        "id" : 2,
        "tags" : [ {
          "key" : "mainApplicationClass",
          "value" : "com.example.startup.StartupApplication"
        } ]
      }
    } ]
  }
}
```

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

### Create symlink to install as init.d service

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

Assuming the application is installed in /var/myapp, create a symlink to /etc/init.d/myapp to enable standard start, stop, restart, and status commands.

```shell
$ sudo ln -s /var/myapp/myapp.jar /etc/init.d/myapp
```

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

### Get detailed help for the init command

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

Running 'spring help init' displays the full usage and options for the init command, including flags like --build, --dependencies, and --target, along with examples.

```shell
$ spring help init
spring init - Initialize a new project using Spring Initializr (start.spring.io)

usage: spring init [options] [location]

Option                       Description
------                       -----------
-a, --artifact-id <String>   Project coordinates; infer archive name (for
                               example 'test')
-b, --boot-version <String>  Spring Boot version (for example '1.2.0.RELEASE')
--build <String>             Build system to use (for example 'maven' or
                               'gradle') (default: maven)
-d, --dependencies <String>  Comma-separated list of dependency identifiers to
                               include in the generated project
--description <String>       Project description
-f, --force                  Force overwrite of existing files
--format <String>            Format of the generated content (for example
                               'build' for a build file, 'project' for a
                               project archive) (default: project)
-g, --group-id <String>      Project coordinates (for example 'org.test')
-j, --java-version <String>  Language level (for example '1.8')
-l, --language <String>      Programming language  (for example 'java')
--list                       List the capabilities of the service. Use it to
                               discover the dependencies and the types that are
                               available
-n, --name <String>          Project name; infer application name
-p, --packaging <String>     Project packaging (for example 'jar')
--package-name <String>      Package name
-t, --type <String>          Project type. Not normally needed if you use --
                               build and/or --format. Check the capabilities of
                               the service (--list) for more details
--target <String>            URL of the service to use (default: https://start.
                               spring.io)
-v, --version <String>       Project version (for example '0.0.1-SNAPSHOT')
-x, --extract                Extract the project archive. Inferred if a
                               location is specified without an extension

examples:

    To list all the capabilities of the service:
        $ spring init --list

    To creates a default project:
        $ spring init

    To create a web my-app.zip:
        $ spring init -d=web my-app.zip

    To create a web/data-jpa gradle project unpacked:
        $ spring init -d=web,jpa --build=gradle my-dir

```

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

### start(LogLevel, List<String>)

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

Runs 'docker compose start' with additional arguments to start services, waiting until all containers are started and healthy.

```APIDOC
## start(LogLevel, List<String>)

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

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

### Parameters
- **logLevel** (LogLevel) - Required - The log level used to report progress.
- **arguments** (List<String>) - Required - The arguments to pass to the start command.

### Since
3.4.0

```

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

### start()

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/web/embedded/jetty/JettyWebServer.html

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

```APIDOC
## start()

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

### Method
void

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

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

### start()

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

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

```APIDOC
## start()

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

### Method
`public void start() throws WebServerException`

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

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

### start(LogLevel)

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

Runs 'docker compose start' to start services, waiting until all containers are started and healthy.

```APIDOC
## start(LogLevel)

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

### Method
void start(LogLevel logLevel)

### Parameters
- **logLevel** (LogLevel) - Required - The log level used to report progress.

```

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

### hasNotFailed Example

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

Verifies that the application has not failed to start. Throws AssertionError if the context failed to start.

```java
assertThat(context).hasNotFailed();
```

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

### hasFailed Example

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

Verifies that the application has failed to start. Throws AssertionError if the context started without a failure.

```java
assertThat(context).hasFailed();
```

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

### starting(ConfigurableBootstrapContext)

Source: https://docs.spring.io/spring-boot/3.4/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(ConfigurableBootstrapContext)

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

### Method
starting

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

### Response
void
```

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

### getFailure Example

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

Asserts that the application context failed to start and the failure message contains 'missing bean'. Throws AssertionError if the context started without a failure.

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

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

### persist Example

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/test/autoconfigure/orm/jpa/TestEntityManager.html

Shows how to persist an entity and get the original entity back.

```java
MyEntity entity = this.testEntityManager.persist(new MyEntity("Spring"));
```

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

### start(String name)

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

Starts a new StartupStep with the given name. This method is specified by the ApplicationStartup interface.

```APIDOC
## Method: start(String name)

### Description
Start a new `StartupStep` with the given name. This method is specified by the `ApplicationStartup` interface.

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

### Returns
- `StartupStep` - The started step.

```

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

### start()

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/devtools/filewatch/FileSystemWatcher.html

Starts monitoring the source directory for changes.

```APIDOC
## start()

### Description
Starts monitoring the source directory for changes.

### Method
`public void start()`

### Parameters
None.

### Returns
void

```

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

### PropertiesLauncher.main(String[] args)

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

Static main method to launch the application using PropertiesLauncher. It delegates to the launcher's launch mechanism.

```APIDOC
## [MAIN] PropertiesLauncher.main(String[] args)

### Description
Static main method to launch the application using PropertiesLauncher. It delegates to the launcher's launch mechanism.

### Method
main

### Signature
`public static void main(String[] args)`

### Parameters
- **args** (String[]) - Required - Command line arguments passed to the application.

### Usage
This method is the entry point for launching a Spring Boot application with PropertiesLauncher.

### Response
No return value.
```

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

### Kotlin @PulsarReader example

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

Kotlin equivalent of the Java example, creating a reader endpoint that starts reading from the beginning of 'someTopic'. Uses the same annotation and configuration as the Java version.

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

@Component
class MyBean {

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

}
```

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

### logStartupInfo(boolean isRoot) - Deprecated

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

Deprecated method for logging startup information. Use logStartupInfo(ConfigurableApplicationContext) instead. This method is subject to removal in a future version.

```APIDOC
## logStartupInfo(boolean isRoot) - Deprecated

### Description
Deprecated, for removal: This API element is subject to removal in a future version. Since 3.4.0 for removal in 4.0.0 in favor of logStartupInfo(ConfigurableApplicationContext). Called to log startup information, subclasses may override to add additional logging.

### Method
@Deprecated(since="3.4.0", forRemoval=true) protected void logStartupInfo(boolean isRoot)

### Parameters
- **isRoot** (boolean) - Required - Indicates if this is the root application context.

### Deprecated
Since 3.4.0, for removal in 4.0.0. Use logStartupInfo(ConfigurableApplicationContext) instead.
```

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

### HTTP Response for GET integrationgraph

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

Example HTTP response from the GET request, showing a 200 OK status and a JSON body with Spring Integration component details.

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

{
  "contentDescriptor" : {
    "providerVersion" : "6.4.10",
    "providerFormatVersion" : 1.2,
    "provider" : "spring-integration"
  },
  "nodes" : [ {
    "nodeId" : 1,
    "componentType" : "null-channel",
    "integrationPatternType" : "null_channel",
    "integrationPatternCategory" : "messaging_channel",
    "properties" : { },
    "name" : "nullChannel",
    "observed" : false
  }, {
    "nodeId" : 2,
    "componentType" : "publish-subscribe-channel",
    "integrationPatternType" : "publish_subscribe_channel",
    "integrationPatternCategory" : "messaging_channel",
    "properties" : { },
    "name" : "errorChannel",
    "observed" : false
  }, {
    "nodeId" : 3,
    "componentType" : "logging-channel-adapter",
    "integrationPatternType" : "outbound_channel_adapter",
    "integrationPatternCategory" : "messaging_endpoint",
    "properties" : { },
    "input" : "errorChannel",
    "name" : "errorLogger",
    "observed" : false
  } ],
  "links" : [ {
    "from" : 2,
    "to" : 3,
    "type" : "input"
  } ]
}

```

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

### startRecording()

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

Starts the recording of steps and marks the beginning of the StartupTimeline. The constructor implicitly calls this, but it can be reset if no steps have been recorded yet.

```APIDOC
## Method: 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.

### Method
void

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

```

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

### WebClient usage example in Kotlin

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

Kotlin version of the WebClient example. It injects the WebClient.Builder, builds a WebClient with a base URL, and performs a GET request returning a Mono<Details>.

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

}
```

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

### logStartupInfo(ConfigurableApplicationContext context)

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

Called to log startup information. Subclasses may override to add additional logging. Available since 3.4.0.

```APIDOC
## logStartupInfo(ConfigurableApplicationContext context)

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

### Method
protected void logStartupInfo(ConfigurableApplicationContext context)

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

### Since
3.4.0
```

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

### Start the init.d service on Debian-based systems

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

Start the service using the service command. If the application fails to start, check the log file written to /var/log/<appname>.log for errors.

```shell
$ service myapp start
```

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

### Example response for GET /actuator/prometheus

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

Example response showing the Prometheus text format with JVM metrics. The response includes headers and metric lines with HELP and TYPE comments.

```http
HTTP/1.1 200 OK
Content-Type: text/plain;version=0.0.4;charset=utf-8
Content-Length: 3088

# HELP jvm_buffer_count_buffers An estimate of the number of buffers in the pool
# TYPE jvm_buffer_count_buffers gauge
jvm_buffer_count_buffers{id="direct"} 3.0
jvm_buffer_count_buffers{id="mapped"} 0.0
jvm_buffer_count_buffers{id="mapped - 'non-volatile memory'"} 0.0
# HELP jvm_buffer_memory_used_bytes An estimate of the memory that the Java virtual machine is using for this buffer pool
# TYPE jvm_buffer_memory_used_bytes gauge
jvm_buffer_memory_used_bytes{id="direct"} 45056.0
jvm_buffer_memory_used_bytes{id="mapped"} 0.0
jvm_buffer_memory_used_bytes{id="mapped - 'non-volatile memory'"} 0.0
# HELP jvm_buffer_total_capacity_bytes An estimate of the total capacity of the buffers in this pool
# TYPE jvm_buffer_total_capacity_bytes gauge
jvm_buffer_total_capacity_bytes{id="direct"} 45056.0
jvm_buffer_total_capacity_bytes{id="mapped"} 0.0
jvm_buffer_total_capacity_bytes{id="mapped - 'non-volatile memory'"} 0.0
# HELP jvm_memory_committed_bytes The amount of memory in bytes that is committed for the Java virtual machine to use
# TYPE jvm_memory_committed_bytes gauge
jvm_memory_committed_bytes{area="heap",id="G1 Eden Space"} 4.6137344E7
jvm_memory_committed_bytes{area="heap",id="G1 Old Gen"} 1.11149056E8
jvm_memory_committed_bytes{area="heap",id="G1 Survivor Space"} 4194304.0
jvm_memory_committed_bytes{area="nonheap",id="CodeHeap 'non-nmethods'"} 2555904.0
jvm_memory_committed_bytes{area="nonheap",id="CodeHeap 'non-profiled nmethods'"} 2818048.0
jvm_memory_committed_bytes{area="nonheap",id="CodeHeap 'profiled nmethods'"} 1.8808832E7
jvm_memory_committed_bytes{area="nonheap",id="Compressed Class Space"} 1.1337728E7
jvm_memory_committed_bytes{area="nonheap",id="Metaspace"} 8.060928E7
# HELP jvm_memory_max_bytes The maximum amount of memory in bytes that can be used for memory management
# TYPE jvm_memory_max_bytes gauge
jvm_memory_max_bytes{area="heap",id="G1 Eden Space"} -1.0
jvm_memory_max_bytes{area="heap",id="G1 Old Gen"} 1.073741824E9
jvm_memory_max_bytes{area="heap",id="G1 Survivor Space"} -1.0
jvm_memory_max_bytes{area="nonheap",id="CodeHeap 'non-nmethods'"} 5836800.0
jvm_memory_max_bytes{area="nonheap",id="CodeHeap 'non-profiled nmethods'"} 1.22912768E8
jvm_memory_max_bytes{area="nonheap",id="CodeHeap 'profiled nmethods'"} 1.22908672E8
jvm_memory_max_bytes{area="nonheap",id="Compressed Class Space"} 1.073741824E9
jvm_memory_max_bytes{area="nonheap",id="Metaspace"} -1.0
# HELP jvm_memory_used_bytes The amount of used memory
# TYPE jvm_memory_used_bytes gauge
jvm_memory_used_bytes{area="heap",id="G1 Eden Space"} 2.3068672E7
jvm_memory_used_bytes{area="heap",id="G1 Old Gen"} 8.3431936E7
jvm_memory_used_bytes{area="heap",id="G1 Survivor Space"} 3300800.0
jvm_memory_used_bytes{area="nonheap",id="CodeHeap 'non-nmethods'"} 1377280.0
jvm_memory_used_bytes{area="nonheap",id="CodeHeap 'non-profiled nmethods'"} 2808704.0
jvm_memory_used_bytes{area="nonheap",id="CodeHeap 'profiled nmethods'"} 1.8747904E7
jvm_memory_used_bytes{area="nonheap",id="Compressed Class Space"} 1.0977192E7
jvm_memory_used_bytes{area="nonheap",id="Metaspace"} 7.983456E7
```

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

### persistAndGetId with Type Example

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/test/autoconfigure/orm/jpa/TestEntityManager.html

Shows how to persist an entity and get its ID cast to a specific type, such as Long.

```java
Long entityId = this.testEntityManager.persist(new MyEntity("Spring"), Long.class);
```

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

### start()

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/devtools/livereload/LiveReloadServer.html

Starts the livereload server and accepts incoming connections. Returns the port on which the server is listening.

```APIDOC
## start()

### Description
Starts the livereload server and accepts incoming connections. Returns the port on which the server is listening.

### Method
`public int start() throws IOException`

### Parameters
None.

### Returns
- **int** - the port on which the server is listening

### Throws
- `IOException` - in case of I/O errors

### Example
```java
LiveReloadServer server = new LiveReloadServer();
int port = server.start();
```
```

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

### persistAndGetId Example

Source: https://docs.spring.io/spring-boot/3.4/api/java/org/springframework/boot/test/autoconfigure/orm/jpa/TestEntityManager.html

Shows how to persist an entity and get its ID as an Object. Useful for setting up test data.

```java
Object entityId = this.testEntityManager.persist(new MyEntity("Spring"));
```

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

### BufferingApplicationStartup(int)

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

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

```APIDOC
## BufferingApplicationStartup(int)

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

### Constructor
`BufferingApplicationStartup(int capacity)`

### Parameters
- **capacity** (int) - Required - The maximum number of steps to buffer.
```

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

### hasBean example

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

Verifies that the application context contains a bean with the given name. Throws AssertionError if the context did not start or does not contain the bean.

```java
assertThat(context).hasBean("fooBean");
```

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

### doesNotHaveBean by name example

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

Verifies that the application context does not contain a bean with the given name. Throws AssertionError if the context did not start or contains a bean with the name.

```java
assertThat(context).doesNotHaveBean("fooBean");
```

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

### onStart()

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

Called when the operation starts. This is a default method that can be overridden.

```APIDOC
## onStart()

### Description
Called when the operation starts.

### Method
`default void onStart()`

### Parameters
None.

### Returns
void
```

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

### Retrieve a single SBOM with curl

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

Make a GET request to /actuator/sbom/{id} to retrieve a specific SBOM. The example retrieves the SBOM named 'application'.

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

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

### spring-devtools.properties example for restart classloader customization

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

Example properties file that excludes local class files and includes extra libraries in the restart classloader. Property keys must be unique and start with restart.include. or restart.exclude. to be considered. All META-INF/spring-devtools.properties from the classpath are loaded; system properties cannot be used.

```properties
restart:
  exclude:
    companycommonlibs: "/mycorp-common-[\w\d-\.]/(build|bin|out|target)/"
  include:
    projectcommon: "/mycorp-myproj-[\w\d-\.]+\.jar"
```

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

### Classpath Index Example

Source: https://docs.spring.io/spring-boot/3.4/specification/executable-jar/nested-jars.html

Shows the format of BOOT-INF/classpath.idx, listing jar names in classpath order. Each line starts with dash space and names are in double quotes.

```none
- "BOOT-INF/lib/dependency2.jar"
- "BOOT-INF/lib/dependency1.jar"
```

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

### initialize(LoggingInitializationContext, String, LogFile)

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

Fully initializes the logging system with the given configuration.

```APIDOC
## initialize(LoggingInitializationContext, String, LogFile)

### Description
Fully initialize the logging system.

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

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

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

### SpringApplication.logStartupInfo(ConfigurableApplicationContext context)

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

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

```APIDOC
## logStartupInfo(ConfigurableApplicationContext context)

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

### Method
protected void

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

### Returns
void
```

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

### doesNotHaveBean by type example

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

Verifies that the application context (or ancestors) does not contain any beans of the given type. Throws AssertionError if the context did not start or contains any beans of the type.

```java
assertThat(context).doesNotHaveBean(Foo.class);
```

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

### initialize

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

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

```APIDOC
## initialize

### Description
Fully initializes the logging system.

### Method
initialize

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

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

### Returns
void
```

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

### HTTP response for job details

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

Example response from the GET request, showing job details and associated triggers. Sensitive data map values are sanitized.

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

{
  "group" : "samples",
  "name" : "jobOne",
  "description" : "A sample job",
  "className" : "org.springframework.scheduling.quartz.DelegatingJob",
  "durable" : false,
  "requestRecovery" : false,
  "data" : {
    "password" : "secret",
    "user" : "admin"
  },
  "triggers" : [ {
    "group" : "samples",
    "name" : "every-day",
    "previousFireTime" : "2020-12-04T03:00:00.000+00:00",
    "nextFireTime" : "2020-12-04T12:00:00.000+00:00",
    "priority" : 7
  }, {
    "group" : "samples",
    "name" : "3am-weekdays",
    "nextFireTime" : "2020-12-07T03:00:00.000+00:00",
    "priority" : 3
  } ]
}
```

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

### applicationStartup(ApplicationStartup applicationStartup)

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

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

```APIDOC
## Method: applicationStartup(ApplicationStartup applicationStartup)

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

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

### Returns
- **SpringApplicationBuilder** - The builder instance for fluent chaining.

### Example
```java
new SpringApplicationBuilder(Application.class)
    .applicationStartup(startup)
```
```

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

### hasSingleBean example

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

Verifies that the application context (or ancestors) contains a single bean of the given type. Throws AssertionError if the context did not start, has no beans of the type, or has multiple beans of the type.

```java
assertThat(context).hasSingleBean(Foo.class);
```

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

### HTTP response for retrieving a single logger

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

Example HTTP response for a GET request to /actuator/loggers/com.example. It returns a 200 OK status with a JSON body containing configuredLevel and effectiveLevel.

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

{
  "configuredLevel" : "INFO",
  "effectiveLevel" : "INFO"
}

```

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

### start()

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

Starts the encoder lifecycle.

```APIDOC
## start()

### Description
Starts the encoder lifecycle.

### Method
start

### Signature
`public void start()`

```

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

### logStartupInfo(boolean logStartupInfo)

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

Flag to indicate the startup information should be logged.

```APIDOC
## Method: logStartupInfo(boolean logStartupInfo)

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

### Parameters
- **logStartupInfo** (boolean) - Required - Whether to log startup info.

### Returns
- **SpringApplicationBuilder** - The builder instance for fluent chaining.

### Example
```java
new SpringApplicationBuilder(Application.class)
    .logStartupInfo(true)
```
```

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

### JsonbTester usage example in JUnit test

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

Shows how to instantiate JsonbTester via initFields in a test setup, then use it to write an object and assert the JSON equals an expected file.

```java
public class ExampleObjectJsonTests {

        private JsonbTester<ExampleObject> json;

        @Before
        public void setup() {
                Jsonb jsonb = JsonbBuilder.create();
                JsonbTester.initFields(this, jsonb);
        }

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

 }
```

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

### doesNotHaveBean by type with scope example

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

Verifies that the application context does not contain any beans of the given type within the specified scope. Throws AssertionError if the context did not start or contains any beans of the type.

```java
assertThat(context).doesNotHaveBean(Foo.class, Scope.NO_ANCESTORS);
```

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

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

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

Create an application from an existing main method that can run with additional @Configuration or bean classes. Helpful for test harnesses that need to start an application with additional configuration.

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

### Description
Create an application from an existing `main` method that can run with additional `@Configuration` or bean classes. This method can be helpful when writing a test harness that needs to start an application with additional configuration.

### Method
from

### Parameters
- `main` (ThrowingConsumer<String[]>) - Required - The main method entry point that runs the `SpringApplication`.

### Returns
- `SpringApplication.Augmented` - A `SpringApplication.Augmented` instance that can be used to add configuration and run the application.

### Since
3.1.0

### See Also
- `withHook(SpringApplicationHook, Runnable)`
```

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

### Typical RestClient usage in Kotlin

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

Kotlin version of the typical RestClient example. It injects the auto-configured RestClient.Builder, sets a base URL, and performs a GET request to retrieve a Details object.

```kotlin
import org.springframework.boot.docs.io.restclient.restclient.ssl.Details
import org.springframework.stereotype.Service
import org.springframework.web.client.RestClient

@Service
class MyService(restClientBuilder: RestClient.Builder) {

	private val restClient: RestClient

	init {
		restClient = restClientBuilder.baseUrl("https://example.org").build()
	}

	fun someRestCall(name: String?): Details {
		return restClient.get().uri("/{name}/details", name)
				.retrieve().body(Details::class.java)!!
	}

}
```

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

### LoggingSystem.initialize(LoggingInitializationContext, String, LogFile)

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

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

```APIDOC
## initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)

### Description
Fully initialize the logging system.

### Method
void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile)

### Parameters
- **initializationContext** (LoggingInitializationContext) - Required - The initialization context.
- **configLocation** (String) - Required - The location of the logging configuration.
- **logFile** (LogFile) - Required - The log file to use.

### Returns
void
```

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

### Retrieve Job Group Overview with curl

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

Makes a GET request to /actuator/quartz/jobs/{groupName} to retrieve an overview of jobs in a particular group. The example retrieves the summary for jobs in the 'samples' group.

```bash
$ curl 'http://localhost:8080/actuator/quartz/jobs/samples' -i -X GET

```

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

{
  "group" : "samples",
  "jobs" : {
    "jobOne" : {
      "className" : "org.springframework.scheduling.quartz.DelegatingJob"
    },
    "jobTwo" : {
      "className" : "org.quartz.Job"
    }
  }
}

```

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

### Create single instance environment with eb create -s

Source: https://docs.spring.io/spring-boot/3.4/how-to/deployment/cloud.html

Use this CLI command to create a single instance environment, avoiding the significant cost of a load balancer.

```none
eb create -s
```

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

### Java @PulsarReader example

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

Creates a reader endpoint that starts reading messages from the beginning of the 'someTopic' topic. The @PulsarReader annotation relies on a PulsarReaderFactory, which can be customized via spring.pulsar.reader.* properties or ReaderBuilderCustomizer beans.

```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) {
		// ...
	}

}
```

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

### curl GET request to retrieve trigger details

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

Use this curl command to retrieve details of a trigger identified by group 'samples' and name 'example' from the Spring Boot Actuator Quartz endpoint.

```bash
$ curl 'http://localhost:8080/actuator/quartz/triggers/samples/example' -i -X GET
```

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

### List start.spring.io capabilities with spring init --list

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

Displays available dependencies and project types from the start.spring.io service. The output is truncated with `...` in the source, indicating additional content not shown.

```shell
$ 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)

...
```
Tokens:
Raw