使用 Maven

    通过 kotlin.version 属性定义要使用的 Kotlin 版本：

    依赖

    Kotlin 有一个广泛的标准库可用于应用程序。在 pom 文件中配置以下依赖关系：

    2.     <dependency>
    3.         <groupId>org.jetbrains.kotlin</groupId>
    4.         <artifactId>kotlin-stdlib</artifactId>
    5.         <version>${kotlin.version}</version>
    6.     </dependency>
    7. </dependencies>

    如果是面向 JDK 7 或 JDK 8，那么可以使用扩展版本的 Kotlin 标准库， 其中包含为新版 JDK 所增 API 而加的额外的扩展函数。使用 kotlin-stdlib-jdk7 或 kotlin-stdlib-jdk8 取代 kotlin-stdlib，这取决于你的 JDK 版本（对于 Kotlin 1.1.x 用 kotlin-stdlib-jre7 与 kotlin-stdlib-jre8，因为相应的 jdk 构件在 1.2.0 才引入）。

    如果你的项目使用 或者测试设施，那么你还需要添加相应的依赖项。 其构件 ID 对于反射库是 kotlin-reflect，对于测试库是 kotlin-test 与 kotlin-test-junit 。

    编译只有 Kotlin 的源代码

    要编译源代码，请在 <build> 标签中指定源代码目录：

    1. <build>
    2.     <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
    3.     <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
    4. </build>

    同时编译 Kotlin 与 Java 源代码

    要编译混合代码应用程序，必须在 Java 编译器之前调用 Kotlin 编译器。 按照 maven 的方式，这意味着应该使用以下方法在 maven-compiler-plugin 之前运行 kotlin-maven-plugin。 确保 pom.xml 文件中的 kotlin 插件位于 maven-compiler-plugin 之前：

    1. <build>
    2.     <plugins>
    3.         <plugin>
    4.             <groupId>org.jetbrains.kotlin</groupId>
    5.             <artifactId>kotlin-maven-plugin</artifactId>
    6.             <version>${kotlin.version}</version>
    7.             <executions>
    8.                 <execution>
    9.                     <id>compile</id>
    10.                     <goals>
    11.                         <goal>compile</goal>
    12.                     </goals>
    13.                     <configuration>
    14.                         <sourceDirs>
    15.                             <sourceDir>${project.basedir}/src/main/java</sourceDir>
    16.                         </sourceDirs>
    17.                     </configuration>
    18.                 </execution>
    19.                 <execution>
    20.                     <id>test-compile</id>
    21.                     <goals> <goal>test-compile</goal> </goals>
    22.                     <configuration>
    23.                         <sourceDirs>
    25.                             <sourceDir>${project.basedir}/src/test/java</sourceDir>
    26.                         </sourceDirs>
    27.                     </configuration>
    28.                 </execution>
    29.             </executions>
    30.         </plugin>
    31.         <plugin>
    32.             <groupId>org.apache.maven.plugins</groupId>
    33.             <artifactId>maven-compiler-plugin</artifactId>
    34.             <version>3.5.1</version>
    35.             <executions>
    36.                 <!-- 替换会被 maven 特别处理的 default-compile -->
    37.                 <execution>
    38.                     <id>default-compile</id>
    39.                     <phase>none</phase>
    40.                 </execution>
    41.                 <!-- 替换会被 maven 特别处理的 default-testCompile -->
    42.                 <execution>
    43.                     <id>default-testCompile</id>
    44.                     <phase>none</phase>
    45.                 </execution>
    46.                 <execution>
    47.                     <id>java-compile</id>
    48.                     <phase>compile</phase>
    49.                     <goals>
    50.                         <goal>compile</goal>
    51.                     </goals>
    52.                 </execution>
    53.                 <execution>
    54.                     <id>java-test-compile</id>
    55.                     <goals>
    56.                         <goal>testCompile</goal>
    57.                     </goals>
    58.                     <configuration>
    59.                         <skip>${maven.test.skip}</skip>
    60.                     </configuration>
    61.                 </execution>
    62.             </executions>
    63.         </plugin>
    64.     </plugins>
    65. </build>

    为了使构建更快，可以为 Maven 启用增量编译（从 Kotlin 1.1.2 起支持）。 为了做到这一点，需要定义 kotlin.compiler.incremental 属性：

    1. <properties>
    2.     <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
    3. </properties>

    或者，使用 -Dkotlin.compiler.incremental=true 选项运行构建。

    注解处理

    请参见 Kotlin 注解处理工具（kapt）的描述。

    Jar 文件

    要创建一个仅包含模块代码的小型 Jar 文件，请在 Maven pom.xml 文件中的 build->plugins 下面包含以下内容， 其中 定义为一个属性，并指向主 Kotlin 或 Java 类：

    独立的 Jar 文件

    1. <plugin>
    2.     <groupId>org.apache.maven.plugins</groupId>
    3.     <artifactId>maven-assembly-plugin</artifactId>
    4.     <version>2.6</version>
    5.     <executions>
    6.         <execution>
    7.             <id>make-assembly</id>
    8.             <phase>package</phase>
    9.             <goals> <goal>single</goal> </goals>
    10.             <configuration>
    11.                 <archive>
    12.                     <manifest>
    13.                         <mainClass>${main.class}</mainClass>
    14.                     </manifest>
    15.                 </archive>
    16.                 <descriptorRefs>
    17.                     <descriptorRef>jar-with-dependencies</descriptorRef>
    18.                 </descriptorRefs>
    19.             </configuration>
    20.         </execution>
    21.     </executions>
    22. </plugin>

    这个独立的 jar 文件可以直接传给 JRE 来运行应用程序：

    1. java -jar target/mymodule-0.0.1-SNAPSHOT-jar-with-dependencies.jar

    可以将额外的编译器选项与参数指定为 Maven 插件节点的 <configuration> 元素下的标签 ：

    许多选项还可以通过属性来配置：

    1. <project ……>
    2.     <properties>
    3.         <kotlin.compiler.languageVersion>1.0</kotlin.compiler.languageVersion>
    4. </project>

    支持以下属性：

    生成文档

    标准的 JavaDoc 生成插件（maven-javadoc-plugin）不支持 Kotlin 代码。 要生成 Kotlin 项目的文档，请使用 ； 相关配置说明请参见 Dokka README 。Dokka 支持混合语言项目，并且可以生成多种格式的输出 ，包括标准 JavaDoc。

    OSGi

    示例

    一个示例 Maven 项目可以