可能是最通用全面的Android studio打包jar方法

最新推荐文章于 2024-08-16 08:58:07 发布
最新推荐文章于 2024-08-16 08:58:07 发布
阅读量4.1k 收藏 9
点赞数 3
分类专栏： android studio 文章标签： android android studio jar gradle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013493809/article/details/52344841
版权

现状

网上关于Android studio打包jar的教程很多，基本思路如下

  1. 项目build.gradle中增加一个Jar任务,
  2. 指定打包路径。如下：
task buildJar(dependsOn: ['assembleDebug'], type: Jar) {

    ....

    def srcClassDir = [project.buildDir.absolutePath + "/intermediates/classes/debug"];
    from srcClassDir
    include "**/*.class"
    ....
}

这样做个人觉得有几个问题：

  1. 只能给当前项目应用module打包/intermediates/classes/debug

    对于依赖的aar，如support v7，编译输出class是在/intermediates/exploded-aar/
    对于依赖的jar包，目测在intermediates中根本找不到

  2. 不能混淆，当然你也可以在build.gradle写一个ProGuardTask，具体可参见这篇文章,这里直接复制其最终生成build.gradle如下：

   import com.android.build.gradle.AppPlugin
   import com.android.build.gradle.LibraryPlugin
   import proguard.gradle.ProGuardTask
   apply plugin: 'com.android.application'
   android {
       compileSdkVersion 23
       buildToolsVersion "23.0.2"
       defaultConfig {
           applicationId "org.chaos.demo.jar"
           minSdkVersion 19
           targetSdkVersion 22
           versionCode 1
           versionName "1.0"
       }
       buildTypes {
           release {
               minifyEnabled true
               proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
           }
       }
   }
   dependencies {
       compile fileTree(dir: 'libs', include: ['*.jar'])
   }
   //dependsOn 可根据实际需要增加或更改
   task buildJar(dependsOn: ['compileReleaseJavaWithJavac'], type: Jar) {
       appendix = "demo"
       baseName = "androidJar"
       version = "1.0.0"
       classifier = "release"
       //后缀名
       extension = "jar"
       //最终的 Jar 包名，如果没设置，默认为 [baseName]-[appendix]-[version]-[classifier].[extension]
       archiveName = "AndroidJarDemo.jar"
       //需打包的资源所在的路径集
       def srcClassDir = [project.buildDir.absolutePath + "/intermediates/classes/release"];
       //初始化资源路径集
       from srcClassDir
       //去除路径集下部分的资源
   //    exclude "org/chaos/demo/jar/MainActivity.class"
   //    exclude "org/chaos/demo/jar/MainActivity\$*.class"
   //    exclude "org/chaos/demo/jar/BuildConfig.class"
   //    exclude "org/chaos/demo/jar/BuildConfig\$*.class"
   //    exclude "**/R.class"
   //    exclude "**/R\$*.class"
       //只导入资源路径集下的部分资源
       include "org/chaos/demo/jar/**/*.class"
       //注: exclude include 支持可变长参数
   }
   task proguardJar(dependsOn: ['buildJar'], type: ProGuardTask) {
       //Android 默认的 proguard 文件
       configuration android.getDefaultProguardFile('proguard-android.txt')
       //manifest 注册的组件对应的 proguard 文件
       configuration project.buildDir.absolutePath + "/intermediates/proguard-rules/release/aapt_rules.txt"
       configuration 'proguard-rules.pro'
       String inJar = buildJar.archivePath.getAbsolutePath()
       //输入 jar
       injars inJar
       //输出 jar
       outjars inJar.substring(0, inJar.lastIndexOf('/')) + "/proguard-${buildJar.archiveName}"
       //设置不删除未引用的资源(类，方法等)
       dontshrink
       Plugin plugin = getPlugins().hasPlugin(AppPlugin) ?
               getPlugins().findPlugin(AppPlugin) :
               getPlugins().findPlugin(LibraryPlugin)
       if (plugin != null) {
           List<String> runtimeJarList
           if (plugin.getMetaClass().getMetaMethod("getRuntimeJarList")) {
               runtimeJarList = plugin.getRuntimeJarList()
           } else if (android.getMetaClass().getMetaMethod("getBootClasspath")) {
               runtimeJarList = android.getBootClasspath()
           } else {
               runtimeJarList = plugin.getBootClasspath()
           }
           for (String runtimeJar : runtimeJarList) {
               //给 proguard 添加 runtime
               libraryjars(runtimeJar)
           }
       }
   }

