Spring Framework

https://docs.spring.io/spring-framework/reference
Admin
Spring Framework is a comprehensive Java framework for building enterprise applications with...
Tokens:781,378
Snippets:6,746
Trust Score:10
Update:7 hours ago
Show doc for...
Tokens:
Raw
### Log output from declarative transaction example

Source: https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/first-example.html

Shows the expected log output when running the declarative transaction example. It demonstrates proxy creation, transaction start, and rollback on UnsupportedOperationException. The output is truncated for clarity.

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

<!-- the insertFoo(..) method from DefaultFooService throws an exception... -->
[RuleBasedTransactionAttribute] - Applying rules to determine whether transaction should rollback on java.lang.UnsupportedOperationException
[TransactionInterceptor] - Invoking rollback for transaction on x.y.service.FooService.insertFoo due to throwable [java.lang.UnsupportedOperationException]

<!-- and the transaction is rolled back (by default, RuntimeException instances cause rollback) -->
[DataSourceTransactionManager] - Rolling back JDBC transaction on Connection [org.apache.commons.dbcp.PoolableConnection@a53de4]
[DataSourceTransactionManager] - Releasing JDBC Connection after transaction
[DataSourceUtils] - Returning JDBC Connection to DataSource

Exception in thread "main" java.lang.UnsupportedOperationException at x.y.service.DefaultFooService.insertFoo(DefaultFooService.java:14)
<!-- AOP infrastructure stack trace elements removed for clarity -->
at $Proxy0.insertFoo(Unknown Source)
at Boot.main(Boot.java:11)
Copied!
```

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

### ProxyFactory setup with advice (Kotlin)

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

Kotlin version of the ProxyFactory setup.

```kotlin
fun main() {
	val factory = ProxyFactory(SimplePojo())
	factory.addInterface(Pojo::class.java)
	factory.addAdvice(RetryAdvice())

	val pojo = factory.proxy as Pojo
	// this is a method call on the proxy!
	pojo.foo()
}
```

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

### Create FileSystemXmlApplicationContext with leading slash path (Java)

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

Java example creating a FileSystemXmlApplicationContext with a path starting with a slash '/conf/context.xml'. Due to FileSystemXmlApplicationContext behavior, this is treated as relative and is equivalent to 'conf/context.xml'.

```java
ApplicationContext ctx =
	new FileSystemXmlApplicationContext("/conf/context.xml");
```

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

### Output of the InstantiationTracingBeanPostProcessor example

Source: https://docs.spring.io/spring-framework/reference/core/beans/factory-extension.html

Example output showing the BeanPostProcessor message and the messenger bean's toString() result.

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

```

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

### ResourceDatabasePopulator example in Kotlin

Source: https://docs.spring.io/spring-framework/reference/testing/testcontext-framework/executing-sql.html

Kotlin version of the ResourceDatabasePopulator example. Runs SQL scripts against a DataSource with a custom statement separator.

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

```

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

### Standalone MockMvcTester setup with MockMvcTester.of (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/assertj/setup.html

Kotlin version of the standalone MockMvcTester setup, using MockMvcTester.of with an AccountController instance.

```kotlin
class AccountControllerStandaloneTests {

	val mockMvc = MockMvcTester.of(AccountController())

	// ...

}
```

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

### ProxyFactory setup with advice (Java)

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

Shows how to create a proxy using ProxyFactory, add an interface and advice, and invoke a method on the proxy. This is the proxied scenario where advice can run.

```java
public class Main {

