———————————————–

—
–
——————————————————-

//apply plugin: 'com.android.application'
apply plugin: 'com.android.library'

.........................
//自定义编译任务名称
task makeMyJar(type: proguard.gradle.ProGuardTask, dependsOn: "build") {
    // 未混淆的jar: compile_library_classes为android studio 3.6.2版本编译产出
    // 其他版本可能不一样,可打开build/intermediates/目录查找,低版本的事bundle
    injars 'build/intermediates/compile_library_classes/release/classes.jar'
    // 混淆后的jar路径
    outjars 'build/My-sdk.jar'
    // 混淆规则文件,具体需要keep的类
    configuration 'proguard-rules.pro'
}

简介：安卓发开中，往往需要将部分功能或者核心功能运用到另一个APP中，这时候，SDK的开发模式就体现出来其优越性。我们可以将这部分功能打包成jar包或者arr包，直接运用到另一个项目中，下面讲Androidstudio 打包jar包的流程。

1. build/rebuild项目，获取 classes.jar
build/rebuild一下项目，在library Module下找到classes.jar
D:\york_android\WifiDemo\wifishare\build\intermediates\compile_library_classes\debug\classes.jar

2.修改 build.gredle内容
在 dependencies 之后 加入

def SDK_BASENAME = “WifiSdk”;
def SDK_VERSION = “_V1.0”;
def sdkDestinationPath = “build”;
def zipFile = file(‘build/intermediates/compile_library_classes/debug/classes.jar’)

task deleteBuild(type: Delete) {
delete sdkDestinationPath + SDK_BASENAME + SDK_VERSION + “.jar”
}

