Spring框架语言支持

版本 6.0.0

Spring框架语言支持_json

1. 科特林

Kotlin是一种面向 JVM 的静态类型语言。（和其他平台），允许编写简洁优雅的代码，同时提供与用 Java 编写的现有库具有非常好的互操作性。

Spring 框架为 Kotlin 提供了一流的支持，并允许开发人员编写 Kotlin 应用程序几乎就像 Spring Framework 是一个原生的 Kotlin 框架。参考文档的大多数代码示例是除了 Java 之外，还以 Kotlin 提供。

使用 Kotlin 构建 Spring 应用程序的最简单方法是利用 Spring Boot 和其专门的 Kotlin 支持。这个全面的教程将教你如何使用start.spring.io 使用 Kotlin 构建 Spring Boot 应用程序。

如果您需要支持，请随时加入Kotlin Slack的#spring频道，或者在Stackoverflow上提出带有标签的问题。springkotlin

1.1. 要求

Spring 框架支持 Kotlin 1.3+ 并需要 kotlin-stdlib（或其变体之一，如kotlin-stdlib-jdk8）和Kotlin-reflect出现在类路径上。如果您在start.spring.io 上引导 Kotlin 项目，则默认提供它们。

1.2. 扩展

Kotlin扩展提供了以使用附加功能扩展现有类。Spring Framework Kotlin API 使用这些扩展为现有的 Spring API 添加新的特定于 Kotlin 的便利。

Spring Framework KDoc API列表并记录所有可用的 Kotlin 扩展和 DSL。

例如，Kotlin 化类型参数为 JVM泛型类型擦除提供了一种解决方法， Spring 框架提供了一些扩展来利用此功能。这允许更好的 Kotlin API，对于 newfrom Spring WebFlux，以及各种其他API。RestTemplateWebClient

要在 Java 中检索对象列表，您通常需要编写以下内容：User

Flux<User> users  = client.get().retrieve().bodyToFlux(User.class)

使用 Kotlin 和 Spring Framework 扩展，您可以编写以下内容：

val users = client.get().retrieve().bodyToFlux<User>()
// or (both are equivalent)
val users : Flux<User> = client.get().retrieve().bodyToFlux()

与Java一样，Kotlin是强类型的，但是Kotlin的聪明类型推断允许用于较短的语法。users

1.3. 零安全

Kotlin 的主要特性之一是零安全，它在编译时干净地处理值，而不是碰到著名的 at 运行时。这通过可空性使应用程序更安全声明和表达“值或无值”语义而不支付包装器的成本，例如。（Kotlin 允许使用具有可为空值的函数构造。请参阅此Kotlin 零安全综合指南。nullNullPointerExceptionOptional

虽然Java不允许你在其类型系统中表达null-safety，但Spring Framework。通过在包中声明的工具友好注释，提供整个 Spring 框架 API 的空安全性。默认情况下，Kotlin 中使用的 Java API 中的类型被识别为平台类型，放宽了空检查。Kotlin 对 JSR-305注释和 Spring 可空性注释的支持为 Kotlin 开发人员提供了整个 Spring 框架 API 的空安全性，具有在编译时处理相关问题的优点。org.springframework.langnull

您可以通过添加具有以下内容的编译器标志来配置 JSR-305 检查选项：。-Xjsr305-Xjsr305={strict|warn|ignore}

对于 kotlin 版本 1.1+，默认行为与相同。该值需要考虑 Spring 框架 API 空值安全性在 Kotlin 类型中从 Spring API 推断出来，但应该在 Spring 的知识下使用 API 可空性声明甚至可以在次要版本之间发展，并且可能会进行更多检查将来添加。-Xjsr305=warnstrict

1.4. 类和接口

Spring 框架支持各种 Kotlin 构造，例如实例化 Kotlin 类通过主构造函数、不可变类数据绑定和函数可选参数使用默认值。

Kotlin 参数名称通过专用的、它允许查找接口方法参数名称，而无需在编译期间启用 Java 8compiler 标志。KotlinReflectionParameterNameDiscoverer-parameters

您可以将配置类声明为顶级或嵌套，但不能声明为内部，因为后者需要引用外部类。

1.5. 注释

Spring 框架还利用Kotlin null-safety来确定是否需要 HTTP 参数，而无需显式定义属性。这意味着被治疗作为非必需的，相反，被视为必需的。 Spring Messagingannotation也支持此功能。required@RequestParam name: String?@RequestParam name: String@Header

以类似的方式，春豆注入，，或此信息用于确定是否需要 Bean。@Autowired@Bean@Inject

例如，暗示一个豆子的类型必须在应用程序上下文中注册，而如果这样的 Bean 不存在，则不会引发错误。@Autowired lateinit var thing: ThingThing@Autowired lateinit var thing: Thing?

遵循相同的原则，暗示类型的 Bean 必须在应用程序上下文中注册，而类型可能存在，也可能不存在。相同的行为适用于自动连线的构造函数参数。@Bean fun play(toy: Toy, car: Car?) = Baz(toy, Car)ToyCar

1.6. Bean 定义 DSL

Spring 框架支持使用 lambda 以函数式方式注册 bean。作为 XML 或 Java 配置的替代方法（和）。简而言之它允许您使用充当 A 的 lambda 注册 bean。这种机制非常有效，因为它不需要任何反射或CGLIB代理。@Configuration@BeanFactoryBean

例如，在 Java 中，您可以编写以下内容：

class Foo {}

class Bar {
    private final Foo foo;
    public Bar(Foo foo) {
        this.foo = foo;
    }
}

GenericApplicationContext context = new GenericApplicationContext();
context.registerBean(Foo.class);
context.registerBean(Bar.class, () -> new Bar(context.getBean(Foo.class)));

在 Kotlin 中，使用化的类型参数和 Kotlin 扩展，您可以改为编写以下内容：GenericApplicationContext

class Foo

class Bar(private val foo: Foo)

val context = GenericApplicationContext().apply {
    registerBean<Foo>()
    registerBean { Bar(it.getBean()) }
}

当类具有单个构造函数时，您甚至可以只指定 Bean 类，构造函数参数将按类型自动连接：Bar

val context = GenericApplicationContext().apply {
    registerBean<Foo>()
    registerBean<Bar>()
}