	public static void main(String[] args) {
		ProxyFactory factory = new ProxyFactory(new SimplePojo());
		factory.addInterface(Pojo.class);
		factory.addAdvice(new RetryAdvice());

		Pojo pojo = (Pojo) factory.getProxy();
		// this is a method call on the proxy!
		pojo.foo();
	}
}
```

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

### Get resource with leading slash path (Kotlin)

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

Kotlin example using ctx.getResource with a path starting with a slash '/some/resource/path/myTemplate.txt'. This is treated as relative and is equivalent to the version without the leading slash.

```kotlin
val ctx: FileSystemXmlApplicationContext = ...
ctx.getResource("/some/resource/path/myTemplate.txt")
```

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

### Get resource with leading slash path (Java)

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

Java example using ctx.getResource with a path starting with a slash '/some/resource/path/myTemplate.txt'. This is treated as relative and is equivalent to the version without the leading slash.

```java
FileSystemXmlApplicationContext ctx = ...;
ctx.getResource("/some/resource/path/myTemplate.txt");
```

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

### RestClient GET request and print response body

Source: https://docs.spring.io/spring-framework/reference/integration/rest-clients.html

Perform a simple GET request with RestClient and print the response body as a String. The Java example uses .body(String.class); the Kotlin example uses .body<String>(). Both set the URL via .uri("https://example.com") and retrieve the response with .retrieve().

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

System.out.println(result); __**(5)**

```

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

println(result) __**(5)**

```

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

### Instrument base package scanning with ApplicationStartup in Java

Source: https://docs.spring.io/spring-framework/reference/core/beans/context-introduction.html

Creates a StartupStep for scanning base packages in AnnotationConfigApplicationContext, adds a tag with the package names, and performs the scan. The step is closed automatically via try-with-resources. Use this to track custom startup phases.

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

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

### Instrument base package scanning with ApplicationStartup in Kotlin

Source: https://docs.spring.io/spring-framework/reference/core/beans/context-introduction.html

Kotlin version of the same instrumentation: creates a StartupStep for scanning base packages, tags it with the package names, and performs the scan. The step is closed automatically via try-with-resources.

```kotlin
// create a startup step and start recording
try (val 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);
}
```

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

### IntroductionAdvisor and IntroductionInfo interfaces

Source: https://docs.spring.io/spring-framework/reference/core/aop-api/advice.html

IntroductionAdvisor extends Advisor and IntroductionInfo, adding a ClassFilter and a validateInterfaces method. IntroductionInfo provides the getInterfaces method to return the introduced interfaces.

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

	ClassFilter getClassFilter();

	void validateInterfaces() throws IllegalArgumentException;
}

public interface IntroductionInfo {

	Class<?>[] getInterfaces();
}
```

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

### GET /something

Source: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-methods/responseentity.html

Example of using ResponseEntity in a Spring MVC controller method to return a response with status and headers.

```APIDOC
## [GET] /something

### Description
Returns a response with status and headers using ResponseEntity.

### Method
GET

### Endpoint
/something

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
No request body.

### Response
#### Success Response (200)
- **body** (String) - The response body.
- **ETag** (String) - The ETag header value.

#### Response Example
```
HTTP/1.1 200 OK
ETag: ...
Content-Type: text/plain

[body]
```
```

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

### Use .exchange() to get MvcTestResult for multiple assertions (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/assertj/requests.html

Kotlin version of the .exchange() example. The result is stored in a val and then used in assertThat().

```kotlin
val result = mockMvc.post().uri("/hotels/{id}", 42)
	.accept(MediaType.APPLICATION_JSON).exchange()
assertThat(result)
	. // ...
```

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

### Full URI template with build (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-uri-building.html

Kotlin version of the full URI template example.

```kotlin
val uri = UriComponentsBuilder
		.fromUriString("https://example.com/hotels/{hotel}?q={q}")
		.build("Westin", "123")

```

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

### Request with context and servlet paths (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/assertj/requests.html

Kotlin equivalent of the context/servlet path example.

```kotlin
assertThat(mockMvc.get().uri("/app/main/hotels/{id}", 42)
		.contextPath("/app").servletPath("/main"))
	. // ...

```

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

### Kotlin bean using MessageSource to get a message

Source: https://docs.spring.io/spring-framework/reference/core/beans/context-introduction.html

