Spring Framework

https://docs.spring.io/spring-framework/docs/5.3.4/
Admin
Spring Framework is a comprehensive Java framework for building enterprise applications with support...
Tokens:6,938,153
Snippets:88,377
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Basic MockMvcWebClientBuilder Setup (Java/Kotlin)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Repeats the simplest MockMvcWebClientBuilder setup, building a WebClient from the WebApplicationContext loaded by the Spring TestContext Framework. This is the baseline for advanced configuration examples.

```java
WebClient webClient;

@BeforeEach
void setup(WebApplicationContext context) {
    webClient = MockMvcWebClientBuilder
            .webAppContextSetup(context)
            .build();
}
```

```kotlin
lateinit var webClient: WebClient

@BeforeEach
fun setup(context: WebApplicationContext) {
    webClient = MockMvcWebClientBuilder
            .webAppContextSetup(context)
            .build()
}
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/jms/config/JmsListenerEndpointRegistry.html

Starts the registry.

```APIDOC
## start

### Description
Starts this component.

### Method
start

### Parameters
None

### Return Type
void
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/context/support/AbstractApplicationContext.html

Start this component.

```APIDOC
## [METHOD] [ENDPOINT]

### Description
Start this component.

### Method
void

### Endpoint
start()

### Parameters
None

### Response
#### Success Response (200)
- **void** - No return value

#### Response Example
```
void
```
```

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

### start

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/jms/listener/AbstractJmsListeningContainer.html

Start this container. Throws JmsException if starting fails.

```APIDOC
## start

### Description
Start this container.

### Method
start

### Signature
`public void start() throws JmsException`

### Parameters
None

### Throws
- **JmsException** - if starting failed

### See Also
- `doStart()`
```

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

### Output of the InstantiationTracingBeanPostProcessor example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Example output from the Boot application. It shows the message printed by the InstantiationTracingBeanPostProcessor and the toString() result of the messenger bean.

```text
Bean 'messenger' created : org.springframework.scripting.groovy.GroovyMessenger@272961
org.springframework.scripting.groovy.GroovyMessenger@272961
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/test/context/transaction/TestTransaction.html

Starts a new test-managed transaction.

```APIDOC
## start()

### Description
Starts a new test-managed transaction. Only call this method if `end()` has been called or if no transaction has been previously started.

### Method
start()

### Return Type
void

### Throws
- `IllegalStateException` - if the transaction context could not be retrieved or if a transaction is already active for the current test

### See Also
- `isActive()`
- `end()`
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/socket/client/JettyWebSocketClient.html

Starts the component. If the component is already running, it should not throw an exception. For containers, this propagates the start signal to all components.

```APIDOC
## start()

### Description
Start this component. Should not throw an exception if the component is already running. In the case of a container, this will propagate the start signal to all components that apply.

### Method
N/A (Java method)

### Signature
`void start()`

### Specified by
- `start` in interface `Lifecycle`

### See Also
- `SmartLifecycle.isAutoStartup()`

```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/util/backoff/FixedBackOff.html

Starts a new back off execution and returns a fresh BackOffExecution ready to be used.

```APIDOC
## start()

### Description
Starts a new back off execution. This method is specified by the BackOff interface.

### Method
`public BackOffExecution start()`

### Returns
- **BackOffExecution** - A fresh BackOffExecution ready to be used.

### Example
```java
BackOffExecution execution = backOff.start();
```
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/socket/client/ConnectionManagerSupport.html

Starts the WebSocket connection. This method is final and is part of the Lifecycle interface.

```APIDOC
## start()

### Description
Starts the WebSocket connection. This method is final and is part of the Lifecycle interface.

### Method
start

### Response
No return value.
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/jms/listener/DefaultMessageListenerContainer.html

Starts the listener container, resetting any stop callback.

```APIDOC
## start()

### Description
Overridden to reset the stop callback, if any.

### Method
start

### Return Type
void
```

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

