如何使用Ant脚本编译出Jar和Apk包






如何使用Ant脚本编译出Jar和Apk包                     

1077人阅读 评论(3) 收藏 举报
本文章已收录于:
分类:

一、前言

今天我们来看一个非常出名的工具ant,我们知道AndroidStudio中已经集成了gradle了,那么ant已经没有往日的辉煌了,但是他并没有被淘汰,因为在web项目中打出war包的时候也是可以用到的,虽然maven也很火,其实我开始工作已经快三年了,但是真心的还没用过ant脚本,因为在第一年的时候,我没有实际的出过release包,后面又开始用gradle了,所以直接略过了ant脚本了,但是今天因为有一个需求,就是想自动化的打出一个jar包,所以就想到了ant脚本,正好也算是学习了,其实ant脚本网上的资料也很多了,这里其实也不算是教程了,只是自己在实际的过程中学习了一下,就写个文章记录一下,以备后面使用呢。那么今天我这里不会很详细的介绍ant的所有内容,比如ant中的每个标签的含义以及用法啥的,因为那个网上太多了,就不介绍了,这里就直接介绍如何使用ant打出一个jar和apk包,这部分资料其实网上也有,但是都是不全的,自己遇到的问题网上也是没有的,这里就记录一下。

首先ant脚本工具是apache开发的一个工具,他的下载地址可以去apache官网下载,下载下来是一个压缩包,解压之后,在bin目录下面有一个ant.bat。运行这个即可,但是为了后面的工作方便,我们将这个添加到环境变量中。


二、使用ant脚本打包jar

首先我们来看看如何使用ant脚本打出一个jar包

我们新建一个工程AntExportJar


在工程的目录下面新建一个build.xml,这个是ant脚本规定的一个入口脚本文件,文件名都是:build.xml

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <project name="AntExportJar" basedir="." default="exportJar">  
  3.     <!-- 设置全局变量 -->  
  4.     <property name="src" value="src" />  
  5.     <property name="dist" value="dist" />  
  6.     <property name="app.name" value="ant" />  
  7.     <property name="app.version" value="1.0" />  
  8.     <property name="classes.encode" value="GBK" />  
  9.     <property name="lib" value="libs" />  
  10.       
  11.     <property  
  12.         name="project-dir"  
  13.         value="C:\Users\i\workspace\AntExportJar" />  
  14.     <property  
  15.         name="sdk-folder"  
  16.         value="C:\Users\i\AppData\Local\Android\sdk" />  
  17.     <property  
  18.         name="platform-folder"  
  19.         value="${sdk-folder}\platforms\android-22" />  
  20.     <property  
  21.         name="android-jar"  
  22.         value="${platform-folder}\android.jar" />  
  23.     <property  
  24.         name="src"  
  25.         value="${project-dir}\src" />  
  26.     <property  
  27.         name="bin"  
  28.         value="${project-dir}\bin" />  
  29.     <property  
  30.         name="libs"  
  31.         value="${project-dir}\lib" />  
  32.   
  33.     <!-- task -->  
  34.     <target name="init" >  
  35.         <echo>  
  36.             Initialize...  
  37.         </echo>  
  38.         <delete dir="${bin}" />  
  39.         <mkdir dir="${bin}" />  
  40.     </target>  
  41.       
  42.     <target name="buildFiles" depends="init">  
  43.         <javac  
  44.                 bootclasspath="${android-jar}"  
  45.                 compiler="javac1.7"  
  46.                 target="1.7"  
  47.                 destdir="${bin}"  
  48.                 encoding="GBK"  
  49.                 includeAntRuntime="true"  
  50.                 listfiles="true">  
  51.                 <src path="${project-dir}"/>   
  52.                 <classpath>  
  53.                      <!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->  
  54.                      <fileset dir="${libs}" includes="*.jar" />  
  55.                 </classpath>  
  56.         </javac>  
  57.     </target>  
  58.       
  59.     <!-- 导出jar文件 -->  
  60.     <target name="exportJar" depends="buildFiles">  
  61.         <delete dir="${dist}" />  
  62.         <!-- Create the distribution directory -->  
  63.         <mkdir dir="${dist}" />  
  64.         <!-- Put everything in ${classes} into the MyProject-${DSTAMP}.jar file -->  
  65.         <jar jarfile="${dist}/${app.name}.jar" basedir="${bin}">  
  66.             <!--  
  67.             <fileset dir="${libs}" includes="**/*.jar" /> 
  68.             -->  
  69.             <zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" />    
  70.             <zipfileset excludes="META-INF/*.SF" src="${libs}/gdt_mob_release.jar" />    
  71.         </jar>  
  72.     </target>  
  73. </project>  
