anchor.diff:  * `@Transactional`
   * `@Cacheable`
   
  -Meta-annotations support means that types annotated with `@Configuration`, `@Controller`,
  +Meta-annotation support means that types annotated with `@Configuration`, `@Controller`,
   `@RestController`, `@Service`, or `@Repository` are automatically opened since these
   annotations are meta-annotated with `@Component`.
   
  -https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io] enables it by default, so, in practice,
  -you can write your Kotlin beans without any additional `open` keyword, as in Java.
  -
  -NOTE: The Kotlin code samples in Spring Framework documentation do not specify explicitly `open` on these classes and
  -their member functions, they are written for projects using the `kotlin-allopen` plugin since this is the most commonly
  -used setup.
  +https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io] enables
  +the `kotlin-spring` plugin by default. So, in practice, you can write your Kotlin beans
  +without any additional `open` keyword, as in Java.
  +
  +NOTE: The Kotlin code samples in Spring Framework documentation do not explicitly specify
  +`open` on the classes and their member functions. The samples are written for projects
  +using the `kotlin-allopen` plugin, since this is the most commonly used setup.
   
   === Using Immutable Class Instances for Persistence
   
  
positive.code: 
  === Injecting Dependencies
  
  Our recommendation is to try and favor constructor injection with `val` read-only (and
  non-nullable when possible) https://kotlinlang.org/docs/reference/properties.html[properties],
  as the following example shows:
  
  
negative.code: 
  While Kotlin's JVM-friendly design is generally frictionless with Spring, this specific Kotlin feature
  can prevent the application from starting, if this fact is not taken into consideration. This is because
  Spring beans (such as `@Configuration` annotated classes which by default need to be extended at runtime for technical
  reasons) are normally proxied by CGLIB. The workaround is to add an `open` keyword on each class and
  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.
  
  Fortunately, Kotlin provides a
  https://kotlinlang.org/docs/reference/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
  