关于gradle.build

1.HelloWorld.java

先看一个简单的示例：HelloWorld.java（没有外部库）

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

它的build.gradle：

plugins {
    id 'java'
}

group 'com.example'
version '1.0'

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'junit:junit:4.12'
}

task run(type: JavaExec) {
    mainClassName = 'HelloWorld'
    classpath sourceSets.main.runtimeClasspath
}

解析：

（1）plugins

build.gradle 文件的顶部指定了使用的插件，这里我们使用了 java 插件。

（2）group和version

接着设置了项目的基本信息，如组名（group）和版本号（version）。

注：组名（group）在构建脚本中是用来标识项目所属的组织或公司的标识符。它一般使用反向域名的格式命名，以确保唯一性。

（3）repositories

然后配置了项目的仓库（repositories），这里使用了 Maven 中央仓库。

注：在构建脚本中，项目的仓库（repositories）用于定义构建工具在何处查找项目所需的外部依赖库。仓库是一个存储和分发依赖库的地方，它可以是远程的（如 Maven 中央仓库）或本地的（位于你的计算机上）。当构建工具需要下载依赖库时，它会根据仓库配置去获取。这里的 mavenCentral() 是一个内置的函数，它告诉构建系统使用 Maven 中央仓库作为一个远程仓库。除了 Maven 中央仓库外，还有其他许多公共的远程仓库可供选择，比如 JCenter、Google Maven 仓库等。你也可以配置私有的远程仓库，以满足特定的需求。此外，你还可以定义本地仓库，将依赖库保存在本地磁盘上，这样构建工具就可以从本地仓库获取依赖库，而不必每次都从远程仓库下载。总之，项目的仓库用于指定构建工具在构建过程中获取依赖库的位置。通过配置仓库，你可以轻松地管理项目所需的外部依赖库。

（4）dependencies

在依赖关系（dependencies）部分，我们指定了用于测试的 JUnit 依赖库。

在构建工具中，依赖关系（dependencies）部分用于声明项目所依赖的外部库或模块。当你的项目需要使用某些功能或引入第三方库时，你可以在依赖关系部分指定这些依赖。构建工具会根据这些声明来下载并提供这些依赖库，以供项目使用。在 Maven 或 Gradle 的构建脚本中，你可以添加依赖关系的声明，通常是通过指定坐标（Coordinate），如组名（group）、模块名（artifact）、版本等。构建工具根据这些坐标来定位并获取正确的依赖库。依赖关系部分允许你声明不同类型的依赖关系，例如编译依赖（implementation）、测试依赖（testImplementation）、运行时依赖（runtimeOnly）等。这样可以根据不同的情况将依赖关系限定在特定的构建过程中。

（5）task run（type JavaExec）

最后定义了一个自定义的任务（run），它使用了 JavaExec 类型来运行 Java 应用程序。我们指定了主类名（mainClassName）为 HelloWorld，并将项目的类路径作为运行时类路径。

注：

1. mainClassName = 'HelloWorld'： 这行代码设置了要执行的 Java 主类的名称。在这个示例中，主类名称是 HelloWorld。

2. classpath sourceSets.main.runtimeClasspath： 这行代码定义了 Java 主类运行时所需的类路径。sourceSets.main.runtimeClasspath 表示使用了项目中的 main 源集（默认源集），并获取其运行时类路径。它包含了编译后的项目源代码以及所依赖的外部库的路径。

当你运行 ./gradlew run 命令时，Gradle 将执行 run 任务，并根据指定的主类名称和类路径来运行 Java 程序。

2.HelloWorld.java和my-library

下面是一个示例的自定义库（my-library）和经典代码（HelloWorld.java），以及一个用于编译它们的 build.gradle 文件：

1.自定义库 my-library 的代码结构：

my-library/ src/ main/ java/ com/ example/ MyLibrary.java

MyLibrary.java 的代码示例：

package com.example;

public class MyLibrary {
    public static void helloWorld() {
        System.out.println("Hello, World!");
    }
}

 my-library 是自定义库模块，其中包含 com.example.MyLibrary 类。

2.经典代码 HelloWorld.java 的代码结构：

src/ main/ java/ com/ example/ HelloWorld.java

HelloWorld.java 的代码示例：

package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        MyLibrary.helloWorld();
    }
}