<?xml version="1.0" encoding="UTF-8"?>
<project name="AntExportJar" basedir="." default="exportJar">
	<!-- 设置全局变量 -->
	<property name="src" value="src" />
	<property name="dist" value="dist" />
	<property name="app.name" value="ant" />
	<property name="app.version" value="1.0" />
	<property name="classes.encode" value="GBK" />
	<property name="lib" value="libs" />
    
    <property
        name="project-dir"
        value="C:\Users\i\workspace\AntExportJar" />
    <property
        name="sdk-folder"
        value="C:\Users\i\AppData\Local\Android\sdk" />
    <property
        name="platform-folder"
        value="${sdk-folder}\platforms\android-22" />
    <property
        name="android-jar"
        value="${platform-folder}\android.jar" />
    <property
        name="src"
        value="${project-dir}\src" />
    <property
        name="bin"
        value="${project-dir}\bin" />
    <property
        name="libs"
        value="${project-dir}\lib" />

    <!-- task -->
    <target name="init" >
        <echo>
			Initialize...
        </echo>
        <delete dir="${bin}" />
        <mkdir dir="${bin}" />
    </target>
    
    <target name="buildFiles" depends="init">
		<javac
	            bootclasspath="${android-jar}"
	            compiler="javac1.7"
	            target="1.7"
	            destdir="${bin}"
	            encoding="GBK"
	            includeAntRuntime="true"
	            listfiles="true">
	            <src path="${project-dir}"/> 
	            <classpath>
	                 <!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->
	                 <fileset dir="${libs}" includes="*.jar" />
	            </classpath>
	    </javac>
    </target>
    
	<!-- 导出jar文件 -->
	<target name="exportJar" depends="buildFiles">
		<delete dir="${dist}" />
		<!-- Create the distribution directory -->
		<mkdir dir="${dist}" />
		<!-- Put everything in ${classes} into the MyProject-${DSTAMP}.jar file -->
		<jar jarfile="${dist}/${app.name}.jar" basedir="${bin}">
		    <!-- 
		    <fileset dir="${libs}" includes="**/*.jar" />
		    -->
		    <zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" />  
            <zipfileset excludes="META-INF/*.SF" src="${libs}/gdt_mob_release.jar" />  
		</jar>
	</target>
</project>
脚本很简单,下面我们就来分析一下:
  1. <project name="AntExportJar" basedir="." default="exportJar">  
<project name="AntExportJar" basedir="." default="exportJar">

最外围的一个标签是project,是一个工程标签,有名字,还有就是工程的目录baseDir,用点号:"."

接下来就是定义全局变量,或者是属性值:

  1. <!-- 设置全局变量 -->  
  2. <property name="src" value="src" />  
  3. <property name="dist" value="dist" />  
  4. <property name="app.name" value="ant" />  
  5. <property name="app.version" value="1.0" />  
  6. <property name="classes.encode" value="GBK" />  
  7. <property name="lib" value="libs" />  
  8.   
  9. <property  
  10.     name="project-dir"  
  11.     value="C:\Users\i\workspace\AntExportJar" />  
  12. <property  
  13.     name="sdk-folder"  
  14.     value="C:\Users\i\AppData\Local\Android\sdk" />  
  15. <property  
  16.     name="platform-folder"  
  17.     value="${sdk-folder}\platforms\android-22" />  
  18. <property  
  19.     name="android-jar"  
  20.     value="${platform-folder}\android.jar" />  
  21. <property  
  22.     name="src"  
  23.     value="${project-dir}\src" />  
  24. <property  
  25.     name="bin"  
  26.     value="${project-dir}\bin" />  
  27. <property  
  28.     name="libs"  
  29.     value="${project-dir}\lib" />  
<!-- 设置全局变量 -->
<property name="src" value="src" />
<property name="dist" value="dist" />
<property name="app.name" value="ant" />
<property name="app.version" value="1.0" />
<property name="classes.encode" value="GBK" />
<property name="lib" value="libs" />

<property
	name="project-dir"
	value="C:\Users\i\workspace\AntExportJar" />
<property
	name="sdk-folder"
	value="C:\Users\i\AppData\Local\Android\sdk" />
<property
	name="platform-folder"
	value="${sdk-folder}\platforms\android-22" />
<property
	name="android-jar"
	value="${platform-folder}\android.jar" />
<property
	name="src"
	value="${project-dir}\src" />
<property
	name="bin"
	value="${project-dir}\bin" />
<property
	name="libs"
	value="${project-dir}\lib" />
这样我们在后面就可以使用:${name值} 来使用value值的定义了,所以这里就相当于定义了变量的作用,这里我们看到有一些value值是路径,但是这里我们感觉有一个不好的地方,就是这些路径是写死的,那么我们还可以怎么做能让他变得灵活呢?其实很简单,ant脚本中是可以访问环境变量的,那么我们只要将这些路径定义成环境变量就可以了:

  1. <property environment="env"/>  
  2. <property name="ANDROID_HOME" value="${env.ANDROID_HOME}" />  
<property environment="env"/>
<property name="ANDROID_HOME" value="${env.ANDROID_HOME}" />
第一行先申明一个环境变量值,这个env是公共的写法,也是ant自带的,他表示当前的环境变量的值,那么后面就可以访问具体的哪些环境变量了,比如这里我配置了ANDROID_HOME这个环境变量,那么就可以用${env.ANDROID_HOME}来访问androidsdk的目录了,和上面的那个直接使用绝对路径的方式是一样的。

解析来就是定义task了,在ant中task也是最重要的,我们最终运行的都是task,就相当于Java中的main方法一样。ant脚本中可以定义多个task,而且每个task可以有执行的先后顺序的。相当于Java中的方法中调用其他方法一样。

  1. <!-- task -->  
  2. <target name="init" >  
  3.     <echo>  
  4.         Initialize...  
  5.     </echo>  
  6.     <delete dir="${bin}" />  
  7.     <mkdir dir="${bin}" />  
  8. </target>  
<!-- task -->
<target name="init" >
	<echo>
		Initialize...
	</echo>
	<delete dir="${bin}" />
	<mkdir dir="${bin}" />
