Android 使用maven publish插件发布产物(aar)全过程实践

背景

平时开发中会把一些独立的功能模块抽取出来作为sdk，既方便业务接入，又能让其他业务线快速复用。那么我们就需要将sdk打包上传到maven仓库，让业务侧依赖即可。

一、编译后的产物

在上传产物到maven仓库之前，我们的知道产物到底是什么。

Android Gradle插件根据项目gradle中应用不同的插件类型在编译组装后会生成不同的产物：

1.1 APK 构件

Android项目的主工程app的gradle配置文件依赖：

apply plugin: 'com.android.application' 

因此，在通过编译命令./gradlew assembleDebug 或./gradlew assembleRelease后，就会在build/outputs/apk文件下生成产物：

如图，apk就是产物(构件)。

1.2 AAB（Android app bundle）构件

如果是海外市场，在Google Play上架的应用必须要打aab包，而不是之前的apk格式。具体区别就暂不讨论了~ 编译命令为:./gradlew bundleDebug 或./gradlew bundleRelease。产物为：

1.3 AAR 构件

一般的module在编译打包后，会生成aar:

二、publish插件

有了产物，我们就需要把产物上传到maven仓库(一般是私有仓库)，方便公司项目直接依赖。而上传就要用到publish插件。APG 3.6.0之前用的maven插件，之后都用maven-publish插件。

2.1 maven-publish插件使用

我们可以新建一个gradle文件，如：maven_publish.gradle。专门用来上传aar。配置如下：

 //maven-publish 新方式
plugins {
    //todo 1 上传插件
    id 'maven-publish'
}

afterEvaluate{
    publishing {
        publications {

            // Creates a Maven publication called "myPublication".
            myPublication(MavenPublication) {
                groupId 'com.sdk.aarpub'
                artifactId 'aar-test'
                version '1.2.2'             // Your package version
//                artifact publishArtifact    //Example: *./target/myJavaClasses.jar*
                artifact "build/outputs/aar/aar-test-release.aar"//aar包的目录

                //带上依赖 ，否则会报错
                pom.withXml {
                    def dependenciesNode = asNode().appendNode('dependencies')

                    def scopes = [configurations.compile]
                    if (configurations.hasProperty("api")) {
                        scopes.add(configurations.api)
                    }
                    if (configurations.hasProperty("implementation")) {
                        scopes.add(configurations.implementation)
                    }
                    if (configurations.hasProperty("debugImplementation")) {
                        scopes.add(configurations.debugImplementation)
                    }
                    if (configurations.hasProperty("releaseImplementation")) {
                        scopes.add(configurations.releaseImplementation)
                    }

//                    if (project.ext.targetType != "jar") {
//                        scopes.add(configurations.provided)
//                    }

                    scopes.each { scope ->
                        scope.allDependencies.each {
                            if (it instanceof ModuleDependency) {
                                boolean isTransitive = ((ModuleDependency) it).transitive
                                if (!isTransitive) {
                                    println "<<<< not transitive dependency: [${it.group}, ${it.name}, ${it.version}]"
                                    return
                                }
                            }

                            if (it.group == "${project.rootProject.name}.libs" || it.version == 'unspecified') {
                                return
                            }

                            if (it.group && it.name && it.version) {
                                def dependencyNode = dependenciesNode.appendNode('dependency')
                                dependencyNode.appendNode('groupId', it.group)
                                dependencyNode.appendNode('artifactId', it.name)
                                dependencyNode.appendNode('version', it.version)
                                dependencyNode.appendNode('scope', scope.name)
                            }
                        }
                    }
                }
            }
        }

        // Repositories *to* which Gradle can publish artifacts
        repositories {
            maven {
            //上传到项目本地仓库
                url uri('../local_mavenrepo')
//            credentials {
//                username "default"
//                password "default"
//            }
            }
        }
    }
} 

在assemble命令后，执行publish命令：

./gradlew publish 

2.2 maven插件使用

旧方式：

plugins {
    //todo 1 上传插件
    id 'maven'
}


uploadArchives{
    // 方式一
    repositories {
        mavenDeployer{
            repository(url: uri('../local_mavenrepo'))
            //todo 2 配置版本信息 方式二
            pom.groupId = 'com.sdk.aarpub'
            pom.artifactId = 'aar-test'
            pom.version = '1.1.0'
        }
        //mavenLocal 这个是本机上的maven本地缓存仓库
//        mavenLocal()
    }

} 