### start method

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/socket/sockjs/client/JettyXhrTransport.html

Starts the component. Should not throw an exception if already running. For a container, propagates the start signal to all components.

```java
public void start()
```

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

### start

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/socket/sockjs/client/SockJsClient.html

Starts the component, propagating the start signal to all components that apply.

```APIDOC
## start

### Description
Start this component. Should not throw an exception if the component is already running. In the case of a container, this will propagate the start signal to all components that apply.

### Method
start

### Specified By
- `start` in interface `Lifecycle`

### See Also
- `SmartLifecycle.isAutoStartup()`
```

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

### Make requests from server to client in @ConnectMapping

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web-reactive.html

Shows how to make requests from a server to connected clients using the RSocketRequester argument in @ConnectMapping methods. Because @ConnectMapping methods handle the SETUP frame, requests must be started asynchronously (e.g., via subscribe or GlobalScope.launch) and decoupled from the handling logic. The method returns a completion Mono<Void> or performs handling in a suspending function.

```java
@ConnectMapping
Mono<Void> handle(RSocketRequester requester) {
    requester.route("status").data("5")
        .retrieveFlux(StatusReport.class)
        .subscribe(bar -> { __**(1)**
            // ...
        });
    return ... __**(2)**
}
```

```kotlin
@ConnectMapping
suspend fun handle(requester: RSocketRequester) {
    GlobalScope.launch {
        requester.route("status").data("5").retrieveFlow<StatusReport>().collect { __**(1)**
            // ...
        }
    }
    /// ... __**(2)**
}
```

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

### prepare

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/remoting/rmi/JndiRmiClientInterceptor.html

Fetches the RMI stub on startup.

```APIDOC
## prepare

### Description
Fetches the RMI stub on startup, if necessary.

### Method
prepare

### Parameters
None

### Return
void
```

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

### WebClient.get()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/client/WebClient.html

Starts building an HTTP GET request.

```APIDOC
## WebClient.get()

### Description
Starts building an HTTP GET request.

### Method
GET

### Endpoint
N/A (request builder)

### Parameters
None

### Returns
- **WebClient.RequestHeadersUriSpec<?>** - a spec for specifying the target URL

### Example
```java
WebClient.RequestHeadersUriSpec<?> spec = client.get();
```
```

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

### SQL Sequence Table Setup Example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/jdbc/support/incrementer/SqlServerMaxValueIncrementer.html

Example SQL commands to create a table and its corresponding sequence table for use with SqlServerMaxValueIncrementer.

```sql
create table tab (id int not null primary key, text varchar(100))
 create table tab_sequence (id bigint identity)
 insert into tab_sequence default values
```

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

### prepare

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/remoting/rmi/JndiRmiClientInterceptor.html

Fetches the RMI stub on startup, if necessary.

```APIDOC
## prepare

### Description
Fetches the RMI stub on startup, if necessary.

### Method
prepare

### Throws
- `RemoteLookupFailureException` - if RMI stub creation failed

### See Also
- `setLookupStubOnStartup(boolean)`, `lookupStub()`
```

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

### GET(String pattern, RequestPredicate, HandlerFunction) route builder method with example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/server/RouterFunctions.Builder.html

Adds a route to the given handler function that handles all HTTP GET requests that match the given pattern and predicate. The example routes GET requests for "/user" that accept JSON to the listUsers method in userController. Returns this builder. See also RequestPredicates.

```java
RouterFunctions.Builder GET(String pattern,
                            RequestPredicate predicate,
                            HandlerFunction<ServerResponse> handlerFunction)
```

```java
 RouterFunction<ServerResponse> route =
   RouterFunctions.route()
     .GET("/user", RequestPredicates.accept(MediaType.APPLICATION_JSON), userController::listUsers)
     .build();

```

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

### start(String name)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/core/metrics/ApplicationStartup.html

