ant的精髓

学习 Ant 主要的就是：抄
如何能够对 Ant 有更深的掌握。

1. 首先我们需要知道一些基本的元素以及使用方法
2. 写一些简单的程序，然后在构建文件中使用我们讲解的元素来编译运行程序；
3. 遇到比较多的程序的时候，我们需要借助一些现有的构建文件，比如我们需要把一个 webproject 打成 war 包，但是我们又不会写构建文件，这个时候我们就需要一个别人写好的构建文件，然后仔细揣摩写法，遇到不懂的地方再查阅该元素的详细用法，最后修改构建文件满足自己的要求；
4. 遇到新的功能我们也要尝试使用 Ant 来完成，比如我们需要使用 JUnit 来测试程序，这个时候我们就需要借助 Ant 的 JUnit 任务，我们首先查阅 junit 的用法，然后在构建文件中写入该任务，不断修改直至成功运行。
   下面我给出几个常用的构建过程，大家可以拿来仔细研究，对于不懂的部分，有些注释写的也很详细。
   例子：

  //简单打成jar包，仅仅把编译后的文件坐在的目录 classes 中的 class 文件打成 jar包。
   <?xml version="1.0"?>
    <project name="javaTest" default="jar" basedir=".">
        <target name="jar" description="打JAR包">
            <jar destfile="helloworld.jar" basedir="build/classes">
                <manifest>
                    <attribute name="Main-class" value="HelloWorld" />
                </manifest>
            </jar>
        </target>
    </project>

打包操作的的还有 war、tgz，解压操作 uzip

   <!-- 创建zip -->
    <zip basedir="${basedir}\classes" zipfile="temp\output.zip"/> 
    <!-- 创建tgz -->
    <gzip src="classes\**\*.class" zipfile="output.class.gz"/>
    <!-- 解压zip -->
    <unzip src="output.class.gz" dest="extractDir"/>
    <!-- 建立war包 -->
    <war destfile="${webRoot}/ash.war" basedir="${basedir}/web" webxml="${basedir}/web/WEB-INF/web.xml">
        <exclude name="WEB-INF/classes/**"/>
        <exclude name="WEB-INF/lib/**"/>
        <exclude name="WEB-INF/work/_jsp/**"/>
        <lib dir="${lib.dir}" includes="**/*.jar, **/*.so, **/*.dll">
            <exclude name="${webRoot}\${helloworld_jar}"/>
        </lib>
        <lib file="${webRoot}/${helloworld_jar}"/>
        <classes dir="${dest}" includes="**/*.xml, **/*.properites, **/*.xsd"> </classes>
    </war>
    

打成 war 包

<project name="antwebproject" default="war" basedir=".">
    <!--定义常量，任务可以引用-->
    <property name="classes" value="build/classes" />
    <property name="build" value="build" />
    <property name="lib" value="WebRoot/WEB-INF/lib" />
    <!-- 删除build路径-->
    <target name="clean">
        <delete dir="build" />
    </target>
    <!-- 建立build/classes路径，并编译class文件到build/classes路径下-->
    <target name="compile" depends="clean">
        <mkdir dir="${classes}" />
        <javac srcdir="src" destdir="${classes}" />
    </target>
    <!-- 打war包-->
    <target name="war" depends="compile">
        <war destfile="${build}/AntProject.war" webxml="WebRoot/WEB-INF/web.xml">
            <!-- 拷贝WebRoot下除了WEB-INF和META-INF的两个文件夹 , **意为:匹配0或者更多的目录-->
            <fileset dir="WebRoot" includes="**/*.jsp" />
 
            <!-- 拷贝lib目录下的jar包-->
            <lib dir="${lib}" />
 
            <!-- 拷贝build/classes下的class文件-->
            <classes dir="${classes}" />
        </war>
    </target>
</project>

<?xml version="1.0" encoding="UTF-8"?>                                    
 
