Spring Framework

https://github.com/spring-projects/spring-framework
Admin
The Spring Framework is the foundation for all Spring projects, providing comprehensive...
Tokens:1,767,556
Snippets:11,372
Trust Score:-
License:Apache-2.0
Update:1 week ago
Show doc for...
Tokens:
Raw
### Use CDS archive to start application

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/aot-cache.adoc

Starts the application with the CDS archive. The classpath must be the same (or a superset) as the training run.

```bash
# With the same classpath (or a superset) tan the training run
java -XX:SharedArchiveFile=app.jsa ...
```

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

### Perform a GET request with RestClient (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Shows how to set up a GET request using RestClient's fluent API. The example specifies a URI with a template variable, retrieves the response, and converts it to a String. The retrieve() call is a no-op until a terminal operation like body() is invoked.

```java
int id = 42;
restClient.get()
	.uri("https://example.com/orders/{id}", id)
	// ...
```

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

### ResourceDatabasePopulator example in Kotlin

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/testcontext-framework/executing-sql.adoc

Kotlin version of the ResourceDatabasePopulator example. Configures the same scripts and separator, then executes against a DataSource.

```kotlin
	@Test
	fun databaseTest() {
		val populator = ResourceDatabasePopulator()
		populator.addScripts(
				ClassPathResource("test-schema.sql"),
				ClassPathResource("test-data.sql"))
		populator.setSeparator("@@")
		populator.execute(dataSource)
		// run code that uses the test schema and data
	}

```

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

### Add Servlet request parameters with param() (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/requests.adoc

Kotlin equivalent of the param example. Uses the get extension function and sets the param property.

```kotlin
	import org.springframework.test.web.servlet.get

	mockMvc.get("/hotels") {
		param("thing", "somewhere")
	}

```

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

### Get all matrix variables as MultiValueMap (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/matrix-variables.adoc

Shows how to retrieve all matrix variables using MultiValueMap. The example maps GET /owners/42;q=11;r=12/pets/21;q=22;s=23 and demonstrates getting all variables and those for a specific path variable.

```java
	// GET /owners/42;q=11;r=12/pets/21;q=22;s=23

	@GetMapping("/owners/{ownerId}/pets/{petId}")
	public void findPet(
			@MatrixVariable MultiValueMap<String, String> matrixVars,
			@MatrixVariable(pathVar="petId") MultiValueMap<String, String> petMatrixVars) {

		// matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
		// petMatrixVars: ["q" : 22, "s" : 23]
	}

```

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

### Specify query parameters in URI template style (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/requests.adoc

Kotlin equivalent of the query parameter example. Uses the get extension function.

```kotlin
	mockMvc.get("/hotels?thing={thing}", "somewhere")

```

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

### MockMvcHtmlUnitDriverBuilder Basic Setup (Java and Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/htmlunit/webdriver.adoc

Basic setup of MockMvcHtmlUnitDriverBuilder using the WebApplicationContext. Java and Kotlin versions are shown.

```java
WebDriver driver;

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

```kotlin
lateinit var driver: WebDriver

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

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

### Example request with headers

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/requestheader.adoc

Shows a sample HTTP request with headers such as Host, Accept, Accept-Language, Accept-Encoding, Accept-Charset, and Keep-Alive. This is the request that the subsequent controller examples handle.

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

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

### Standalone setup with MockMvcBuilders.standaloneSetup

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/setup.adoc

Configures MockMvc directly for a specific controller. Use MockMvcBuilders.standaloneSetup in a @BeforeEach setup method, building a MockMvc instance from the given controller. Equivalent alternatives are shown for Java and Kotlin.

```Java
class MyWebTests {

	MockMvc mockMvc;

	@BeforeEach
	void setup() {
		this.mockMvc = MockMvcBuilders.standaloneSetup(new AccountController()).build();
	}

	// ...

}
```

```Kotlin
class MyWebTests {

	lateinit var mockMvc : MockMvc

	@BeforeEach
	fun setup() {
		mockMvc = MockMvcBuilders.standaloneSetup(AccountController()).build()
	}

	// ...

}
```

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

### Install JDK from .sdkmanrc with SDKMAN!

Source: https://github.com/spring-projects/spring-framework/blob/main/CONTRIBUTING.md

Install the JDK version specified in the .sdkmanrc file. Run this command in the project root to set up the required JDK (currently JDK 25) when using SDKMAN!.

```shell
sdk env install
```

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

### Example class loading log output

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/aot-cache.adoc

Example output from the class loading log showing classes loaded from the cache with 'shared objects file' as the source.

```shell
[0.151s][info][class,load] org.springframework.core.env.EnvironmentCapable source: shared objects file
[0.151s][info][class,load] org.springframework.beans.factory.BeanFactory source: shared objects file
[0.151s][info][class,load] org.springframework.beans.factory.ListableBeanFactory source: shared objects file
[0.151s][info][class,load] org.springframework.beans.factory.HierarchicalBeanFactory source: shared objects file
[0.151s][info][class,load] org.springframework.context.MessageSource source: shared objects file
```

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