Creates a new startup step and marks its beginning. The step name should be namespaced with dots and can be reused to describe other instances of the same step during application startup.

```APIDOC
## start(String name)

### Description
Creates a new step and marks its beginning. The step name describes the current action or phase and should be namespaced with dots. This method is part of the ApplicationStartup interface for instrumenting application startup.

### Method
start

### Signature
StartupStep start(String name)

### Parameters
- **name** (String) - Required - The step name, a technical name that should be dot-namespaced.

### Returns
- **StartupStep** - The created StartupStep instance representing the started step.

### Example
```java
StartupStep step = applicationStartup.start("spring.boot.application");
// ... perform startup actions ...
step.end();
```
```

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

### Kotlin Example class with MessageSource

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Kotlin equivalent of the Example class, using lateinit var and arrayOf for arguments.

```kotlin
class Example {

    lateinit var messages: MessageSource

    fun execute() {
        val message = messages.getMessage("argument.required",
                arrayOf("userDao"), "Required", Locale.ENGLISH)
        println(message)
    }
}
```

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

### Kotlin placeholder for MockMvc setup

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Kotlin placeholder indicating that the equivalent setup is not possible until a specific issue is fixed.

```kotlin
// Not possible in Kotlin until https://youtrack.jetbrains.com/issue/KT-22208 is fixed
```

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

### Track application startup with ApplicationStartup

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Instrument the application context startup by creating a StartupStep, tagging it with package information, performing the scan, and ending the step. The Java and Kotlin versions are equivalent.

```java
// create a startup step and start recording
StartupStep scanPackages = this.getApplicationStartup().start("spring.context.base-packages.scan");
// add tagging information to the current step
scanPackages.tag("packages", () -> Arrays.toString(basePackages));
// perform the actual phase we're instrumenting
this.scanner.scan(basePackages);
// end the current step
scanPackages.end();
```

```kotlin
// create a startup step and start recording
val scanPackages = this.getApplicationStartup().start("spring.context.base-packages.scan")
// add tagging information to the current step
scanPackages.tag("packages", () -> Arrays.toString(basePackages))
// perform the actual phase we're instrumenting
this.scanner.scan(basePackages)
// end the current step
scanPackages.end()
```

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

### asyncDispatch usage example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/test/web/servlet/request/MockMvcRequestBuilders.html

Usage example for asyncDispatch: first perform a request that starts async processing and capture the MvcResult, then perform the async dispatch re-using that MvcResult and verify the response.

```java
 MvcResult mvcResult = this.mockMvc.perform(get("/1"))
        .andExpect(request().asyncStarted())
        .andReturn();
```

```java
 this.mockMvc.perform(asyncDispatch(mvcResult))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(content().string("{\"name\":\"Joe\",\"someDouble\":0.0,\"someBoolean\":false}"));
```

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

### Example usage of mergePdfDocument

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/servlet/view/document/AbstractPdfStamperView.html

Example of what can be done in mergePdfDocument: getting the AcroFields from the PdfStamper, setting form field values, and setting the Content-disposition header. Note that the response is only for setting cookies or headers; the PDF is written automatically after the method returns.

```java
 // get the form from the document
 AcroFields form = stamper.getAcroFields();

 // set some values on the form
 form.setField("field1", "value1");
 form.setField("field2", "Vvlue2");

 // set the disposition and filename
 response.setHeader("Content-disposition", "attachment; FILENAME=someName.pdf");
```

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

### initialize

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.html

Set up the ExecutorService.

```APIDOC
## initialize

### Description
Set up the ExecutorService.

### Method
initialize

### Parameters
None

### Return
void
```

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

### Register a filter with MockMvc

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Registers a Servlet Filter when setting up a MockMvc instance. This example adds a CharacterEncodingFilter to a standalone setup.

```java
mockMvc = standaloneSetup(new PersonController()).addFilters(new CharacterEncodingFilter()).build();
```

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

