Socket 发布到 MavenCentral

1. Sonatype 账号

  1.1 第一次使用，注册账号 Sonatype Signup，如图:

  1.2 注册过了，直接登录账号 Sonatype Login，如图:

  1.3 创建一个新的问题工单，填写信息，如下图：

  1.4 创建完成之后，将开启一个issue，会显示 Waiting for Response，会有相关机器人和管理员进行验证，如图:

  1.5 管理员会生成一个地址，进行验证，如下图操作:

  1.6 当 Sonatype 管理员评论时，用了邮箱，评论信息会第一时间通过邮件进行通知，进行评论回复如下图:

2. Gradle 配置

  2.1 Maven 提交脚本

  在项目的跟目录下新建一个 publish-maven.gradle 文件，内容如下:

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

Properties localProperties = new Properties()
localProperties.load(project.rootProject.file('local.properties').newDataInputStream())
localProperties.each { name, value -> project.ext[name] = value
}

def mavenUsername = localProperties.getProperty("sonatype.username")
def mavenPassword = localProperties.getProperty("sonatype.password")
def projectGroupId = project.ext.groupId
def projectArtifactId = project.getName()
def projectVersionName = project.ext.has('version') ? project.ext.getProperty('version') : project.extensions.findByName("android")["defaultConfig"].versionName
def projectDescription = project.ext.has('description') ? project.ext.getProperty('description') : null
def projectGitUrl = project.ext.has('gitUrl') ? project.ext.getProperty('gitUrl') : null
def projectLicense = project.ext.has('license') ? project.ext.getProperty('license') : null
def projectLicenseUrl = projectLicense ? "https://opensource.org/licenses/${projectLicense.toString().replace(" ", "-")} " : null

def developerAuthorId = mavenUsername
def developerAuthorName = mavenUsername
def developerAuthorEmail = project.ext.has('authorEmail') ? project.ext.getProperty('authorEmail') : null

println("${mavenUsername} ${mavenPassword} - ${projectGroupId}:${projectArtifactId}:${projectVersionName}")
println("${projectLicense} - ${projectLicenseUrl}")

if (!mavenUsername || !mavenPassword || !projectGroupId || !projectArtifactId || !projectVersionName) {
    println('error：missing parameter')
    return
}
if (!projectDescription || !projectGitUrl || !projectLicense || !projectLicenseUrl || !developerAuthorId || !developerAuthorName || !developerAuthorEmail) {
    println('warning：missing optional parameter')
}

def isAndroidProject = project.hasProperty('android')
if (isAndroidProject) {
    println("Android project publish")
    // Android 工程
    task androidJavadocs(type: Javadoc) {
        source = android.sourceSets.main.java.srcDirs
        classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
    }
    task javadocsJar(type: Jar, dependsOn: androidJavadocs) {
        archiveClassifier.set("javadoc")
        from androidJavadocs.destinationDir
    }
    task sourcesJar(type: Jar) {
        archiveClassifier.set("sources")
        from android.sourceSets.main.java.srcDirs
    }
} else {
    println("Java project publish")
    // Java 工程
    task javadocsJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier.set("javadoc")
        from javadoc.destinationDir
    }
    task sourcesJar(type: Jar) {
        archiveClassifier.set("sources")
        from sourceSets.main.allJava
    }
}

tasks.withType(Javadoc).all {
    options {
        encoding "UTF-8"
        charSet 'UTF-8'
        author true
        version true
        links "http://docs.oracle.com/javase/11/docs/api"
        if (isAndroidProject) {
            linksOffline "http://d.android.com/reference", "${android.sdkDirectory}/docs/reference"
        }
        failOnError = false
    }
    enabled = false
}

artifacts {
    archives javadocsJar, sourcesJar
}

publishing {
    publications {
        aar(MavenPublication) {
            groupId = projectGroupId
            artifactId = projectArtifactId
            version = projectVersionName
            // Tell maven to prepare the generated "*.aar" file for publishing
            if (isAndroidProject) {
                artifact("$buildDir/outputs/aar/${project.getName()}-release.aar")
            } else {
                artifact("$buildDir/libs/${project.getName()}.jar")
            }
            artifact javadocsJar
            artifact sourcesJar

            pom {
                name = projectArtifactId
                description = projectDescription
                // If your project has a dedicated site, use its URL here
                url = projectGitUrl
                licenses {
                    license {
                        name = projectLicense
                        url = projectLicenseUrl
                    }
                }
                developers {
                    developer {
                        id = developerAuthorId
                        name = developerAuthorName
                        email = developerAuthorEmail
                    }
                }
                // Version control info, if you're using GitHub, follow the format as seen here
                scm {
                    connection = "scm:git:${projectGitUrl}"
                    developerConnection = "scm:git:${projectGitUrl}"
                    url = projectGitUrl
                }
                withXml {
                    def dependenciesNode = asNode().appendNode('dependencies')
                    configurations.api.allDependencies.each { dependency ->
                        if (!dependency.hasProperty('dependencyProject')) {
                            def dependencyNode = dependenciesNode.appendNode('dependency')
                            dependencyNode.appendNode('groupId', dependency.group)
                            dependencyNode.appendNode('artifactId', dependency.name)
                            dependencyNode.appendNode('version', dependency.version)
                        }
                    }
                }
            }
        }
    }

    repositories {
        maven {
            name = projectArtifactId
            // release版本：发布版本即稳定版本，开发人员同一个版本多次发布，使用者不能自动load最新版本。
            def releasesRepoUrl = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
            //snapshots版本：快照版本即开发版本，版本号以-SNAPSHOT结尾，开发人员同一个版本多次发布，使用者可以自动load最新版本
            def snapshotsRepoUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"

            // You only need this if you want to publish snapshots, otherwise just set the URL
            // to the release repo directly
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
            // The username and password we've fetched earlier
            credentials {
                username mavenUsername
                password mavenPassword
            }
        }
    }
}