HelloWorld.java 是经典代码模块，其中包含 com.example.HelloWorld 类。

3.build.gradle 文件示例：

plugins {
    id 'java'
}

group 'com.example'
version '1.0'

repositories {
    mavenCentral()
}

dependencies {
    implementation project(':my-library')
}

sourceSets {
    main {
        java {
            srcDirs = ['src/main/java']
        }
    }
}

jar {
    manifest {
        attributes 'Main-Class': 'com.example.HelloWorld'
    }
}

build.gradle 文件中的配置说明：

（1）plugins

插件部分使用了 java 插件，用于支持 Java 项目的构建。

（2）group和version

group 指定了项目的组名，这里是 com.example。

version 指定了项目的版本号，这里是 1.0。

（3）repositories

repositories 配置使用 Maven 中央仓库作为远程仓库。

（4）dependencies

dependencies 使用 implementation 配置了对自定义库模块 my-library 的依赖。

（5）sourceSets 

sourceSets 定义了项目的源代码目录，这里指定 src/main/java 为主要源代码目录。

注：sourceSets 定义了项目的源代码集合（source sets），其中 main 是默认的源代码集合。在这个示例中，我们对 main 源代码集合进行了配置。main 的子属性是 java，表示该源代码集合包含 Java 代码。通过 srcDirs 属性，我们指定了 src/main/java 目录作为 main 源代码集合的源代码目录。简而言之，上述配置表示 main 源代码集合包含 src/main/java 目录下的 Java 源代码文件。当构建项目时，Gradle 将考虑这些源代码文件，并执行相应的编译操作。

（6）jar

jar 配置了构建可执行的 JAR 文件，并通过 Main-Class 指定了入口类。

请注意，以上示例描述了自定义库和经典代码的基本结构和构建配置，你可以根据实际情况进行修改以适应你的项目需求。确保在 Gradle 项目中按照示例的目录结构和文件命名进行配置，并运行 ./gradlew build 命令来编译你的项目。

3.如果我用gradle来编译一个用多个java代码书写的目录，其中有一个1.java文件既做2.java的头文件也做一个源文件，如何在build gradle里面表示

您可以通过在 build.gradle 文件中使用 和 配置来指定不同源文件的目录和属性。对于您提到的情况，其中某个 Java 文件即是头文件又是源文件，可以按照以下方式进行配置：sourceSetscompileJava

sourceSets {
    main {
        java {
            srcDirs 'src/main/java' // 指定主要的 Java 源文件目录
            exclude 'src/main/java/2.java' // 排除 2.java 文件
        }
        resources {
            srcDirs 'src/main/resources' // 指定资源文件目录
        }
    }
    custom {
        java {
            srcDirs 'src/main/java' // 指定额外的 Java 源文件目录
            include 'src/main/java/2.java' // 包括 2.java 文件
            exclude 'src/main/java/1.java' // 排除 1.java 文件
        }
    }
}

compileJava {
    sourceSets.main.java.srcDirs += project.sourceSets.custom.java.srcDirs // 合并主要和额外的 Java 源文件目录
}

上述配置中，我们使用了自定义的 sourceSets 名称为 “custom”，其中指定了额外的 Java 源文件目录并包含了 2.java 文件。在 配置中，我们将额外的 Java 源文件目录添加到主要的 Java 源文件目录中，以确保编译时包括这些额外的源文件。compileJava

请根据您的项目结构和需要进行适当的调整和修改。这只是一个示例，您可以根据实际情况进行更详细和精确的配置。

希望这能帮助您配置 build.gradle 文件来编译具有多个 Java 源文件的目录，并处理包含头文件和源文件的特殊情况。

4.救援仿真

plugins {
  id 'java-library'
  id 'maven-publish'
}

defaultTasks 'build'

group = 'com.github.roborescue'

sourceCompatibility = '17'
targetCompatibility = '17'
version = '4.0'

def getDateTime() {
  new Date().format('yyyyMMddHHmmss', TimeZone.getTimeZone('UTC'))
}

dependencies {
  implementation 'com.github.roborescue:rcrs-server:master-SNAPSHOT'

  implementation 'com.fasterxml.jackson.core:jackson-annotations:2.13.0'
  implementation 'com.fasterxml.jackson.core:jackson-core:2.13.0'
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
  implementation 'com.google.code.findbugs:jsr305:3.0.2'
  implementation 'com.google.common:google-collect:0.5'
  implementation 'javax.activation:activation:1.1.1'
  implementation 'javax.xml.bind:jaxb-api:2.4.0-b180830.0359'
  implementation 'log4j:log4j:1.2.17'
  implementation 'org.msgpack:jackson-dataformat-msgpack:0.9.0'

  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}