为了允许更多的声明式方法和更清晰的语法，Spring 框架提供了一个Kotlin bean 定义 DSL它通过一个干净的声明式 API 声明，这使您可以处理配置文件和自定义豆子是如何注册的。ApplicationContextInitializerEnvironment

在以下示例中，请注意：

类型推断通常允许避免为 Bean 引用指定类型，例如ref("bazBean")
可以使用 Kotlin 顶级函数使用可调用引用来声明 bean，如本例所示bean(::myRouter)
指定或时，参数按类型自动连线bean<Bar>()bean(::myRouter)
只有当个人资料处于活动状态时，才会注册FooBarfoobar

class Foo
class Bar(private val foo: Foo)
class Baz(var message: String = "")
class FooBar(private val baz: Baz)

val myBeans = beans {
    bean<Foo>()
    bean<Bar>()
    bean("bazBean") {
        Baz().apply {
            message = "Hello world"
        }
    }
    profile("foobar") {
        bean { FooBar(ref("bazBean")) }
    }
    bean(::myRouter)
}

fun myRouter(foo: Foo, bar: Bar, baz: Baz) = router {
    // ...
}

然后，您可以使用此函数在应用程序上下文中注册 bean，如以下示例所示：beans()

val context = GenericApplicationContext().apply {
    myBeans.initialize(this)
    refresh()
}

1.7. 网络

1.7.1. 路由器 DSL

Spring 框架附带一个 Kotlin 路由器 DSL，有 3 种版本：

WebMvc.fn DSL with router { }
WebFlux.fn Reactive DSL with router { }
WebFlux.fn Coroutines DSL with coRouter { }

这些 DSL 允许您编写干净且惯用的 Kotlin 代码来构建实例，如以下示例所示：RouterFunction

@Configuration
class RouterRouterConfiguration {

    @Bean
    fun mainRouter(userHandler: UserHandler) = router {
        accept(TEXT_HTML).nest {
            GET("/") { ok().render("index") }
            GET("/sse") { ok().render("sse") }
            GET("/users", userHandler::findAllView)
        }
        "/api".nest {
            accept(APPLICATION_JSON).nest {
                GET("/users", userHandler::findAll)
            }
            accept(TEXT_EVENT_STREAM).nest {
                GET("/users", userHandler::stream)
            }
        }
        resources("/**", ClassPathResource("static/"))
    }
}

有关具体示例，请参阅MiXiT 项目。

1.7.2. 模拟Mvc DSL

Kotlin DSL 通过 Kotlin 扩展提供，以提供更多惯用的 Kotlin API 并允许更好的可发现性（不使用静态方法）。MockMvc

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

1.7.3. Kotlin 脚本模板

Spring 框架提供了一个ScriptTemplateView，它支持JSR-223使用脚本引擎渲染模板。

通过利用依赖关系，它可以使用此类功能来渲染基于 Kotlin 的模板，其中包含kotlinx.htmlDSL 或 Kotlin 多行插值。scripting-jsr223String

build.gradle.kts

dependencies {
        runtime("org.jetbrains.kotlin:kotlin-scripting-jsr223:${kotlinVersion}")
}

配置通常由 andbean 完成。ScriptTemplateConfigurerScriptTemplateViewResolver

KotlinScriptConfiguration.kt

@Configuration
class KotlinScriptConfiguration {

    @Bean
    fun kotlinScriptConfigurer() = ScriptTemplateConfigurer().apply {
        engineName = "kotlin"
        setScripts("scripts/render.kts")
        renderFunction = "render"
        isSharedEngine = false
    }

    @Bean
    fun kotlinScriptViewResolver() = ScriptTemplateViewResolver().apply {
        setPrefix("templates/")
        setSuffix(".kts")
    }
}

参见kotlin 脚本模板示例项目了解更多详情。

1.7.4. Kotlin 多平台序列化

从 Spring Framework 5.3 开始，Kotlin 多平台序列化是在Spring MVC，Spring WebFlux和Spring Messaging （RSocket）中支持。内置支持目前针对CBOR，JSON和ProtoBuf格式。

要启用它，请按照这些说明添加相关的依赖项和插件。使用 Spring MVC 和 WebFlux，如果 Kotlin 序列化和 Jackson 都在类路径中，则默认情况下都会进行配置，因为它们位于类路径中。 Kotlin 序列化旨在仅序列化带有注释的 Kotlin 类。使用 Spring 消息传递（RSocket），如果要自动配置，请确保 Jackson、GSON 或 JSONB 都不在类路径中，如果需要杰克逊手动配置。@SerializableKotlinSerializationJsonMessageConverter

1.8. 协程

Kotlin协程是Kotlin 轻量级线程允许以命令式方式编写非阻塞代码。在语言方面，挂起函数为异步操作提供了抽象，而在库端，kotlinx.coroutines提供异步 { } 等函数和Flow 等类型。

Spring 框架在以下范围内为协程提供支持：

Spring MVC 和 WebFlux 中的延迟和流返回值支持注释@Controller
Spring MVC 和 WebFlux 中的暂停功能支持已注释@Controller
WebFlux客户端和服务器功能 API 的扩展。
WebFlux.fn coRouter { } DSL
RSocketan注释方法中的挂起功能和支持Flow@MessageMapping
RSocketRequester 的扩展

1.8.1. 依赖

当依赖项位于类路径中时，将启用协程支持：kotlinx-coroutines-corekotlinx-coroutines-reactor

build.gradle.kts

dependencies {

    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${coroutinesVersion}")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor:${coroutinesVersion}")
}

支持版本及以上版本。1.4.0

1.8.2. 响应式如何转换为协程？

对于返回值，从反应式 API 到协程 API 的转换如下所示：

fun handler(): Mono<Void>成为suspend fun handler()
fun handler(): Mono<T>变得取决于是否可以为空（具有更静态类型的优点）suspend fun handler(): Tsuspend fun handler(): T?Mono
fun handler(): Flux<T>成为fun handler(): Flow<T>

对于输入参数：

如果不需要惰性，则成为因为可以调用挂起函数来获取 value 参数。fun handler(mono: Mono<T>)fun handler(value: T)
如果需要懒惰，就成为fun handler(mono: Mono<T>)fun handler(supplier: suspend () → T)fun handler(supplier: suspend () → T?)