在assemble命令后，执行uploadArchives命令：

./gradlew uploadArchives 

2.3 业务侧使用

在项目的根gradle文件中，配置仓库：

maven { url '../local_mavenrepo/'} 

在对应的模块中引入依赖：

implementation 'com.sdk.aarpub:aar-test:1.2.2' 

三、问题总结

3.1 项目中依赖本地aar的时候打包报错Direct local .aar file dependencies are not supported when building an AAR…

原因：当打包aar时候直接依赖本地的aar是不被允许的。 解决方案：通过把依赖的aar放到单独的模块中，让直接依赖本地aar变成依赖模块。

1. 新建一个文件夹aar-lib
2. 新建一个libs文件夹，把oaid_sdk_1.0.30.aar放入到libs目录中

3. 新建build.gradle文件，写入如下内容

configurations.maybeCreate("default")
def publishArtifact = artifacts.add("default", file('libs/oaid_sdk_1.0.30.aar')) 

4. 在项目的settings文件中引入该模块

include ':aar-lib' 

5. 删除报错模块中的aar文件，替换原来依赖方式

//    implementation files('libs/oaid_sdk_1.0.30.aar') 旧的方式
    implementation project(path:":aar-lib") 

3.2 module打包aar时依赖aar导致的类引用不到的问题

3.1 只是解决了在项目打包过程中依赖本地aar的问题。 当module作为sdk同时又依赖aar时，此时接入sdk会报错，提示引用不到aar中的类。当然我们可以直接把aar给到业务测，直接引入即可，但这样增加了接入成本。因此，我们的解决方案跟原理跟3.1一样，但是会把aar上传到远程库，作为远程来依赖。

比如 A模块依赖了oaid_sdk_1.0.30.aar，同时A模块作为sdk是要提供给业务侧app使用的。

1. 按照3.1的方式创建一个aar-lib，build.gradle内容有所不同：

plugins {
    id 'maven-publish'
}

//生成文档注释
task androidJavadocs(type: Javadoc) {
    failOnError = false
    source = android.sourceSets.main.java.srcDirs
    ext.androidJar = "${android.sdkDirectory}/platforms/${android.compileSdkVersion}/android.jar"
    classpath += files(ext.androidJar)
}
//将文档打包成jar
task androidJavadocsJar(type: Jar, dependsOn: androidJavadocs) {
    archiveClassifier.set('javadoc')
    from androidJavadocs.destinationDir
}
//将源码打包，这一点对kotlin来说很重要，否则业务侧无法看到源码
task androidSourcesJar(type: Jar) {
    archiveClassifier.set('sources')
    from android.sourceSets.main.java.srcDirs
}
configurations.maybeCreate("default")
def publishArtifact = artifacts.add("default", file('libs/oaid_sdk_1.0.30.aar'))

afterEvaluate{
    publishing {
        publications {

            myPublication(MavenPublication) {
                groupId 'com.sdk.aarpub'
                artifactId 'aar-lib'
                version '1.0.0'             // Your package version
                artifact(androidSourcesJar)//将源码打包进aar，如果不需要可以去掉
                artifact(androidJavadocsJar)//将注释打包进aar，如果不需要可以去掉
                // 将aar推送到远程仓库
                artifact publishArtifact    //Example: *./target/myJavaClasses.jar*
            }
        }

        // Repositories *to* which Gradle can publish artifacts
        repositories {
            maven {
                url uri('../local_maverepo')
//            credentials {
//                username "default"
//                password "default"
//            }
            }
        }
    }
} 

2. 执行发布命令

./gradlew :aar-lib:publish 

3. 让A模块依赖第二步中推送到远程的aar库

implementation 'com.sdk.aarpub:aar-lib:1.0.0' 

4. 重新打包A模块，当app依赖A模块时候，A模块中的aar就会被引用到了