<project name="ant_firsttest" default="dist" basedir=".">                                    
  <description>ant firsttest!</description>                                    
 
  <!-- set global properties for this build -->        
  <!--设定变量，之后用。location为文件夹路径-->                            
  <property name="src" location="src"/>                                    
  <property name="build" location="build"/>                                    
  <property name="dist"  location="dist"/>                                    
  <property name="web"  location="web"/>                                    
 
  <!--设置properties文件位置.这里没用到。-->                                       
  <!--<property file="nbproject/project.properties"/>-->                                    
 
  <!--初始化命令-->                                    
  <target name="init">                                    
    <!-- Create the time stamp -->                                    
    <tstamp/>                                    
 
    <!--mkdir是建立文件夹，${build}即刚才设定的变量。这几行都在干这事。-->    
    <!-- Create the build directory structure used by compile -->                                    
    <mkdir dir="${build}/WEB-INF/lib"/>                                    
    <mkdir dir="${build}/WEB-INF/classes"/>                                    
 
    <mkdir dir="${build}/WEB-INF/classes/javafile/package1"/>                                          
    <mkdir dir="${build}/WEB-INF/classes/javafile/package2"/>                                               
 
  </target>                                    
 
  <!--编译-->                                    
  <target name="compile" depends="init"                                    
        description="compile the source " >                                    
 
    <!-- Compile the java code from ${src} into ${build} -->                                    
    <!--javac标签用来设置编译程序的参数，srcdir为java文件路径，destdir为编译后class文件的保存路径。-->
    <javac srcdir="${src}/javafile/package1" destdir="${build}/WEB-INF/classes/javafile/package1"/>                                    
    <javac srcdir="${src}/javafile/package2" destdir="${build}/WEB-INF/classes/javafile/package2"/>                                    
    <!--如果路径下还有别的文件需要一起打包，用copy 命令。-->    
    <copy file="${src}/hello_ant.xml" tofile="${build}/WEB-INF/classes/hello_ant.xml" />                                                                             
 
  </target>                                    
 
  <!--编译后就要打包了。-->                                    
  <target name="dist" depends="compile"                                    
        description="generate the distribution" >                                    
    <!-- Create the distribution directory -->                                    
    <mkdir dir="${dist}"/>                                    
 
       <!--像jsp,jar这些直接用不用编译的文件，直接用copy命令。-->                                
    <copy file="${web}/image/a.gif" tofile="${build}/image/a.gif" />                                    
    <copy file="${web}/WEB-INF/web.xml" tofile="${build}/WEB-INF/web.xml" />                                     
    <copy file="${web}/WEB-INF/lib/a.jar" tofile="${build}/WEB-INF/lib/a.jar" />                                          
    <copy file="${web}/index.jsp" tofile="${build}/index.jsp" />                                     
 
    <!--最后用jar命令打成jar/war文件，文件名和后缀随便起。basedir为欲打包的原文件路经-->                                    
    <jar jarfile="${dist}/ant_firsttest.jar" basedir="${build}"/>                                    
  </target>                                    
 
  <!--删除-->
  <target name="clean"                                    
        description="clean up" >                                    
    <!--设定删除命令要删的路径。-->    
    <!-- Delete the ${build} and ${dist} directory trees -->                                    
    <delete dir="${build}"/>                                    
    <delete dir="${dist}"/>                                    
  </target>                                    
</project> 

打成 jar 包