Kotlin version of the same example, using lateinit var for the MessageSource property 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)
	}
}
```

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

### Explicit resource semantics: classpath and file system (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/testcontext-framework/ctx-management/web.html

Kotlin version of the explicit resource semantics example, using classpath: and file: prefixes.

```kotlin
@ExtendWith(SpringExtension::class)

// classpath resource
@WebAppConfiguration("classpath:test-web-resources")

// file system resource
@ContextConfiguration("file:src/main/webapp/WEB-INF/servlet-config.xml")
class WacTests {
	//...
}
```

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

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

Source: https://docs.spring.io/spring-framework/reference/web/webflux/controller/ann-initbinder.html

Kotlin example of an @InitBinder method that adds a DateFormatter with pattern 'yyyy-MM-dd' to the WebDataBinder, using a Formatter-based setup.

```kotlin
@Controller
class FormController {

	@InitBinder
	fun initBinder(binder: WebDataBinder) {
		binder.addCustomFormatter(DateFormatter("yyyy-MM-dd"))
	}

	// ...
}
```

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

### Bootstrap with GenericGroovyApplicationContext (Kotlin)

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

Kotlin version of the GenericGroovyApplicationContext example for Groovy configuration.

```kotlin
val context = GenericGroovyApplicationContext("services.groovy", "daos.groovy")
```

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

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

Source: https://docs.spring.io/spring-framework/reference/web/webflux/controller/ann-initbinder.html

Java example of an @InitBinder method that adds a DateFormatter with pattern 'yyyy-MM-dd' 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"));
	}

	// ...
}
```

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

### Serve resources from a root location (Kotlin)

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

Kotlin equivalent of the Java example. Uses the router DSL to serve resources from a root location.

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

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

### Add servlet request parameters (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/hamcrest/requests.html

Kotlin equivalent of the servlet request parameter example using the get extension function and param property.

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

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

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

### Java main using ClassPathXmlApplicationContext to get a message

Source: https://docs.spring.io/spring-framework/reference/core/beans/context-introduction.html

Java example of using ClassPathXmlApplicationContext to load a MessageSource from beans.xml and retrieve a message with the UK locale.

```java
public static void main(final String[] args) {
	MessageSource resources = new ClassPathXmlApplicationContext("beans.xml");
	String message = resources.getMessage("argument.required",
		new Object [] {"userDao"}, "Required", Locale.UK);
	System.out.println(message);
}
```

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

### Conventions: @WebAppConfiguration and @ContextConfiguration defaults (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/testcontext-framework/ctx-management/web.html

Kotlin version of the convention-based example, using @WebAppConfiguration and @ContextConfiguration with default resource detection.

```kotlin
@ExtendWith(SpringExtension::class)

// defaults to "file:src/main/webapp"
@WebAppConfiguration

// detects "WacTests-context.xml" in the same package
// or static nested @Configuration classes
@ContextConfiguration
class WacTests {
	//...
}
```

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

### Using T operator to get Class instances and compare enum values (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/core/expressions/language-ref/types.html

Kotlin example showing how to use the T operator in SpEL to get Class instances for java.util.Date and String, and to compare enum constants. The StandardTypeLocator understands java.lang, so T(String) does not need a fully qualified name.

```kotlin
val dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class::class.java)

val stringClass = parser.parseExpression("T(String)").getValue(Class::class.java)

val trueValue = parser.parseExpression(
		"T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
		.getValue(Boolean::class.java)
```

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

### Start application with CDS archive using -XX:SharedArchiveFile

Source: https://docs.spring.io/spring-framework/reference/integration/aot-cache.html

Use this command to start the application with a CDS archive file (app.jsa). The classpath must be the same as (or a superset of) the one used during training.

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

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

### Direct build to URI (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-uri-building.html

Kotlin version of the direct build to URI example.

```kotlin
val uri = UriComponentsBuilder
		.fromUriString("https://example.com/hotels/{hotel}")
		.queryParam("q", "{q}")
		.build("Westin", "123")

```

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

### Using T operator to get Class instances and compare enum values (Java)

