Extract recurring asciidoc links to attributes, cleanup old doc files

This commit extract spring-related links and recurring external links
into asciidoctor attributes to be used by the Antora toolchain.

It notably homogenizes links to:
 - IETF RFCs
 - Java Community Process JSRs
 - the Java API Documentation (on the Java 17 version)
 - Kotlin documentations (on the Kotlinlang.org version)
 - the Spring Boot reference guide (on the `html` version)

This commit also reworks most link attributes to follow a
Project-Category-Misc syntax. For example, `spring-boot-docs` rather
than `docs-spring-boot`.

Finally, it makes an effort to clean up remainders from the previous
documentation toolchain, namely the `docs/asciidoc` folder and 
`modules/ROOT/pages/attributes.adoc` file.

Closes gh-26864
Closes gh-31619

framework-docs/modules/ROOT/pages/languages/kotlin.adoc

@@ -2,9 +2,9 @@
 = Kotlin
 :page-section-summary-toc: 1
 
-https://kotlinlang.org[Kotlin] is a statically typed language that targets the JVM
+{kotlin-site}[Kotlin] is a statically typed language that targets the JVM
 (and other platforms) which allows writing concise and elegant code while providing
-very good https://kotlinlang.org/docs/reference/java-interop.html[interoperability]
+very good {kotlin-docs}/java-interop.html[interoperability]
 with existing libraries written in Java.
 
 The Spring Framework provides first-class support for Kotlin and lets developers write
@@ -13,13 +13,13 @@ Most of the code samples of the reference documentation are
 provided in Kotlin in addition to Java.
 
 The easiest way to build a Spring application with Kotlin is to leverage Spring Boot and
-its https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-kotlin.html[dedicated Kotlin support].
-https://spring.io/guides/tutorials/spring-boot-kotlin/[This comprehensive tutorial]
+its{spring-boot-docs}/boot-features-kotlin.html[dedicated Kotlin support].
+{spring-site-guides}/tutorials/spring-boot-kotlin/[This comprehensive tutorial]
 will teach you how to build Spring Boot applications with Kotlin using https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].
 
 Feel free to join the #spring channel of https://slack.kotlinlang.org/[Kotlin Slack]
 or ask a question with `spring` and `kotlin` as tags on
-https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you need support.
+{stackoverflow-spring-kotlin-tags}[Stackoverflow] if you need support.
 
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/annotations.adoc

@@ -1,7 +1,7 @@
 [[kotlin-annotations]]
 = Annotations
 
-The Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety]
+The Spring Framework also takes advantage of {kotlin-docs}/null-safety.html[Kotlin null-safety]
 to determine if an HTTP parameter is required without having to explicitly
 define the `required` attribute. That means `@RequestParam name: String?` is treated
 as not required and, conversely, `@RequestParam name: String` is treated as being required.
@@ -20,9 +20,9 @@ type `Car` may or may not exist. The same behavior applies to autowired construc
 
 NOTE: If you use bean validation on classes with properties or a primary constructor
 parameters, you may need to use
-https://kotlinlang.org/docs/reference/annotations.html#annotation-use-site-targets[annotation use-site targets],
+{kotlin-docs}/annotations.html#annotation-use-site-targets[annotation use-site targets],
 such as `@field:NotNull` or `@get:Size(min=5, max=15)`, as described in
-https://stackoverflow.com/a/35853200/1092077[this Stack Overflow response].
+{stackoverflow-site}/a/35853200/1092077[this Stack Overflow response].
 
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/bean-definition-dsl.adoc

@@ -51,7 +51,7 @@ the constructor parameters will be autowired by type:
 ----
 
 In order to allow a more declarative approach and cleaner syntax, Spring Framework provides
-a {docs-spring-framework}/kdoc-api/spring-context/org.springframework.context.support/-bean-definition-dsl/index.html[Kotlin bean definition DSL]
+a {spring-framework-api-kdoc}/spring-context/org.springframework.context.support/-bean-definition-dsl/index.html[Kotlin bean definition DSL]
 It declares an `ApplicationContextInitializer` through a clean declarative API,
 which lets you deal with profiles and `Environment` for customizing
 how beans are registered.
