8

我有一个 Gradle 项目，它使用Spring 的依赖管理插件来定义依赖版本列表。我还使用Maven 插件将项目部署到 Maven 存储库。

我希望能够将其部署为 Maven 物料清单 (BOM)，以便我可以在其他 Gradle 项目中使用它来定义我的依赖版本。只要我还部署了一个 JAR 文件，我就可以让它工作。但是，JAR 完全是空的和多余的。我的目标是只生成和部署 POM 文件，如果这是一个带有“pom”包装的 Maven 项目，我将能够做到这一点。

如果我从要发布的工件列表中手动排除 JAR，则不会安装任何内容，甚至不会安装 POM 文件。

这是演示该问题的测试版本：

group 'test'
version '1.0.0-SNAPSHOT'

buildscript {
  repositories {
    mavenCentral()

  }
  dependencies {
    classpath 'org.springframework.boot:spring-boot-gradle-plugin:1.5.1.RELEASE' //Matches the Spring IO version
  }
}

apply plugin: 'java'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'maven'

dependencyManagement {
  dependencies {
    dependency 'cglib:cglib-nodep:3.2.4'
    dependency 'junit:junit:4.12'
  }
}

////Uncommenting this causes nothing at all to be deployed:
//jar.enabled = false
//configurations.archives.artifacts.with { archives ->
//  archives.removeAll { it.type == 'jar' }
//}

以上正确生成以下 POM 文件并将其安装到我的本地 Maven 存储库中：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>test</groupId>
  <artifactId>gradle-pom-packaging-test</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib-nodep</artifactId>
        <version>3.2.4</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

但是，它还会安装一个空的 JAR 文件，以保存 MANIFEST.MF 文件。

我能够使用maven-publish插件成功地完成这项工作。但是，我还使用Gradle Sonatype Nexus 插件将工件发布到 Nexus 实例。由于它建立在maven插件之上，因此该maven-publish插件无法满足我的需求。以下是我需要添加的所有内容以使其与maven-publish插件一起使用：

apply plugin: 'maven-publish'
publishing {
  publications {
    maven(MavenPublication) {
    }
  }
}

有没有办法只使用mavenGradle 插件生成和部署 POM 文件，就像我可以做的那样，如果这是一个带有“pom”包装的 Maven 项目？

4

4 回答 4

8

在 Gradle 6+ 版本中，我们可以使用Gradle Java Platform Plugin发布一个 maven-bom，而无需太多配置和脚本。

group 'test.platform.simple.bom'
version '1.0.0-SNAPSHOT'

repositories {
    maven {
        mavenCentral()
    }        
}

apply plugin: 'java-platform'
apply plugin: 'maven-publish'

javaPlatform {
    allowDependencies()
}

dependencies {
    constraints {
        api 'junit:junit:4.12'
        api 'cglib:cglib-nodep:3.2.4'
        // runtime 'org.postgresql:postgresql:42.2.5' <-- runtime constraint
        // api project(":core") <-- constraint from local project
    }

    // api platform('com.fasterxml.jackson:jackson-bom:2.9.8') <-- constraint from another platform
}

publishing {
  publications {
    maven(MavenPublication) {
      from components.javaPlatform
    }
  }
}

要管理的依赖项可以在依赖项下定义为api 或运行时约束。约束可用于管理来自本地项目以及来自另一个平台/bom的依赖项。请注意，我们需要配置一个使用javaPlatform组件的 Maven 发布，以将其发布为 maven bom 工件。

于 2020-12-20T18:16:34.560 回答
4

Tha acdcjunior的答案可以改进一点。可以在标准部分build.gradle中声明依赖项。dependencies此外，pom.xml应在以下dependencyManagement部分声明 BOM 版本：

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

group = 'com.example'
version = '1.0.0'

repositories {
    mavenCentral()
}

dependencies {
    api 'org.apache.commons:commons-lang3:3.9'
    api 'org.postgresql:postgresql:42.2.11'
}

publishing {
    repositories {
        maven {
            url = "$nexusUrl"
            credentials {
                username = "$nexusUsername"
                password = "$nexusPassword"
            }
        }
    }

    publications {
        maven(MavenPublication) {
            groupId = "${project.group}"
            artifactId = "${project.name}"
            version = "${project.version}"

            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST

                    name 'My BOM'
                    description 'My Bill of Materials (BOM)'

                    dependencyManagement {
                        dependencies {
                            project.configurations.each { conf ->
                                conf.dependencies.each { dep ->
                                    dependency {
                                        groupId "${dep.group}"
                                        artifactId "${dep.name}"
                                        version "${dep.version}"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

结果pom.xml可以使用命令发布到 Nexus

./gradlew clean build publish -i

或本地 Maven 存储库 ( ~/.m2/repository)

./gradlew clean build pTML -i

这种表示法不仅更短，而且还允许处理依赖关系。例如，使用 OWASP Dependency-Check 插件执行漏洞扫描：

plugins {
    //...
    id 'org.owasp.dependencycheck' version '5.3.0'
}

dependencyCheck {
    failBuildOnCVSS = 9 //Critical Severity
}

check.dependsOn dependencyCheckAnalyze
于 2020-03-22T10:08:46.703 回答
2

你可以有一个build.gradle这样的：

apply plugin: 'maven-publish'
apply plugin: 'signing'

publishing {
    repositories {
        maven {
            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
            credentials {
                username ossrhUsername
                password ossrhPassword
            }
        }
    }

    publications {
        maven(MavenPublication) {
            groupId = 'com.example.id'
            artifactId = 'my-artifact-id'
            version = '1.0.0'

            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST

                    name 'My Lib Name'
                    description 'My Lib Description'
                    url 'https://example.com/id/lib'

                    licenses {
                        license {
                            name 'The Apache License, Version 2.0'
                            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    scm {
                        connection 'scm:git:git@example.com:acdcjunior/lib/id.git'
                        developerConnection 'scm:git:git@example.com:acdcjunior/lib/id.git'
                        url 'git@example.lib/id.git'
                    }
                    developers {
                        developer {
                            id 'someone'
                            name 'Someone Name'
                            email 'someone@example.com'
                        }
                    }
                    dependencies {
                        dependency {
                            groupId 'com.example.other'
                            artifactId 'some-dependency'
                            version '1.0.0'
                        }
                        dependency {
                            groupId 'org.apache.commons'
                            artifactId 'commons-lang3'
                            version '3.9'
                        }
                    }
                }
            }
        }
    }
}

signing {
    sign publishing.publications.maven
}

使用此项目的示例：https ://github.com/acdcjunior/domain-id/blob/master/domain-id-all/build.gradle

于 2019-05-25T06:13:40.903 回答
1

您应该考虑使用 DSL 以 gradle 方式创建 BOM 的插件：

https://github.com/xvik/gradle-pom-plugin

朱利安

于 2017-04-12T16:43:29.127 回答