编译器插件

    例如，当你使用 Spring 时，你不需要打开所有的类，而只需要使用特定的注解标注，如 @Configuration 或 @Service。All-open 允许指定这些注解。

    我们为全开放插件提供 Gradle 与 Maven 支持并有完整的 IDE 集成。

    注意：对于 Spring，你可以使用 kotlin-spring 编译器插件（）。

    将插件构件添加到 buildscript 依赖中并应用该插件：

    另一种方式是使用 plugins 块启用之：

    1. plugins {
    2.   id "org.jetbrains.kotlin.plugin.allopen" version "1.4.20"
    3. }

    然后指定会打开类的注解的列表：

    1. allOpen {
    2.     annotation("com.my.Annotation")
    3.     // annotations("com.another.Annotation", "com.third.Annotation")
    4. }

    如果类（或任何其超类）标有 com.my.Annotation 注解，类本身及其所有成员会变为开放。

    它也适用于元注解：

    1. @com.my.Annotation
    2. annotation class MyFrameworkAnnotation
    4. @MyFrameworkAnnotation
    5. class MyClass // 将会全开放

    MyFrameworkAnnotation 已由全开放元注解 com.my.Annotation 标注，所以它也成了一个全开放注解。

    在 Maven 中使用

    下面是全开放与 Maven 一起使用的用法：

    1. <plugin>
    2.     <artifactId>kotlin-maven-plugin</artifactId>
    3.     <groupId>org.jetbrains.kotlin</groupId>
    4.     <version>${kotlin.version}</version>
    6.     <configuration>
    7.         <compilerPlugins>
    8.             <!-- 或者 "spring" 对于 Spring 支持 -->
    9.             <plugin>all-open</plugin>
    10.         </compilerPlugins>
    12.         <pluginOptions>
    13.             <!-- 每个注解都放在其自己的行上 -->
    14.             <option>all-open:annotation=com.my.Annotation</option>
    15.             <option>all-open:annotation=com.their.AnotherAnnotation</option>
    16.         </pluginOptions>
    17.     </configuration>
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.jetbrains.kotlin</groupId>
    22.             <artifactId>kotlin-maven-allopen</artifactId>
    23.             <version>${kotlin.version}</version>
    24.         </dependency>
    25.     </dependencies>
    26. </plugin>

    关于全开放注解如何工作的详细信息，请参考上面的“在 Gradle 中使用”一节。

    Spring 支持

    如果使用 Spring，可以启用 kotlin-spring 编译器插件而不是手动指定 Spring 注解。kotlin-spring 是在全开放之上的一层包装，并且其运转方式也完全相同。

    1. buildscript {
    2.     dependencies {
    3.         classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"
    4.     }
    5. }
    6. apply plugin: "kotlin-spring" // 取代 "kotlin-allopen"

    或者使用 Gradle 插件 DSL：

    1. plugins {
    2.   id "org.jetbrains.kotlin.plugin.spring" version "1.4.20"
    3. }

    在 Maven 中，kotlin-maven-allopen 插件的依赖项提供了 spring 插件，因此可以这样启用：

    1. <configuration>
    2.     <compilerPlugins>
    3.         <plugin>spring</plugin>
    4.     </compilerPlugins>
    5. </configuration>
    7. <dependencies>
    8.     <dependency>
    9.         <groupId>org.jetbrains.kotlin</groupId>
    11.         <version>${kotlin.version}</version>
    12.     </dependency>
    13. </dependencies>

    该插件指定了以下注解： @Component、 、 @Transactional、 以及 @SpringBootTest。由于元注解的支持，标注有 、 @Controller、 、 @Service 或者 的类会自动打开，因为这些注解标注有元注解 @Component。

    当然，你可以在同一个项目中同时使用 kotlin-allopen 与 kotlin-spring。

    请注意，如果使用 服务生成的项目模板，那么默认会启用 kotlin-spring 插件。

    全开放编译器插件的 JAR 包已随 Kotlin 编译器的二进制发行版分发。可以使用 kotlinc 选项 Xplugin 提供该 JAR 文件的路径来附加该插件：

    可以使用 annotation 插件选项或者启用“预设”来直接指定全开放注解。现在可用于全开放的唯一预设是 spring。

    1. # The plugin option format is: "-P plugin:<plugin id>:<key>=<value>". 
    2. # Options can be repeated.
    4. -P plugin:org.jetbrains.kotlin.allopen:annotation=com.my.Annotation
    5. -P plugin:org.jetbrains.kotlin.allopen:preset=spring

    无参（no-arg）编译器插件为具有特定注解的类生成一个额外的零参数构造函数。

    这个生成的构造函数是合成的，因此不能从 Java 或 Kotlin 中直接调用，但可以使用反射调用。

    这允许 Java Persistence API（JPA）实例化一个类，就算它从 Kotlin 或 Java 的角度看没有无参构造函数（参见下面的 kotlin-jpa 插件的描述）。

    在 Gradle 中使用

    其用法非常类似于全开放插件。

    添加该插件并指定注解的列表，这些注解一定会导致被标注的类生成无参构造函数。

    1. buildscript {
    2.     dependencies {
    3.         classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
    4.     }
    5. }
    7. apply plugin: "kotlin-noarg"
    1. plugins {
    2.   id "org.jetbrains.kotlin.plugin.noarg" version "1.4.20"
    3. }

    然后指定无参注解列表：

    1. noArg {
    2.     annotation("com.my.Annotation")
    3. }

    如果希望该插件在合成的构造函数中运行其初始化逻辑，请启用 invokeInitializers 选项。由于在未来会解决的 及 KT-18668，自 Kotlin 1.1.3-2 起，它被默认禁用。

    1. noArg {
    2.     invokeInitializers = true
    3. }

    在 Maven 中使用

    1. <plugin>
    2.     <artifactId>kotlin-maven-plugin</artifactId>
    3.     <groupId>org.jetbrains.kotlin</groupId>
    4.     <version>${kotlin.version}</version>
    6.     <configuration>
    7.         <compilerPlugins>
    8.             <!-- 或者对于 JPA 支持用 "jpa" -->
    9.             <plugin>no-arg</plugin>
    10.         </compilerPlugins>
    12.         <pluginOptions>
    13.             <option>no-arg:annotation=com.my.Annotation</option>
    14.             <!-- 在合成的构造函数中调用实例初始化器 -->
    15.             <!-- <option>no-arg:invokeInitializers=true</option> -->
    16.         </pluginOptions>
    17.     </configuration>
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>org.jetbrains.kotlin</groupId>
    22.             <artifactId>kotlin-maven-noarg</artifactId>
    23.             <version>${kotlin.version}</version>
    24.         </dependency>

    与 kotlin-spring 插件类似（在 all-open 之上的一层包装），kotlin-jpa 是在 no-arg 之上的一层包装。该插件自动指定了 、 @Embeddable 与 这几个 无参 注解。

    这是在 Gradle 中添加该插件的方法：

    1. buildscript {
    2.     dependencies {
    3.         classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
    4.     }
    5. }
    7. apply plugin: "kotlin-jpa"

    或者使用 Gradle 插件 DSL：

    在 Maven 中，则启用 jpa 插件：

    1. <compilerPlugins>
    2.     <plugin>jpa</plugin>
    3. </compilerPlugins>

    在命令行中使用

    与全开放类似，将插件 JAR 文件添加到编译器插件类路径并指定注解或预设：

    1. -Xplugin=$KOTLIN_HOME/lib/noarg-compiler-plugin.jar
    2. -P plugin:org.jetbrains.kotlin.noarg:annotation=com.my.Annotation
    3. -P plugin:org.jetbrains.kotlin.noarg:preset=jpa

    编译器插件 sam-with-receiver 使所注解的 Java“单抽象方法”接口方法的第一个参数成为 Kotlin 中的接收者。这一转换只适用于当 SAM 接口作为 Kotlin 的 lambda 表达式传递时，对 SAM 适配器与 SAM 构造函数均适用（详见其文档）。

    这里有一个示例：

    1. public @interface SamWithReceiver {}
    3. @SamWithReceiver
    4. public interface TaskRunner {
    5.     void run(Task task);
    6. }
    1. fun test(context: TaskContext) {
    2.     val runner = TaskRunner {
    3.         // 这里的“this”是“Task”的一个实例
    5.         println("$name is started")
    6.         context.executeTask(this)
    7.         println("$name is finished")
    8.     }
    9. }

    在 Gradle 中使用

    除了事实上 sam-with-receiver 没有任何内置预设、并且需要指定自己的特殊处理注解列表外，其用法与 all-open 及 no-arg 相同。

    1. buildscript {
    2.     dependencies {
    3.         classpath "org.jetbrains.kotlin:kotlin-sam-with-receiver:$kotlin_version"
    4.     }
    5. }
    7. apply plugin: "kotlin-sam-with-receiver"

    然后指定 SAM-with-receiver 的注解列表：

    1. samWithReceiver {
    2.     annotation("com.my.SamWithReceiver")
    3. }
    1. <plugin>
    2.     <artifactId>kotlin-maven-plugin</artifactId>
    3.     <groupId>org.jetbrains.kotlin</groupId>
    4.     <version>${kotlin.version}</version>
    6.     <configuration>
    7.         <compilerPlugins>
    8.             <plugin>sam-with-receiver</plugin>
    9.         </compilerPlugins>
    11.         <pluginOptions>
    12.             <option>
    13.                 sam-with-receiver:annotation=com.my.SamWithReceiver
    14.             </option>
    15.         </pluginOptions>
    16.     </configuration>
    18.     <dependencies>
    19.         <dependency>
    20.             <groupId>org.jetbrains.kotlin</groupId>
    21.             <artifactId>kotlin-maven-sam-with-receiver</artifactId>
    22.             <version>${kotlin.version}</version>
    23.         </dependency>
    24. </plugin>

    在 CLI 中使用

    只需将该插件的 JAR 文件添加到编译器插件类路径中，并指定 sam-with-receiver 注解列表即可：