</target>
首先这里定义了一个初始化的task,其中echo标签也是很常用的,就是打印信息的,然后是删除目录${bin},这个bin变量在上面已经定义了,然后在创建${bin}目录。

初始化完之后,开始执行编译工作:

  1. <target name="buildFiles" depends="init">  
  2.     <javac  
  3.         bootclasspath="${android-jar}"  
  4.         compiler="javac1.7"  
  5.         target="1.7"  
  6.         destdir="${bin}"  
  7.         encoding="GBK"  
  8.         includeAntRuntime="true"  
  9.         listfiles="true">  
  10.         <src path="${project-dir}"/>   
  11.             <classpath>  
  12.                 <!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->  
  13.                 <fileset dir="${libs}" includes="*.jar" />  
  14.             </classpath>  
  15.     </javac>  
  16. </target>  
<target name="buildFiles" depends="init">
	<javac
		bootclasspath="${android-jar}"
		compiler="javac1.7"
		target="1.7"
		destdir="${bin}"
		encoding="GBK"
		includeAntRuntime="true"
		listfiles="true">
		<src path="${project-dir}"/> 
			<classpath>
				<!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->
				<fileset dir="${libs}" includes="*.jar" />
			</classpath>
	</javac>
</target>

这里在此定义一个buildFiles的task,depends的值是表示当前的task在这个depends的task执行完之后在执行,这里就是先执行init的task,然后在执行buildFiles的task,这里的task主要是编译Java成class文件:

bootclasspath:表示编译依赖的系统库,这里依赖的是Android.jar

compiler:表示编译的java版本

target:表示编译之后的class的版本,就是能够运行的java版本

destDir:表示编译之后的class文件的存放目录

其他的就不说了,这里还有一个重点,也就是我们在编译的时候会遇到的问题,就是我们在编译的时候,会引用到第三发的jar,所以这里我们为了保证能够编译过,这里还必须用classpath标签来引用这些jar,当然这里只是能够保证编译通过,并不会把这些jar也编译到最终我们想要的jar中,这个问题我们后面再说。

下面在看最后的一个task,就是将编译完之后的class文件打包成jar文件:

  1. <!-- 导出jar文件 -->  
  2. <target name="exportJar" depends="buildFiles">  
  3.     <delete dir="${dist}" />  
  4.     <!-- Create the distribution directory -->  
  5.     <mkdir dir="${dist}" />  
  6.     <!-- Put everything in ${classes} into the MyProject-${DSTAMP}.jar file -->  
  7.     <jar jarfile="${dist}/${app.name}.jar" basedir="${bin}">  
  8.         <!--  
  9.         <fileset dir="${libs}" includes="**/*.jar" /> 
  10.         -->  
  11.     <zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" />    
  12.     <zipfileset excludes="META-INF/*.SF" src="${libs}/gdt_mob_release.jar" />    
  13.     </jar>  
  14. </target>  
<!-- 导出jar文件 -->
<target name="exportJar" depends="buildFiles">
	<delete dir="${dist}" />
	<!-- Create the distribution directory -->
	<mkdir dir="${dist}" />
	<!-- Put everything in ${classes} into the MyProject-${DSTAMP}.jar file -->
	<jar jarfile="${dist}/${app.name}.jar" basedir="${bin}">
		<!-- 
		<fileset dir="${libs}" includes="**/*.jar" />
		-->
	<zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" />  
	<zipfileset excludes="META-INF/*.SF" src="${libs}/gdt_mob_release.jar" />  
	</jar>
</target>
这里我们定义了一个exportJar的task,他是在buildFiles的task运行完之后在运行。

首先删除目标目录${dist},然后在创建一个目录。这个目录就是存放最后编译好的jar文件的目录

然后就是用jar标签来导出jar文件了:

jarfile:表示编译完之后存放的jar文件名路径

basedir:表示需要编译jar的class文件目录

其他就OK了,但是在实际中我们在编译的过程中会引用到第三方的jar,那么这时候我们把这些jar编译到最终的jar中,说道这里,其实我们在使用Eclipse导出jar的时候,有一个插件可以做到这点:fat-jar,安装完插件之后,右击工程会出现此菜单:


这样也可以导出第三方的jar.

那么在ant中我们如何导出第三方的jar呢?

这里也很简单:

  1. <zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" />   
<zipfileset excludes="META-INF/*.SF" src="${libs}/Baidu_NativeAd_SDK.jar" /> 
使用zipfileset标签就可以了。

excludes:表示剔除这个文件,意思就是不要把第三方的jar中的*.SF文件打包进去

src:表示需要打包的第三方jar

那么到这里我们就介绍完了ant脚本,其实还有很多标签和功能这里都没有在介绍了,当然这里也不会详细的介绍,如果后面遇到有问题的或者不知道的功能可以搜一下就可以了,下面我们就来跑这个脚本了。

首先进入到build.xml脚本的根目录下面,然后运行:ant exportJar

这里的exportJar是上面我们定义的最后一个task的名称,也就是脚本的入口task

这里还需要注意的一个问题就是,ant运行的目录下面一定要有build.xml,因为这个是ant需要寻找到的文件才可以解析运行。


运行完之后,我们再看看dist目录下:


有了这个ant.jar包了,成功了,我们用jd-gui工具查看jar:


看到了,这里把第三方的两个jar包含进来了吧。


项目下载地址:http://download.csdn.net/detail/jiangwei0910410003/9444178


三、使用ant脚本编译apk包

下面我们继续来介绍如何使用ant脚本编译出一个apk包