### preProcess

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/context/request/async/CallableProcessingInterceptor.html

Method to perform setup before the Callable is invoked in the async thread.

```APIDOC
## CallableProcessingInterceptor.preProcess

### Description
Invoked after the start of concurrent handling in the async thread in which the Callable is executed and before the actual invocation of the Callable.

### Method
preProcess

### Signature
`default <T> void preProcess(NativeWebRequest request, Callable<T> task) throws Exception`

### Parameters
- **request** (NativeWebRequest) - The current request.
- **task** (Callable<T>) - The task for the current async request.

### Throws
- **Exception** - in case of errors.
```

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

### HTML output for form:select with multiple

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web.html

Example HTML output for a select with multiple selection. The selected option gets the selected attribute.

```html
<tr>
    <td>Skills:</td>
    <td>
        <select name="skills" multiple="true">
            <option value="Potions">Potions</option>
            <option value="Herbology" selected="selected">Herbology</option>
            <option value="Quidditch">Quidditch</option>
        </select>
    </td>
</tr>
```

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

### nest(RequestPredicate, RouterFunction) example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/server/RouterFunctions.html

Creates nested routes by composing a route for GET and POST, then nesting it under a "/user" path predicate. GET requests for "/user" list users, POST requests create a new user.

```java
RouterFunction<ServerResponse> userRoutes =
  RouterFunctions.route(RequestPredicates.method(HttpMethod.GET), this::listUsers)
    .andRoute(RequestPredicates.method(HttpMethod.POST), this::createUser);
RouterFunction<ServerResponse> nestedRoute =
  RouterFunctions.nest(RequestPredicates.path("/user"), userRoutes);
```

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

### matchStart(String pattern, String path)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/util/AntPathMatcher.html

Matches the given path against the corresponding part of the given pattern, according to this matcher's matching strategy.

```APIDOC
## matchStart(String pattern, String path)

### Description
Matches the given path against the corresponding part of the given pattern, according to this matcher's matching strategy.

### Method
boolean

### Signature
`public boolean matchStart(String pattern, String path)`

### Parameters
- **pattern** (String) - Required - The pattern to match.
- **path** (String) - Required - The path to match.

### Returns
boolean - true if the start of the path matches the pattern, false otherwise.

### Example
```java
boolean matched = matcher.matchStart("/a/**", "/a/b");
```
```

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

### Example Using Status and Content Result Matchers

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/test/web/servlet/ResultMatcher.html

Shows how to use MockMvc with ResultMatcher instances to assert the HTTP status and content type of a response. The example builds a MockMvc from a WebApplicationContext, performs a GET request to '/form', and verifies the status is OK and the content type is application/json.

```java
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;

 // ...

 WebApplicationContext wac = ...;

 MockMvc mockMvc = webAppContextSetup(wac).build();

 mockMvc.perform(get("/form"))
   .andExpect(status().isOk())
   .andExpect(content().mimeType(MediaType.APPLICATION_JSON));
 
```

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

### HTML output for form:select with options

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web.html

Example HTML output for a select with nested options. The selected option gets the selected attribute, as noted by the footnote.

```html
<tr>
    <td>House:</td>
    <td>
        <select name="house">
            <option value="Gryffindor" selected="selected">Gryffindor</option> __**(1)**
            <option value="Hufflepuff">Hufflepuff</option>
            <option value="Ravenclaw">Ravenclaw</option>
            <option value="Slytherin">Slytherin</option>
        </select>
    </td>
</tr>
```

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

### getApplicationStartup

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/beans/factory/config/ConfigurableBeanFactory.html

Returns the application startup metrics recorder.

```APIDOC
## getApplicationStartup

### Description
Returns the `ApplicationStartup` for this bean factory.

### Method
getApplicationStartup

### Returns
- `ApplicationStartup` - The application startup instance.

### Since
5.3
```

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