Source: https://docs.spring.io/spring-framework/reference/core/expressions/language-ref/types.html

Java example showing how to use the T operator in SpEL to get Class instances for java.util.Date and String, and to compare enum constants. The StandardTypeLocator understands java.lang, so T(String) does not need a fully qualified name.

```java
Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);

Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

boolean trueValue = parser.parseExpression(
		"T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
		.getValue(Boolean.class);
```

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

### Get resource with relative path (Kotlin)

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

Kotlin example using ctx.getResource with a relative path 'some/resource/path/myTemplate.txt'. This is equivalent to using a leading slash because FileSystemXmlApplicationContext treats all paths as relative.

```kotlin
val ctx: FileSystemXmlApplicationContext = ...
ctx.getResource("some/resource/path/myTemplate.txt")
```

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

### Directory layout for ClassPathXmlApplicationContext shortcut

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

Shows the directory layout used in the shortcut example: XML files and a class in the com/example package.

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

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

### Get resource with relative path (Java)

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

Java example using ctx.getResource with a relative path 'some/resource/path/myTemplate.txt'. This is equivalent to using a leading slash because FileSystemXmlApplicationContext treats all paths as relative.

```java
FileSystemXmlApplicationContext ctx = ...;
ctx.getResource("some/resource/path/myTemplate.txt");
```

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

### Kotlin application running the InstantiationTracingBeanPostProcessor example

Source: https://docs.spring.io/spring-framework/reference/core/beans/factory-extension.html

Kotlin version of the application that loads the XML configuration and prints the messenger bean.

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

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

```

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

### Java bean using MessageSource to get a message

Source: https://docs.spring.io/spring-framework/reference/core/beans/context-introduction.html

Example of a Java class that uses MessageSource to retrieve a message with arguments and a default value. The message key is 'argument.required' and the locale is English.

```java
public class Example {

	private MessageSource messages;

	public void setMessages(MessageSource messages) {
		this.messages = messages;
	}

	public void execute() {
		String message = this.messages.getMessage("argument.required",
			new Object [] {"userDao"}, "Required", Locale.ENGLISH);
		System.out.println(message);
	}
}
```

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

### Create FileSystemXmlApplicationContext with relative path (Java)

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

Java example creating a FileSystemXmlApplicationContext with a relative path 'conf/context.xml'. This is equivalent to using '/conf/context.xml' because FileSystemXmlApplicationContext treats all paths as relative.

```java
ApplicationContext ctx =
	new FileSystemXmlApplicationContext("conf/context.xml");
```

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

### Create FileSystemXmlApplicationContext with leading slash path (Kotlin)

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

Kotlin example creating a FileSystemXmlApplicationContext with a path starting with a slash '/conf/context.xml'. Due to FileSystemXmlApplicationContext behavior, this is treated as relative and is equivalent to 'conf/context.xml'.

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

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

### Java application running the InstantiationTracingBeanPostProcessor example

Source: https://docs.spring.io/spring-framework/reference/core/beans/factory-extension.html

Loads the XML configuration and retrieves the 'messenger' bean, triggering the BeanPostProcessor output.

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

}

```

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

### Use .exchange() to get MvcTestResult for multiple assertions (Java)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/assertj/requests.html

Instead of a single assertThat() statement, use .exchange() to obtain a MvcTestResult that can be used in multiple assertThat() statements. The example shows a POST with an Accept header.

```java
MvcTestResult result = mockMvc.post().uri("/hotels/{id}", 42)
		.accept(MediaType.APPLICATION_JSON).exchange();
assertThat(result). // ...
```

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

### Kotlin: Using assignment operator with setValue and getValue

Source: https://docs.spring.io/spring-framework/reference/core/expressions/language-ref/operators.html

Kotlin version of the assignment operator example. Uses the same SpEL expressions and EvaluationContext setup, with Kotlin syntax for creating an Inventor and calling getValue with String::class.java.