@@ -104,10 +104,10 @@ as the following example shows:
 ----
 
 NOTE: Spring Boot is based on JavaConfig and
-https://github.com/spring-projects/spring-boot/issues/8115[does not yet provide specific support for functional bean definition],
+{spring-boot-issues}/8115[does not yet provide specific support for functional bean definition],
 but you can experimentally use functional bean definitions through Spring Boot's `ApplicationContextInitializer` support.
-See https://stackoverflow.com/questions/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
-for more details and up-to-date information. See also the experimental Kofu DSL developed in https://github.com/spring-projects/spring-fu[Spring Fu incubator].
+See {stackoverflow-questions}/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
+for more details and up-to-date information. See also the experimental Kofu DSL developed in {spring-github-org}/spring-fu[Spring Fu incubator].
 
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/classes-interfaces.adoc

@@ -12,7 +12,7 @@ compiler flag to be enabled during compilation. (For completeness, we neverthele
 running the Kotlin compiler with its `-java-parameters` flag for standard Java parameter exposure.)
 
 You can declare configuration classes as
-https://kotlinlang.org/docs/reference/nested-classes.html[top level or nested but not inner],
+{kotlin-docs}/nested-classes.html[top level or nested but not inner],
 since the later requires a reference to the outer class.
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/coroutines.adoc

@@ -1,21 +1,21 @@
 [[coroutines]]
 = Coroutines
 
-Kotlin https://kotlinlang.org/docs/reference/coroutines-overview.html[Coroutines] are Kotlin
+Kotlin {kotlin-docs}/coroutines-overview.html[Coroutines] are Kotlin
 lightweight threads allowing to write non-blocking code in an imperative way. On language side,
 suspending functions provides an abstraction for asynchronous operations while on library side