### Example request headers

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web-reactive.html

Example HTTP request headers used to illustrate @RequestHeader binding. Shows typical header names and values.

```http
Host                    localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300
```

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

### exchange() example: consume response body manually

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/client/WebClient.RequestHeadersSpec.html

Shows how to use the deprecated exchange() method to get a ClientResponse and then consume the body. The application is responsible for consuming the response content to avoid memory leaks. Two examples are shown: one for a single Person and one for a Flux of Person.

```java
 Mono<Person> mono = client.get()
     .uri("/persons/1")
     .accept(MediaType.APPLICATION_JSON)
     .exchange()
     .flatMap(response -> response.bodyToMono(Person.class));

 Flux<Person> flux = client.get()
     .uri("/persons")
     .accept(MediaType.APPLICATION_STREAM_JSON)
     .exchange()
     .flatMapMany(response -> response.bodyToFlux(Person.class));
 
```

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

### FlightRecorderApplicationStartup() - Constructor

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/index-files/index-6.html

Default constructor for FlightRecorderApplicationStartup.

```APIDOC
## FlightRecorderApplicationStartup() - Constructor

### Description
Default constructor for FlightRecorderApplicationStartup.

### Class
org.springframework.core.metrics.jfr.FlightRecorderApplicationStartup

### Constructor
FlightRecorderApplicationStartup()

### Parameters
None
```

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

### Output of MessageSource example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

The output produced by the Java and Kotlin examples when run with the provided properties file. It shows the placeholder replaced with 'userDao'.

```text
Ebagum lad, the 'userDao' argument is required, I say, required.
```

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

### onStartup(ServletContext servletContext)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/server/adapter/AbstractReactiveWebInitializer.html

The onStartup method is the main entry point for initializing the reactive web application within a servlet container. It configures the provided ServletContext with the necessary components.

```APIDOC
## onStartup(ServletContext servletContext)

### Description
Configures the given ServletContext with any servlets, filters, listeners, context-params, and attributes necessary for initializing this web application. This method is called by the servlet container during startup.

### Method
onStartup

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

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

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

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

### JVM system property to use Oracle DocumentBuilder

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/beans/factory/xml/DefaultDocumentLoader.html

Command-line example to set the JAXP DocumentBuilderFactory system property to use Oracle's implementation when starting the application.

```bash
java -Djavax.xml.parsers.DocumentBuilderFactory=oracle.xml.jaxp.JXDocumentBuilderFactory MyMainClass
```

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

### MockMvcHtmlUnitDriverBuilder setup Kotlin

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Kotlin setup for creating a WebDriver using MockMvcHtmlUnitDriverBuilder in a @BeforeEach function, directing localhost requests to MockMvc.

```kotlin
lateinit var driver: WebDriver

@BeforeEach
fun setup(context: WebApplicationContext) {
    driver = MockMvcHtmlUnitDriverBuilder
            .webAppContextSetup(context)
            .build()
}
```

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

### start()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/jca/endpoint/GenericMessageEndpointManager.html

Activates the configured message endpoint.

```APIDOC
## start()

### Description
Activates the configured message endpoint.

### Method
start

### Signature
`public void start()`

```

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

### route(RequestPredicate, HandlerFunction) example

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/server/RouterFunctions.html

Routes GET requests for "/user" to the listUsers method in userController. The predicate is tested and if it applies, the handler function is invoked.

```java
RouterFunction<ServerResponse> route =
    RouterFunctions.route(RequestPredicates.GET("/user"), userController::listUsers);
```

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

### Example PropertyOverrideConfigurer properties file

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Example properties file for PropertyOverrideConfigurer, overriding driver and url properties of a dataSource bean.

```properties
dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql:mydb
```

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

### onStartup(ServletContext)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/WebApplicationInitializer.html

Documentation for the onStartup method of the WebApplicationInitializer interface.

```APIDOC
## onStartup(ServletContext)