### Kotlin: @BeforeTransaction method

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/annotations/integration-spring/annotation-beforetransaction.adoc

Kotlin version of the @BeforeTransaction example, showing a function annotated to run before a transaction starts.

```kotlin
	@BeforeTransaction // <1>
	fun beforeTransaction() {
		// logic to be run before a transaction is started
	}

```

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

### Example output of queryForList

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc

Example output of queryForList() showing a list of maps with column names as keys.

```text
[{name=Bob, id=1}, {name=Mary, id=2}]
```

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

### Use AOT cache to start application

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/aot-cache.adoc

Starts the application with the AOT cache. The classpath must be the same (or a superset) as the training run.

```bash
# With the same classpath (or a superset) tan the training run
java -XX:AOTCache=app.aot ...
```

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

### Use JDK from .sdkmanrc with SDKMAN!

Source: https://github.com/spring-projects/spring-framework/blob/main/CONTRIBUTING.md

Use the JDK specified in .sdkmanrc in the current shell. Run this command after installing the JDK with 'sdk env install'.

```shell
sdk env
```

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

### Set contextPath and servletPath on a request (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/requests.adoc

Kotlin equivalent of the contextPath and servletPath example.

```kotlin
	import org.springframework.test.web.servlet.get

	mockMvc.get("/app/main/hotels/{id}") {
		contextPath = "/app"
		servletPath = "/main"
	}

```

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

### @ProfileValueSourceConfiguration (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/annotations/integration-junit4.adoc

Kotlin version of the @ProfileValueSourceConfiguration example, using ::class syntax.

```kotlin
	@ProfileValueSourceConfiguration(CustomProfileValueSource::class) // <1>
	class CustomProfileValueSourceTests {
		// class body...
	}

```

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

### MessageSource example output

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/context-introduction.adoc

Expected output when running the Java or Kotlin example with the provided properties file. Shows the formatted message with the placeholder replaced by 'userDao'.

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

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

### Client SUBSCRIBE example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/websocket/stomp/overview.adoc

Example of a client subscribing to receive stock quotes on the destination /topic/price.stock.*.

```stomp
SUBSCRIBE
id:sub-1
destination:/topic/price.stock.*

^@
```

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

### Install all Spring Framework jars to local Maven

Source: https://github.com/spring-projects/spring-framework/blob/main/CONTRIBUTING.md

Install all Spring Framework jars into your local Maven repository. This runs the full publish task without skipping documentation.

```shell
./gradlew publishToMavenLocal
```

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

### POJO init() method example (Java and Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/factory-nature.adoc

POJO initialization method example in Java and Kotlin, paired with the XML bean definition using init-method. The init() method performs initialization work without implementing a Spring-specific interface.

```java
	public class ExampleBean {

		public void init() {
			// do some initialization work
		}
	}

```

```kotlin
	class ExampleBean {

		fun init() {
			// do some initialization work
		}
	}

```

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

### Minimal Ternary Example in Kotlin

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/expressions/language-ref/operator-ternary.adoc

Kotlin equivalent of the minimal ternary example, returning 'falseExp'.

```kotlin
	val falseString = parser.parseExpression(
			"false ? 'trueExp' : 'falseExp'").getValue(String::class.java)
```

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

### MockMvc DSL example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/languages/kotlin/web.adoc

Uses the MockMvc Kotlin DSL to perform a GET request and assert the response. Demonstrates setting request attributes, headers, and principal, then verifying status, content type, JSON path, and JSON content.

```kotlin
	val mockMvc: MockMvc = ...
	mockMvc.get("/person/{name}", "Lee") {
		secure = true
		accept = APPLICATION_JSON
		headers {
			contentLanguage = Locale.FRANCE
		}
		principal = Principal { "foo" }
	}.andExpect {
		status { isOk }
		content { contentType(APPLICATION_JSON) }
		jsonPath("$.name") { value("Lee") }
		content { json("""{"someBoolean": false}""", false) }
	}.andDo {
		print()
	}
```

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

### WebAsyncTask example in Kotlin

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-async.adoc

Kotlin version of the WebAsyncTask example, with a timeout of 20000 ms and a long-running task simulation.

```kotlin
@GetMapping("/callable")
fun handle(): WebAsyncTask<String> {
    return WebAsyncTask(20000L) {
        Thread.sleep(10000) // simulate long-running task
        "asynchronous request completed"
    }
}
```

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

### Java: Test async request with MockMvc

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/async-requests.adoc

Java example for testing async request handling. It performs a GET request, asserts the async result, manually performs the async dispatch, and verifies the final response. Requires static imports of MockMvcRequestBuilders.* and MockMvcResultMatchers.*.