流在协程世界中是等效的，适用于热流或冷流、有限流或无限流，主要区别如下：Flux

Flow是基于推的，而是推挽混合的Flux
通过悬挂功能实现背压
Flow只有一个挂起收集方法，运算符作为扩展实现
借助协程，运算符易于实现
扩展允许将自定义运算符添加到Flow
收集操作正在暂停功能
map运算符支持异步操作（不需要），因为它需要一个挂起函数参数flatMap

阅读这篇关于使用Spring、协程和 Kotlin Flow 进行响应式的博客文章，了解更多详细信息，包括如何与协程同时运行代码。

1.8.3. 控制器

下面是协程的示例。@RestController

@RestController
class CoroutinesRestController(client: WebClient, banner: Banner) {

    @GetMapping("/suspend")
    suspend fun suspendingEndpoint(): Banner {
        delay(10)
        return banner
    }

    @GetMapping("/flow")
    fun flowEndpoint() = flow {
        delay(10)
        emit(banner)
        delay(10)
        emit(banner)
    }

    @GetMapping("/deferred")
    fun deferredEndpoint() = GlobalScope.async {
        delay(10)
        banner
    }

    @GetMapping("/sequential")
    suspend fun sequential(): List<Banner> {
        val banner1 = client
                .get()
                .uri("/suspend")
                .accept(MediaType.APPLICATION_JSON)
                .awaitExchange()
                .awaitBody<Banner>()
        val banner2 = client
                .get()
                .uri("/suspend")
                .accept(MediaType.APPLICATION_JSON)
                .awaitExchange()
                .awaitBody<Banner>()
        return listOf(banner1, banner2)
    }

    @GetMapping("/parallel")
    suspend fun parallel(): List<Banner> = coroutineScope {
        val deferredBanner1: Deferred<Banner> = async {
            client
                    .get()
                    .uri("/suspend")
                    .accept(MediaType.APPLICATION_JSON)
                    .awaitExchange()
                    .awaitBody<Banner>()
        }
        val deferredBanner2: Deferred<Banner> = async {
            client
                    .get()
                    .uri("/suspend")
                    .accept(MediaType.APPLICATION_JSON)
                    .awaitExchange()
                    .awaitBody<Banner>()
        }
        listOf(deferredBanner1.await(), deferredBanner2.await())
    }

    @GetMapping("/error")
    suspend fun error() {
        throw IllegalStateException()
    }

    @GetMapping("/cancel")
    suspend fun cancel() {
        throw CancellationException()
    }

}

还支持使用 ais 进行视图渲染。@Controller

@Controller
class CoroutinesViewController(banner: Banner) {

    @GetMapping("/")
    suspend fun render(model: Model): String {
        delay(10)
        model["banner"] = banner
        return "index"
    }
}

1.8.4. 网络通量

下面是通过coRouter { }DSL 和相关处理程序定义的协程路由器的示例。

@Configuration
class RouterConfiguration {

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

class UserHandler(builder: WebClient.Builder) {

    private val client = builder.baseUrl("...").build()

    suspend fun listView(request: ServerRequest): ServerResponse =
            ServerResponse.ok().renderAndAwait("users", mapOf("users" to
            client.get().uri("...").awaitExchange().awaitBody<User>()))

    suspend fun listApi(request: ServerRequest): ServerResponse =
                ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyAndAwait(
                client.get().uri("...").awaitExchange().awaitBody<User>())
}

1.8.5. 交易

协程上的事务通过反应式的编程变体得到支持从 Spring 框架 5.2 开始提供的事务管理。

对于挂起功能，提供了扩展。TransactionalOperator.executeAndAwait

class PersonRepository(private val operator: TransactionalOperator) {

    suspend fun initDatabase() = operator.executeAndAwait {
        insertPerson1()
        insertPerson2()
    }

    private suspend fun insertPerson1() {
        // INSERT SQL statement
    }

    private suspend fun insertPerson2() {
        // INSERT SQL statement
    }
}

对于 Kotlin，提供了一个扩展。FlowFlow<T>.transactional

class PersonRepository(private val operator: TransactionalOperator) {

    fun updatePeople() = findPeople().map(::updatePerson).transactional(operator)

    private fun findPeople(): Flow<Person> {
        // SELECT SQL statement
    }

    private suspend fun updatePerson(person: Person): Person {
        // UPDATE SQL statement
    }
}

1.9. 科特林的春季项目

本节提供了一些具体的提示和建议，值得开发 Spring 项目在科特林。

1.9.1. 默认为最终

默认情况下，Kotlin 中的所有类都是最终的。类上的主题符号与Java相反：它允许其他人从中继承。 .class。这也适用于成员函数，因为它们需要标记为被重写。openfinalopen

虽然 Kotlin 的 JVM 友好设计通常与 Spring 无摩擦，但这种特定的 Kotlin 特性如果不考虑这一事实，可以阻止应用程序启动。这是因为 Spring bean（这种带注释的类，默认情况下需要在运行时扩展以进行技术原因）通常由 CGLIB 代理。解决方法是在每个类上添加一个关键字，并且由CGLIB代理的春豆成员函数，可以很快就会变得痛苦，并且违背了保持代码简洁和可预测的 Kotlin 原则。@Configurationopen

幸运的是，Kotlin 提供了一个kotlin-spring插件（插件的预配置版本），可以自动打开类以及使用以下之一进行批注或元批注的类型的成员函数附注：kotlin-allopen

@Component
@Async
@Transactional
@Cacheable

元注释支持意味着注释的类型,,,,或自动打开，因为这些注释是元注释的。@Configuration@Controller@RestController@Service@Repository@Component

start.spring.io启用默认情况下的插件。所以，在实践中，你可以写你的 Kotlin bean 没有任何额外的关键字，就像在Java中一样。kotlin-springopen

1.9.2. 使用不可变的类实例进行持久性

在 Kotlin 中，声明只读属性很方便，被认为是最佳实践在主构造函数中，如以下示例所示：

class Person(val name: String, val age: Int)

可以选择添加data关键字，使编译器自动从声明的所有属性派生以下成员在主构造函数中：

equals()和hashCode()
toString()的形式"User(name=John, age=42)"
componentN()按声明顺序与属性对应的函数
copy()功能

如以下示例所示，这允许对单个属性进行轻松更改，即使属性是只读的也是如此：Person

data class Person(val name: String, val age: Int)

val jack = Person(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)

常见的持久性技术（如 JPA）需要默认构造函数，从而防止这种情况发生一种设计。幸运的是，有一个解决方法可以解决这个“默认构造函数地狱”，因为 Kotlin 提供了一个Kotlin-JPA插件，该插件为使用 JPA 注释注释的类生成合成的 no-arg 构造函数。

如果需要将这种机制用于其他持久性技术，则可以配置 Kotlin-noarg插件。

1.9.3. 注入依赖

我们的建议是尝试支持只读的构造函数注入（和尽可能不可为空）属性，如以下示例所示：val

@Component
class YourBean(
    private val mongoTemplate: MongoTemplate,
    private val solrClient: SolrClient
)

如果真的需要使用字段注入，可以使用构造，如以下示例所示：lateinit var

@Component
class YourBean {

