使用Gradle向Maven发布模块化库

假设我使用Gradle进行模块化库开发。在我的根项目中，我有子项目

geometry

，

algorithms

，

visualizer

，我想发布每个子项目的jar工件

现在，在我的root

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

---

接下来，我的子项目相互依赖，

算法

和

可视化工具

都依赖于

几何体

中的类，但此时JAR不包含依赖项，例如，如果用户想要使用

算法，则必须向
几何体
和
算法
添加依赖项

那么，有没有一种方法可以提供某种类型的自动依赖性，这样添加
算法
也会添加
几何体
？如果是，我该怎么做？如果没有，提供模块化库的惯用方法是什么？我应该用依赖项来组装jar吗

UPD：我应该使用project（“：…”）.components.java中的
，而不是
artifact…
，因为它将同时获取工件和依赖项，对吗？如果我使用
artifact…
？
您可以通过向每个子项目中注入相同的发布配置来减少冗长的发布声明。例如，对于具有以下结构的多版本项目：

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

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

在root
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
会导致此结构的回购：

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

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

依赖关系
此配置还自动处理依赖项。例如，如果在subproject
subA
中，您有：

dependencies{
    compile project(':subB')
}

由于我使用的是components.java中的
，而不是
工件
，因此插件知道如何查找依赖项并为
subA
生成pom，其中包括：

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


org.gradle.sample.B
subB
1
运行时
答案绝对精彩。谢谢：）这是可行的，但会生成类似于
：generatePomFileForFooPublication
的任务，而不是
：foo:generatePomFileForMavenPublication
，我需要它，这样我就可以用一个命令完成所有发布。但是，如果我将
“$project.name”
替换为
maven
，它会抱怨
maven出版物“maven”不能包含多个组件。有什么办法可以让这一切顺利吗？谢谢@max回答说（我写了答案，但几年前，我不记得细节了）运行
gradle publish
应该一次完成所有的发布，这对你不合适吗？