第五十二章. Maven 插件

通过 Gradle，你可以部署到远程 Maven 仓库或是安装到本地 Maven 仓库。这包括所有 Maven 元数据的操作，并且 Maven 快照也可以用。实际上，Gradle 的部署是 100% 兼容 Maven 的，因为我们在本质上使用的是原生 Maven Ant 任务。
With Gradle you can deploy to remote Maven repositories or install to your local Maven repository. This includes all Maven metadata manipulation and works also for Maven snapshots. In fact, Gradle's deployment is 100 percent Maven compatible as we use the native Maven Ant tasks under the hood.

如果你没有 POM，部署到 Maven 仓库只有一半的乐趣。幸运的是 Gradle 可以使用它的依赖信息为你生成这个 POM。
Deploying to a Maven repository is only half the fun if you don't have a POM. Fortunately Gradle can generate this POM for you using the dependency information it has.

让我们假设你的项目只生成默认的 jar 文件，现在你想将这个 jar 文件部署到远程 Maven 仓库。
Let's assume your project produces just the default jar file. Now you want to deploy this jar file to a remote Maven repository.

apply plugin: 'maven'

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
        }
    }
}

调用 uploadArchives 任务将生成 POM，并将工件和 POM 部署到指定的仓库。
That is all. Calling the uploadArchives task will generate the POM and deploys the artifact and the POM to the specified repository.

如果你需要对 file 以外的其他协议支持，那么还要再做一些事情。在这种情况下，我们委派的本地 Maven 代码需要其他的库。具体是哪些库，则取决于你需要的协议。表 52.3，“用于Maven部署的协议 jar” 中列出了可用的协议和相应的库（这些库有传递依赖，而这些依赖也有其自己的传递依赖）。 ^[19] 例如，要使用 SSH 协议，你可以执行以下操作：
There is some more work to do if you need support for other protocols than file. In this case the native Maven code we delegate to needs additional libraries. Which libraries depend on the protocol you need. The available protocols and the corresponding libraries are listed in Table 52.3, “Protocol jars for Maven deployment” (those libraries have again transitive dependencies which have transitive dependencies). ^[19] For example to use the ssh protocol you can do:

configurations {
    deployerJars
}

repositories {
    mavenCentral()
}

dependencies {
    deployerJars "org.apache.maven.wagon:wagon-ssh:2.2"
}

uploadArchives {
    repositories.mavenDeployer {
        configuration = configurations.deployerJars
        repository(url: "scp://repos.mycompany.com/releases") {
            authentication(userName: "me", password: "myPassword")
        }
    }
}

Maven 部署器有许多配置选项，配置通过 Groovy 构建器完成。配置树的所有元素都是 Java bean。你可以传一个 map 到 bean 元素来配置简单的属性。如果要将其他 bean 元素添加到其 parent，可以使用闭包。在上面的示例中，repository 和 authentication 都是这样的 bean 元素。表 52.4，“MavenDeployer的配置元素” 列出了可用的 bean 元素以及对应类的 javadoc 链接。在 javadoc 中，你可以查看能够为特定元素设置的属性。
There are many configuration options for the Maven deployer. The configuration is done via a Groovy builder. All the elements of this tree are Java beans. To configure the simple attributes you pass a map to the bean elements. To add another bean elements to its parent, you use a closure. In the example above repository and authentication are such bean elements. Table 52.4, “Configuration elements of the MavenDeployer” lists the available bean elements and a link to the javadoc of the corresponding class. In the javadoc you can see the possible attributes you can set for a particular element.

在 Maven 中，你可以定义普通仓库和可选的快照仓库。如果没有定义快照仓库，那么发行版和快照都会部署到 repository 元素中。否则，快照将部署到 snapshotRepository 元素。
In Maven you can define repositories and optionally snapshot repositories. If no snapshot repository is defined, releases and snapshots are both deployed to the repository element. Otherwise snapshots are deployed to the snapshotRepository element.

Maven 插件向项目添加 install 任务。这个任务依赖于 archives 配置的所有归档任务。它将这些归档安装到本地 Maven 仓库中。Maven settings.xml 中是否重新定义了本地仓库的默认位置，该任务也会考虑到。
The Maven plugin adds an install task to your project. This task depends on all the archives task of the archives configuration. It installs those archives to your local Maven repository. If the default location for the local repository is redefined in a Maven settings.xml, this is considered by this task.

当部署一个工件到 Maven 仓库时，Gradle 会自动为它生成一个 POM。下表展示了用于 POM 的 groupId、artifactId、 version 和 package 元素的默认值。dependency 元素则是根据项目的依赖声明来创建的。
When deploying an artifact to a Maven repository, Gradle automatically generates a POM for it. The groupId, artifactId, version and packaging elements used for the POM default to the values shown in the table below. The dependency elements are created from the project's dependency declarations.

在这里，uploadTask 和 archiveTask 分别指的是用于上传和生成归档的任务（例如，uploadArchives 和 jar）。archiveTask.baseName 默认为 project.archivesBaseName ，后者默认为 project.name。
Here, uploadTask and archiveTask refer to the tasks used for uploading and generating the archive, respectively (for example uploadArchives and jar). archiveTask.baseName defaults to project.archivesBaseName which in turn defaults to project.name.

生成的 POM 可以在 <buildDir>/poms 中找到。它们可以通过 MavenPom API 进一步自定义。比如，你可能希望部署到 Maven 仓库的工件版本或名称与 Gradle 生成的工件不同。要自定义这些内容，你可以这样做：
Generated POMs can be found in <buildDir>/poms. They can be further customized via the MavenPom API. For example, you might want the artifact deployed to the Maven repository to have a different version or name than the artifact generated by Gradle. To customize these you can do:

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
            pom.version = '1.0Maven'
            pom.artifactId = 'myMavenName'
        }
    }
}

如果要将其他内容添加到 POM，可以用 pom.project 构建器。通过这个构建器，Maven POM 参考 中所列出的任何元素都可以被添加进来。
To add additional content to the POM, the pom.project builder can be used. With this builder, any element listed in the Maven POM reference can be added.

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
            pom.project {
                licenses {
                    license {
                        name 'The Apache Software License, Version 2.0'
                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        distribution 'repo'
                    }
                }
            }
        }
    }
}

注：groupId、artifactId、version 和 packaging 应该始终在 pom 对象上直接设置。
Note: groupId, artifactId, version, and packaging should always be set directly on the pom object.

def installer = install.repositories.mavenInstaller
def deployer = uploadArchives.repositories.mavenDeployer

[installer, deployer]*.pom*.whenConfigured {pom ->
    pom.dependencies.find {dep -> dep.groupId == 'group3' && dep.artifactId == 'runtime' }.optional = true
}

如果要发布多个工件，那么要做的事情会有些不同。请参阅第 52.6.4.1 节，“每个项目多个工件”。
If you have more than one artifact to publish, things work a little bit differently. SeeSection 52.6.4.1, “Multiple artifacts per project”.

要自定义 Maven 安装器（见第 52.6.3 节，“安装到本地仓库”)的设置，你可以：
To customize the settings for the Maven installer (seeSection 52.6.3, “Installing to the local repository”), you can do:

install {
    repositories.mavenInstaller {
        pom.version = '1.0Maven'
        pom.artifactId = 'myName'
    }
}

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
            addFilter('api') {artifact, file ->
                artifact.name == 'api'
            }
            addFilter('service') {artifact, file ->
                artifact.name == 'service'
            }
            pom('api').version = 'mySpecialMavenVersion'
        }
    }
}

task mappings << {
    println conf2ScopeMappings.mappings
}