task makeJar(type: Jar) {
from zipTree(zipFile)
from fileTree(dir: ‘src/main’,includes: [‘assets/**’])//将assets目录打入jar包
// from fileTree(dir: ‘src/main’,includes: [‘res/**’])//将res目录打入jar包
baseName = SDK_BASENAME + SDK_VERSION
destinationDir = file(sdkDestinationPath)
}

makeJar.dependsOn(deleteBuild, build)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
build.gredle 完整代码如下：

apply plugin: ‘com.android.library’

android {
compileSdkVersion 28
buildToolsVersion “29.0.1”
useLibrary ‘org.apache.http.legacy’

defaultConfig {
minSdkVersion 23
targetSdkVersion 28
versionCode 1
versionName “1.0”
testInstrumentationRunner “android.support.test.runner.AndroidJUnitRunner”
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile(‘proguard-android-optimize.txt’), ‘proguard-rules.pro’
}
}
lintOptions {
abortOnError false
}
}
dependencies {
implementation fileTree(dir: ‘libs’, include: [‘*.jar’])
implementation ‘com.android.support:appcompat-v7:28.0.0’
implementation ‘com.google.code.gson:gson:2.8.5’
testImplementation ‘junit:junit:4.12’
androidTestImplementation ‘com.android.support.test:runner:1.0.2’
androidTestImplementation ‘com.android.support.test.espresso:espresso-core:3.0.2’
}

def SDK_BASENAME = “WifiSdk”;
def SDK_VERSION = “_V1.0”;
def sdkDestinationPath = “build”;
def zipFile = file(‘build/intermediates/compile_library_classes/debug/classes.jar’)

task deleteBuild(type: Delete) {
delete sdkDestinationPath + SDK_BASENAME + SDK_VERSION + “.jar”
}

task makeJar(type: Jar) {
from zipTree(zipFile)
from fileTree(dir: ‘src/main’,includes: [‘assets/**’])//将assets目录打入jar包
// from fileTree(dir: ‘src/main’,includes: [‘res/**’])//将res目录打入jar包
baseName = SDK_BASENAME + SDK_VERSION
destinationDir = file(sdkDestinationPath)
}

makeJar.dependsOn(deleteBuild, build)
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
3.在 gredle 窗口 运行 makejar
如图：先找到gredle 窗口，点击 other

在other中，找到 makeJar，点击 makeJar 开始打包

看到 BUILD SUCCESSFUL 表示打包成功，否则会提示相关错误，那就需要纠错。

关键点在下图：

york2017
关注

————————————————
版权声明：本文为CSDN博主「york2017」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/york2017/article/details/106249311

公司经常和客户提供SDK，提供一个jar包sdk是一件很平常的事。Eclipse 有图形界面和向导供开发者将一个项目导出为jar包，相对来讲是比较简单的，切换到Android Studio后，则需要结合gradle来配置生成jar 包。下面介绍两种生成jar的方法
1.新建New Project ，然后 New Module（名字以ylwlibrary为例）

2.主工程app:build.gradle 中添加依赖

dependencies {
…
compile project(‘:ylwlibrary’)
}
1.
2.
3.
4.

一，傻瓜式搬运工
1.在library的app:build.gradle 中添加如下代码：

//Copy类型
task makeJar(type: Copy) {
//删除存在的
delete ‘build/libs/SkSDK.jar’
//设置拷贝的文件
from(‘build/intermediates/bundles/release/’)
//打进jar包后的文件目录
into(‘build/libs/’)
//将classes.jar放入build/libs/目录下
//include ,exclude参数来设置过滤
//（我们只关心classes.jar这个文件）
include(‘classes.jar’)
//指定打包的class
include “com/test/**/*.class”
//重命名
rename (‘classes.jar’, ‘SkSDK.jar’)
}
makeJar.dependsOn(build)
//在终端执行生成JAR包
// gradlew makeJar
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
2.Terminal 中输入命令gradlew makeJar

然后在终端执行 gradlew makeJar 命令，就可以在bulid/libs 目录下生成对应的jar包。

（我使用的是AS2.3.3 ，郁闷的是找不到build/intermediates/bundles/release，解决方案详见另一篇博客）

但这种打包方式经常会把一些冗余的文件一块打进jar ,不仅影响jar包的体积，还会经常导致com.android.dex.DexException: Multiple dex files define 此类的错误 。

原因是sdk 的jar包中打入了BuildConfig.class，解决方法很简单：解包，删除里面的 BuildConfig.class，然后重新打包 jar。
具体如下：
1. 解压jar包： jar xf xxx.jar
2. 删除解压后目录里面的//BuildConfig.class
3. 重新打包： jar cvf xxx.jar *

当然我们不希望自己提供的jar 也给其他开发者带来同样的困扰，所以我们期待可以有选择性的选择需要打包的class，排除不需要的class ,如BuildConfig.class、R.class 等

task makeJar(type: Jar) {
delete ‘build/libs/SkSDK.jar’
from file(‘build/intermediates/classes/release’)
archiveName = ‘SkSDK.jar’
destinationDir = file(‘build/libs’)
//过滤不需要的class
exclude “**/**/BuildConfig.class”
exclude “**/**/BuildConfig\$*.class”
exclude “**/R.class”
exclude “**/R\$*.class”
//指定打包的class
include “com/test/**/*.class”
}
makeJar.dependsOn(build)
//在终端执行生成JAR包
// gradlew makeJar
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
二，纯手工打造
在library的app:build.gradle 中添加如下代码：

登录后复制
task clearJar(type: Delete) {
delete ‘build/libs/TestSDK.jar’
delete ‘libs/TestSDK.jar’
}
//打包任务
task makeJar(type: Jar) {
//指定生成的jar名
baseName ‘TestSDK’
//从哪里打包class文件
from(‘build/intermediates/classes/release/com/interjoy/ylwlibrary’)
//打包到jar后的目录结构
into(‘com/interjoy/ylwlibrary/’)
//去掉不需要打包的目录和文件
exclude(‘BuildConfig.class’, ‘R.class’)
//去掉R$开头的文件
exclude { it.name.startsWith(‘R$’); }
}
makeJar.dependsOn(clearJar, build)
———————————–
Android Studio如何打jar包
https://blog.51cto.com/u_15057813/4511751

在Android开发中，我们总是会引入其他第三方的库或者资源等，有时候是添加一个jar文件，有时候添加一个aar文件，那么这两种类型的文件有什么区别吗？详情请看下文。

一、描述。

1.   *.jar，JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。只包含了class文件与清单文件 ，不包含资源文件，如图片等所有res中的文件。找一个jar文件，然后修改后缀名为‘zip’或者‘rar’格式，然后解压该文件，打开解压后的文件夹，截图如下所示：

点击‘com‘文件夹就会看到里面全部是‘.class’文件。

PS: JAR 文件格式以流行的 ZIP 文件格式为基础。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。JAR（Java Archive，Java 归档文件）是与平台无关的文件格式，它允许将许多文件组合成一个压缩文件。为 J2EE 应用程序创建的 JAR 文件是 EAR 文件（企业 JAR 文件）。JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如 ZIP 或者 TAR 所没有提供的。它们包括： 安全性、减少下载时间、传输平台扩展、包密封、包版本控制、可移植性

2. *.aar，AAR（Android Archive）包是一个Android库项目的二进制归档文件。我们随便找一个aar文件，然后修改后缀名为‘zip’或者‘rar’格式，然后解压该文件，打开解压后的文件夹，截图如下所示：（每个aar解压后的内容可能不完全一样，但是都会包含AndroidManifest.xml，classes.jar，res，R.txt）

*.aar文件中包含所有资源，class以及res资源文件。

二、生成aar文件和jar文件。

1.生成jar文件。

在Android Studio中，在某一个Module的Gradle脚本开头声明

接着编译该Module，编译完成之后会在Module的build–>intermediates–>bundles–>debug(release)–>classes.jar，如下图所示：

2.生成aar文件。

在Android Studio中，在某一个Module的Gradle脚本开头声明

接着编译该Module，编译完成之后会在Module的build–>outputs–>aar–>xxxxx.aar ，如下图所示：

如何在Eclipse中生成文件jar文件或者aar文件，此处不详说，建议还是尽快更换开发平台为Android Studio吧！

三、使用。

1. *.jar文件使用。

*.jar文件拷贝到libs目录，eclipse直接导入即可，AndroidStudio项目中添加：

重新编译即可完成。

2.  *.aar文件使用。

*.aar文件使用有两种方式，一种是使用在线的（网上的），一种是添加本地的*.aar文件。网络加载，只要你知道*.aar文件在maven中的路径即可，此处不演示了。下面主要看看在Android Studio中如何加载本地的*.aar文件。

(1).把aar文件放在一个文件目录内，比如就放在libs目录内；

(2).在app的build.gradle文件添加如下内容；

(3).之后只需要添加一句gradle依赖便方便的引用了该aar文件；

至此，在Android Studio中加载本地的*.aar文件就结束，是不是很简单呢！需要补充一点，如果*.aar文件中引用了其他Maven 仓库的包，那么需要在gradle中添加依赖，否则在运行的时候，可能会报“Caused by: Java.lang.ClassNotFoundException”！

可能有的朋友还有疑问，“如何在Eclipse中使用aar文件“”，这里就不讲解了，建议尽快更换为Android Studio吧！

四、小结。

在什么情况下使用*.jar文件？在什么情况下使用*.aar文件呢？

如果你只是一个简单的类库那么使用生成的*.jar文件即可；如果你的是一个UI库，包含一些自己写的控件布局文件以及字体等资源文件那么就只能使用*.aar文件。

文本我们将讲解Android studio打包apk，aar，jar包的相关知识。apk包就是android系统的安装包，这里没什么好说的，aar包是android中独有的类库包，而jar包是java中特有的类库包，在具体的介绍打包之前，我们先来aar包和jar包的区别。

jar包与aar包的区别

• jar是java字节码文件（class文件）的归档文件，其不包含android中的资源文件等信息；
• aar是android中特有的归档文件，既包含字节码文件也包含android的资源文件等；

区别：大家都知道jar文件把，如果你有一个Android Library项目，可以很容易的导出jar文件，然后在其他项目中很方便的引用，aar和jar类似，区别就是一个Android Library项目导出的jar文件不能包含资源文件，比如一些drawable文件、xml资源文件之类的，所以这就有很大的限制，在gradle之前我们要引用带资源文件的Android Library必须要把整个library导入进来进行引用，但是有了gradle之后，Android Library项目可以直接导出成aar，然后其他项目像引用jar的方式直接方便的引用。

具体可参看下图：

• aar包解压之后的结构：
  
• jar包解压之后的目录结构：
  

怎么样？jar包和aar包的区别很明显吧。

打包apk文件

在android studio中打包apk文件有两种方式：

• 通过gradle配置输出apk文件
• 执行Generate singed apk操作获得apk文件

下面我们将分别介绍一下这两种方式的具体步骤，首先我们先看一下如何通过gradle配置的方式，输出apk文件。

android studio中配置打包脚本

• 配置打包类型

buildTypes {
        debug {
            // 显示Log
            buildConfigField "boolean", "LOG_DEBUG", "true"
            //混淆
            minifyEnabled false
            //Zipalign优化
            zipAlignEnabled true
            // 移除无用的resource文件
            shrinkResources true
            //加载默认混淆配置文件
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            //签名
            signingConfig signingConfigs.debug
        }
        release {
            // 不显示Log
            buildConfigField "boolean", "LOG_DEBUG", "false"
            //混淆
            minifyEnabled true
            //Zipalign优化
            zipAlignEnabled true
            // 移除无用的resource文件
            shrinkResources true
            //加载默认混淆配置文件
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            //签名
            signingConfig signingConfigs.relealse
        }
    }

• 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

• 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

可以发现这里的buildType中配置了release包和debug包，以及各自的签名信息：

singingConfig singingConfigs.release

• 1

• 1

更加具体的签名信息配置在singingCongis中，下面我们来看一下其实如何设置的

• 配置签名信息

//签名
    signingConfigs {
        debug {
            storeFile file("aaa.keystore")
            storePassword "111111111"
            keyAlias "aaa.keystore"
            keyPassword "111111111"
        }
        relealse {
            storeFile file("aaa.keystore")
            storePassword "111111111"
            keyAlias "aaa.keystore"
            keyPassword "111111111"
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

这样我们就配置好了apk打包的签名信息，然后我们可以打开Build Variants操作框了…

• 配置Build Variants

这里可以看到我们在mobile module中定义了两个buildType，其中debug和release Type，并且其打包时默认使用的签名信息就是我们刚刚配置的各自的签名信息。

这里需要说明的是android studio中module默认都会有debug和release两个buildType，就算你什么都不配置的话，这里也会存在这两个buildType，而且，除了这两个之外你还可以配置额外的定制化的buildType，比如你想打一个信息的debug01包，使用另外的一套签名信息：

• 在buildType节点下添加

debug01 {
            // 显示Log
            buildConfigField "boolean", "LOG_DEBUG", "true"
            //混淆
            minifyEnabled false
            //Zipalign优化
            zipAlignEnabled true
            // 移除无用的resource文件
            shrinkResources true
            //加载默认混淆配置文件
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            //签名
            signingConfig signingConfigs.debug01
        }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

• 添加新的签名信息

debug01 {
            storeFile file("bbb.keystore")
            storePassword "222222222"
            keyAlias "bbb.keystore"
            keyPassword "222222222"
        }

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

• 配置Build Variants

可以发现这时候Build Variant中mobile module多了一个buildType：debug01，其就是我们刚刚配置的debug01 buildType，并且使用的是另外的一套签名信息，若我们选中debug01，则android studio默认run或者是build apk的时候就会编译debug01版本的apk了。

• 执行run app或者是Build apk操作

这样我们最终就能够输出一个apk格式的安装包了。

执行Generate singned apk操作

除了上面的通过gradle配置的方式生成apk文件，我们还可以执行Generate singned apk操作，通过这样的操作，我们也可以获得一个apk的输出文件，具体步骤如下：

• 执行Build –> Generate singed apk操作
• 填写相应的签名信息
  
• 选择打包的类型
  

好吧，上面就是我们所要介绍的打包apk的两种方式。下面我们在讲解一下如何通过android studio打包aar和jar。

android studio如何打jar包

目前通过android studio打包jar，基本有两种方式：

• 创建module，然后编译完成之后 module中自动的创建了相关的jar文件

这里的classes.jar就是module相关的jar包，我们可以将其更改名称之后拷贝到app下的lib目录中；

• 另一种方式其实跟第一种方式是一样的，只不过其是通过gradle脚本实现的

app为我们的主工程，librarydemo是我们要将其生成jar包的model.
在librarydemo中加入如下代码：

task makeJar(type: Copy) {
    delete 'build/libs/mysdk.jar'
    from('build/intermediates/bundles/release/')
    into('build/libs/')
    include('classes.jar')
    rename ('classes.jar', 'mysdk.jar')
}

makeJar.dependsOn(build)
//在终端执行生成JAR包
// gradlew makeJar

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

在Terminal中键入 gradlew makeJar 回车看到如下所示就OK了：

当然在主工程App的build中要加入librarys 这个依赖model：

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.2.0'
    compile project(':librarys')
}

• 1
• 2
• 3
• 4
• 5

• 1
• 2
• 3
• 4
• 5

（二）android studio如何打aar包
其实打aar包和jar包类似，只不过是其目录变化了而已：

可以看到同样需要其作为library，而且其生成的目录为：/build/output/aar/

好了，以上就是如何通过androd studio打包apk，aar和jar的相关内容了。

Java jar

在Java开发中，添加组件简单的以添加jar文件依赖为途径，jar有两个含义：

• jar文件格式：Java Archive，就是zip文件格式，文件名后缀是jar，包含了java class，metadata，资源（文本、图片等）。
• Java archive tool: JDK中的工具，用来生成jar包的工具。

jar在Android开发中的不足

在Android应用资源中，Java Source，Resouce以及所需的so文件和jar包，用jar格式可以很好的处理Java Source,但对于目录比较复杂的Android Res目录，二进制依赖so文件和jar包则显得的乏力。当你收到一个第三方SDK zip包，要添加到自己的项目中，解压后是一个jar包和一堆文件夹，不停的复制粘贴甚至解决冲突的时候，心里肯定开始不满意这血吸虫组件分发方式了。

aar

什么是aar

为了解决Android开发中组件引用的问题，引入aar格式。也是简单的zip格式。
定义：The ‘aar’ bundle is the binary distribution of an Android Library Project.
Zip包中的内容有：

• /AndroidManifest.xml (mandatory)
• /classes.jar (mandatory)
• /res/ (mandatory)
• /R.txt (mandatory)
• /assets/ (optional)
• /libs/*.jar (optional)
• /jni//*.so (optional)
• /proguard.txt (optional)
• /lint.jar (optional)
  其中，R.txt是aapt –output-text-symbols命令的输出。

生成aar

在Android Studio1.4中，New project，先默认新建一个Applicaton module，接后File > New > New Module，选择Androd Library > Next，指定Library Name和Module Name。

新建的Library与正常的Application最大区别是module build.gradle中是apply plugin: ‘com.android.library’ 而不是 apply plugin: ‘com.android.application’.

Build > Make project(⌘F9),自动生成aar文件。

1
2
3
4
5

| build
	| outputs
		| aar
			| mylibrary-debug.aar
			| mylibrary-release.aar

使用aar

aar可通过以下三种方式引入到项目中：

• 公共Maven仓库
• 私有Maven仓库
• 复制粘贴aar文件
  前两种引入方式涉及到Gradle发布Library到Maven，另文介绍。
  重点介绍第三种方式：
• 把aar粘贴到要引入库的Application Module/libs目录下，如没有libs目录，创建就好。注意要在Application Module根目录下，不是Project根目录下。
• 在Application Module/build.gradle中添加
  

  1 2 3 4 5

  repositories { flatDir { dirs 'libs' } }

flatDir repositories用来声明文件目录做为依赖库，’libs’路径是build.gradle的相对路径，目录名称可以任意，也可以同时声明多个dirs。

• 在Application Module/build.gradle中添加依赖
  

  1 2 3

  dependencies { compile(name:'mylibrary-debug', ext:'aar') }

关于AndroidManifest.xml合并

在上文中看到aar文件中还包含了库中的AndroidManifest.xml文件，但是最终应用APK中只能有一个AndroidManifest.xml，就涉及到应用AndroidManifest.xml和所有库AndroidManifest.xml的合并。

合并顺序：

• 1.与Produt flavors和build types指定的清单文件
• 2.application module的主清单文件
• 3.library module的清单文件

大多数情况下合并不会造成什么问题，如果发现合并后出现了问题：

• 检查最终的AndroidManifest.xml
• 检查合并报告（app\build\outputs\logs\），日志文件的格式和内容

后记

本文中所用的项目代码托管在github。

引用

AAR File Format
http://tools.android.com/tech-docs/new-build-system/aar-format

Manifest merging user guide
http://tools.android.com/tech-docs/new-build-system/user-guide/manifest-merger

apply plugin: 'maven'

compile 'com.nineoldandroids:library:2.4.0+'