```java
	// static import of MockMvcRequestBuilders.* and MockMvcResultMatchers.*

	@Test
	void test() throws Exception {
		MvcResult mvcResult = this.mockMvc.perform(get("/path"))
				.andExpect(status().isOk()) <1>
				.andExpect(request().asyncStarted()) <2>
				.andExpect(request().asyncResult("body")) <3>
				.andReturn();

		this.mockMvc.perform(asyncDispatch(mvcResult)) <4>
				.andExpect(status().isOk()) <5>
				.andExpect(content().string("body"));
	}

```

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

### WebApplicationContext setup with MockMvcBuilders.webAppContextSetup

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/setup.adoc

Configures MockMvc from a Spring configuration loaded with @SpringJUnitWebConfig. In the @BeforeEach setup method, pass the injected WebApplicationContext to MockMvcBuilders.webAppContextSetup and call build(). The XML location is 'my-servlet-context.xml' in Java and a list with the same string in Kotlin.

```Java
@SpringJUnitWebConfig(locations = "my-servlet-context.xml")
class MyWebTests {

	MockMvc mockMvc;

	@BeforeEach
	void setup(WebApplicationContext wac) {
		this.mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
	}

	// ...

}
```

```Kotlin
@SpringJUnitWebConfig(locations = ["my-servlet-context.xml"])
class MyWebTests {

	lateinit var mockMvc: MockMvc

	@BeforeEach
	fun setup(wac: WebApplicationContext) {
		mockMvc = MockMvcBuilders.webAppContextSetup(wac).build()
	}

	// ...

}
```

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

### Use RSocketRequester in @ConnectMapping method

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/rsocket.adoc

Shows how to obtain an RSocketRequester in a @ConnectMapping method to make requests to a connected client. Requests at the start must be decoupled from handling because @ConnectMapping methods handle the SETUP frame before requests can begin. The Java example starts the request asynchronously and returns a Mono<Void>; the Kotlin example uses a coroutine with GlobalScope.launch.

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

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

### Run MessageSource example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/context-introduction.adoc

Program to run the MessageSource functionality. Both Java and Kotlin examples create a ClassPathXmlApplicationContext, retrieve a message using the getMessage method with a default value, and print it. Output is 'Alligators rock!'.

```java
public static void main(String[] args) {
    MessageSource resources = new ClassPathXmlApplicationContext("beans.xml");
    String message = resources.getMessage("message", null, "Default", Locale.ENGLISH);
    System.out.println(message);
}
```

```kotlin
fun main() {
    val resources = ClassPathXmlApplicationContext("beans.xml")
    val message = resources.getMessage("message", null, "Default", Locale.ENGLISH)
    println(message)
}
```

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

### Create custom StartupStep for scanning base packages

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/context-introduction.adoc

Instrument the scanning of base packages in an AnnotationConfigApplicationContext. This code creates and records a StartupStep, tags it with the package names, and then performs the actual scan. Use this pattern to track custom startup phases in your own application context subclasses.

```java
	// create a startup step and start recording
	try (StartupStep scanPackages = 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);
	}
```

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

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

### Compact log message for request processing

Source: https://github.com/spring-projects/spring-framework/wiki/Logging

Example showing how to compact a log message from 'Processing GET request for [/spring-mvc-showcase/data/param]' to 'GET /spring-mvc-showcase/data/param'.

```text
Processing GET request for [/spring-mvc-showcase/data/param]
```

```text
GET /spring-mvc-showcase/data/param
```

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

### Directory layout for ClassPathXmlApplicationContext shortcut

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/resources.adoc

Shows the directory layout used in the example: services.xml and repositories.xml are in the com/example package alongside MessengerService.class.

```text
com/
  example/
    services.xml
    repositories.xml
    MessengerService.class
```

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

### Server MESSAGE example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/websocket/stomp/overview.adoc

Example of a server broadcasting a stock quote to a subscribed client, with the subscription header matching the client's subscription id.

```stomp
MESSAGE
message-id:nxahklf6-1
subscription:sub-1
destination:/topic/price.stock.MMM

{"ticker":"MMM","price":129.45}^@
```

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

### GET request with RestClient (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Performs a GET request to the specified URI and retrieves the response body as a String. The example shows the basic usage of RestClient in Kotlin.

```kotlin
	val result= restClient.get() <1>
		.uri("https://example.com") <2>
		.retrieve() <3>
		.body<String>() <4>
	
	println(result) <5>

```

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

### Kotlin: Using @ContextConfiguration with initializers attribute

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/initializers.adoc

Kotlin version of the same example, using Kotlin syntax for annotations and class references.

```kotlin
@ExtendWith(SpringExtension::class)
// ApplicationContext will be loaded from TestConfig
// and initialized by TestAppCtxInitializer
@ContextConfiguration(
		classes = [TestConfig::class],
		initializers = [TestAppCtxInitializer::class]) // <1>
class MyTest {
	// class body...
}
```

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