```Kotlin
val inventor = Inventor()
val context = SimpleEvaluationContext.forReadWriteDataBinding().build()

parser.parseExpression("name").setValue(context, inventor, "Aleksandar Seovic")

// alternatively
val aleks = parser.parseExpression(
		"name = 'Aleksandar Seovic'").getValue(context, inventor, String::class.java)
```

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

### Expected output from Boot

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

Example output from running the `Boot` class, showing the `StopWatch` output that the profiler advice prints to standard output.

```plaintext
StopWatch 'Profiling for 'Pengo' and '12': running time (millis) = 0
-----------------------------------------
ms     %     Task name
-----------------------------------------
00000  ?  execution(getFoo)

```

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

### Stream fragments with SseEmitter in Kotlin

Source: https://docs.spring.io/spring-framework/reference/web/webmvc-view/mvc-fragments.html

Kotlin version of returning SseEmitter to stream ModelAndView fragments over SSE. The example starts a worker thread that sends events with ModelAndView data; IOException is caught to cancel sending.

```kotlin
@GetMapping
fun handle(): SseEmitter {
	val emitter = SseEmitter()
	startWorkerThread{
		try {
			emitter.send(SseEmitter.event().data(ModelAndView("posts")))
			emitter.send(SseEmitter.event().data(ModelAndView("comments")))
			// ...
		}
		catch (ex: IOException) {
			// Cancel sending
		}
	}
	return emitter
}
```

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

### Boot driver to trigger advice (Java/Kotlin)

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

Driver script that loads the Spring context from `beans.xml`, retrieves the `PersonService` bean, and calls `getPerson`. Requires the preceding XML configuration and service classes.

```java
public class Boot {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		PersonService person = ctx.getBean(PersonService.class);
		person.getPerson("Pengo", 12);
	}
}
Copied!

```

```kotlin
fun main() {
	val ctx = ClassPathXmlApplicationContext("beans.xml")
	val person = ctx.getBean(PersonService.class)
	person.getPerson("Pengo", 12)
}
Copied!

```

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

### Stream fragments with SseEmitter in Java

Source: https://docs.spring.io/spring-framework/reference/web/webmvc-view/mvc-fragments.html

Controller method returns SseEmitter to stream ModelAndView fragments over SSE. The example starts a worker thread that sends events with ModelAndView data; IOException is caught to cancel sending.

```java
@GetMapping
SseEmitter handle() {
	SseEmitter emitter = new SseEmitter();
	startWorkerThread(() -> {
		try {
			emitter.send(SseEmitter.event().data(new ModelAndView("posts")));
			emitter.send(SseEmitter.event().data(new ModelAndView("comments")));
			// ...
		}
		catch (IOException ex) {
			// Cancel sending
		}
	});
	return emitter;
}
```

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

### Consolidate with buildAndExpand (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/web/webflux/uri-building.html

Kotlin version of the consolidated buildAndExpand example.

```kotlin
val uri = UriComponentsBuilder
		.fromUriString("https://example.com/hotels/{hotel}")
		.queryParam("q", "{q}")
		.encode()
		.buildAndExpand("Westin", "123")
		.toUri()
```

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

### MockMvc Kotlin DSL example

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

Shows how to use the MockMvc Kotlin DSL to perform a GET request with security, headers, and principal, then assert status, content type, JSON path, and JSON content, and print the result.

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

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

### Interface-based configuration classes to reduce coupling (Java)

Source: https://docs.spring.io/spring-framework/reference/core/beans/java/composing-configuration-classes.html

This example shows how to use an interface-based @Configuration class (RepositoryConfig) to decouple ServiceConfig from the concrete DefaultRepositoryConfig. It includes the full setup with @Import and a main method to run the application.