首先我们需要了解的是Android中编译一个apk包的流程和步骤,其实这个我在之前的一篇解析resource.arsc文件格式的文章末尾介绍了一下:http://blog.csdn.net/jiangwei0910410003/article/details/50628894

1、使用Android SDK提供的aapt.exe生成R.java类文件
2、使用Android SDK提供的aidl.exe把.aidl转成.java文件(如果没有aidl,则跳过这一步)
3、使用JDK提供的javac.exe编译.java类文件生成class文件
4、使用Android SDK提供的dx.bat命令行脚本生成classes.dex文件
5、使用Android SDK提供的aapt.exe生成资源包文件(包括res、assets、androidmanifest.xml等)
6、使用Android SDK提供的apkbuilder.bat生成未签名的apk安装文件
7、使用jdk的jarsigner.exe对未签名的包进行apk签名


那么这些步骤AndroidSdk在build-tools目录下面全部提供了相对应的工具,这里就来一一介绍一下:

1、使用aapt命令编译资源文件

aapt package -f -m -J gen -S res -I D:/android-sdk-windows/platforms/android-16/android.jar -M AndroidManifest.xml 

这里的命令参数有点多就不全部介绍了,就说明几个:

-J 后面跟着是gen目录,也就是编译之后产生的R类,存放的资源Id

-S 后面跟着是res目录,也就是需要编译的资源目录

-l 后面跟着是系统的库,因为我们在项目资源中会用到系统的一些资源文件,所以这里需要链接一下

-M 后面跟着是工程的清单文件,需要从这个文件中得到应用的包名,然后产生对应的R文件和包名。


2、使用javac命令编译源文件

javac -target 1.6 -bootclasspath D:/android-sdk-windows/platforms/android-17/android.jar -d bin gen\com\example\antdemo\*.java src\com\example\antdemo\*.java

这里的参数没什么好说的,其实都很简单

-target:表示编译之后的class文件运行的环境版本

-bootclasspath:表示编译需要用到的系统库

-d:表示编译之后的class文件存放的目录

后面就是需要编译的java文件了,不同的包下面的java文件,可以用空格分开即可,这里需要编译gen目录下面的java文件,和src下面的所有java文件。


3、使用dx命令,将class文件转化成dex

dx --dex --output=G:\Code\Android\Workspace\AntDemo\bin\classes.dex G:\Code\Android\Workspace\AntDemo\bin

这个命令简单,这里就不说了,而且这个命令我在很多篇文章中都用到,他的作用还是很大的。


4、使用aapt命令生成资源包文件(编码AndroidManifest.xml,resource.arsc等)

aapt package -f -A assets -S res -I D:/android-sdk-windows/platforms/android-17/android.jar -M AndroidManifest.xml -F bin/AntDemo

这个命令其实就是将资源文件进行编码成二进制文件,我们之前介绍的一篇文章中,就是解析这些二进制文件:

http://blog.csdn.net/jiangwei0910410003/article/details/50669898

这些二进制文件都是有自己的格式的,系统编程二进制文件是为了优化,减小包的大小。

但是这里需要注意的是assets目录是不会进行二进制编译的。


5、使用apkbuilder命令来编译apk

apkbuilder G:\Code\Android\Workspace\AntDemo\bin\AntDemo_unsigned.apk -v -u -z G:\Code\Android\Workspace\AntDemo\bin\AntDemo -f G:\Code\Android\Workspace\AntDemo\bin\classes.dex -rf G:\Code\Android\Workspace\AntDemo\src 

这里的一些参数也没什么好说的,但是这里需要注意的是,在AndroidSDK的高版本之后,这个命令是找不到了,被遗弃了,所以我们可以从网上下载一个老版本的命令:查看他的类型,其实是调用了androidsdk根目录/tools/lib/sdklib.jar 这个jar包,后面我们在ant脚本中会看到怎么用。



6、使用keytool来产生一个keystore文件

keytool -genkey -alias ant_test1 -keyalg RSA -validity 20000 -keystore my.keystore

这个命令网上也是有说明的,具体参数这里不多说了


7、使用jarsigner签名apk文件

jarsigner -keystore G:\Code\Android\Workspace\AntDemo\build\my.keystore -storepass 123456 -keypass 123456 -signedjar G:\Code\Android\Workspace\AntDemo\bin\AntDemo_signed.apk G:\Code\Android\Workspace\AntDemo\bin\AntDemo_unsigned.apk ant_test

关于这个命令和signapk命令都可以进行签名apk的,具体他们两什么区别可以参考这篇文章:

http://blog.csdn.net/jiangwei0910410003/article/details/50402000


