anchor.diff:  == Support for Kotlin classes
   
   Spring Framework 5 now supports various Kotlin constructs like instantiating Kotlin classes
  -via primary constructors, immutable classes data binding and optional parameters with default values.
  -
  -== Leveraging Kotlin nullable information in Spring annotations
  -
  -Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety support]
  +via primary constructors, immutable classes data binding and function optional parameters
  +with default values.
  +
  +https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] which is required
  +for serializing / deserializing JSON data is automatically registered when present in the
  +classpath, and will log a warning message if Jackson + Kotlin are detected without Jackson
  +Kotlin module.
  +
  +[NOTE]
  +====
  +As of Spring Boot 2.0, Jackson Kotlin module is automatically provided via the JSON starter.
  +====
  +
  +== Leveraging null-safety in Spring annotations
  +
  +Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety]
   to determine if an HTTP parameter is required without having to define explicitly the `required` attribute.
   That means `@RequestParam name: String?` with be treated as not required and `@RequestParam name: String` as required.
   
   This is also supported on Spring Messaging `@Header` annotation.
   
  -In a similar fashion, Spring bean injection with `@Autowired` or `@Inject` uses this information to know if a bean is required or not.
  -`@Autowired lateinit var foo: Foo` implies that a bean of type `Foo` must be registered in the application context while
  -`@Autowired lateinit var foo: Foo?` won’t raise an error if such bean does not exist.
  +In a similar fashion, Spring bean injection with `@Autowired` or `@Inject` uses this information
  +to know if a bean is required or not. `@Autowired lateinit var foo: Foo` implies that a bean
  +of type `Foo` must be registered in the application context while `@Autowired lateinit var foo: Foo?`
  +won’t raise an error if such bean does not exist.
   
   == Spring WebFlux functional DSL
   
  -Spring Framework 5.0 comes with a {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/-router-function-dsl/[Kotlin routing DSL] that allows you to leverage the
  -<<webflux-fn,WebFlux functional API] with clean and idiomatic Kotlin code:
  +Spring Framework 5 comes with a
  +{doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/-router-function-dsl/[Kotlin routing DSL]
  +that allows you to leverage the <<webflux-fn,WebFlux functional API] with clean and idiomatic Kotlin code:
   
   [source,kotlin]
   ----
  
positive.code: 
  === What is the recommended way to inject dependencies in Kotlin?
  
  Try to favor constructor injection with `val` properties. As of Spring Framework 4.3, you
  just have to write `class MessageController(val repository: MessageService)` and Spring will automatically
  autowire the constructor.
  
  If you really need to use field injection, use `lateinit var`:
  
  
negative.code: As of version 4.3, Spring Framework provides a
  http://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/view/script/ScriptTemplateView.html[ScriptTemplateView]
  to render templates using script engines that supports https://www.jcp.org/en/jsr/detail?id=223[JSR-223]
  and Spring Framework 5 go even further by extending this feature to WebFlux and supporting
  https://jira.spring.io/browse/SPR-15064[i18n and nested templates].
  
  Kotlin 1.1 provides such support and allows to render Kotlin based templates, see
  