```java
@Configuration
public class ServiceConfig {

	@Autowired
	private RepositoryConfig repositoryConfig;

	@Bean
	public TransferService transferService() {
		return new TransferServiceImpl(repositoryConfig.accountRepository());
	}
}

@Configuration
public interface RepositoryConfig {

	@Bean
	AccountRepository accountRepository();
}

@Configuration
public class DefaultRepositoryConfig implements RepositoryConfig {

	@Bean
	public AccountRepository accountRepository() {
		return new JdbcAccountRepository(...);
	}
}

@Configuration
@Import({ServiceConfig.class, DefaultRepositoryConfig.class})  // import the concrete config!
public class SystemTestConfig {

	@Bean
	public DataSource dataSource() {
		// return DataSource
	}

}

public static void main(String[] args) {
	ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class);
	TransferService transferService = ctx.getBean(TransferService.class);
	transferService.transfer(100.00, "A123", "C456");
}
```

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

### Extend AbstractDispatcherServletInitializer for XML config (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-servlet/container-config.html

Kotlin equivalent of the Java example. Overrides createRootApplicationContext, createServletApplicationContext, and getServletMappings. Uses XmlWebApplicationContext with apply to set the config location.

```kotlin
class MyXmlDispatcherServletInitializer : AbstractDispatcherServletInitializer() {

	override fun createRootApplicationContext(): WebApplicationContext? {
		return null
	}

	override fun createServletApplicationContext(): WebApplicationContext {
		return XmlWebApplicationContext().apply {
			setConfigLocation("/WEB-INF/spring/dispatcher-config.xml")
		}
	}

	override fun getServletMappings(): Array<String> {
		return arrayOf("/")
	}
}
```

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

### Kotlin: before and after filters on routing function

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

Kotlin equivalent of the before/after filter example. The `before` filter adds a custom request header and is only applied to the two GET routes, while the `after` filter logs the response and applies to all routes including nested ones.

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

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

### Multipart file upload (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/testing/mockmvc/assertj/requests.html

Kotlin equivalent of the multipart upload example.

```kotlin
assertThat(mockMvc.post().uri("/upload").multipart()
		.file("file1.txt", "Hello".toByteArray(StandardCharsets.UTF_8))
		.file("file2.txt", "World".toByteArray(StandardCharsets.UTF_8)))
	. // ...

```

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

### RestClient GET with response as ResponseEntity

Source: https://docs.spring.io/spring-framework/reference/integration/rest-clients.html

Retrieve the response as a ResponseEntity to access status code, headers, and body. Uses retrieve().toEntity(Class) in Java or retrieve().toEntity<String>() in Kotlin. The example prints all three parts of the response.

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

```

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

```

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

### Share Jetty resources with JettyResourceFactory (Kotlin)

Source: https://docs.spring.io/spring-framework/reference/web/webflux-webclient/client-builder.html

Kotlin version of the JettyResourceFactory example.

```kotlin
@Bean
fun resourceFactory() = JettyResourceFactory()

@Bean
fun webClient(): WebClient {

	val httpClient = HttpClient()
	// Further customizations...

	val connector = JettyClientHttpConnector(httpClient, resourceFactory()) __**(1)**

	return WebClient.builder().clientConnector(connector).build() __**(2)**
}
```

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

### Casting proxy to Advised and manipulating advice (Java)

Source: https://docs.spring.io/spring-framework/reference/core/aop-api/advised.html

Shows how to cast an AOP proxy to Advised, get the current advisors, add an interceptor without a pointcut, and add a selective advisor with a pointcut. The example uses DebugInterceptor and DefaultPointcutAdvisor.

```java
Advised advised = (Advised) myObject;
Advisor[] advisors = advised.getAdvisors();
int oldAdvisorCount = advisors.length;
System.out.println(oldAdvisorCount + " advisors");

// Add an advice like an interceptor without a pointcut
// Will match all proxied methods
// Can use for interceptors, before, after returning or throws advice
advised.addAdvice(new DebugInterceptor());

// Add selective advice using a pointcut
advised.addAdvisor(new DefaultPointcutAdvisor(mySpecialPointcut, myAdvice));

assertEquals("Added two advisors", oldAdvisorCount + 2, advised.getAdvisors().length);
```
Tokens:
Raw