gradle - 使用 Gradle 将模块化库发布到 Maven

Question

假设我正在使用 Gradle 进行模块化库开发。在我的根项目中，我有子项目 geometry , algorithms , visualizer ，并且我想发布每个的 jar 工件。

至于现在在我的根目录build.gradle我有以下部分:

apply plugin: 'maven-publish'
publishing {
    publications {
        publishDemos(MavenPublication) {
            groupId 'ru.ifmo.ctddev.igushkin.cg'
            artifactId 'geometry'
            version globalVersion
            artifact project(':geometry').tasks.getByName('jar')
        }
        publishAlgorithms(MavenPublication) {
            groupId 'ru.ifmo.ctddev.igushkin.cg'
            artifactId 'algorithms'
            version globalVersion
            artifact project(':algorithms').tasks.getByName('jar')
        }
        publishVisualizer(MavenPublication) {
            groupId 'ru.ifmo.ctddev.igushkin.cg'
            artifactId 'visualizer'
            version globalVersion
            artifact project(':visualizer').tasks.getByName('jar')
        }
    }
}

我的第一个问题:有没有更简洁的方式来描述这些出版物？例如，我想声明，对于每个子项目，我需要一个带有 artifactId 的出版物。从它的名字设置。

接下来，我的子项目相互依赖，都是 algorithms和 visualizer依赖于 geometry 的类(class), 但此时 jars 不包含依赖项，例如，用户必须将依赖项添加到 geometry和 algorithms如果他们想使用 algorithms .

那么，有没有办法提供某种自动依赖，以便添加 algorithms还会添加 geometry ?如果是，我该怎么做？如果不是，提供模块化库的惯用方式是什么？我应该组装带有依赖项的 jar 吗？

UPD:我是对的，而不是 artifact ...我应该只使用 from project(':...').components.java ，因为它会同时获取工件和依赖项？如果我使用 artifact ...，如何分别选择依赖项?

Answer 1

您可以通过将相同的发布配置注入(inject)每个子项目来减少冗长的发布声明。例如对于具有以下结构的多构建项目:

ROOT
│   build.gradle
│   settings.gradle
├───subA
│       build.gradle
│
├───subB
│       build.gradle
│
└───subC
        build.gradle

在你的根目录 build.gradle ， 你可以做:

apply plugin:'maven-publish'

subprojects{
    publishing {
        publications {
            "$project.name"(MavenPublication) {
                groupId project.group
                artifactId project.name
                version project.version
                from components.java
            }
        }
    }
}

每个子项目都定义了自己的 groupid 和版本，如下所示:

group = 'org.test.sample.A'
version = '1.0'

artifactId 是从子项目名称中提取的。运行 gradle publish导致此结构的 repo :

org
└───test
    └───sample
        ├───A
        │   └───subA
        │       └───1.0
        │               subA-1.0.jar
        │               subA-1.0.pom
        ├───B
        │   └───subB
        │       └───1.0
        │               subB-1.0.jar
        │               subB-1.0.pom
        └───C
            └───subC
                └───1.0
                        subC-1.0.jar
                        subC-1.0.pom

依赖项

此配置还会自动处理依赖项。例如，如果在子项目 subA你有过:

dependencies{
    compile project(':subB')
}

由于我使用的是 from components.java而不是 artifact ，插件知道寻找依赖关系并为 subA生成一个pom包括:

  <dependencies>
    <dependency>
      <groupId>org.gradle.sample.B</groupId>
      <artifactId>subB</artifactId>
      <version>1.0</version>
      <scope>runtime</scope>
    </dependency>
  </dependencies>