signing {
    sign publishing.publications
}

  2.2 Maven 库配置信息，Module 信息 build.gradle 配置

ext {
    groupId = 'io.gitee.osnetwork'  // 项目组织的唯一标识符
    description = 'Android Socket project' // 项目描述
    gitUrl = 'https://gitee.com/projectes/IOSocket' // Git地址，不包含.git
    authorEmail = '[email protected]' // 作者邮箱
    license = 'MIT' // 开源协议，可选
    version = '1.0.0' // 版本号
}

  2.3 导入 Maven 脚本，在 Module 目录下，build.gradle 文件底部添加如下代码:

//gradle publish
apply from: "${rootProject.projectDir}/publish-maven.gradle"

3. GPG 密钥

  3.1 下载并安装 GPG 客户端

  3.2 在终端命令行中执行命令 gpg --full-gen-key，注意，一定要在终端命令行中执行命令，不能在 GPG 客户端界面做

  3.3 加密方式选择 RSA 和 RSA，长度为4096，过期时间，真实姓名，邮箱，注释，最后选择 O，确定

  3.4 弹窗对话框，输入密码，如下图：

  3.5 创建 secring.gpg 文件，命令行执行 gpg --export-secret-keys -o secring.gpg，弹出对话框，输入上一步骤 3.4 的密码，这时用户根目录下会生成 secring.gpg 文件

  3.6 终端命令行执行，如下图:

  3.7 到 GPG 客户端，选择刚生成的密钥条目，点击右键，选择 Send Public Key to Key Server，上传公钥到服务器，如下图:

4. 配置密钥，在 local.properties 文件中

  当git提交上传项目时，local.properties 文件不会被提交，起到保护个人隐私的作用

#sonatype帐号
sonatype.username=hanyang
#sonatype密码
sonatype.password=********
#秘钥
signing.keyId=FC299E7B
#秘钥密码
signing.password=******
#GPG签名秘钥文件.gpg路径
signing.secretKeyRingFile=/Users/lihanyang/.gnupg/secring.gpg

5. 发布

  5.1 执行打包和上传

  在 Android studio 右侧，点击 Gradle 菜单，找到要提交的 module 库，先后执行 assemble 和 publish... 这两个任务，如下图：

  点击 publish... 上传成功，会出现如下日志:

15:55:13: Executing 'publishAarPublicationToSocketRepository'...

Executing tasks: [publishAarPublicationToSocketRepository] in project ......


> Configure project :socket
......
MIT - https://opensource.org/licenses/MIT
Android project publish

> Task :socket:generatePomFileForAarPublication
> Task :socket:androidJavadocs SKIPPED
> Task :socket:javadocsJar UP-TO-DATE
> Task :socket:sourcesJar UP-TO-DATE
> Task :socket:signAarPublication
> Task :socket:publishAarPublicationToSocketRepository

BUILD SUCCESSFUL in 29s
5 actionable tasks: 3 executed, 2 up-to-date

Build Analyzer results available
15:55:42: Execution finished 'publishAarPublicationToSocketRepository'.

  5.1 点击 Staging Repositories 选项

  上传成功后，打开 Nexus Repository Manager 后台，登录 Sonatype 账号，然后点击左侧的 "Staging Repositories"，如下图:

  5.2 选中上传的包，点击 Content 选项卡，查看包内文件，如下图:

  5.3 确定没问题，点击 Close 按钮，填入描述信息，点击 Confirm，如下图:

  5.4 等待十分钟之内，点击 Activity 选项卡，close 列表中，出现 Repository closed，表示 close 成功，如下图:

  5.5 点击 Release 按钮，即可发布到 MavenCentral 仓库，如下图:

  5.6 等待需要长达四个小时，才能在 Search Maven 查询发布结果，搜索如下图:

  5.7 点击查询到到条目，查看库详细信息，如下图:

6. 解释引用库

  gradle 中会使用 implementation 来依赖某个第三方库，结构为：implementation GroupId:ArtifactId:Version
  例如: implementation 'androidx.appcompat:appcompat:1.5.1'

  6.1 GroupId:

  是项目组织的唯一标识符，在实际开发中一般对应 JAVA 的包的结构，就是 main 目录里 java 的目录结构，如 ‘androidx.appcompat’。

  6.2 ArtifactId:

  是项目的唯一标识符，在实际开发中一般对应项目的名称，就是项目根目录的名称,例：appcompat。

  6.3 Version:

  是项目的版本号，例：1.0-SNAPSHOT 。其中 1.0 是版本号，SNAPSHOT 版本代表不稳定、尚处于开发中的版本。而衍生的有 Release 版本则代表稳定的版本。