【Gradle-9】Gradle插件发布指南

【Gradle-9】Gradle插件发布指南
1、前言

不管是在公司内部，还是开源，Gradle插件发布都是一项必备的技能，本文主要介绍本地发布和远端发布两种方式。

2、本地发布

 2.1、添加依赖

在plugin>build.gradle文件中（插件的项目）先依赖一个maven发布的插件'maven-publish'
```
plugins {
    id 'maven-publish'
}

dependencies {
    implementation 'com.android.tools.build:gradle:7.3.0'
}
1
2
3
4
5
6
7
```
2.2、发布配置

maven的发布配置是在publishing { }闭包中设置的。
本地发布主要为两部分：
- GAV坐标
- 仓库地址
```
group 'com.yechaoa.plugin'
version '1.0.0'

publishing {
    // 配置Plugin GAV
    publications {
        maven(MavenPublication) {
            groupId = group
            artifactId = 'dependencies'
            version = version

            from components.java
        }
    }
    // 配置仓库地址
    repositories {
        maven {
            url layout.buildDirectory.dir("maven-repo")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
2.3、执行发布

以上配置完成即可执行发布操作：
```
./gradlew publish
1
```
或者在Android Studio右边Gradle可视化的面板点击运行publish：

2.4、生成产物

ok，这时候build文件夹下已经有本地发布配置的maven-repo文件夹了。
主要确认jar/aar文件、pom文件、metadata等正确即可。

2.5、使用

ok，本地发布完了，要想使用这个插件，跟我们正常依赖插件是一样的流程。
三步走：
1. 在settings.gradle文件中配置插件仓库地址
```
pluginManagement {
    repositories {
        // ...
        maven {
            url './maven-repo'
        }
    }
}
1
2
3
4
5
6
7
8
```
1. 在project>build.gradle文件中添加插件依赖
```
buildscript {
    dependencies {
        classpath('com.yechaoa.plugin:dependencies:1.0.0')
    }
}
1
2
3
4
5
```
1. 在app:build.gradle文件中依赖我们的plugin
```
plugins {
    id 'com.yechaoa.plugin.dependencies'
}
1
2
3
```
以上配置都是在app模块中添加的，即需要使用的模块。

注意：本地依赖使用的时候，要先发布，再依赖插件，否则就会出现cannot found找不到依赖的情况。

3、Maven远端发布

Maven是一个软件项目管理工具，基于项目对象模型 (POM) 的概念，Maven 可以通过中央信息来管理项目的构建、报告和文档，也是最常用的存储库。

上面我们已经完成了本地发布，Maven远端发布主要是需要各种配置。
基于本地发布，远端发布有几个差异点：
- 注册仓库账号；
- 配置POM；
- 签名；
- 远端仓库地址；
- 准备域名；
比较繁琐，就。。不全流程陪跑了

一个示例：
```
plugins {
    id 'java-library'
    id 'maven-publish'
    id 'signing'
}

group = 'com.example'
version = '1.0'

java {
    withJavadocJar()
    withSourcesJar()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifactId = 'my-library'
            from components.java
            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }
            pom {
                name = 'My Library'
                description = 'A concise description of my library'
                url = 'http://www.example.com/library'
                properties = [
                    myProp: "value",
                    "prop.with.dots": "anotherValue"
                ]
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'johnd'
                        name = 'John Doe'
                        email = 'john.doe@example.com'
                    }
                }
                scm {
                    connection = 'scm:git:git://example.com/my-library.git'
                    developerConnection = 'scm:git:ssh://example.com/my-library.git'
                    url = 'http://example.com/my-library/'
                }
            }
        }
    }
    repositories {
        maven {
            // change URLs to point to your repos, e.g. http://my.org/repo
            def releasesRepoUrl = layout.buildDirectory.dir('repos/releases')
            def snapshotsRepoUrl = layout.buildDirectory.dir('repos/snapshots')
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
        }
    }
}

signing {
    sign publishing.publications.mavenJava
}