### Description
Initializes the web application by configuring the given ServletContext with servlets, filters, listeners, context-params, and attributes.

### Method
onStartup

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

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

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

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

### Company class for BeanWrapper property access

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Example class used with BeanWrapper to demonstrate setting and getting properties. It has a name property and a managingDirector property of type Employee.

```java
public class Company {

    private String name;
    private Employee managingDirector;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

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

### MockMvcHtmlUnitDriverBuilder setup Java

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Java setup for creating a WebDriver using MockMvcHtmlUnitDriverBuilder in a @BeforeEach method, directing localhost requests to MockMvc.

```java
WebDriver driver;

@BeforeEach
void setup(WebApplicationContext context) {
    driver = MockMvcHtmlUnitDriverBuilder
            .webAppContextSetup(context)
            .build();
}
```

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

### Bind to Router Function with WebTestClient

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/testing.html

Java and Kotlin examples for binding WebTestClient to a RouterFunction for testing functional endpoints without a running server. The setup delegates to RouterFunctions.toWebHandler.

```java
RouterFunction<?> route = ...
client = WebTestClient.bindToRouterFunction(route).build();
```

```kotlin
val route: RouterFunction<*> = ...
val client = WebTestClient.bindToRouterFunction(route).build()
```

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

### Boot application to run the InstantiationTracingBeanPostProcessor example (Java and Kotlin)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Application entry point that loads the Spring context from 'scripting/beans.xml', retrieves the 'messenger' bean, and prints it. The Java version uses ClassPathXmlApplicationContext and the Kotlin version uses the same context with getBean.

```Java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scripting.Messenger;

public final class Boot {

    public static void main(final String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("scripting/beans.xml");
        Messenger messenger = ctx.getBean("messenger", Messenger.class);
        System.out.println(messenger);
    }

}
```

```Kotlin
import org.springframework.beans.factory.getBean

fun main() {
    val ctx = ClassPathXmlApplicationContext("scripting/beans.xml")
    val messenger = ctx.getBean<Messenger>("messenger")
    println(messenger)
}
```

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

### DynamicIntroductionAdvice

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/index-files/index-4.html

AOP advice interface for dynamic introductions.

```APIDOC
## DynamicIntroductionAdvice

### Description
Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor.
```

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

### Autowired ApplicationContext field

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Autowire well-known resolvable dependencies like ApplicationContext without special setup. The example shows field injection of ApplicationContext in Java and Kotlin.

```java
public class MovieRecommender {

    @Autowired
    private ApplicationContext context;

    public MovieRecommender() {
    }

    // ...
}
```

```kotlin
class MovieRecommender {

    @Autowired
    lateinit var context: ApplicationContext
```

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

### BeanWrapper property manipulation in Java

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

Java example showing how to use BeanWrapperImpl to set and get properties on Company and Employee instances, including nested property access.

```java
BeanWrapper company = new BeanWrapperImpl(new Company());
// setting the company name..
company.setPropertyValue("name", "Some Company Inc.");
// ... can also be done like this:
PropertyValue value = new PropertyValue("name", "Some Company Inc.");
company.setPropertyValue(value);

// ok, let's create the director and tie it to the company:
BeanWrapper jim = new BeanWrapperImpl(new Employee());
jim.setPropertyValue("name", "Jim Stravinsky");
company.setPropertyValue("managingDirector", jim.getWrappedInstance());

// retrieving the salary of the managingDirector through the company
Float salary = (Float) company.getPropertyValue("managingDirector.salary");
```

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

### Start WebSocket session with ReactorNettyWebSocketClient

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web-reactive.html

Creates a ReactorNettyWebSocketClient and executes a WebSocket session against ws://localhost:8080/path, printing each received message. Use to start a WebSocket session with the WebFlux client abstraction.

```java
WebSocketClient client = new ReactorNettyWebSocketClient();

URI url = new URI("ws://localhost:8080/path");
client.execute(url, session ->
        session.receive()
                .doOnNext(System.out::println)
                .then());
```

```kotlin
val client = ReactorNettyWebSocketClient()