### Perform a GET request with RestClient (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Kotlin version of the RestClient GET request example. It uses the same fluent API and URI template variable syntax as the Java version.

```kotlin
val id = 42
restClient.get()
	.uri("https://example.com/orders/{id}", id)
	// ...
```

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

### Build Spring Framework with Gradle Wrapper

Source: https://github.com/spring-projects/spring-framework/blob/main/CONTRIBUTING.md

Compile, test, and build all jars, distribution zips, and docs. The first run may take a while because it downloads Gradle and dependencies.

```shell
./gradlew build
```

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

### Java: @ResponseBody method example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/responsebody.adoc

Use @ResponseBody on a method to serialize the return value to the response body. The example shows a GET mapping for /accounts/{id} returning an Account object.

```java
	@GetMapping("/accounts/{id}")
	@ResponseBody
	public Account handle() {
		// ...
	}
```

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

### Create CDS archive with ArchiveClassesAtExit

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/aot-cache.adoc

Creates a CDS archive. Requires a JDK/JRE with a base image. Uses -Dspring.context.exit=onRefresh to optimize startup.

```bash
# To create a CDS archive, your JDK/JRE must have a base image
java -XX:ArchiveClassesAtExit=app.jsa -Dspring.context.exit=onRefresh ...
```

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

### Resource location example

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/resources.adoc

A literal resource location path used to illustrate classpath scanning.

```text
com/mycompany/package1/service-context.xml
```

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

### Define a single expectation with andExpect in Kotlin

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/expectations.adoc

Kotlin version of the andExpect example. Note the static import of get from org.springframework.test.web.servlet.

```kotlin
	import org.springframework.test.web.servlet.get

	mockMvc.get("/accounts/1").andExpect {
		status { isOk() }
	}

```

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

### Set up remote, fetch branch, and rebase

Source: https://github.com/spring-projects/spring-framework/wiki/Manually-merging-pull-requests

Commands to add the contributor's remote, fetch their branch, create a local tracking branch, and rebase onto master.

```shell
$> git remote add <ACCOUNT> https://github.com/<ACCOUNT>/spring-framework.git
$> git fetch <ACCOUNT>
$> git checkout --track <ACCOUNT>/<BRANCH> -b <BRANCH>
$> git rebase master
```

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

### Retrieve response body as String with RestClient (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Complete example of a simple GET request using RestClient. It chains get(), uri(), retrieve(), and body(String.class) to obtain the response as a string, then prints it. The numbered comments explain each step.

```java
String result = restClient.get() <1>
	.uri("https://example.com") <2>
	.retrieve() <3>
	.body(String.class); <4>

System.out.println(result); <5>
```

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

### Kotlin: Using only an initializer to configure context

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/initializers.adoc

Kotlin version of the example that uses only an initializer to configure the context.

```kotlin
@ExtendWith(SpringExtension::class)
// ApplicationContext will be initialized by EntireAppInitializer
// which presumably registers beans in the context
@ContextConfiguration(initializers = [EntireAppInitializer::class]) // <1>
class MyTest {
	// class body...
}
```

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

### Create WebClient with builder and codecs customization

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux-webclient/client-builder.adoc

Shows how to create a WebClient with the builder, customizing codecs. The Java and Kotlin variants are equivalent.

```java
WebClient client = WebClient.builder()
		.codecs(configurer -> ... )
		.build();
```

```kotlin
val webClient = WebClient.builder()
		.codecs { configurer -> ... }
		.build()
```

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

### Kotlin: Filter handler functions with before and after

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc-functional.adoc

Kotlin equivalent of the filtering example using the router DSL.

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

	val route = router {
		"/person".nest {
			GET("/{id}", handler::getPerson)
			GET(handler::listPeople)
			before { // <1>
				ServerRequest.from(it)
						.header("X-RequestHeader", "Value").build()
			}
		}
		POST(handler::createPerson)
		after { _, response -> // <2>
			logResponse(response)
		}
	}

```

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

### Add Custom DateFormatter with @InitBinder (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-initbinder.adoc

Java example of an @InitBinder method that adds a DateFormatter with a specific date pattern to the WebDataBinder, using a Formatter-based setup.

```java
	@Controller
	public class FormController {

		@InitBinder
		protected void initBinder(WebDataBinder binder) {
			binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd")); <1>
		}

		// ...
	}

```

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

### Parameters - Kotlin @GetMapping with params

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-requestmapping.adoc

Kotlin equivalent of the params example, testing for myParam=myValue.

```kotlin
	@GetMapping("/pets/{petId}", params = ["myParam=myValue"]) // <1>
	fun findPet(@PathVariable petId: String) {
		// ...
	}