-https://github.com/Kotlin/kotlinx.coroutines[kotlinx.coroutines] provides functions like
-https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html[`async { }`]
-and types like https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[`Flow`].
+{kotlin-github-org}/kotlinx.coroutines[kotlinx.coroutines] provides functions like
+{kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines/async.html[`async { }`]
+and types like {kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[`Flow`].
 
 Spring Framework provides support for Coroutines on the following scope:
 
-* https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html[Deferred] and https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[Flow] return values support in Spring MVC and WebFlux annotated `@Controller`
+* {kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html[Deferred] and {kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[Flow] return values support in Spring MVC and WebFlux annotated `@Controller`
 * Suspending function support in Spring MVC and WebFlux annotated `@Controller`
-* Extensions for WebFlux {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.client/index.html[client] and {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/index.html[server] functional API.
-* WebFlux.fn {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL
+* Extensions for WebFlux {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.client/index.html[client] and {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/index.html[server] functional API.
+* WebFlux.fn {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL
 * Suspending function and `Flow` support in RSocket `@MessageMapping` annotated methods
-* Extensions for {docs-spring-framework}/kdoc-api/spring-messaging/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]
+* Extensions for {spring-framework-api-kdoc}/spring-messaging/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]
 
 
 
@@ -53,17 +53,17 @@ For input parameters:
 * If laziness is not needed, `fun handler(mono: Mono<T>)` becomes `fun handler(value: T)` since a suspending functions can be invoked to get the value parameter.
 * If laziness is needed, `fun handler(mono: Mono<T>)` becomes `fun handler(supplier: suspend () -> T)` or `fun handler(supplier: suspend () -> T?)`
 
-https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[`Flow`] is `Flux` equivalent in Coroutines world, suitable for hot or cold stream, finite or infinite streams, with the following main differences:
+{kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[`Flow`] is `Flux` equivalent in Coroutines world, suitable for hot or cold stream, finite or infinite streams, with the following main differences:
 
 * `Flow` is push-based while `Flux` is push-pull hybrid
 * Backpressure is implemented via suspending functions
-* `Flow` has only a https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/collect.html[single suspending `collect` method] and operators are implemented as https://kotlinlang.org/docs/reference/extensions.html[extensions]
-* https://github.com/Kotlin/kotlinx.coroutines/tree/master/kotlinx-coroutines-core/common/src/flow/operators[Operators are easy to implement] thanks to Coroutines
+* `Flow` has only a {kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/collect.html[single suspending `collect` method] and operators are implemented as {kotlin-docs}/extensions.html[extensions]
+* {kotlin-github-org}/kotlinx.coroutines/tree/master/kotlinx-coroutines-core/common/src/flow/operators[Operators are easy to implement] thanks to Coroutines
 * Extensions allow to add custom operators to `Flow`
 * Collect operations are suspending functions
-* https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/map.html[`map` operator] supports asynchronous operation (no need for `flatMap`) since it takes a suspending function parameter
+* {kotlin-coroutines-api}/kotlinx-coroutines-core/kotlinx.coroutines.flow/map.html[`map` operator] supports asynchronous operation (no need for `flatMap`) since it takes a suspending function parameter
 
-Read this blog post about https://spring.io/blog/2019/04/12/going-reactive-with-spring-coroutines-and-kotlin-flow[Going Reactive with Spring, Coroutines and Kotlin Flow]
+Read this blog post about {spring-site-blog}/2019/04/12/going-reactive-with-spring-coroutines-and-kotlin-flow[Going Reactive with Spring, Coroutines and Kotlin Flow]
 for more details, including how to run code concurrently with Coroutines.
 
 
@@ -170,7 +170,7 @@ class CoroutinesViewController(banner: Banner) {
 [[webflux-fn]]
 == WebFlux.fn
 
-Here is an example of Coroutines router defined via the {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL and related handlers.
+Here is an example of Coroutines router defined via the {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL and related handlers.
 
 [source,kotlin,indent=0]
 ----

framework-docs/modules/ROOT/pages/languages/kotlin/extensions.adoc

@@ -1,11 +1,11 @@
 [[kotlin-extensions]]
 = Extensions
 
-Kotlin https://kotlinlang.org/docs/reference/extensions.html[extensions] provide the ability
+Kotlin {kotlin-docs}/extensions.html[extensions] provide the ability
 to extend existing classes with additional functionality. The Spring Framework Kotlin APIs
 use these extensions to add new Kotlin-specific conveniences to existing Spring APIs.
 
-The {docs-spring-framework}/kdoc-api/[Spring Framework KDoc API] lists
+The {spring-framework-api-kdoc}/[Spring Framework KDoc API] lists
 and documents all available Kotlin extensions and DSLs.
 
 NOTE: Keep in mind that Kotlin extensions need to be imported to be used. This means,
@@ -13,8 +13,8 @@ for example, that the `GenericApplicationContext.registerBean` Kotlin extension
 is available only if `org.springframework.context.support.registerBean` is imported.
 That said, similar to static imports, an IDE should automatically suggest the import in most cases.
 
-For example, https://kotlinlang.org/docs/reference/inline-functions.html#reified-type-parameters[Kotlin reified type parameters]
-provide a workaround for JVM https://docs.oracle.com/javase/tutorial/java/generics/erasure.html[generics type erasure],
+For example, {kotlin-docs}/inline-functions.html#reified-type-parameters[Kotlin reified type parameters]
+provide a workaround for JVM {java-tutorial}/java/generics/erasure.html[generics type erasure],
 and the Spring Framework provides some extensions to take advantage of this feature.
 This allows for a better Kotlin API `RestTemplate`, for the new `WebClient` from Spring
 WebFlux, and for various other APIs.

framework-docs/modules/ROOT/pages/languages/kotlin/getting-started.adoc

@@ -2,7 +2,7 @@
 = Getting Started
 
 The easiest way to learn how to build a Spring application with Kotlin is to follow
-https://spring.io/guides/tutorials/spring-boot-kotlin/[the dedicated tutorial].
+{spring-site-guides}/tutorials/spring-boot-kotlin/[the dedicated tutorial].
 
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/null-safety.adoc

@@ -1,20 +1,20 @@
 [[kotlin-null-safety]]
 = Null-safety
 
-One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety],
+One of Kotlin's key features is {kotlin-docs}/null-safety.html[null-safety],
 which cleanly deals with `null` values at compile time rather than bumping into the famous
 `NullPointerException` at runtime. This makes applications safer through nullability
 declarations and expressing "`value or no value`" semantics without paying the cost of wrappers, such as `Optional`.
 (Kotlin allows using functional constructs with nullable values. See this
-https://www.baeldung.com/kotlin-null-safety[comprehensive guide to Kotlin null-safety].)
+{baeldung-blog}/kotlin-null-safety[comprehensive guide to Kotlin null-safety].)
 
 Although Java does not let you express null-safety in its type-system, the Spring Framework
 provides xref:languages/kotlin/null-safety.adoc[null-safety of the whole Spring Framework API]
 via tooling-friendly annotations declared in the `org.springframework.lang` package.
 By default, types from Java APIs used in Kotlin are recognized as
-https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types],
+{kotlin-docs}/java-interop.html#null-safety-and-platform-types[platform types],
 for which null-checks are relaxed.
-https://kotlinlang.org/docs/reference/java-interop.html#jsr-305-support[Kotlin support for JSR-305 annotations]
+{kotlin-docs}/java-interop.html#jsr-305-support[Kotlin support for JSR-305 annotations]
 and Spring nullability annotations provide null-safety for the whole Spring Framework API to Kotlin developers,
 with the advantage of dealing with `null`-related issues at compile time.
 
@@ -30,7 +30,7 @@ API nullability declaration could evolve even between minor releases and that mo
 be added in the future.
 
 NOTE: Generic type arguments, varargs, and array elements nullability are not supported yet,
-but should be in an upcoming release. See https://github.com/Kotlin/KEEP/issues/79[this discussion]
+but should be in an upcoming release. See {kotlin-github-org}/KEEP/issues/79[this discussion]
 for up-to-date information.
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/requirements.adoc

@@ -9,9 +9,9 @@ and https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-reflect[`kotli
 to be present on the classpath. They are provided by default if you bootstrap a Kotlin project on
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].
 
-WARNING: Kotlin https://kotlinlang.org/docs/inline-classes.html[inline classes] are not yet supported.
+WARNING: Kotlin {kotlin-docs}/inline-classes.html[inline classes] are not yet supported.
 
-NOTE: The https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] is required
+NOTE: The {jackson-github-org}/jackson-module-kotlin[Jackson Kotlin module] is required
 for serializing or deserializing JSON data for Kotlin classes with Jackson, so make sure to add the
 `com.fasterxml.jackson.module:jackson-module-kotlin` dependency to your project if you have such need.
 It is automatically registered when found in the classpath.

framework-docs/modules/ROOT/pages/languages/kotlin/resources.adoc

@@ -4,9 +4,9 @@
 We recommend the following resources for people learning how to build applications with
 Kotlin and the Spring Framework:
 
-* https://kotlinlang.org/docs/reference/[Kotlin language reference]
+* {kotlin-docs}[Kotlin language reference]
 * https://slack.kotlinlang.org/[Kotlin Slack] (with a dedicated #spring channel)
-* https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow, with `spring` and `kotlin` tags]
+* {stackoverflow-spring-kotlin-tags}[Stackoverflow, with `spring` and `kotlin` tags]
 * https://play.kotlinlang.org/[Try Kotlin in your browser]
 * https://blog.jetbrains.com/kotlin/[Kotlin blog]
 * https://kotlin.link/[Awesome Kotlin]
@@ -34,12 +34,12 @@ The following Github projects offer examples that you can learn from and possibl
 The following list categorizes the pending issues related to Spring and Kotlin support:
 
 * Spring Framework
-** https://github.com/spring-projects/spring-framework/issues/20606[Unable to use WebTestClient with mock server in Kotlin]
-** https://github.com/spring-projects/spring-framework/issues/20496[Support null-safety at generics, varargs and array elements level]
+** {spring-framework-issues}/20606[Unable to use WebTestClient with mock server in Kotlin]
+** {spring-framework-issues}/20496[Support null-safety at generics, varargs and array elements level]
 * Kotlin
-** https://youtrack.jetbrains.com/issue/KT-6380[Parent issue for Spring Framework support]
-** https://youtrack.jetbrains.com/issue/KT-5464[Kotlin requires type inference where Java doesn't]
-** https://youtrack.jetbrains.com/issue/KT-20283[Smart cast regression with open classes]
-** https://youtrack.jetbrains.com/issue/KT-14984[Impossible to pass not all SAM argument as function]
-** https://youtrack.jetbrains.com/issue/KT-15125[Support JSR 223 bindings directly via script variables]
-** https://youtrack.jetbrains.com/issue/KT-6653[Kotlin properties do not override Java-style getters and setters]
+** {kotlin-issues}/KT-6380[Parent issue for Spring Framework support]
+** {kotlin-issues}/KT-5464[Kotlin requires type inference where Java doesn't]
+** {kotlin-issues}/KT-20283[Smart cast regression with open classes]
+** {kotlin-issues}/KT-14984[Impossible to pass not all SAM argument as function]
+** {kotlin-issues}/KT-15125[Support JSR 223 bindings directly via script variables]
+** {kotlin-issues}/KT-6653[Kotlin properties do not override Java-style getters and setters]

framework-docs/modules/ROOT/pages/languages/kotlin/spring-projects-in.adoc

@@ -21,10 +21,10 @@ member function of Spring beans that are proxied by CGLIB, which can
 quickly become painful and is against the Kotlin principle of keeping code concise and predictable.
 
 NOTE: It is also possible to avoid CGLIB proxies for configuration classes by using `@Configuration(proxyBeanMethods = false)`.
-See {api-spring-framework}/context/annotation/Configuration.html#proxyBeanMethods--[`proxyBeanMethods` Javadoc] for more details.
+See {spring-framework-api}/context/annotation/Configuration.html#proxyBeanMethods--[`proxyBeanMethods` Javadoc] for more details.
 
 Fortunately, Kotlin provides a
-https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-plugin[`kotlin-spring`]
+{kotlin-docs}/compiler-plugins.html#kotlin-spring-compiler-plugin[`kotlin-spring`]
 plugin (a preconfigured version of the `kotlin-allopen` plugin) that automatically opens classes
 and their member functions for types that are annotated or meta-annotated with one of the following
 annotations:
@@ -59,7 +59,7 @@ within the primary constructor, as in the following example:
 	class Person(val name: String, val age: Int)
 ----
 
-You can optionally add https://kotlinlang.org/docs/reference/data-classes.html[the `data` keyword]
+You can optionally add {kotlin-docs}/data-classes.html[the `data` keyword]
 to make the compiler automatically derive the following members from all properties declared
 in the primary constructor:
 
@@ -80,12 +80,12 @@ As the following example shows, this allows for easy changes to individual prope
 
 Common persistence technologies (such as JPA) require a default constructor, preventing this
 kind of design. Fortunately, there is a workaround for this
-https://stackoverflow.com/questions/32038177/kotlin-with-jpa-default-constructor-hell["`default constructor hell`"],
-since Kotlin provides a https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-jpa-compiler-plugin[`kotlin-jpa`]
+{stackoverflow-questions}/32038177/kotlin-with-jpa-default-constructor-hell["`default constructor hell`"],
+since Kotlin provides a {kotlin-docs}/compiler-plugins.html#kotlin-jpa-compiler-plugin[`kotlin-jpa`]
 plugin that generates synthetic no-arg constructor for classes annotated with JPA annotations.
 
 If you need to leverage this kind of mechanism for other persistence technologies, you can configure
-the https://kotlinlang.org/docs/reference/compiler-plugins.html#how-to-use-no-arg-plugin[`kotlin-noarg`]
+the {kotlin-docs}/compiler-plugins.html#how-to-use-no-arg-plugin[`kotlin-noarg`]
 plugin.
 
 NOTE: As of the Kay release train, Spring Data supports Kotlin immutable class instances and
@@ -98,7 +98,7 @@ does not require the `kotlin-noarg` plugin if the module uses Spring Data object
 == Injecting Dependencies
 
 Our recommendation is to try to favor constructor injection with `val` read-only (and
-non-nullable when possible) https://kotlinlang.org/docs/reference/properties.html[properties],
+non-nullable when possible) {kotlin-docs}/properties.html[properties],
 as the following example shows:
 
 [source,kotlin,indent=0]
@@ -137,13 +137,13 @@ as the following example shows:
 
 In Java, you can inject configuration properties by using annotations (such as pass:q[`@Value("${property}")`)].
 However, in Kotlin, `$` is a reserved character that is used for
-https://kotlinlang.org/docs/reference/idioms.html#string-interpolation[string interpolation].
+{kotlin-docs}/idioms.html#string-interpolation[string interpolation].
 
 Therefore, if you wish to use the `@Value` annotation in Kotlin, you need to escape the `$`
 character by writing pass:q[`@Value("\${property}")`].
 
 NOTE: If you use Spring Boot, you should probably use
-https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[`@ConfigurationProperties`]
+{spring-boot-docs}/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[`@ConfigurationProperties`]
 instead of `@Value` annotations.
 
 As an alternative, you can customize the property placeholder prefix by declaring the
@@ -177,14 +177,14 @@ that uses the `${...}` syntax, with configuration beans, as the following exampl
 [[checked-exceptions]]
 == Checked Exceptions
 
-Java and https://kotlinlang.org/docs/reference/exceptions.html[Kotlin exception handling]
+Java and {kotlin-docs}/exceptions.html[Kotlin exception handling]
 are pretty close, with the main difference being that Kotlin treats all exceptions as
 unchecked exceptions. However, when using proxied objects (for example classes or methods
 annotated with `@Transactional`), checked exceptions thrown will be wrapped by default in
 an `UndeclaredThrowableException`.
 
 To get the original exception thrown like in Java, methods should be annotated with
-https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-throws/index.html[`@Throws`]
+{kotlin-api}/jvm/stdlib/kotlin.jvm/-throws/index.html[`@Throws`]
 to specify explicitly the checked exceptions thrown (for example `@Throws(IOException::class)`).
 
 
@@ -194,7 +194,7 @@ to specify explicitly the checked exceptions thrown (for example `@Throws(IOExce
 
 Kotlin annotations are mostly similar to Java annotations, but array attributes (which are
 extensively used in Spring) behave differently. As explained in the
-https://kotlinlang.org/docs/reference/annotations.html[Kotlin documentation] you can omit
+{kotlin-docs}/annotations.html[Kotlin documentation] you can omit
 the `value` attribute name, unlike other attributes, and specify it as a `vararg` parameter.
 
 To understand what that means, consider `@RequestMapping` (which is one of the most widely
@@ -240,13 +240,13 @@ be matched, not only the `GET` method.
 == Declaration-site variance
 
 Dealing with generic types in Spring applications written in Kotlin may require, for some use cases, to understand
-Kotlin https://kotlinlang.org/docs/generics.html#declaration-site-variance[declaration-site variance]
+Kotlin {kotlin-docs}/generics.html#declaration-site-variance[declaration-site variance]
 which allows to define the variance when declaring a type, which is not possible in Java which supports only use-site
 variance.
 
 For example, declaring `List<Foo>` in Kotlin is conceptually equivalent to `java.util.List<? extends Foo>` because
 `kotlin.collections.List` is declared as
-https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/[`interface List<out E> : kotlin.collections.Collection<E>`].
+{kotlin-api}/jvm/stdlib/kotlin.collections/-list/[`interface List<out E> : kotlin.collections.Collection<E>`].
 
 This needs to be taken into account by using the `out` Kotlin keyword on generic types when using Java classes,
 for example when writing a `org.springframework.core.convert.converter.Converter` from a Kotlin type to a Java type.
@@ -267,7 +267,7 @@ class ListOfAnyConverter : Converter<List<*>, CustomJavaList<*>> {
 ----
 
 NOTE: Spring Framework does not leverage yet declaration-site variance type information for injecting beans,
-subscribe to https://github.com/spring-projects/spring-framework/issues/22313[spring-framework#22313] to track related
+subscribe to {spring-framework-issues}/22313[spring-framework#22313] to track related
 progresses.
 
 
@@ -280,7 +280,7 @@ The recommended testing framework is https://junit.org/junit5/[JUnit 5] along wi
 https://mockk.io/[Mockk] for mocking.
 
 NOTE: If you are using Spring Boot, see
-https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-kotlin-testing[this related documentation].
+{spring-boot-docs}/features.html#features.kotlin.testing[this related documentation].
 
 
 [[constructor-injection]]
@@ -289,7 +289,7 @@ https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-featu
 As described in the xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[dedicated section],
 JUnit Jupiter (JUnit 5) allows constructor injection of beans which is pretty useful with Kotlin
 in order to use `val` instead of `lateinit var`. You can use
-{api-spring-framework}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
+{spring-framework-api}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
 to enable autowiring for all parameters.
 
 NOTE: You can also change the default behavior to `ALL` in a `junit-platform.properties`

framework-docs/modules/ROOT/pages/languages/kotlin/web.adoc

@@ -8,9 +8,9 @@
 
 Spring Framework comes with a Kotlin router DSL available in 3 flavors:
 
-* WebMvc.fn DSL with {docs-spring-framework}/kdoc-api/spring-webmvc/org.springframework.web.servlet.function/router.html[router { }]
-* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/router.html[router { }]
-* WebFlux.fn <<Coroutines>> DSL with {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]
+* WebMvc.fn DSL with {spring-framework-api-kdoc}/spring-webmvc/org.springframework.web.servlet.function/router.html[router { }]
+* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/router.html[router { }]
+* WebFlux.fn <<Coroutines>> DSL with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]
 
 These DSL let you write clean and idiomatic Kotlin code to build a `RouterFunction` instance as the following example shows:
 
@@ -79,12 +79,12 @@ mockMvc.get("/person/{name}", "Lee") {
 == Kotlin Script Templates
 
 Spring Framework provides a
-https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/view/script/ScriptTemplateView.html[`ScriptTemplateView`]
-which supports https://www.jcp.org/en/jsr/detail?id=223[JSR-223] to render templates by using script engines.
+{spring-framework-api}/web/servlet/view/script/ScriptTemplateView.html[`ScriptTemplateView`]
+which supports {JSR}223[JSR-223] to render templates by using script engines.
 
 By leveraging `scripting-jsr223` dependencies, it
 is possible to use such feature to render Kotlin-based templates with
-https://github.com/Kotlin/kotlinx.html[kotlinx.html] DSL or Kotlin multiline interpolated `String`.
+{kotlin-github-org}/kotlinx.html[kotlinx.html] DSL or Kotlin multiline interpolated `String`.
 
 `build.gradle.kts`
 [source,kotlin,indent=0]
@@ -126,10 +126,10 @@ project for more details.
 [[kotlin-multiplatform-serialization]]
 == Kotlin multiplatform serialization
 
-As of Spring Framework 5.3, https://github.com/Kotlin/kotlinx.serialization[Kotlin multiplatform serialization] is
+As of Spring Framework 5.3, {kotlin-github-org}/kotlinx.serialization[Kotlin multiplatform serialization] is
 supported in Spring MVC, Spring WebFlux and Spring Messaging (RSocket). The builtin support currently targets CBOR, JSON, and ProtoBuf formats.
 
-To enable it, follow https://github.com/Kotlin/kotlinx.serialization#setup[those instructions] to add the related dependency and plugin.
+To enable it, follow {kotlin-github-org}/kotlinx.serialization#setup[those instructions] to add the related dependency and plugin.
 With Spring MVC and WebFlux, both Kotlin serialization and Jackson will be configured by default if they are in the classpath since
 Kotlin serialization is designed to serialize only Kotlin classes annotated with `@Serializable`.
 With Spring Messaging (RSocket), make sure that neither Jackson, GSON or JSONB are in the classpath if you want automatic configuration,