    @Autowired
    lateinit var mongoTemplate: MongoTemplate

    @Autowired
    lateinit var solrClient: SolrClient
}

1.9.4. 注入配置属性

在 Java 中，可以使用注释（例如）注入配置属性。但是，在 Kotlin 中，是用于字符串插值的保留字符。@Value("${property}")$

因此，如果你想在 Kotlin 中使用 theannotation，你需要通过写作来转义字符。@Value$@Value("\${property}")

或者，可以通过声明以下配置 Bean：

@Bean
fun propertyConfigurer() = PropertySourcesPlaceholderConfigurer().apply {
    setPlaceholderPrefix("%{")
}

您可以自定义现有代码（例如 Spring Boot 执行器或）使用语法和配置bean，如以下示例所示：@LocalServerPort${…}

@Bean
fun kotlinPropertyConfigurer() = PropertySourcesPlaceholderConfigurer().apply {
    setPlaceholderPrefix("%{")
    setIgnoreUnresolvablePlaceholders(true)
}

@Bean
fun defaultPropertyConfigurer() = PropertySourcesPlaceholderConfigurer()

1.9.5. 检查异常

Java 和 Kotlin 异常处理非常接近，主要区别在于Kotlin 将所有异常视为未经检查的异常。但是，当使用代理对象（例如类或方法）时注释），默认情况下，引发的选中异常将包装在一。@TransactionalUndeclaredThrowableException

要像在 Java 中一样获取抛出的原始异常，应该用方法进行注释@Throws以显式指定引发的已检查异常（例如）。@Throws(IOException::class)

1.9.6. 注释数组属性

Kotlin 注解大多类似于 Java 注解，但数组属性（即在春季广泛使用）的行为有所不同。如Kotlin 文档中所述，您可以省略与其他属性不同，属性名称，并将其指定为 aparameter。valuevararg

要理解这意味着什么，请考虑（这是最广泛的之一）使用弹簧注释）为例。此 Java 注解声明如下：@RequestMapping

public @interface RequestMapping {

    @AliasFor("path")
    String[] value() default {};

    @AliasFor("value")
    String[] path() default {};

    RequestMethod[] method() default {};