```

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

### Kotlin: Serve resources from a root location

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc-functional.adoc

Kotlin equivalent of the resource serving example using the router DSL.

```kotlin
	val location = FileUrlResource("public-resources/")
	val resources = router { resources("/resources/**", location) }

```

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

### @ConnectMapping

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/rsocket.adoc

Handles the SETUP frame at the start of an RSocket connection and any subsequent metadata push notifications. Methods must return void or Mono<Void> and cannot return data.

```APIDOC
## @ConnectMapping

### Description
Handles the SETUP frame at the start of an RSocket connection and any subsequent metadata push notifications through the METADATA_PUSH frame.

### Usage
Use on methods to handle connection setup and metadata push notifications.

### Parameters
- **patterns** (String[]) - Optional - Patterns to narrow handling to specific connections that have a route in the metadata. If no patterns are declared, all connections match.

### Return Value
Must be declared with `void` or `Mono<Void>` as the return value. Cannot return data.

### Behavior
- If handling returns an error for a new connection, the connection is rejected.
- Handling must not be held up to make requests to the RSocketRequester for the connection.
```

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

### Get AOP proxy bean from factory (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/aop-api/pfb.adoc

Retrieves the AOP proxy bean named 'person' from the bean factory and casts it to the Person interface. This is the Java version of the example.

```java
	Person person = (Person) factory.getBean("person");
```

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

### Access response status and headers with ResponseEntity (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Performs a GET request and converts the response to a ResponseEntity<String> to access status code, headers, and body. The example prints these details.

```kotlin
	val result = restClient.get() <1>
		.uri("https://example.com") <1>
		.retrieve()
		.toEntity<String>() <2>
	
	println("Response status: " + result.statusCode) <3>
	println("Response headers: " + result.headers) <3>
	println("Contents: " + result.body) <3>

```

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

### Access response status and headers with ResponseEntity (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Performs a GET request and converts the response to a ResponseEntity<String> to access status code, headers, and body. The example prints these details.

```java
	ResponseEntity<String> result = restClient.get() <1>
		.uri("https://example.com") <1>
		.retrieve()
		.toEntity(String.class); <2>
	
	System.out.println("Response status: " + result.getStatusCode()); <3>
	System.out.println("Response headers: " + result.getHeaders()); <3>
	System.out.println("Contents: " + result.getBody()); <3>