repositories {
  mavenCentral()

  maven {
    url = 'https://sourceforge.net/projects/jsi/files/m2_repo'
  }
  maven {
    url = 'https://repo.enonic.com/public/'
  }
  maven {
    url 'https://jitpack.io'
  }
}

test {
  useJUnitPlatform()
}

jar {
  manifest {
    attributes 'Main-Class': 'adf.core.Main'
    attributes 'Build-Timestamp': getDateTime();
  }
  archiveFileName = 'adf-core.jar'
}

javadoc {
  options {
    encoding = 'UTF-8'
    addStringOption('Xdoclint:none', '-quiet')
  }
}

publishing {
  publications {
    maven(MavenPublication) {
      groupId = 'com.github.roborescue'
      artifactId = 'adf-core'
      version = 'master-SNAPSHOT'

      from components.java
    }
  }
}

clean{
  doFirst {
    delete file( new File( rootDir, 'bin' ) )
    delete file( new File( rootDir, 'build' ) )
  }
}

[compileJava, compileTestJava].each {
  it.options.encoding = 'UTF-8'
  it.options.compilerArgs += [ '-Xlint:unchecked', '-Xlint:deprecation' ]
}

task javadocJar(type: Jar, dependsOn: javadoc) {
  classifier = 'javadoc'
  from javadoc.destinationDir
  archiveFileName = 'adf-core-javadoc.jar'
}

task sourcesJar(type: Jar, dependsOn: classes) {
  classifier = 'sources'
  from sourceSets.main.allSource
  archiveFileName = 'adf-core-sources.jar'
}

artifacts {
  archives sourcesJar
  archives javadocJar
}

task start (type: JavaExec) {
  classpath = sourceSets.main.runtimeClasspath
  mainClass = 'adf.core.Main'
  if (project.hasProperty('args')) {
    args project.args.split('\\s+')
  }
  jvmArgs '-Xms512m', '-Xmx8g'
}

这段代码是一个使用 Gradle 构建 Java 项目的配置文件。它包含了一些常见的配置项和任务，下面对其中的关键部分进行解析：

1. 插件声明：

   • java-library 插件用于构建 Java 库项目。
   • maven-publish 插件用于发布构建好的库到 Maven 仓库。

2. 默认任务：

   • defaultTasks 'build' 表示默认执行的任务是 build。

3. 项目信息：

   • group 定义了项目的组织标识。
   • version 定义了项目的版本号。

4. 依赖项：

   • implementation 声明了项目的主要依赖库，这些依赖将会在编译和运行时使用。
   • testImplementation 和 testRuntimeOnly 声明了测试所需的依赖库。

5. 仓库配置：

   • mavenCentral() 声明了项目使用 Maven Central 仓库。
   • maven 声明了其他自定义的 Maven 仓库地址。

6. 测试配置：

   • useJUnitPlatform() 指定使用 JUnit Jupiter 运行测试。

7. JAR 构建：

   • jar 任务定义了生成可执行 JAR 文件的设置，包括指定入口类和构建时间戳。

8. 文档生成：

   • javadoc 任务生成项目的 Javadoc 文档。
   • javadocJar 任务将 Javadoc 文档打包成一个独立的 JAR 文件。

9. 构建发布：

   • publishing 配置定义了如何发布项目到 Maven 仓库。
   • publications 定义了发布的内容，此处使用 MavenPublication 发布格式，发布的产物包含了 Java 组件。

10. 清理配置：

    • clean 定义了在执行 clean 任务时需要删除的文件和目录。

11. 编译选项：

    • [compileJava, compileTestJava].each 声明了在编译 Java 源代码时的选项，如设置编码、关闭某些编译警告等。

12. 自定义任务：

    • start 任务是一个自定义的任务，它用于运行项目的入口类。在任务中可以指定传递给入口类的命令行参数和 JVM 参数。

最后，这些配置项和任务共同组成了一个完整的构建脚本，用于构建和管理 Java 项目。你可以根据自己的需求进行修改和扩展。