好了,到此我们就介绍完了如何使用纯手工命令来编译一个apk文件,不需要借助任何的IDE工具也是可以做到的,其实为什么先介绍这些命令呢?就是为了下面需要介绍的ant脚本,其实这个脚本就是新建这几个task,然后设置到命令环境变量,最后执行这些命令,所以脚本内容这里就不在一一讲解了:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <project  
  3.     name="AntDemo"  
  4.     default="release" >  
  5.     <!-- tools dir -->  
  6.     <property  
  7.         name="sdk-folder"  
  8.         value="C:\Users\i\AppData\Local\Android\sdk" />  
  9.     <property  
  10.         name="platform-folder"  
  11.         value="${sdk-folder}\platforms\android-22" />  
  12.     <property  
  13.         name="platform-tools-folder"  
  14.         value="${sdk-folder}\build-tools\22.0.1" />  
  15.     <property  
  16.         name="jdk-folder"  
  17.         value="C:\Program Files\Java\jdk1.7.0_71" />  
  18.     <property  
  19.         name="android-jar"  
  20.         value="${platform-folder}\android.jar" />  
  21.     <property  
  22.         name="tools.aapt"  
  23.         value="${platform-tools-folder}\aapt.exe" />  
  24.     <property  
  25.         name="tools.javac"  
  26.         value="${jdk-folder}\bin\javac.exe" />  
  27.     <property  
  28.         name="tools.dx"  
  29.         value="${platform-tools-folder}\dx.bat" />  
  30.     <property  
  31.         name="tools.apkbuilder"  
  32.         value="${sdk-folder}\tools\apkbuilder.bat" />  
  33.     <property  
  34.         name="tools.jarsigner"  
  35.         value="${jdk-folder}\bin\jarsigner.exe" />  
  36.   
  37.     <!-- project dir -->  
  38.     <property  
  39.         name="project-dir"  
  40.         value="C:\Users\i\Desktop\AntDemo\AntDemo" />  
  41.     <property  
  42.         name="res"  
  43.         value="${project-dir}\res" />  
  44.     <property  
  45.         name="gen"  
  46.         value="${project-dir}\gen" />  
  47.     <property  
  48.         name="src"  
  49.         value="${project-dir}\src" />  
  50.     <property  
  51.         name="bin"  
  52.         value="${project-dir}\bin" />  
  53.     <property  
  54.         name="assets"  
  55.         value="${project-dir}\assets" />  
  56.     <property  
  57.         name="libs"  
  58.         value="${project-dir}\libs" />  
  59.   
  60.     <!-- file lists -->  
  61.     <property  
  62.         name="manifest"  
  63.         value="${project-dir}\AndroidManifest.xml" />  
  64.     <property  
  65.         name="java-file-gen"  
  66.         value="${gen}\com\example\antdemo\*.java" />  
  67.     <property  
  68.         name="java-file-src"  
  69.         value="${src}\com\example\antdemo\*.java" />  
  70.     <property  
  71.         name="dex-name"  
  72.         value="${bin}\classes.dex" />  
  73.     <property  
  74.         name="pakcage-temp-name"  
  75.         value="${bin}\${ant.project.name}" />  
  76.     <property  
  77.         name="unsigned-apk-name"  
  78.         value="${ant.project.name}_unsigned.apk" />  
  79.     <property  
  80.         name="unsigned-apk-path"  
  81.         value="${bin}\${unsigned-apk-name}" />  
  82.     <property  
  83.         name="signed-apk-name"  
  84.         value="${ant.project.name}.apk" />  
  85.     <property  
  86.         name="signed-apk-path"  
  87.         value="${bin}\${signed-apk-name}" />  
  88.     <property  
  89.         name="keystore-name"  
  90.         value="${project-dir}\my.keystore" />  
  91.     <property  
  92.         name="keystore-alias"  
  93.         value="ant_test" />  
  94.   
  95.     <!-- task -->  
  96.     <target name="init" >  
  97.         <echo>  
  98.             Initialize...  
  99.         </echo>  
  100.         <delete dir="${bin}" />  
  101.         <mkdir dir="${bin}" />  
  102.     </target>  
  103.   
  104.     <target  
  105.         name="gen-R"  
  106.         depends="init" >  
  107.         <echo>  
  108.             Generating R.java from the resources...   
  109.         </echo>  
  110.         <exec  
  111.             executable="${tools.aapt}"  
  112.             failonerror="true" >  
  113.             <arg value="package" />  
  114.             <arg value="-f" />  
  115.             <arg value="-m" />  
  116.             <arg value="-J" />  
  117.             <arg value="${gen}" />  
  118.             <arg value="-S" />  
  119.             <arg value="${res}" />  
  120.             <arg value="-M" />  
  121.             <arg value="${manifest}" />  
  122.             <arg value="-I" />  
  123.             <arg value="${android-jar}" />  
  124.         </exec>  
  125.     </target>  
  126.   
  127.     <target  
  128.         name="compile"  
  129.         depends="gen-R" >  
  130.         <echo>  
  131.             Compile...  
  132.         </echo>  
  133.         <javac  
  134.             bootclasspath="${android-jar}"  
  135.             compiler="javac1.7"  
  136.             target="1.7"  
  137.             destdir="${bin}"  
  138.             encoding="utf-8"  
  139.             includeAntRuntime="true"  
  140.             listfiles="true">  
  141.             <src path="${project-dir}"/>   
  142.             <classpath>  
  143.                  <!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->  
  144.                  <fileset dir="${libs}" includes="*.jar" />  
  145.             </classpath>  
  146.         </javac>  
  147.     </target>  
  148.   
  149.     <target  
  150.         name="dex"  
  151.         depends="compile" >  
  152.         <echo>  
  153.             Generate dex...  
  154.         </echo>  
  155.         <exec  
  156.             executable="${tools.dx}"  
  157.             failonerror="true" >  
  158.             <arg value="--dex" />  
  159.             <arg value="--output=${dex-name}" />  
  160.             <arg value="${bin}" /><!-- classes文件位置 -->  
  161.             <arg value="${libs}"/><!-- 把libs下所有jar打包 -->  
  162.         </exec>  
  163.     </target>  
  164.   
  165.     <target  
  166.         name="package"  
  167.         depends="dex" >  
  168.         <echo>  
  169.             Package resource and assets...  
  170.         </echo>  
  171.         <exec  
  172.             executable="${tools.aapt}"  
  173.             failonerror="true" >  
  174.             <arg value="package" />  
  175.             <arg value="-f" />  
  176.             <arg value="-A" />  
  177.             <arg value="${assets}" />  
  178.             <arg value="-S" />  
  179.             <arg value="${res}" />  
  180.             <arg value="-I" />  
  181.             <arg value="${android-jar}" />  
  182.             <arg value="-M" />  
  183.             <arg value="${manifest}" />  
  184.             <arg value="-F" />  
  185.             <arg value="${pakcage-temp-name}" />  
  186.         </exec>  
  187.     </target>  
  188.   
  189.     <target  
  190.         name="build-unsigned-apk"  
  191.         depends="package" >  
  192.         <echo>  
  193.             Build unsigned apk  
  194.         </echo>  
  195.         <!--  
  196.         <exec  
  197.             executable="${tools.apkbuilder}"  
  198.             failonerror="true" >  
  199.             <arg value="${unsigned-apk-path}" />  
  200.             <arg value="-v" />  
  201.             <arg value="-u" />  
  202.             <arg value="-z" />  
  203.             <arg value="${pakcage-temp-name}" />  
  204.             <arg value="-f" />  
  205.             <arg value="${dex-name}" />  
  206.             <arg value="-rf" />  
  207.             <arg value="${src}" />  
  208.         </exec>  
  209.         -->  
  210.           
  211.         <java classpath="${sdk-folder}/tools/lib/sdklib.jar" classname="com.android.sdklib.build.ApkBuilderMain">    
  212.             <arg value="${unsigned-apk-path}" />    
  213.             <arg value="-u" />    
  214.             <arg value="-z" />    
  215.             <arg value="${pakcage-temp-name}" />    
  216.             <arg value="-f" />    
  217.             <arg value="${dex-name}" />    
  218.             <arg value="-rf" />      
  219.             <arg value="${src}" />     
  220.             <arg value="-rj"/>    
  221.             <arg value="${libs}"/>     
  222.         </java>   
  223.           
  224.     </target>  
  225.       
  226.     <target  
  227.         name="sign-apk"  
  228.         depends="build-unsigned-apk" >  
  229.         <echo>  
  230.             Sign apk  
  231.         </echo>  
  232.         <exec  
  233.             executable="${tools.jarsigner}"  
  234.             failonerror="true" >  
  235.             <arg value="-keystore" />  
  236.             <arg value="${keystore-name}" />  
  237.             <arg value="-storepass" />  
  238.             <arg value="123456" />  
  239.             <arg value="-keypass" />  
  240.             <arg value="123456" />  
  241.             <arg value="-signedjar" />  
  242.             <arg value="${signed-apk-path}" />  
  243.             <arg value="${unsigned-apk-path}" />  
  244.             <arg value="${keystore-alias}" />  
  245.         </exec>  
  246.     </target>  
  247.   
  248.     <target  
  249.         name="release"  
  250.         depends="sign-apk" >  
  251.         <delete file="${pakcage-temp-name}" />  
  252.         <delete file="${unsigned-apk-path}" />  
  253.         <echo>  
  254.             APK is released. path:${signed-apk-path}  
  255.         </echo>  
  256.     </target>  
  257.   
  258. </project>  