        val url = URI("ws://localhost:8080/path")
        client.execute(url) { session ->
            session.receive()
                    .doOnNext(::println)
            .then()
        }
```

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

### Define a coroutine router with coRouter DSL

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/languages.html

Example of a Spring @Configuration class defining a router using the coRouter DSL. The router maps GET requests to handler methods.

```kotlin
@Configuration
class RouterConfiguration {

    @Bean
    fun mainRouter(userHandler: UserHandler) = coRouter {
        GET("/", userHandler::listView)
        GET("/api/user", userHandler::listApi)
    }
}
```

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

### IntroductionAdvisor and IntroductionInfo interfaces

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/core.html

The IntroductionAdvisor interface and the start of the IntroductionInfo interface. Introduction advice can only be used with IntroductionAdvisor, not with any pointcut.

```java
public interface IntroductionAdvisor extends Advisor, IntroductionInfo {

    ClassFilter getClassFilter();

    void validateInterfaces() throws IllegalArgumentException;
}

public interface IntroductionInfo {

```

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

### Nest routes with Consumer

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/reactive/function/server/RouterFunctions.Builder.html

Creates nested routes with a common path predicate using a Consumer. The example nests a route for "/user" that handles GET and POST requests.

```java
 RouterFunction<ServerResponse> nestedRoute =
   RouterFunctions.route()
     .nest(RequestPredicates.path("/user"), builder ->
       builder.GET(this::listUsers)
              .POST(this::createUser))
     .build();

```

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

### onStartup(Set<Class<?>>, ServletContext)

Source: https://docs.spring.io/spring-framework/docs/5.3.4/javadoc-api/org/springframework/web/SpringServletContainerInitializer.html

Delegates the ServletContext to all WebApplicationInitializer implementations found on the classpath. This method is called by the Servlet container and is the main entry point for initializing the application.

```APIDOC
## onStartup(Set<Class<?>>, ServletContext)

### Description
Delegates the ServletContext to all WebApplicationInitializer implementations found on the application classpath. This method is invoked by the Servlet container and is the main entry point for initializing the application.

### Method
onStartup

### Signature
`void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException`

### Parameters
- **webAppInitializerClasses** (Set<Class<?>>) - Required - All implementations of WebApplicationInitializer found on the application classpath.
- **servletContext** (ServletContext) - Required - The servlet context to be initialized.

### Throws
- **ServletException** - If an error occurs during initialization.

### See Also
- WebApplicationInitializer.onStartup(ServletContext)
- AnnotationAwareOrderComparator

### Behavior
- If no WebApplicationInitializer implementations are found, this method is a no-op and an INFO-level log message is issued.
- If implementations are found, they are instantiated and sorted (if @Order annotation is present or Ordered interface is implemented).
- Then WebApplicationInitializer.onStartup(ServletContext) is invoked on each instance, allowing registration of servlets, listeners, and filters.
```

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

### Route GET with Accept header predicate using RouterFunctions.route()

Source: https://docs.spring.io/spring-framework/docs/5.3.4/reference/html/web.html

Creates a router function that maps GET requests for /hello-world with an Accept header of text/plain to a handler returning "Hello World". Uses the RouterFunctions.route() builder and the accept(RequestPredicate) predicate.

```java
RouterFunction<ServerResponse> route = RouterFunctions.route()
    .GET("/hello-world", accept(MediaType.TEXT_PLAIN),
        request -> ServerResponse.ok().body("Hello World")).build();
```

```kotlin
import org.springframework.web.servlet.function.router

val route = router {
    GET("/hello-world", accept(TEXT_PLAIN)) {
        ServerResponse.ok().body("Hello World")
    }
}
```
Tokens:
Raw