javadoc {
    if(JavaVersion.current().isJava9Compatible()) {
        options.addBooleanOption('html5', true)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
```
全流程的大家可以参考：
- 再见JCenter，将你的开源库发布到MavenCentral上吧
- Gradle 构建工具 #4 来开源吧！发布开源组件到 MavenCentral 仓库超详细攻略
4、JitPack

如果你的项目是使用GitHub托管的，那么最常用的发布方式就是使用JitPack了，它是一个简单易用的Git包存储库，使用、发布也非常简单，不需要注册网站账号，搞一堆验证什么的，而且对项目也是无侵入式的，也不需要服务器、域名什么的。

4.1、使用GitHub托管

最基本的就是项目使用GitHub来进行托管了，就是把项目上传到GitHub，Public或者Private都行。
比如我这个GradleX项目：

4.2、发布

你甚至什么都没干，就传了一个项目，就可以直接走发布流程了。

在项目仓库主页的右边菜单列表，找到Releases，点击「Create a new release」。
如果已经发布过了，这里就是发布记录，点进去可以「Draft a new release」。
- 设置tag，即版本号，如果不是正式版，可以在后面加上alpha，比如1.0-alpha；
- 选择发布的分支；
- 发布标题；
- 发布描述；
- 点击「Publish release」进行发布；
发布完成会有产物和记录

 4.3、使用

上面就发布完成了，那么如何使用呢？
打开Jitpack官网：https://www.jitpack.io/，在输入框里输入yechaoa/GradleX，即username+project。
然后点击Look up开始查找和构建。

构建完成有了Log日志之后，即可以点击Get it获取使用方式。
使用方式：
1. 首先要添加jitpack的仓库地址；
2. 然后添加项目依赖，因为是基于GitHub发布的，域名前缀会com.github，自定义需要添加映射；
在添加依赖这里，因为我们是整个项目发布的，包含多个模块，所以我们也可以选择子模块来进行单独依赖。
比如我这个项目中有：

我的项目是GradleX，插件模块是plugin，插件是dependencies。根据最小原则，我们可以直接选择依赖插件dependencies，后面有多个插件的时候，我们可以选择依赖plugin模块。

4.4、验证

发布完了，我们来验证一把试试。

首先在settings.gradle中添加仓库：
```
	repositories {
        maven { url 'https://jitpack.io' }
    }
1
2
3
```
然后再添加依赖：
```
	dependencies {
        classpath('com.github.yechaoa.GradleX:dependencies:1.0')
    }
1
2
3
```
因为我们是依赖插件，所以implementation要换成classpath。

最后是依赖插件和打开插件配置：
```
plugins {
    id 'com.yechaoa.plugin.dependencies'
}

printDependencies {
    enable = true
}
1
2
3
4
5
6
7
```
然后我们sync一下看看。
```
> Configure project :app
DependenciesPlugin >>>>> com.yechaoa.plugin.DependenciesPlugin
---hasProperty isTest no
DependenciesPlugin >>>>> 已开启依赖打印
DependenciesPlugin >>>>> applicationVariant.getName() = debug
Run with --info for a stacktrace.
--------------官方库 start--------------
com.google.android.material:material:1.8.0
androidx.appcompat:appcompat:1.5.0
org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.10
androidx.core:core-ktx:1.8.0
......
1
2
3
4
5
6
7
8
9
10
11
12
```
可以看到，已经有预期的输出结果了。
因为sync会触发Gradle构建，从而我们在编译期打印依赖的插件就会生效，并打印项目中的依赖。

ok，jitpack的发布方式就这些了，是不是非常简单~

5、Gradle Plugin Portal

Gradle插件门户网站是一个专用于Gradle插件的集中式、可搜索的存储库，发布的流程和配置也都比Maven要简单多了。

5.1、注册账号

首先要注册一个Gradle插件门户网站的账号，https://plugins.gradle.org/user/login，我们直接使用Github账号登录即可。

GitHub执行2FA双重校验之后，使用GitHub登录时需要再校验一次，按照流程走就行，不复杂。

5.2、获取秘钥

在API Keys选项下面生成秘钥。

5.3、配置秘钥

秘钥用来发布用，通常是放在HOME_DIR/.gradle/gradle.properties (~/.gradle/gradle.properties)文件中，如果没有，就新建一个。当然也可以放在其他有效的地方，但我还是建议放在这，可以全局用。
如果这一步你没有配置，也可以手动执行发布命令，然后通过传参的方式把秘钥给带上去：
```
$ ./gradlew publishPlugins -Pgradle.publish.key= -Pgradle.publish.secret=
1
```
5.4、发布配置

 5.4.1、依赖发布插件

gradle插件门户发布的话有自己的发布插件
```
plugins {
    id 'com.gradle.plugin-publish' version '1.1.0'
}
1
2
3
```
发布插件1.0.0版本及以上的用法，需要Gradle 7.6及以上。
不过1.0.0版本及以上版本也带来了诸多便利，比如：
- 它包含’java-gradle-plugin’和’maven-publish’插件；
- 自动生成并发布源码和文档；
- 签名也是自动的；
5.4.2、配置发布信息

因为我们前面本地发布的时候依赖过id 'java-gradle-plugin'插件了，这里就省事了，直接在gradlePlugin { } 里面继续配置就行。
```
gradlePlugin {
    // 项目地址
    website = 'https://github.com/yechaoa/GradleX'
    // 项目仓库URI
    vcsUrl = 'https://github.com/yechaoa/GradleX.git'

    // 可以有多个plugin配置
    plugins {
        // register 这个名字可以随便填
        register {
            // 插件id
            id = 'com.yechaoa.plugin.dependencies'
            // 插件全路径
            implementationClass = "com.yechaoa.plugin.DependenciesPlugin"
            // 插件名称
            displayName = 'DependenciesPlugin'
            // 描述、简介
            description = 'Show Dependencies Plugin'
            // 插件类别，即标签、关键词的意思
            tags.addAll('Dependencies', 'yechaoa', 'plugin')
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
```
以上配置需要Gradle7.6版本及以上，老的版本用的是pluginBundle，而不是gradlePlugin。
@since 7.6：
```
    /**
     * Returns the property holding the URL for the plugin's website.
     *
     * @since 7.6
     */
    @Incubating
    public Property getWebsite() {
        return website;
    }
1
2
3
4
5
6
7
8
9
```
发布后的示例：

5.5、执行发布

以上配置完成之后，sync一下。
发布命令：
```
./gradlew publishPlugins
1
```
没配秘钥的话：
```
./gradlew publishPlugins -Pgradle.publish.key= -Pgradle.publish.secret=
1
```
或者在Gradle面板中双击publishPlugins执行：

接下来就是等待审核了。审核是有一些要求的，比如太简单且没有意义的helle word、SNAPSHOT版本等。
审核通过就可以在Gradle插件门户网站搜到了。

5.6、引用方式

7.0之后：
```
plugins {
  id "com.yechaoa.plugin.dependencies" version "1.0.0"
}
1
2
3
```
7.0之前：
```
buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "com.yechaoa.plugin:dependencies:1.0.0"
  }
}

apply plugin: "com.yechaoa.plugin.dependencies"
1
2
3
4
5
6
7
8
9
10
11
12
```
7.0之后因为在pluginManagement{ }中默认加了gradlePluginPortal()地址，所以配置更简单了。

7、总结

Gradle插件发布就介绍到这里了，虽然maven的发布方式很繁琐，但也只是第一次这样，配置完成后就可以抽成一个脚本，每次发布执行一下就ok了，不过还是首推JitPack，毕竟真的太方便了。

8、最后

写作不易，感谢支持~

9、GitHub

https://github.com/yechaoa/GradleX

10、相关文档
相关阅读:
Golang开发--计时器（Timer）和定时器（Ticker）
Spring异步任务笔记
 MVCC【重点】
C语言每日一题(6)：求五位数中的变种水仙花数
 java简介
 Pandas数据操作_Python数据分析与可视化
 如何快速打开Github
参加CSDN第六期编程竞赛感想
 后端面试必备知识点
 [GYCTF2020]Ez_Express
原文地址：https://blog.csdn.net/yechaoa/article/details/133256952

1、前言

2、本地发布

2.1、添加依赖

2.2、发布配置

2.3、执行发布

2.4、生成产物

2.5、使用

3、Maven远端发布

4、JitPack

4.1、使用GitHub托管

4.2、发布

4.3、使用

4.4、验证

5、Gradle Plugin Portal

5.1、注册账号

5.2、获取秘钥

5.3、配置秘钥

5.4、发布配置

5.4.1、依赖发布插件

5.4.2、配置发布信息

5.5、执行发布

5.6、引用方式

7、总结

8、最后

9、GitHub

10、相关文档