<?xml version="1.0" encoding="UTF-8"?>
<project
    name="AntDemo"
    default="release" >
    <!-- tools dir -->
    <property
        name="sdk-folder"
        value="C:\Users\i\AppData\Local\Android\sdk" />
    <property
        name="platform-folder"
        value="${sdk-folder}\platforms\android-22" />
    <property
        name="platform-tools-folder"
        value="${sdk-folder}\build-tools\22.0.1" />
    <property
        name="jdk-folder"
        value="C:\Program Files\Java\jdk1.7.0_71" />
    <property
        name="android-jar"
        value="${platform-folder}\android.jar" />
    <property
        name="tools.aapt"
        value="${platform-tools-folder}\aapt.exe" />
    <property
        name="tools.javac"
        value="${jdk-folder}\bin\javac.exe" />
    <property
        name="tools.dx"
        value="${platform-tools-folder}\dx.bat" />
    <property
        name="tools.apkbuilder"
        value="${sdk-folder}\tools\apkbuilder.bat" />
    <property
        name="tools.jarsigner"
        value="${jdk-folder}\bin\jarsigner.exe" />

    <!-- project dir -->
    <property
        name="project-dir"
        value="C:\Users\i\Desktop\AntDemo\AntDemo" />
    <property
        name="res"
        value="${project-dir}\res" />
    <property
        name="gen"
        value="${project-dir}\gen" />
    <property
        name="src"
        value="${project-dir}\src" />
    <property
        name="bin"
        value="${project-dir}\bin" />
    <property
        name="assets"
        value="${project-dir}\assets" />
    <property
        name="libs"
        value="${project-dir}\libs" />

	<!-- file lists -->
    <property
        name="manifest"
        value="${project-dir}\AndroidManifest.xml" />
    <property
        name="java-file-gen"
        value="${gen}\com\example\antdemo\*.java" />
    <property
        name="java-file-src"
        value="${src}\com\example\antdemo\*.java" />
    <property
        name="dex-name"
        value="${bin}\classes.dex" />
    <property
        name="pakcage-temp-name"
        value="${bin}\${ant.project.name}" />
    <property
        name="unsigned-apk-name"
        value="${ant.project.name}_unsigned.apk" />
    <property
        name="unsigned-apk-path"
        value="${bin}\${unsigned-apk-name}" />
    <property
        name="signed-apk-name"
        value="${ant.project.name}.apk" />
    <property
        name="signed-apk-path"
        value="${bin}\${signed-apk-name}" />
    <property
        name="keystore-name"
        value="${project-dir}\my.keystore" />
    <property
        name="keystore-alias"
        value="ant_test" />

    <!-- task -->
    <target name="init" >
        <echo>
			Initialize...
        </echo>
        <delete dir="${bin}" />
        <mkdir dir="${bin}" />
    </target>

    <target
        name="gen-R"
        depends="init" >
        <echo>
			Generating R.java from the resources... 
        </echo>
        <exec
            executable="${tools.aapt}"
            failοnerrοr="true" >
            <arg value="package" />
            <arg value="-f" />
            <arg value="-m" />
            <arg value="-J" />
            <arg value="${gen}" />
            <arg value="-S" />
            <arg value="${res}" />
            <arg value="-M" />
            <arg value="${manifest}" />
            <arg value="-I" />
            <arg value="${android-jar}" />
        </exec>
    </target>

    <target
        name="compile"
        depends="gen-R" >
        <echo>
			Compile...
        </echo>
        <javac
            bootclasspath="${android-jar}"
            compiler="javac1.7"
            target="1.7"
            destdir="${bin}"
            encoding="utf-8"
            includeAntRuntime="true"
            listfiles="true">
            <src path="${project-dir}"/> 
            <classpath>
                 <!-- 引用第三方jar包需要引用,用于辅助编译,并没有将jar打包进去。jar的打包在dex命令中。-->
                 <fileset dir="${libs}" includes="*.jar" />
            </classpath>
        </javac>
    </target>

    <target
        name="dex"
        depends="compile" >
        <echo>
			Generate dex...
        </echo>
        <exec
            executable="${tools.dx}"
            failοnerrοr="true" >
            <arg value="--dex" />
            <arg value="--output=${dex-name}" />
            <arg value="${bin}" /><!-- classes文件位置 -->
            <arg value="${libs}"/><!-- 把libs下所有jar打包 -->
        </exec>
    </target>

    <target
        name="package"
        depends="dex" >
        <echo>
   			Package resource and assets...
        </echo>
        <exec
            executable="${tools.aapt}"
            failοnerrοr="true" >
            <arg value="package" />
            <arg value="-f" />
            <arg value="-A" />
            <arg value="${assets}" />
            <arg value="-S" />
            <arg value="${res}" />
            <arg value="-I" />
            <arg value="${android-jar}" />
            <arg value="-M" />
            <arg value="${manifest}" />
            <arg value="-F" />
            <arg value="${pakcage-temp-name}" />
        </exec>
    </target>

    <target
        name="build-unsigned-apk"
        depends="package" >
        <echo>
  			Build unsigned apk
        </echo>
        <!--
        <exec
            executable="${tools.apkbuilder}"
            failοnerrοr="true" >
            <arg value="${unsigned-apk-path}" />
            <arg value="-v" />
            <arg value="-u" />
            <arg value="-z" />
            <arg value="${pakcage-temp-name}" />
            <arg value="-f" />
            <arg value="${dex-name}" />
            <arg value="-rf" />
            <arg value="${src}" />
        </exec>
        -->
        
        <java classpath="${sdk-folder}/tools/lib/sdklib.jar" classname="com.android.sdklib.build.ApkBuilderMain">  
            <arg value="${unsigned-apk-path}" />  
            <arg value="-u" />  
            <arg value="-z" />  
            <arg value="${pakcage-temp-name}" />  
            <arg value="-f" />  
            <arg value="${dex-name}" />  
            <arg value="-rf" />    
            <arg value="${src}" />   
            <arg value="-rj"/>  
            <arg value="${libs}"/>   
        </java> 
        
    </target>
    
    <target
        name="sign-apk"
        depends="build-unsigned-apk" >
        <echo>
  			Sign apk
        </echo>
        <exec
            executable="${tools.jarsigner}"
            failοnerrοr="true" >
            <arg value="-keystore" />
            <arg value="${keystore-name}" />
            <arg value="-storepass" />
            <arg value="123456" />
            <arg value="-keypass" />
            <arg value="123456" />
            <arg value="-signedjar" />
            <arg value="${signed-apk-path}" />
            <arg value="${unsigned-apk-path}" />
            <arg value="${keystore-alias}" />
        </exec>
    </target>

    <target
        name="release"
        depends="sign-apk" >
        <delete file="${pakcage-temp-name}" />
        <delete file="${unsigned-apk-path}" />
        <echo>
			APK is released. path:${signed-apk-path}
        </echo>
    </target>