```

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

### Invoke constructors with new operator (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/expressions/language-ref/constructors.adoc

Kotlin equivalent of the Java example, using `Inventor::class.java` to get the class. Creates an `Inventor` instance and adds it to a list via SpEL.

```kotlin
	val einstein = parser.parseExpression(
		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
			.getValue(Inventor::class.java)

	// create new Inventor instance within the add() method of List
	parser.parseExpression(
		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
			.getValue(societyContext)
```

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

### Basic HelloController example in Java

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller.adoc

A simple @RestController with a @GetMapping method that returns a String to be written to the response body.

```java
@RestController
public class HelloController {

	@GetMapping("/hello")
	public String handle() {
		return "Hello WebFlux";
	}
}
```

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

### Basic HelloController example in Kotlin

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller.adoc

A simple @RestController with a @GetMapping method that returns a String to be written to the response body.

```kotlin
@RestController
class HelloController {

	@GetMapping("/hello")
	fun handle() = "Hello WebFlux"
}
```

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

### Custom error handling with onStatus (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Overrides the default error handling for 4xx client errors by throwing a custom exception. The example shows a GET request to a URL that returns 404.

```kotlin
	val result = restClient.get() <1>
		.uri("https://example.com/this-url-does-not-exist") <1>
		.retrieve()
		.onStatus(HttpStatusCode::is4xxClientError) { _, response -> <2>
			throw MyCustomRuntimeException(response.getStatusCode(), response.getHeaders()) } <3>
		.body<String>()

```

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

### Headers - Kotlin @GetMapping with headers

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-requestmapping.adoc

Kotlin equivalent of the headers example, testing for myHeader=myValue.

```kotlin
	@GetMapping("/pets/{petId}", headers = ["myHeader=myValue"]) // <1>
	fun findPet(@PathVariable petId: String) {
		// ...
	}

```

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

### Enable component scanning with XML <context:component-scan>

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/classpath-scanning.adoc

Shows XML configuration for component scanning using <context:component-scan> with base-package="org.example". Note that this implicitly enables <context:annotation-config>.

```xml
	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:context="http://www.springframework.org/schema/context"
		xsi:schemaLocation="http://www.springframework.org/schema/beans
			https://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/context
			https://www.springframework.org/schema/context/spring-context.xsd">

		<context:component-scan base-package="org.example"/>

	</beans>
```

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

### Custom error handling with onStatus (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

Overrides the default error handling for 4xx client errors by throwing a custom exception. The example shows a GET request to a URL that returns 404.

```java
	String result = restClient.get() <1>
		.uri("https://example.com/this-url-does-not-exist") <1>
		.retrieve()
		.onStatus(HttpStatusCode::is4xxClientError, (request, response) -> { <2>
			throw new MyCustomRuntimeException(response.getStatusCode(), response.getHeaders()); <3>
		})
		.body(String.class);

```

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

### Company class for BeanWrapper property access

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/validation/data-binding.adoc

Example classes used with the BeanWrapper to get and set properties. The Java version uses standard getter/setter methods, while the Kotlin version uses nullable properties.

```java
public class Company {

	private String name;
	private Employee managingDirector;

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

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

	public Employee getManagingDirector() {
		return this.managingDirector;
	}

	public void setManagingDirector(Employee managingDirector) {
		this.managingDirector = managingDirector;
	}
}
```

```kotlin
class Company {
	var name: String? = null
	var managingDirector: Employee? = null
}
```

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

### Kotlin: Test async request with MockMvc

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/async-requests.adoc

Kotlin example for testing async request handling. It performs a GET request, asserts the async result, manually performs the async dispatch, and verifies the final response.

```kotlin
	@Test
	fun test() {
		var mvcResult = mockMvc.get("/path").andExpect {
			status { isOk() } // <1>
			request { asyncStarted() } // <2>
			request { asyncResult("body") } // <3>
		}.andReturn()


		mockMvc.perform(asyncDispatch(mvcResult)) // <4>
				.andExpect {
					status { isOk() } // <5>
					content().string("body")
				}
	}

```

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

### Load FileSystemXmlApplicationContext with file URL (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/resources.adoc

Kotlin equivalent of the Java example, showing how to force a FileSystemXmlApplicationContext to load its definition via a UrlResource by passing a file:// URL to the constructor.

```kotlin
	// force this FileSystemXmlApplicationContext to load its definition via a UrlResource
	val ctx = FileSystemXmlApplicationContext("file:///conf/context.xml")
```

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

### Using NamedParameterJdbcTemplate with Map-based style (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc

Shows the Map-based style of passing named parameters to NamedParameterJdbcTemplate. The example is incomplete in the source; it only shows the DAO class setup and setDataSource method. The remaining methods are not shown.

```java
// some JDBC-backed DAO class...
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

	public void setDataSource(DataSource dataSource) {
		this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
	}
```

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

### Create java.util.Properties using PropertiesFactoryBean and <util:properties/>

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/appendix/xsd-schemas.adoc

Both examples create a `java.util.Properties` instance named `jdbcConfiguration` loaded from `classpath:com/foo/jdbc-production.properties`. The first uses `PropertiesFactoryBean`; the second uses the concise `util:properties` element. The location is a `Resource` location.

```xml
	<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
	<bean id="jdbcConfiguration" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
		<property name="location" value="classpath:com/foo/jdbc-production.properties"/>
	</bean>
```

```xml
	<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
	<util:properties id="jdbcConfiguration" location="classpath:com/foo/jdbc-production.properties"/>
```

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

### Get AOP proxy bean from factory (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/aop-api/pfb.adoc

Retrieves the AOP proxy bean named 'person' from the bean factory and casts it to the Person type using Kotlin's 'as' operator. This is the Kotlin version of the example.

```kotlin
	val person = factory.getBean("person") as Person
```

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

### Expected output from running the Boot class

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/data-access/transaction/declarative/first-example.adoc

This XML-like output shows the expected log messages when running the Boot class, including proxy creation and transaction management. It is provided for verification.

```xml
	<!-- the Spring container is starting up... -->
	[AspectJInvocationContextExposingAdvisorAutoProxyCreator] - Creating implicit proxy for bean 'fooService' with 0 common interceptors and 1 specific interceptors

	<!-- the DefaultFooService is actually proxied -->
	[JdkDynamicAopProxy] - Creating JDK dynamic proxy for [x.y.service.DefaultFooService]

	<!-- ... the insertFoo(..) method is now being invoked on the proxy -->
	[TransactionInterceptor] - Getting transaction for x.y.service.FooService.insertFoo

	<!-- the transactional advice kicks in here... -->
	[DataSourceTransactionManager] - Creating new transaction with name [x.y.service.FooService.insertFoo]
	[DataSourceTransactionManager] - Acquired Connection [org.apache.commons.dbcp.PoolableConnection@a53de4] for JDBC transaction
```

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

### Register DateFormatter with @InitBinder

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-initbinder.adoc

Defines an @InitBinder method that registers a DateFormatter with pattern yyyy-MM-dd via addCustomFormatter. This approach is used when a Formatter-based setup through a shared FormattingConversionService is in place. The Java and Kotlin versions are equivalent renderings of the same example.

```java
	@Controller
	public class FormController {

		@InitBinder // <1>
		protected void initBinder(WebDataBinder binder) {
			binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd"));
		}

		// ...
	}

```

```kotlin
	@Controller
	class FormController {

		@InitBinder // <1>
		protected fun initBinder(binder: WebDataBinder) {
			binder.addCustomFormatter(DateFormatter("yyyy-MM-dd"))
		}

		// ...
	}

```

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

### Java main method to run the configuration

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/java/composing-configuration-classes.adoc

Bootstraps the Spring context using AnnotationConfigApplicationContext with AppConfig and retrieves the TransferService bean.

```java
public static void main(String[] args) {
	ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
	TransferService transferService = ctx.getBean(TransferService.class);
	// ...
}
```

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

### Kotlin: Route to index.html for SPA

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc-functional.adoc

Kotlin equivalent of the Java SPA routing example, using the router DSL.

```kotlin
	val redirectToIndex = router {
		val index = ClassPathResource("static/index.html")
		val spaPredicate = !(path("/api/**") or path("/error"))
		resource(spaPredicate, index)
	}

```

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

### Using @BeforeAll and @AfterAll on non-static methods

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/languages/kotlin/spring-projects-in.adoc

Shows how to use @BeforeAll and @AfterAll on non-static methods by setting the test instance lifecycle to PER_CLASS. The example starts and stops an application around a test that verifies HTML content.

```kotlin
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class IntegrationTests {

	val application = Application(8181)
	val client = WebClient.create("http://localhost:8181")

	@BeforeAll
	fun beforeAll() {
		application.start()
	}

	@Test
	fun `Find all users on HTML page`() {
		client.get().uri("/users")
				.accept(TEXT_HTML)
				.retrieve()
				.bodyToMono<String>()
				.test()
				.expectNextMatches { it.contains("Foo") }
				.verifyComplete()
	}

	@AfterAll
	fun afterAll() {
		application.stop()
	}
}
```

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

### Create a RouterFunction with route() in Java

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux-functional.adoc

Shows how to build a RouterFunction using the route() builder, defining GET and POST routes with request predicates. The handler methods are defined in a PersonHandler class. This is the Java version of the router creation example.

```java
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.server.RequestPredicates.*;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);

RouterFunction<ServerResponse> route = route() <1>
	.GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
	.GET("/person", accept(APPLICATION_JSON), handler::listPeople)
	.POST("/person", handler::createPerson)
	.build();


public class PersonHandler {

	// ...

	public Mono<ServerResponse> listPeople(ServerRequest request) {
		// ...
	}

	public Mono<ServerResponse> createPerson(ServerRequest request) {
		// ...
	}

	public Mono<ServerResponse> getPerson(ServerRequest request) {
		// ...
	}
}
```

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

### Disambiguate matrix variables with pathVar (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/matrix-variables.adoc

Shows how to specify which path variable a matrix variable belongs to using the pathVar attribute. The example maps GET /owners/42;q=11/pets/21;q=22 and binds q1 to 11 and q2 to 22.

```java
	// GET /owners/42;q=11/pets/21;q=22

	@GetMapping("/owners/{ownerId}/pets/{petId}")
	public void findPet(
			@MatrixVariable(name="q", pathVar="ownerId") int q1,
			@MatrixVariable(name="q", pathVar="petId") int q2) {

		// q1 == 11
		// q2 == 22
	}

```

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

### Connect to WebSocket with ReactorNettyWebSocketClient (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux-websocket.adoc

Java example of creating a ReactorNettyWebSocketClient and executing a WebSocket session. Receives messages and prints them to stdout, then completes.

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

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

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

### Connect to WebSocket with ReactorNettyWebSocketClient (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux-websocket.adoc

Kotlin example of creating a ReactorNettyWebSocketClient and executing a WebSocket session. Receives messages and prints them to stdout, then completes.

```kotlin
	val client = ReactorNettyWebSocketClient()

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

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

### Optional matrix variable with default value (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/matrix-variables.adoc

Shows how to make a matrix variable optional and provide a default value using required=false and defaultValue. The example maps GET /pets/42 and binds q to 1 when no matrix variable is present.

```java
	// GET /pets/42

	@GetMapping("/pets/{petId}")
	public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {

		// q == 1
	}

```

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

### Access matrix variables with @MatrixVariable (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/matrix-variables.adoc

Shows how to access a matrix variable from a controller method. Requires a URI variable in the path segment where matrix variables are expected. The example maps GET /pets/42;q=11;r=22 and binds q to 11.

```java
	// GET /pets/42;q=11;r=22

	@GetMapping("/pets/{petId}")
	public void findPet(@PathVariable String petId, @MatrixVariable int q) {

		// petId == 42
		// q == 11
	}

```

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

### Configure declarative rollback-for exception pattern in XML

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/data-access/transaction/declarative/rolling-back.adoc

Uses the rollback-for attribute to define an exception pattern for a checked, application-specific exception. A value of "NoProductInStockException" matches that exception and its subclasses. This example also marks get* methods as read-only.

```XML
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" rollback-for="NoProductInStockException"/>
			<tx:method name="*"/>
		</tx:attributes>
	</tx:advice>
```

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

### Programmatic registration and initialization of DispatcherServlet

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-servlet.adoc

Shows how to register and initialize the DispatcherServlet programmatically, which is auto-detected by the Servlet container. The example is referenced from the source as 'MyWebApplicationInitializer' and is included via an include directive, so the actual code is not visible on this page.

```java
// Code not visible on this page; included from external file.
```

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

### Get beans with ClassPathXmlApplicationContext (Java)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/beans/basics.adoc

Use this snippet to load XML bean definitions from classpath files and retrieve a typed bean instance. Note that the retrieved bean is cast to the required type. This is the classic Spring ApplicationContext setup for XML files.

```java
	// create and configure beans
	ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

	// retrieve configured instance
	PetStoreService service = context.getBean("petStore", PetStoreService.class);

	// use configured instance
	List<String> userList = service.getUsernameList();
```

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

### ResourceDatabasePopulator example in Java

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/testing/testcontext-framework/executing-sql.adoc

Programmatically populates a database with SQL scripts from classpath resources, sets the statement separator to '@@', and executes against a DataSource. Useful for setting up test schema and data within a test method.

```java
	@Test
	void databaseTest() {
		ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
		populator.addScripts(
				new ClassPathResource("test-schema.sql"),
				new ClassPathResource("test-data.sql"));
		populator.setSeparator("@@");
		populator.execute(this.dataSource);
		// run code that uses the test schema and data
	}

```

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

### XML configuration for declarative transactions (context.xml)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/data-access/transaction/declarative/first-example.adoc

Spring XML configuration that makes the FooService transactional. It defines a tx:advice with read-only semantics for methods starting with 'get' and default settings for others, applies it via AOP pointcut, and configures a DataSource and TransactionManager.

```xml
	<!-- from the file 'context.xml' -->
	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:aop="http://www.springframework.org/schema/aop"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="
			http://www.springframework.org/schema/beans
			https://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/tx
			https://www.springframework.org/schema/tx/spring-tx.xsd
			http://www.springframework.org/schema/aop
			https://www.springframework.org/schema/aop/spring-aop.xsd">

		<!-- this is the service object that we want to make transactional -->
		<bean id="fooService" class="x.y.service.DefaultFooService"/>

		<!-- the transactional advice (what 'happens'; see the <aop:advisor/> bean below) -->
		<tx:advice id="txAdvice" transaction-manager="txManager">
			<!-- the transactional semantics... -->
			<tx:attributes>
				<!-- all methods starting with 'get' are read-only -->
				<tx:method name="get*" read-only="true"/>
				<!-- other methods use the default transaction settings (see below) -->
				<tx:method name="*"/>
			</tx:attributes>
		</tx:advice>

		<!-- ensure that the above transactional advice runs for any execution
			of an operation defined by the FooService interface -->
		<aop:config>
			<aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/>
			<aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
		</aop:config>

		<!-- don't forget the DataSource -->
		<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
			<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
			<property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>
			<property name="username" value="scott"/>
			<property name="password" value="tiger"/>
		</bean>

		<!-- similarly, don't forget the TransactionManager -->
		<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
			<property name="dataSource" ref="dataSource"/>
		</bean>

		<!-- other <bean/> definitions here -->

	</beans>

```

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

### Create FileSystemXmlApplicationContext with a simple path (Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/core/resources.adoc

Kotlin equivalent of creating a FileSystemXmlApplicationContext with a filesystem-relative path.

```kotlin
val ctx = FileSystemXmlApplicationContext("conf/appContext.xml")
```

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

### Bind request parameter with @RequestParam in Spring MVC (Java/Kotlin)

Source: https://github.com/spring-projects/spring-framework/blob/main/framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/requestparam.adoc

Binds a required request parameter 'petId' to an int method argument in a Spring MVC controller. The parameter is required by default; type conversion is applied automatically when the target type is not String. The example shows the Java and Kotlin equivalents for a GET endpoint that loads a pet and adds it to the model.

```java
	@Controller
	@RequestMapping("/pets")
	public class EditPetForm {

		// ...

		@GetMapping
		public String setupForm(@RequestParam("petId") int petId, Model model) { <1>
			Pet pet = this.clinic.loadPet(petId);
			model.addAttribute("pet", pet);
			return "petForm";
		}

		// ...

	}

```

```kotlin
	import org.springframework.ui.set

	@Controller
	@RequestMapping("/pets")
	class EditPetForm {

		// ...

		@GetMapping
		fun setupForm(@RequestParam("petId") petId: Int, model: Model): String { // <1>
			val pet = this.clinic.loadPet(petId);
			model["pet"] = pet
			return "petForm"
		}

		// ...

	}

```
Tokens:
Raw