<?xml version="1.0" encoding="UTF-8"?>
<!-- name是当前工程的名称，default是默认执行的任务，basedir是工作目录（.代表当前根目录） -->
<project name="HelloWorld" default="run" basedir=".">
    <!-- property类似于程序中定义简单的变量 -->
    <property name="src" value="src"/>
    <property name="dest" value="classes"/>
    <property name="hello_jar" value="helloWorld.jar"/>
    <!-- 
    target是一个事件、事情、任务， name是当前事情的名称，depends是依赖的上一件或是多件事情
    如果所依赖的事情没有执行，ant会先运行依赖事情，然后再运行当前事情
    -->
 
    <!-- 初始化 -->
    <target name="init">
        <!-- 建立classes目录 -->
        <mkdir dir="${dest}"/>
        <mkdir dir="temp"/>
        <mkdir dir="temp2"/>
    </target>
 
    <!-- 编译 -->
    <target name="compile" depends="init">
        <javac srcdir="${src}" destdir="${dest}"/>
        <!-- 设置jvm内存
        <javac srcdir="src" fork="true"/> 
        <javac srcdir="src" fork="true" executable="d:\sdk141\bin\javac" 
        memoryMaximumSize="128m"/> 
        -->
    </target>
 
    <!-- 建立jar包 -->
    <target name="build" depends="compile">
        <!-- 
        <jar jarfile="${hello_jar}" basedir="${dest}"/>
        创建一个名称是package.jar文件
        <jar destfile="package.jar" basedir="classes"/> 
        -->
        <jar destfile="${hello_jar}" basedir="classes"> 
            <!-- 向jar包中的main文件中添加内容 -->
            <manifest> 
                <attribute name="Built-By" value="${user.name}"/> 
                <attribute name="Main-class" value="package.Main"/> 
            </manifest> 
        </jar> 
        <!-- 复制jar文件  todir="复制到目录"-->
        <copy file="${hello_jar}" tofile="${dest}\temp.jar"/> 
        <copy todir="temp"> 
            <!-- 不按照默认方式 defaultexcludes="" -->
              <fileset dir="src"> 
                <include name="**/*.java"/>
              </fileset> 
        </copy> 
 
        <copy todir="temp2"> 
            <fileset dir="src">
                <and>
                    <contains text="main"/> 
                    <size value="1" when="more"/> 
                </and>
            </fileset>
        </copy> 
 
        <!-- 移动jar文件 -->
        <move file="${dest}\temp.jar" tofile="temp\move-temp.jar"/> 
        <!-- 创建zip -->
        <zip basedir="${basedir}\classes" zipfile="temp\output.zip"/> 
        <!-- 创建tgz -->
        <gzip src="classes\**\*.class" zipfile="output.class.gz"/>
        <!-- 解压zip -->
        <unzip src="output.class.gz" dest="extractDir"/> 
        <!--替换input.txt内容中的old为new
        <replace file="input.txt" token="old" value="new"/>
        --> 
    </target>
 
    <!-- 运行 -->
    <target name="run" depends="build">
        <java classname="com.hoo.test.HelloWorld" classpath="${hello_jar}"/>
    </target>
 
    <!-- 清除 -->
    <target name="clean">
        <!-- 删除生成的文件 -->
        <delete dir="${dest}"/>
        <delete file="${hello_jar}"/>
    </target>
 
    <tstamp> 
       <format property="OFFSET_TIME" 
               pattern="HH:mm:ss" 
               offset="10" unit="minute"/> 
    </tstamp>
 
    <!-- 重新运行 -->
    <target name="rerun" depends="clean,run">
        <echo message="###${TSTAMP}#${TODAY}#${DSTAMP}###"/>
        <aunt target="clean"/>
        <aunt target="run"/>
    </target>
</project>

<?xml version="1.0"?>
<!--默认为打包操作-->
<project name="structured" default="archive">
    <description>编译并打包一个应用程序</description>
    <!--在工程目录下创建输出目录：build/classes 和 dist-->
    <target name="init" description="创建目录">
        <mkdir dir="build/classes" />
        <mkdir dir="dist" />
    </target>
 
    <!--编译输出目录：srcdir-源目录和destdir-目标目录-->
    <target name="compile" depends="init" description="编译">
        <javac srcdir="src" destdir="build/classes" />
    </target>
 
    <!--打包 , depends依赖哪些target-->
    <target name="archive" depends="compile" description="打包">
        <war destfile="dist/antwebproject.war" basedir="build/classes" />
        <jar destfile="dist/project.jar" basedir="build/classes" />
    </target>
 
    <!--清理删除-->
    <target name="clean" depends="init" description="清理">
        <delete dir="build" />
        <delete dir="dist" />
    </target>
</project>

良好的目录结构的基本组成。

发布项目 ：
一些准备工作：

1. 撰写文档。
2. 撰写和平台相关的自启动脚本 bootstrap script，批处理文件 batch file，或者程序。
3. 撰写安装脚本，使用安装工具。
4. 检查版本控制系统中和项目相关的源码，文档，以及其他资料。
5. 将版本控制系统中的源码打上标签。
6. 运行一次完整的 build。
7. 运行一次完整的测试。
8. 将软件打包成适当的形式，用于发布和安装。
   打包步骤
   
   将源码和数据文件打包成 jar，将文档和生成的文档保存在某个目录，然后将整体打包 zip 或者 tar。
   任何一个复杂的程序除了代码之外还包括了数据，例如初始化数据，配置文件，xml 文件，schema 文件，还有些国际化和本地化文本文件，最理想化的方式是将这些数据打包在 jar 文件里面，然后通过 java 的 getResource 或者 getResourceAsStream 这样的方法来访问这些数据，对于打包在 jar 文件中的文件，java 提供了目录模式 reference pattern 来访问它们，如 org/example/helloworld/helloworld.properties。