</project>
使用ant跑一下脚本: ant release


我们再看一下bin目录下,产生了最终的apk脚本了。


其实从这里我们看到,我们不借助ant脚本,自己编写一个bat脚本也是可以做到的,就是顺序的执行这7条命令即可。

项目下载:http://download.csdn.net/detail/jiangwei0910410003/9444220


到这里我们就介绍完了,如何使用ant脚本打包jar和apk,这里我也是第一次用ant脚本,感觉他的作用还是蛮大的,在编译的大家庭中,他也是一个重要的角色。


四、技术概要

1、学习了ant脚本的基本语法和简单标签

2、如何使用ant脚本打包携带第三方jar的工程为jar

3、学会了Android中apk包产生的步骤了流程以及各个流程用到的命令

4、最重要的是学习到了如何不借助任何的IDE工具就可以打出一个apk包


五、总结

这篇文章的易读性还是可以的,没什么难点,就是自己在实际的项目中遇到了一些问题,就总结了一下,网上的资料也比较多,也很杂,所以这里也算是记录了一些,当然关于ant脚本更深入的内容,这里并没有介绍了,比如使用ant脚本编译出各个渠道包,这些网上有很多资料,但是写了这篇文章之后最大的感触是,有时候我们太依赖于IDE这样的工具,导致我们队整个项目的编译过程知道的少之又少,所以使用Linux系统会比使用Windows系统学习到的更多,因为Windows系统已经把我们当做傻瓜看待,什么都帮我们做好了,我只要点击下一步就可以了,所以对于技术开发来说,学习到的肯定也是好了。