当然在A模块发布的时候记得要带上依赖：

 //带上依赖 ，否则会报错
                pom.withXml {
                    def dependenciesNode = asNode().appendNode('dependencies')

                    def scopes = [configurations.compile]
                    if (configurations.hasProperty("api")) {
                        scopes.add(configurations.api)
                    }
                    if (configurations.hasProperty("implementation")) {
                        scopes.add(configurations.implementation)
                    }
                    if (configurations.hasProperty("debugImplementation")) {
                        scopes.add(configurations.debugImplementation)
                    }
                    if (configurations.hasProperty("releaseImplementation")) {
                        scopes.add(configurations.releaseImplementation)
                    }

//                    if (project.ext.targetType != "jar") {
//                        scopes.add(configurations.provided)
//                    }

                    scopes.each { scope ->
                        scope.allDependencies.each {
                            if (it instanceof ModuleDependency) {
                                boolean isTransitive = ((ModuleDependency) it).transitive
                                if (!isTransitive) {
                                    println "<<<< not transitive dependency: [${it.group}, ${it.name}, ${it.version}]"
                                    return
                                }
                            }

                            if (it.group == "${project.rootProject.name}.libs" || it.version == 'unspecified') {
                                return
                            }

                            if (it.group && it.name && it.version) {
                                def dependencyNode = dependenciesNode.appendNode('dependency')
                                dependencyNode.appendNode('groupId', it.group)
                                dependencyNode.appendNode('artifactId', it.name)
                                dependencyNode.appendNode('version', it.version)
                                dependencyNode.appendNode('scope', scope.name)
                            }
                        }
                    }
                } 

文末

要想成为架构师，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

一、架构师筑基必备技能

1、深入理解Java泛型
2、注解深入浅出
3、并发编程
4、数据传输与序列化
5、Java虚拟机原理
6、高效IO
……

二、Android百大框架源码解析

1.Retrofit 2.0源码解析
2.Okhttp3源码解析
3.ButterKnife源码解析
4.MPAndroidChart 源码解析
5.Glide源码解析
6.Leakcanary 源码解析
7.Universal-lmage-Loader源码解析
8.EventBus 3.0源码解析
9.zxing源码分析
10.Picasso源码解析
11.LottieAndroid使用详解及源码解析
12.Fresco 源码分析——图片加载流程

三、Android性能优化实战解析

• 腾讯Bugly:对字符串匹配算法的一点理解
• 爱奇艺：安卓APP崩溃捕获方案——xCrash
• 字节跳动：深入理解Gradle框架之一：Plugin, Extension, buildSrc
• 百度APP技术：Android H5首屏优化实践
• 支付宝客户端架构解析：Android 客户端启动速度优化之「垃圾回收」
• 携程：从智行 Android 项目看组件化架构实践
• 网易新闻构建优化：如何让你的构建速度“势如闪电”？
• …

四、高级kotlin强化实战

1、Kotlin入门教程
2、Kotlin 实战避坑指南
3、项目实战《Kotlin Jetpack 实战》

• 从一个膜拜大神的 Demo 开始

• Kotlin 写 Gradle 脚本是一种什么体验？

• Kotlin 编程的三重境界

• Kotlin 高阶函数

• Kotlin 泛型

• Kotlin 扩展

• Kotlin 委托

• 协程“不为人知”的调试技巧

• 图解协程：suspend

五、Android高级UI开源框架进阶解密

1.SmartRefreshLayout的使用
2.Android之PullToRefresh控件源码解析
3.Android-PullToRefresh下拉刷新库基本用法
4.LoadSir-高效易用的加载反馈页管理框架
5.Android通用LoadingView加载框架详解
6.MPAndroidChart实现LineChart（折线图）
7.hellocharts-android使用指南
8.SmartTable使用指南
9.开源项目android-uitableview介绍
10.ExcelPanel 使用指南
11.Android开源项目SlidingMenu深切解析
12.MaterialDrawer使用指南

六、NDK模块开发

1、NDK 模块开发
2、JNI 模块
3、Native 开发工具
4、Linux 编程
5、底层图片处理
6、音视频开发
7、机器学习

七、Flutter技术进阶

1、Flutter跨平台开发概述
2、Windows中Flutter开发环境搭建
3、编写你的第一个Flutter APP
4、Flutter开发环境搭建和调试
5、Dart语法篇之基础语法(一)
6、Dart语法篇之集合的使用与源码解析(二)
7、Dart语法篇之集合操作符函数与源码分析(三)
…

八、微信小程序开发

1、小程序概述及入门
2、小程序UI开发
3、API操作
4、购物商场项目实战……

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接点击文末CSDN官方认证微信卡片免费领取【保证100%免费】↓↓↓