    // ...
}

典型的用例是将处理程序方法映射到特定路径和方法。在 Java 中，您可以为注释数组属性指定单个值，它会自动转换为数组。@RequestMapping

这就是为什么一个人可以写。@RequestMapping(value = "/toys", method = RequestMethod.GET)@RequestMapping(path = "/toys", method = RequestMethod.GET)

但是，在 Kotlin 中，您必须编写或（方括号需要使用命名数组属性指定）。@RequestMapping("/toys", method = [RequestMethod.GET])@RequestMapping(path = ["/toys"], method = [RequestMethod.GET])

此特定属性（最常见的属性）的替代方法是使用快捷方式批注，例如、等。method@GetMapping@PostMapping

1.9.7. 测试

本节讨论使用 Kotlin 和 Spring Framework 的组合进行测试。推荐的测试框架是JUnit 5以及用于模拟的Mockk。

构造函数注入

如专用部分所述， JUnit 5 允许构造函数注入 bean，这对 Kotlin 非常有用为了使用代替。您可以使用@TestConstructor（自动连线模式 = 自动连线模式.ALL）为所有参数启用自动连线。vallateinit var

@SpringJUnitConfig(TestConfig::class)
@TestConstructor(autowireMode = AutowireMode.ALL)
class OrderServiceIntegrationTests(val orderService: OrderService,
                                   val customerService: CustomerService) {

    // tests that use the injected OrderService and CustomerService
}

`PER_CLASS`生命周期

Kotlin 允许您在反引号（）之间指定有意义的测试函数名称。从 JUnit 5 开始，Kotlin 测试类可以使用 theannotation 来实现测试类的单个实例化，这允许在非静态方法上使用 andannotations，这非常适合 Kotlin。`@TestInstance(TestInstance.Lifecycle.PER_CLASS)@BeforeAll@AfterAll

您还可以将默认行为更改为感谢带有属性的文件。PER_CLASSjunit-platform.propertiesjunit.jupiter.testinstance.lifecycle.default = per_class

下面的示例演示了非静态方法的注释：@BeforeAll@AfterAll

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

类似规范的测试

您可以使用 JUnit 5 和 Kotlin 创建类似规范的测试。以下示例演示如何执行此操作：

class SpecificationLikeTests {

  @Nested
  @DisplayName("a calculator")
  inner class Calculator {
     val calculator = SampleCalculator()

     @Test
     fun `should return the result of adding the first number to the second number`() {
        val sum = calculator.sum(2, 4)
        assertEquals(6, sum)
     }

     @Test
     fun `should return the result of subtracting the second number from the first number`() {
        val subtract = calculator.subtract(4, 2)
        assertEquals(2, subtract)
     }
  }
}

`WebTestClient`Kotlin 中的类型推理问题

由于类型推断问题，您必须使用 Kotlinextension（例如），因为它为 Java API 的 Kotlin 问题提供了一种解决方法。expectBody.expectBody<String>().isEqualTo("toys")

另请参阅相关的SPR-16057问题。

1.10. 入门

学习如何使用 Kotlin 构建 Spring 应用程序的最简单方法是遵循专用教程。

1.10.1. `start.spring.io`

在 Kotlin 中启动新的 Spring 框架项目的最简单方法是创建一个新的 Spring 在 start.spring.io 上启动 2 项目。

1.10.2. 选择网页风格

Spring Framework 现在带有两个不同的 Web 堆栈：Spring MVC和Spring WebFlux。

如果您想创建将处理延迟的应用程序，建议使用 Spring WebFlux，长期连接、流式处理方案或如果要使用 Web 功能 Kotlin DSL.

对于其他用例，特别是如果您使用的是 JPA、Spring 等阻塞技术。 MVC 及其基于注释的编程模型是推荐的选择。

1.11. 资源

我们建议以下资源供学习如何构建应用程序的用户使用 Kotlin 和 Spring 框架：

Kotlin 语言参考
Kotlin Slack（带有专用#spring频道）
Stackoverflow，带有弹簧和kotlin标签
在浏览器中试用 Kotlin。
Kotlin 博客
真棒科特林

1.11.1. 例子

以下 Github 项目提供了一些示例，您可以从中学习甚至扩展：

spring-boot-kotlin-demo：常规的Spring Boot和Spring Data JPA项目
mixit：Spring Boot 2、WebFlux 和 Reactive Spring Data MongoDB
spring-kotlin-functional：Standalone WebFlux and functional bean definition DSL
spring-kotlin-fullstack：WebFlux Kotlin 全栈示例，使用 Kotlin2js 代替 JavaScript 或 TypeScript
spring-petclinic-kotlin：Spring PetClinic 示例应用程序的 Kotlin 版本
spring-kotlin-deepdive：从 Boot 1.0 和 Java 到 Boot 2.0 和 Kotlin 的分步迁移指南
spring-cloud-gcp-kotlin-app-sample：Spring Boot with Google Cloud Platform Integrations

1.11.2. 问题

以下列表对与 Spring 和 Kotlin 支持相关的未决问题进行了分类：

弹簧框架

无法在 Kotlin 中将 WebTestClient 与模拟服务器一起使用
在泛型、varargs 和数组元素级别支持空值安全

科特林

Spring 框架支持的父问题
Kotlin 需要类型推断，而 Java 不需要
具有开放类的智能强制转换回归
不可能将所有 SAM 参数作为函数传递
直接通过脚本变量支持 JSR 223 绑定
Kotlin 属性不会覆盖 Java 风格的 getter 和 setters

2. 阿帕奇时髦

Groovy是一种功能强大，可选类型和动态语言，具有静态类型和静态编译功能。它提供了简洁的语法，并与任何现有的 Java 应用程序。

Spring 框架提供了一个专用的，支持基于 Groovy 的 Bean 定义 DSL。有关更多详细信息，请参阅Groovy Bean 定义 DSL。ApplicationContext

进一步支持 Groovy，包括用 Groovy 编写的 bean、可刷新的脚本 bean，动态语言支持中提供了更多内容。

3. 动态语言支持

Spring 为使用已通过在 Spring 中使用动态语言（如 Groovy）来定义。这种支持让你用支持的动态语言编写任意数量的类，并拥有 Spring 容器透明地实例化、配置和依赖注入结果对象。

Spring 的脚本支持主要针对 Groovy 和 BeanShell。除此之外特别支持的语言，支持 JSR-223 脚本机制用于与任何支持 JSR-223 的语言提供程序集成（从 Spring 4.2 开始），例如JRuby。

您可以找到这种动态语言支持的完整工作示例立即在场景中有用。

3.1. 第一个例子

本章的大部分内容涉及描述动态语言支持细节。在深入了解动态语言支持的所有细节之前，我们看一个用动态语言定义的 Bean 的快速示例。动态第一个豆子的语言是Groovy。（这个例子的基础取自弹簧测试套件。如果您想在任何其他示例中查看等效示例支持的语言，看看源代码）。

下一个示例显示了 Groovy bean 将要访问的接口实现。请注意，此接口是用纯 Java 定义的。依赖对象被注入了对不知道底层的引用实现是一个Groovy脚本。以下清单显示了界面：MessengerMessengerMessenger

package org.springframework.scripting;

public interface Messenger {

    String getMessage();
}

下面的示例定义一个依赖于接口的类：Messenger

package org.springframework.scripting;

public class DefaultBookingService implements BookingService {

    private Messenger messenger;

    public void setMessenger(Messenger messenger) {
        this.messenger = messenger;
    }

    public void processBooking() {
        // use the injected Messenger object...
    }
}

以下示例在 Groovy 中实现接口：Messenger

// from the file 'Messenger.groovy'
package org.springframework.scripting.groovy;

// import the Messenger interface (written in Java) that is to be implemented

// define the implementation in Groovy
class GroovyMessenger implements Messenger {

    String message
}

最后，以下示例显示了影响注入 Groovy定义的实现到类的实例中：MessengerDefaultBookingService

<?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:lang="http://www.springframework.org/schema/lang"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

    <!-- this is the bean definition for the Groovy-backed Messenger implementation -->
    <lang:groovy id="messenger" script-source="classpath:Messenger.groovy">
        <lang:property name="message" value="I Can Do The Frug" />
    </lang:groovy>

    <!-- an otherwise normal bean that will be injected by the Groovy-backed Messenger -->
    <bean id="bookingService" class="x.y.DefaultBookingService">
        <property name="messenger" ref="messenger" />
    </bean>

</beans>

Thebean （a）现在可以正常使用其私有成员变量，因为注入其中的实例是 ainstance.这里没有什么特别的事情发生 - 只是普通的Java和普通的咕噜咕噜。bookingServiceDefaultBookingServicemessengerMessengerMessenger

希望前面的 XML 代码段是不言自明的，但如果不是，请不要过度担心。继续阅读有关上述配置的原因和原因的深入详细信息。

3.2. 定义由动态语言支持的 bean

本节确切地描述了如何在任何支持的动态语言。

请注意，本章不试图解释支持的语法和习语动态语言。例如，如果你想使用Groovy来编写某些类。在您的应用程序中，我们假设您已经了解Groovy。如果您需要更多详细信息关于动态语言本身，请参阅本章。

3.2.1. 常见概念

使用动态语言支持的 Bean 所涉及的步骤如下：

为动态语言源代码编写测试（自然）。
然后编写动态语言源代码本身。
使用 XML 配置中的相应元素定义动态语言支持的 Bean（可以通过编程方式定义此类 Bean）使用 Spring API，尽管您必须查阅源代码有关如何执行此操作的说明，因为本章不涉及此类高级配置）。请注意，这是一个迭代步骤。每个动态至少需要一个 Bean 定义语言源文件（尽管多个 Bean 定义可以引用同一个源文件）。<lang:language/>

前两个步骤（测试和编写动态语言源文件）超出了本章的范围。请参阅语言规范和参考手册对于您选择的动态语言，并继续开发您的动态语言源文件。不过，您首先要阅读本章的其余部分，因为 Spring的动态语言支持确实对内容做出了一些（小的）假设。的动态语言源文件。

<lang：language/> 元素

上一节列表中的最后一步涉及定义动态语言支持的 Bean 定义，每个 Bean 定义一个想要配置（这与普通的JavaBean配置没有什么不同）。然而而不是指定要成为的类的完全限定类名由容器实例化和配置，您可以使用 Element 来定义动态语言支持的 Bean。<lang:language/>

每种支持的语言都有一个相应的元素：<lang:language/>

<lang:groovy/>（嘟嘟）
<lang:bsh/>（豆壳）
<lang:std/>（JSR-223，例如与JRuby一起使用）

可用于配置的确切属性和子元素取决于确切地定义了 Bean 的语言（特定于语言的部分）本章后面将详细介绍这一点）。

可提神豆

动态语言最引人注目的附加值之一（也许是唯一的）最引人注目的附加值之一春季的支持是“可刷新豆”功能。

可刷新的 Bean 是动态语言支持的 Bean。用少量配置，动态语言支持的 Bean 可以监视其底层的更改源文件资源，然后在动态语言源文件为已更改（例如，当您编辑并保存对文件系统上的文件的更改时）。

这允许您部署任意数量的动态语言源文件作为应用程序，配置 Spring 容器以创建由动态支持的 bean 语言源文件（使用本章中描述的机制）和（稍后，随着需求的变化或其他一些外部因素发挥作用）编辑动态语言源文件，并且它们所做的任何更改都会反映在 Bean 中由更改的动态语言源文件提供支持。无需关闭正在运行应用程序（如果是 Web 应用程序，则重新部署）。这动态语言支持的 Bean 如此修正从更改了动态语言源文件。

现在我们可以看一个例子，看看开始使用可刷新是多么容易豆。要打开可刷新的 bean 功能，您必须指定一个 Bean 定义的元素上的附加属性。所以如果我们坚持前面的例子本章，下面的示例展示了我们将在 Spring XML 中更改的内容影响可刷新豆类的配置：<lang:language/>

<beans>

    <!-- this bean is now 'refreshable' due to the presence of the 'refresh-check-delay' attribute -->
    <lang:groovy id="messenger"
            refresh-check-delay="5000" <!-- switches refreshing on with 5 seconds between checks -->
            script-source="classpath:Messenger.groovy">
        <lang:property name="message" value="I Can Do The Frug" />
    </lang:groovy>

    <bean id="bookingService" class="x.y.DefaultBookingService">
        <property name="messenger" ref="messenger" />
    </bean>

</beans>

这真的是你所要做的。在 bean 定义上定义的属性是 bean 之后的毫秒数使用对基础动态语言源文件所做的任何更改进行刷新。您可以通过为属性分配负值来关闭刷新行为。请记住，默认情况下，刷新行为为禁用。如果不需要刷新行为，请不要定义该属性。refresh-check-delaymessengerrefresh-check-delay

如果我们然后运行以下应用程序，我们可以执行可刷新功能。（请原谅“跳过箍暂停执行”的恶作剧在下一段代码中。该呼叫仅存在，以便程序的执行在您（在此方案中为开发人员）关闭时暂停并编辑基础动态语言源文件，以便刷新触发器在程序恢复执行时，在动态语言支持的 Bean 上。System.in.read()

下面的清单显示了此示例应用程序：

public final class Boot {

    public static void main(final String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Messenger messenger = (Messenger) ctx.getBean("messenger");
        System.out.println(messenger.getMessage());
        // pause execution while I go off and make changes to the source file...
        System.in.read();
        System.out.println(messenger.getMessage());
    }
}

然后，出于此示例的目的，假设必须更改对实现方法的所有调用，以便消息用引号括起来。以下清单显示了您所做的更改（开发者）应该在源文件时程序的执行已暂停：getMessage()MessengerMessenger.groovy

package org.springframework.scripting

class GroovyMessenger implements Messenger {

    private String message = "Bingo"

    public String getMessage() {
        // change the implementation to surround the message in quotes
        return "'" + this.message + "'"
    }

    public void setMessage(String message) {
        this.message = message
    }
}

当程序运行时，输入暂停前的输出将是。对源文件进行更改并保存并且程序恢复执行后，在动态语言支持的实现上调用该方法的结果是（注意包含附加引号）。I Can Do The FruggetMessage()Messenger'I Can Do The Frug'

如果对脚本的更改发生在的价值。对脚本的更改实际上不会被选取，直到在动态语言支持的 Bean 上调用一个方法。只有当一个方法是调用一个动态语言支持的 Bean，它检查它是否底层脚本来源已更改。与刷新脚本相关的任何异常（例如遇到编译错误或发现脚本文件已被删除）导致将致命异常传播到调用代码。refresh-check-delay

前面描述的可刷新 Bean 行为不适用于动态语言使用元素表示法定义的源文件（请参阅内联动态语言源文件）。此外，它仅适用于以下豆类：实际上可以检测到对基础源文件的更改（例如，通过代码检查存在于文件系统）。<lang:inline-script/>

内联动态语言源文件

动态语言支持还可以满足动态语言源文件的需求：直接嵌入在春豆定义中。更具体地说，该元素允许您立即定义动态语言源在 Spring 配置文件中。一个示例可能会阐明内联脚本如何功能作品：<lang:inline-script/>

<lang:groovy id="messenger">
    <lang:inline-script>

package org.springframework.scripting.groovy;

import org.springframework.scripting.Messenger

class GroovyMessenger implements Messenger {
    String message
}

    </lang:inline-script>
    <lang:property name="message" value="I Can Do The Frug" />
</lang:groovy>

If we put to one side the issues surrounding whether it is good practice to define dynamic language source inside a Spring configuration file, the element can be useful in some scenarios. For instance, we might want to quickly add a Spring implementation to a Spring MVC . This is but a moment’s work using inline source. (See Scripted Validators for such an example.)<lang:inline-script/>ValidatorController

Understanding Constructor Injection in the Context of Dynamic-language-backed Beans

There is one very important thing to be aware of with regard to Spring’s dynamic language support. Namely, you can not (currently) supply constructor arguments to dynamic-language-backed beans (and, hence, constructor-injection is not available for dynamic-language-backed beans). In the interests of making this special handling of constructors and properties 100% clear, the following mixture of code and configuration does not work:

An approach that cannot work

// from the file 'Messenger.groovy'
package org.springframework.scripting.groovy;

class GroovyMessenger implements Messenger {

    GroovyMessenger() {}

    // this constructor is not available for Constructor Injection
    GroovyMessenger(String message) {
        this.message = message;
    }

    String message

    String anotherMessage
}

<lang:groovy id="badMessenger"
    script-source="classpath:Messenger.groovy">
    <!-- this next constructor argument will not be injected into the GroovyMessenger -->
    <!-- in fact, this isn't even allowed according to the schema -->
    <constructor-arg value="This will not work" />

    <!-- only property values are injected into the dynamic-language-backed object -->
    <lang:property name="anotherMessage" value="Passed straight through to the dynamic-language-backed object" />

</lang>

在实践中，这种限制并不像最初看起来那么重要，因为二传手注入是绝大多数开发者青睐的注入方式（我们将关于这是否是一件好事的讨论留到另一天）。

3.2.2. 时髦的豆子

本节介绍如何使用在 Groovy in Spring 中定义的 bean。

Groovy主页包括以下描述：

“Groovy是Java 2平台的敏捷动态语言，具有许多人们非常喜欢Python，Ruby和Smalltalk等语言的功能，使它们可供使用类似Java语法的Java开发人员使用。

如果你直接从顶部阅读了本章，你已经看到了一个Groovy-dynamic-language支持的例子。豆。现在考虑另一个示例（再次使用Spring 测试套件中的示例）：

package org.springframework.scripting;

public interface Calculator {

    int add(int x, int y);
}

以下示例在 Groovy 中实现接口：Calculator

// from the file 'calculator.groovy'
package org.springframework.scripting.groovy

class GroovyCalculator implements Calculator {

    int add(int x, int y) {
        x + y
    }
}

以下 Bean 定义使用 Groovy 中定义的计算器：

<!-- from the file 'beans.xml' -->
<beans>
    <lang:groovy id="calculator" script-source="classpath:calculator.groovy"/>
</beans>

最后，以下小型应用程序执行上述配置：

package org.springframework.scripting;

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Calculator calc = ctx.getBean("calculator", Calculator.class);
        System.out.println(calc.add(2, 8));
    }
}

运行上述程序的结果输出是（不出所料）。（有关更多有趣的示例，请参阅动态语言展示项目以获取更多信息复杂示例或参阅本章后面的示例方案）。10

不能为每个 Groovy 源文件定义多个类。虽然这是完美的在Groovy中合法，这（可以说）是一种不好的做法。为了一致方法，你应该（在Spring团队看来）尊重标准的Java。每个源文件一个（公共）类的约定。

使用回调自定义时髦对象

接口是一个回调，可让您挂钩其他创建逻辑到创建 Groovy 支持的 Bean 的过程中。例如此接口的实现可以调用任何所需的初始化方法，设置一些默认属性值，或指定自定义。以下列表显示接口定义：GroovyObjectCustomizerMetaClassGroovyObjectCustomizer

public interface GroovyObjectCustomizer {

    void customize(GroovyObject goo);
}

Spring 框架实例化了 Groovy 支持的 Bean 的一个实例，然后将创建的传递给指定的（如果一个已定义）。您可以使用提供的引用做任何您喜欢的事情。我们希望大多数人都想以此设置习俗回调，以下示例演示了如何执行此操作：GroovyObjectGroovyObjectCustomizerGroovyObjectMetaClass

public final class SimpleMethodTracingCustomizer implements GroovyObjectCustomizer {

    public void customize(GroovyObject goo) {
        DelegatingMetaClass metaClass = new DelegatingMetaClass(goo.getMetaClass()) {

            public Object invokeMethod(Object object, String methodName, Object[] arguments) {
                System.out.println("Invoking '" + methodName + "'.");
                return super.invokeMethod(object, methodName, arguments);
            }
        };
        metaClass.initialize();
        goo.setMetaClass(metaClass);
    }

}

在Groovy中对元编程进行全面讨论超出了Spring的范围参考手册。请参阅Groovy参考手册的相关部分或执行在线搜索。很多文章都谈到了这个话题。实际上，如果您使用 Spring 命名空间支持，则很容易使用 ais 作为以下示例显示：GroovyObjectCustomizer

<!-- define the GroovyObjectCustomizer just like any other bean -->
<bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>

    <!-- ... and plug it into the desired Groovy bean via the 'customizer-ref' attribute -->
    <lang:groovy id="calculator"
        script-source="classpath:org/springframework/scripting/groovy/Calculator.groovy"
        customizer-ref="tracingCustomizer"/>

如果不使用 Spring 命名空间支持，您仍然可以使用该功能，如以下示例所示：GroovyObjectCustomizer

<bean id="calculator" class="org.springframework.scripting.groovy.GroovyScriptFactory">
    <constructor-arg value="classpath:org/springframework/scripting/groovy/Calculator.groovy"/>
    <!-- define the GroovyObjectCustomizer (as an inner bean) -->
    <constructor-arg>
        <bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>
    </constructor-arg>
</bean>

<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>

3.2.3. 豆壳豆

本节介绍如何在春季使用BeanShell bean。

BeanShell 主页包括以下内容描述：

BeanShell is a small, free, embeddable Java source interpreter with dynamic language
features, written in Java. BeanShell dynamically runs standard Java syntax and
extends it with common scripting conveniences such as loose types, commands, and method
closures like those in Perl and JavaScript.

与Groovy相比，BeanShell支持的bean定义需要一些（小的）额外的。配置。在 Spring 中实现的 BeanShell 动态语言支持是有趣的是，因为 Spring 创建了一个 JDK 动态代理来实现所有在元素的属性值中指定的接口（这就是为什么您必须在值中至少提供一个接口的原因的属性，因此，当您使用 BeanShell 支持时，编程到接口豆子）。这意味着对 BeanShell 支持的对象的每个方法调用都要经过 JDK 动态代理调用机制。script-interfaces<lang:bsh>

现在我们可以展示一个完全工作的示例，使用基于 BeanShell 的 bean 来实现本章前面定义的接口。我们再次展示接口的定义：MessengerMessenger

package org.springframework.scripting;

public interface Messenger {

    String getMessage();
}

下面的示例显示了 BeanShell 的“实现”（我们在这里松散地使用术语）的界面：Messenger

String message;

String getMessage() {
    return message;
}

void setMessage(String aMessage) {
    message = aMessage;
}

下面的示例显示了定义上述“实例”的 Spring XML。 “类”（同样，我们在这里非常松散地使用这些术语）：

<lang:bsh id="messageService" script-source="classpath:BshMessenger.bsh"
    script-interfaces="org.springframework.scripting.Messenger">

    <lang:property name="message" value="Hello World!" />
</lang:bsh>

有关您可能想要使用的某些方案，请参阅方案基于豆壳的豆。

3.3. 场景

在脚本语言中定义 Spring 管理的 Bean 的可能场景有益的是多种多样的。本节介绍春季的动态语言支持。

3.3.1. 脚本化弹簧 MVC 控制器

可以从使用动态语言支持的 bean 中受益的一组类是弹簧 MVC 控制器。在纯弹簧MVC应用中，导航流通过Web应用程序在很大程度上是由封装在您的弹簧MVC控制器。作为导航流和其他表示层逻辑的 Web 应用程序需要更新以响应支持问题或更改业务需求，则可能更容易通过以下方式实现任何此类所需的更改编辑一个或多个动态语言源文件并查看这些更改立即反映在正在运行的应用程序的状态中。

请记住，在诸如春天，你通常的目标是有一个非常薄的表示层，所有包含在域和服务中的应用程序的丰富业务逻辑图层类。将Spring MVC控制器开发为动态语言支持的bean，让您可以通过编辑和保存文本文件来更改表示层逻辑。任何对此类动态语言源文件的更改是（取决于配置）自动反映在由动态语言源文件支持的 Bean 中。

以下示例显示已实现的通过使用Groovy动态语言：org.springframework.web.servlet.mvc.Controller

// from the file '/WEB-INF/groovy/FortuneController.groovy'
package org.springframework.showcase.fortune.web

class FortuneController implements Controller {

    @Property FortuneService fortuneService

    ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse httpServletResponse) {
        return new ModelAndView("tell", "fortune", this.fortuneService.tellFortune())
    }
}

<lang:groovy id="fortune"
        refresh-check-delay="3000"
        script-source="/WEB-INF/groovy/FortuneController.groovy">
    <lang:property name="fortuneService" ref="fortuneService"/>
</lang:groovy>

3.3.2. 脚本化验证器

Spring 应用程序开发的另一个领域可能会从动态语言支持的 Bean 提供的灵活性是验证的灵活性。它可以通过使用松散类型的动态语言更轻松地表达复杂的验证逻辑（也可能支持内联正则表达式）而不是正则 Java。

同样，将验证器开发为动态语言支持的 bean 可以让你改变通过编辑和保存简单文本文件来验证逻辑。任何此类更改都是（取决于配置）自动反映在执行正在运行应用程序，并且不需要重新启动应用程序。

下面的示例展示了一个使用 Groovy 动态语言实现的 Spring（有关接口的讨论，请参阅Validation Using Spring 的 Validator 接口）：org.springframework.validation.ValidatorValidator

class TestBeanValidator implements Validator {

    boolean supports(Class clazz) {
        return TestBean.class.isAssignableFrom(clazz)
    }

    void validate(Object bean, Errors errors) {
        if(bean.name?.trim()?.size() > 0) {
            return
        }
        errors.reject("whitespace", "Cannot be composed wholly of whitespace.")
    }
}

3.4. 其他细节

最后一部分包含与动态语言支持相关的一些其他详细信息。

3.4.1. AOP — 为脚本化 Bean 提供建议

您可以使用 Spring AOP 框架来建议脚本化 bean。春季AOP 框架实际上不知道被建议的 Bean 可能是脚本 bean，因此您使用（或打算使用）的所有 AOP 用例和功能使用脚本化 Bean。当您建议脚本化 Bean 时，不能使用基于类的代理。您必须使用基于接口的代理。

您不仅限于为脚本化 Bean 提供建议。您也可以自己编写方面在支持的动态语言中，并使用这些 bean 来建议其他 Spring bean。不过，这确实是对动态语言支持的高级使用。

3.4.2. 范围界定

如果不是很明显，脚本化 bean 的范围可以与任何其他豆子。各种元素的属性让您可以控制底层脚本化 Bean 的作用域，就像控制常规豆。（默认范围为单一实例，就像“普通”豆子一样。scope<lang:language/>

下面的示例使用 theattribute 来定义作用域为原型：scope

<?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:lang="http://www.springframework.org/schema/lang"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

    <lang:groovy id="messenger" script-source="classpath:Messenger.groovy" scope="prototype">
        <lang:property name="message" value="I Can Do The RoboCop" />
    </lang:groovy>

    <bean id="bookingService" class="x.y.DefaultBookingService">
        <property name="messenger" ref="messenger" />
    </bean>

</beans>

请参阅IoC 容器中的Bean Scopes，了解 Spring 框架中作用域支持的完整讨论。

3.4.3. XML 架构`lang`

Spring XML 配置中的元素处理公开已用动态语言（如Groovy或BeanShell）编写，作为Spring容器中的bean。lang

动态语言支持中全面介绍了这些元素（以及动态语言支持）。请参阅该部分有关此支持和元素的完整详细信息。lang

要使用架构中的元素，您需要在顶部的 Spring XML 配置文件。以下代码段引用中的文本正确的架构，以便命名空间中的标记可供您使用：langlang

<?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:lang="http://www.springframework.org/schema/lang"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

    <!-- bean definitions here -->

</beans>

标签：语言,框架,示例,Spring,bean,Bean,Kotlin
From： https://blog.51cto.com/u_15326439/5872686