PS: 关注微信,最新Android技术实时推送

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: ant.jar包是Apache Ant项目的核心组件之一,它的作用是提供了Ant构建工具的运行环境和功能支持。 Ant是一种基于Java的构建工具,它用于自动化软件构建过程。Ant使用XML文件作为构建脚本,通过定义一系列的任务和目标来描述软件的构建过程。而ant.jar包则是Ant运行所必需的,它含了Ant运行时所需的类库和资源文件。 具体来说,ant.jar包的功能括: 首先,ant.jar包提供了Ant任务的执行引擎。它可以解析构建脚本,执行任务并控制任务的执行顺序,从而实现整个构建过程的自动化。 其次,ant.jar包提供了一系列的核心任务和类型。这些任务和类型括文件操作、编译、打、文档生成等等,可以满足不同项目的构建需求。开发人员可以根据具体的项目需求,选择适当的任务和类型来完成构建过程中的各种操作。 此外,ant.jar包还提供了丰富的插件支持。开发人员可以将自定义的任务和类型打为插件,然后通过ant.jar包将这些插件集成到Ant的运行环境中,从而扩展Ant的功能。这使得Ant可以灵活应对各种构建需求,满足不同项目的特殊要求。 总之,ant.jar包Ant构建工具的核心组件之一,它提供了Ant运行环境和功能支持,使得开发人员可以通过Ant实现软件构建的自动化,并根据项目需求灵活扩展功能。 ### 回答2: ant.jar包是Apache Ant工具的核心库文件,它是一种用于构建Java应用程序的自动化构建工具。Ant是基于Java的构建工具,用于编译、测试和打Java项目,以及执行各种构建任务。ant.jar包的作用是为Ant提供必要的类和方法,以支持Ant自身的功能和扩展。 ant.jar包含了Ant的核心类和任务,其中括了任务执行流程的控制、构建目标的定义和执行、文件操作、运行系统命令、资源管理等功能。通过引入ant.jar包,可以在Java项目中通过Ant脚本来定义和执行构建任务,提高了项目构建的效率和可维护性。 ant.jar包具有以下功能和特点: 1. 定义构建目标和任务:通过ant.jar包,可以使用Ant的XML脚本语言来定义构建目标和任务,按照需要执行编译、测试、打等构建任务。 2. 跨平台支持:Ant是基于Java的,因此ant.jar包可以在不同的操作系统上运行,实现跨平台的构建工作。 3. 灵活性和可扩展性:ant.jar包Ant工具的核心库文件,提供了大量的任务和扩展点,用户可以根据自己的需求和项目要求来编写自定义的任务和扩展。 4. 集成第三方工具:ant.jar包可以与其他开发工具和构建工具(如JUnit、Ivy等)进行集成,方便进行项目管理和构建工作。 5. 构建任务的自动化:通过ant.jar包,可以自动执行一系列编译、打、部署等构建任务,减少了手动执行这些任务的工作量。 总而言之,ant.jar包是Apache Ant工具的核心库文件,为Ant提供必要的类和方法,实现了自动化构建和项目管理的功能,提高了Java项目的开发效率和可维护性。 ### 回答3: ant.jar是Apache Ant工具的核心库文件,它主要用于构建和自动化构建过程中使用的任务和操作。具体来说,ant.jar包的作用括以下几个方面: 1. 构建自动化:ant.jar提供了一组任务和操作,可以通过编写Ant构建文件来定义和执行各种构建过程。开发人员可以使用Ant的任务来编译源代码、打应用程序、运行单元测试、生成文档等,从而实现构建自动化。 2. 构建管理:ant.jar支持将构建过程分解为多个独立的目标和任务,以及定义它们之间的依赖关系。这使得构建过程更加模块化和可管理,开发人员可以根据需要选择性地执行某些目标,或者定义特定的构建流程。 3. 跨平台性:ant.jar是基于Java的,因此可以在多个操作系统平台上运行。开发人员可以使用相同的Ant构建文件在不同的平台上执行构建过程,无需担心平台差异和兼容性问题。 4. 扩展性:ant.jar提供了插件机制,开发人员可以编写自定义任务和操作,并将其添加到Ant构建文件中。这使得Ant可以根据具体项目的需求进行扩展,并实现更多特定的构建功能。 总之,ant.jar是一个功能强大的构建工具库,它可以帮助开发人员实现构建自动化和管理,并且具有跨平台性和扩展性。通过使用ant.jar,开发人员可以更高效地进行软件开发和构建过程。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值