看起来真不太舒服不是？(无意冒犯)

  1. 对于一个强迫症的程序员，除了代码要整洁之外，编译脚本文件build.gradle不整洁也不能忍
apply plugin: 'com.android.application'
apply plugin: 'jar-gradle-plugin'
android {
    compileSdkVersion 24
    buildToolsVersion "24.0.0"

    defaultConfig {
        applicationId "com.adison.testjarplugin"
        minSdkVersion 15
        targetSdkVersion 24
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:24.0.0'
    compile 'com.android.support:design:24.0.0'
}

BuildJar{
    //输出目录
    outputFileDir= project.buildDir.path+"/jar"
    //输出原始jar包名
    outputFileName="test.jar"
    //输出混淆jar包名
    outputProguardFileName="test_proguard.jar"
    //混淆配置
    proguardConfigFile="proguard-rules.pro"
    //是否需要默认的混淆配置proguard-android.txt
    needDefaultProguard=true
}

这样感觉是不是好些了哈

实践

关于第一个问题，我们可以利用Android Transform Task解决，其官方说明如下：

Starting with 1.5.0-beta1, the Gradle plugin includes a Transform API allowing 3rd party plugins to manipulate compiled class files before they are converted to dex files.(The API existed in 1.4.0-beta2 but it’s been completely revamped in 1.5.0-beta1)

可见Transform Task的输入文件肯定包含apk所有依赖class及其本身class，我们只要取得其输入文件就行了

关于第三个问题，我们写一个Gradle插件，把业务逻辑都交给插件处理就好了，关于Gradle及自定义Gradle插件可以参考Gradle深入与实战系列文章，在此不展开说明。废话不多说，直接上插件代码：

class BuildJarPlugin implements Plugin<Project> {
    public static final String EXTENSION_NAME = "BuildJar";

    @Override
    public void apply(Project project) {
        DefaultDomainObjectSet<ApplicationVariant> variants
        if (project.getPlugins().hasPlugin(AppPlugin)) {
            variants = project.android.applicationVariants;
            project.extensions.create(EXTENSION_NAME, BuildJarExtension);  
            applyTask(project, variants);
        }
    }

    private void applyTask(Project project, variants) {

        project.afterEvaluate {
            BuildJarExtension jarExtension = BuildJarExtension.getConfig(project);
            def includePackage = jarExtension.includePackage
            def excludeClass = jarExtension.excludeClass
            def excludePackage = jarExtension.excludePackage
            def excludeJar = jarExtension.excludeJar

            variants.all { variant ->
                if (variant.name.capitalize() == "Debug") {
                    def dexTask = project.tasks.findByName(BuildJarUtils.getDexTaskName(project, variant))
                    if (dexTask != null) {
                        def buildJarBeforeDex = "buildJarBeforeDex${variant.name.capitalize()}"

                        def buildJar = project.tasks.create("buildJar", Jar)
                        buildJar.setDescription("构建jar包")
                        Closure buildJarClosure = {
                            //过滤R文件和BuildConfig文件
                            buildJar.exclude("**/BuildConfig.class")
                            buildJar.exclude("**/BuildConfig\$*.class")
                            buildJar.exclude("**/R.class")
                            buildJar.exclude("**/R\$*.class")
                            buildJar.archiveName = jarExtension.outputFileName
                            buildJar.destinationDir = project.file(jarExtension.outputFileDir)
                            if (excludeClass != null && excludeClass.size() > 0) {
                                excludeClass.each {
                                    //排除指定class
                                    buildJar.exclude(it)
                                }

                            }
                            if (excludePackage != null && excludePackage.size() > 0) {
                                excludePackage.each {
                                    //过滤指定包名下class
                                    buildJar.exclude("${it}/**/*.class")
                                }

                            }
                            if (includePackage != null && includePackage.size() > 0) {
                                includePackage.each {
                                    //仅仅打包指定包名下class
                                    buildJar.include("${it}/**/*.class")
                                }

                            } else {
                                //默认全项目构建jar
                                buildJar.include("**/*.class")

                            }
                        }
                        project.task(buildJarBeforeDex) << {
                            Set<File> inputFiles = BuildJarUtils.getDexTaskInputFiles(project, variant, dexTask)

                            inputFiles.each { inputFile ->
                                def path = inputFile.absolutePath
                                if (path.endsWith(SdkConstants.DOT_JAR) && !BuildJarUtils.isExcludedJar(path, excludeJar)) {
                                    buildJar.from(project.zipTree(path))
                                } else if (inputFile.isDirectory()) {
                                    //intermediates/classes/debug
                                    buildJar.from(inputFile)
                                }
                            }
                        }

                        def buildProguardJar = project.tasks.create("buildProguardJar", ProGuardTask);
                        buildProguardJar.setDescription("混淆jar包")
                        buildProguardJar.dependsOn buildJar
                        //设置不删除未引用的资源(类，方法等)
                        buildProguardJar.dontshrink();
                        //忽略警告
                        buildProguardJar.ignorewarnings()
                        //需要被混淆的jar包
                        buildProguardJar.injars(jarExtension.outputFileDir + "/" + jarExtension.outputFileName)
                        //混淆后输出的jar包
                        buildProguardJar.outjars(jarExtension.outputFileDir + "/" + jarExtension.outputProguardFileName)

                        //libraryjars表示引用到的jar包不被混淆
                        // ANDROID PLATFORM
                        buildProguardJar.libraryjars(project.android.getSdkDirectory().toString() + "/platforms/" + "${project.android.compileSdkVersion}" + "/android.jar")
                        // JAVA HOME
                        def javaBase = System.properties["java.home"]
                        def javaRt = "/lib/rt.jar"
                        if (System.properties["os.name"].toString().toLowerCase().contains("mac")) {
                            if (!new File(javaBase + javaRt).exists()) {
                                javaRt = "/../Classes/classes.jar"
                            }
                        }
                        buildProguardJar.libraryjars(javaBase + "/" + javaRt)
                        //混淆配置文件
                        buildProguardJar.configuration(jarExtension.proguardConfigFile)
                        if (jarExtension.needDefaultProguard) {
                            buildProguardJar.configuration(project.android.getDefaultProguardFile('proguard-android.txt'))
                        }
                        //applymapping
                        def applyMappingFile=jarExtension.applyMappingFile
                        if(applyMappingFile!=null){
                            buildProguardJar.applymapping(applyMappingFile)
                        }
                        //输出mapping文件
                        buildProguardJar.printmapping(jarExtension.outputFileDir + "/" + "mapping.txt")
                        def buildJarBeforeDexTask = project.tasks[buildJarBeforeDex]
                        buildJarBeforeDexTask.dependsOn dexTask.taskDependencies.getDependencies(dexTask)
                        buildJar.dependsOn buildJarBeforeDexTask
                        buildJar.doFirst(buildJarClosure)
                    }
                }

            }
        }
    }


}

插件使用

既然标题说了这是一个通用的打包jar插件，那么一些基本特性，如过滤包名，指定包名等是必须要支持的，目前该插件支持特性如下：

  1. 按需打包jar：
    • 全项目打包jar
    • 指定输出Jar包的包名路径列表
    • 过滤指定包名路径列表
    • 过滤指定class
    • 过滤指定jar
  2. 支持混淆打包jar
  3. 支持applymapping

具体使用说明

  1. 引入依赖

    dependencies {
       classpath 'com.android.tools.build:gradle:2.1.3'
       classpath 'com.adison.gradleplugin:jar:1.0.1'
   }

    ​

  2. 应用插件

    apply plugin: 'jar-gradle-plugin'
BuildJar{
   //输出目录
   outputFileDir= project.buildDir.path+"/jar"
   //输出原始jar包名
   outputFileName="test.jar"
   //输出混淆jar包名
   outputProguardFileName="test_proguard.jar"
   //混淆配置
   proguardConfigFile="proguard-rules.pro"
   //是否需要默认的混淆配置proguard-android.txt
   needDefaultProguard=true
   applyMappingFile="originMapping/mapping.txt"
   //需要输出jar的包名列表,当此参数为空时，则默认全项目输出,支持多包,如 includePackage=['com/adison/testjarplugin/include','com/adison/testjarplugin/include1'...]
   includePackage=['com/adison/testjarplugin/include']
   //不需要输出jar的jar包列表,如['baidu.jar','baidu1.jar'...]
   excludeJar=[]
   //不需要输出jar的类名列表,如['baidu.calss','baidu1.class'...]
   excludeClass=['com/adison/testjarplugin/TestExcude.class']
   //不需要输出jar的包名列表,如 excludePackage=['com/adison/testjarplugin/exclude','com/adison/testjarplugin/exclude1'...]
   excludePackage=['com/adison/testjarplugin/exclude']
}
  3. 使用
    • 打包普通jar
./gradlew buildJar
  • 打包混淆jar
./gradlew buildProguardJar

使用可参见使用demo

插件源码

https://github.com/adisonhyh/buildJar

北极adison
关注
专栏目录
Android Studio 打包Jar
Okloong的博客
10-17 541
博客导航 Eclipse打包Jar包很容易，直接选择相应的资源打包即可。Android Studio要打包Jar则没有图形界面，只有用gradle来打包。下面就讲述Android Studio打包Jar，并处理Android Studio的terminal中文重码、不能正常输入等问题，gradle禁用lint报错。 一、环境设置 在win10的环境下，Android Studio的termi...
android和java中的jar 不能通用,可能是最通用全面的Android studio打包jar方法
weixin_42349135的博客
03-12 404
现状网上关于Android studio打包jar的教程很多，基本思路如下项目build.gradle中增加一个Jar任务,指定打包路径。如下：task buildJar(dependsOn: ['assembleDebug'], type: Jar) {....def srcClassDir = [project.buildDir.absolutePath + "/intermediates/c...
Android studio打包jar
Magiccrystal的专栏
08-08 532
AndroidStudio将资源文件打包成jar包方法是不一样的，AS不像Eclipse可以直接导出。在build.gradle 文件中新建一个task. 网上有很多的方法，下面介绍一种插件，直接打包。 本文打包方式有参考：https://blog.csdn.net/ItJavawfc/article/details/62227129，因为我的androidstudio有升级到3.4.2，所以大...
探索高效Java项目打包新纪元：buildJar —— 你的Gradle插件新宠
最新发布
gitblog_00122的博客
08-16 525
探索高效Java项目打包新纪元：buildJar —— 你的Gradle插件新宠 buildJar通用的打包jar gradle插件项目地址:https://gitcode.com/gh_mirrors/bu/buildJar 在快速迭代的软件开发过程中，高效的打包流程是提升团队效率的关键。今天，我们来深入探讨一个开源宝藏——buildJar，一款专为简化和细化Java项目jar打包过程而生的G...
Android studio 打包jar包
叫我Aso的专栏
03-23 851
在Android前期的开发时，我们使用的IDE工具大多是Eclipse，所以对其熟练度相信大家都是OK的，所以对于如何将一个项目导出为jar包，供其它项目使用的操作都是没问题的。 　　那么现在问题来了，谷歌新提供的Android Studio工具，也都已经update到2.x版本了，到目前为止，不知道有多少人懂得对module进行打包？至少在我写下这篇文字之前，我都只关心写代码！ 　　现在，个
Android Studio 打包jar makeJar
guojiayuan002的博客
07-20 906
Android Studio 打包jar makeJar 在模块的 build.gradle dependencies{}后面设置 task clearJar(type: Delete) { // 先删除原来的jar delete 'build/libs/Test.jar' } //指定生成jar包的来源和存放位置以及名称 task makeJar(type: Jar) { //指定生成的jar名 baseName 'Test' //从哪里打包class文件
android studio 项目打包jar包
woaibianche的博客
01-03 434
android studio 打包jar包
如何利用Android Studio将moudle变成jar示例详解
08-29
这种方法适用于那些不需要原生库（NDK）支持，且不涉及Android特定API的通用Java库。如果你的Module包含了Android特定的功能或原生库，可能需要考虑使用AAR（Android Library Archive）格式，它更全面地包含了...
AndroidStudio-NDK开发 编译c代码提供so库和jar包 另外一个app调用，实例源码
07-22
6. **生成.jar包**：如果C/C++代码包含一些通用的功能，可能需要将它们封装成.jar包，供其他应用使用。这可以通过Java Native Interface (JNI)来实现。创建一个Java项目，将本地库的头文件和Java接口类放入其中，...
Android Studio混淆打包
HardWorkingAnt的博客
04-13 863
混淆背景Android Studio中的项目可以用compile的形式引入GitHub上的开源项目，可以引用module，而不一定都要用libs文件夹中添加jar包的形式。在最终realease打包时，混淆的设置是比较重要的，否则会导致生成的包有很多功能不能正常使用。注意，混淆打包后的apk文件大小会比不使用混淆要小。设置混淆在app根目录下设置build.gradle和混淆文件，然后把混淆选项写入
Android Studio配置
haohaoxuexi010的博客
07-02 1387
1、安装 Java JDK(本部分内容参考https://www.runoob.com/java/java-environment-setup.html)（3）JRE的内部有一个Java虚拟机（Java Virtual Machine，JVM）以及一些标准的类别函数库（Class Library）。（1）辅助开发某一类软件的相关文档、演示举例和一些工具的集合，这些都可以称为SDK。3、Java开发工具包（JDK，Java Development Kit）（1）作为Java语言的SDK，
Android studio打包生成jar包文件
weixin_43117800的博客
08-28 4637
2.通过Android Studio右边的Gradle的makeJar命令。将应用模块application转换成库模块library后生成jar包。2、打开清单文件AndroidManifest.xml。接下来将生成的jar包放入到另一个项目中进行测试。测试，这说明已经调用jar包中的方法成功啦。如出现下图所示错误解决方式。接下来就可以打jar包了。2、将jar包添加进项目。通过cmd命令行方式。
android studio 打包jar文件
wentaotao90的专栏
10-05 327
突然间要用android studio 打包一个jar包，我翻阅很多资料，如同大海捞针，找了好几个别人的方法，要么就是不知道发生什么，总之就是找不到自己生成的jar包，因为看的多了，查的的多了，我就来告诉我是如何打包这个jar包，虽然感觉还是有些怪怪的，但是可以完美带在其他项目中运行。 1.新建Android Libarary 2.写入自己的项目或者java文件 3.设置打包参数，请参照图，存放的位置 task makeJar(type: Copy) { //删除存在的...
android studio 打包jar 打包
qq_35879034的博客
09-06 256
搜索了好久，感觉都是很麻烦的操作，发现一个最速度的解决办法，有两种需求，一、将现有的app项目改成jar，二、建立的module lib 打包成jar，一般在AS 里是可以直接引用，，废话不多说，下面是现有app打包成jar示例，用图解释。 上面操作改完后rebuild 一下，然后按下面操作。 展开后再找到下面这个，双击编译 大约2秒后，run 下面会提示编译succeed ,到...
AndroidStudio打包成jar
曦笑大海的博客
04-13 1283
在eclipse中我们知道如何将一个项目导出为jar包，现在普遍AndroidStuido开发，这里一步一步详加介绍AS项目打包成jar和jar+aar的使用...
Android Studio模块打包成Jar教程：自定义生成与配置方法
本文档详细介绍了在Android Studio中将Module打包成Jar的方法。首先，Android Studio默认情况下会在library模块的依赖项目构建后自动生成.jar文件，这个jar位于`Module根目录/build/intermediates/bundles/debug`或`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值