Ant是什么

Ant是什么？

一、总结

一句话总结：

编译 打包 测试 工具 xml

Ant是Java的生成工具，是Apache的核心项目；
Ant类似于Unix中的Make工具，都是用来编译、生成；
Ant是跨平台的，而Make不能；
Ant的主要目的就是把你想做的事情自动化，不用你手动一步一步做，因为里面内置了javac、java、创建目录、复制文件等功能，所以可以直接点击Ant文件，即可编译生成你的项目。

当一个代码项目大了以后，每次重新编译，打包，测试等都会变得非常复杂而且重复，因此c语言中有make脚本来帮助这些工作的批量完成。在Java 中应用是平台无关性的，当然不会用平台相关的make脚本来完成这些批处理任务了，ANT本身就是这样一个流程脚本引擎，用于自动化调用程序完成项目的编译，打包，测试等。除了基于JAVA是平台无关的外，脚本的格式是基于XML的，比make脚本来说还要好维护一些。

1、ant一般在项目中以什么样的形式存在？

build.xml

当在项目中创建一个build.xml时，这个文件就是ant的生成文件。

2、ant的文件结构是怎样的？

project target task

ant的默认生成文件为build.xml；
输入ant后，ant会在当前目录下搜索是否有build.xml，如果有，则执行；当然也可以自定义生成文件，通过ant -f a.xml即可指定a.xml为生成文件；
ant的生成文件是xml文件，整体结构为：

<?xml version="1.0" encoding="GBK"?>
<project default="targetname">
    <target name="name">
    </target>
</project>

project是生成文件的根元素，表示一个工程；
target是project的子元素，表示一个任务；一个project中可以定义多个target元素，表示多个任务；
default属性表示默认执行的target，如果ant命令没有指定target，则执行default的target；
ant targetname; 则会执行此target，而忽略default设置的target；targetname不能重复。

在Ant中Task是target的子元素，即一个target中可以有多个task；而Task分为：
(1)核心Task；
(2)可选Task；
(3)自定义Task；

二、ant是用来干什么的？（百度百科）

问题：

ant是java工具，那么它是用来干什么的？是用来开发java项目的吗？和myeclipse一样。
我在myeclipse里开发项目，怎么使用ant进行编译、打包呀。还有，需要安装ant吗？我在myeclipse中perferece --- ant --- 看到有默认的ant,还需要我再安装一个吗？我编译时会报unable to find a javac compiler。
我需要完整的操作步骤。

答案一：

一般情况下，大多数软件公司做开发的时候都不用myeclipse开发，这是利用ant部署就给我们带来极大的方便，它先将你的project打包成war包，然后部署到指定的服务器中。

Ant的概念
当一个代码项目大了以后，每次重新编译，打包，测试等都会变得非常复杂而且重复，因此c语言中有make脚本来帮助这些工作的批量完成。在Java 中应用是平台无关性的，当然不会用平台相关的make脚本来完成这些批处理任务了，ANT本身就是这样一个流程脚本引擎，用于自动化调用程序完成项目的编译，打包，测试等。除了基于JAVA是平台无关的外，脚本的格式是基于XML的，比make脚本来说还要好维护一些。
每个ant脚本（缺省叫build.xml）中设置了一系列任务(target)：比如对于一个一般的项目可能需要有以下任务。
* 任务1：usage 打印本脚本的帮助信息（缺省）
* 任务2：clean <-- init 清空初始化环境
* 任务3：javadoc <-- build <-- init 生成JAVADOC
* 任务4：jar <-- build <-- init 生成JAR
* 任务5：all <-- jar + javadoc <-- build <-- init 完成以上所有任务：jar javadoc
而多个任务之间往往又包含了一定了依赖关系：比如把整个应用打包任务(jar)的这个依赖于编译任务(build)，而编译任务又依赖于整个环境初始化任务(init)等。
注：我看到很多项目的ant脚本中的命名基本上都是一致的，比如：编译一般叫build或者compile；打包一般叫jar或war；生成文档一般命名为 javadoc或javadocs；执行全部任务all。在每个任务的中，ANT会根据配置调用一些外部应用并配以相应参数执行。虽然ANT可调用的外部应用种类非常丰富，但其实最常用的就2，3个：比如javac javadoc jar等。

Ant的优点
Ant是Apache软件基金会JAKARTA目录中的一个子项目，它有以下的优点。
跨平台性。Ant是纯Java语言编写的，所示具有很好的跨平台性。
操作简单。Ant是由一个内置任务和可选任务组成的。Ant运行时需要一个XML文件(构建文件)。
Ant通过调用target树，就可以执行各种task。每个task实现了特定接口对象。由于Ant构建文件时XML格式的文件，所以和容易维护和书写，而且结构很清晰。
Ant可以集成到开发环境中。由于Ant的跨平台性和操作简单的特点，它很容易集成到一些开发环境中去。

答案二：

不是的！myEclipse是继承开发环境。。ant是一个构建工具！

三、Ant是什么？（转）

转自：Ant是什么？ - 贤者CLUB - CSDN博客
https://blog.csdn.net/qq997404392/article/details/76986978

一、Ant介绍

Ant是Java的生成工具，是Apache的核心项目；
Ant类似于Unix中的Make工具，都是用来编译、生成；
Ant是跨平台的，而Make不能；
Ant的主要目的就是把你想做的事情自动化，不用你手动一步一步做，因为里面内置了javac、java、创建目录、复制文件等功能，所以可以直接点击Ant文件，即可编译生成你的项目。
下载地址：http://ant.apache.org/bindownload.cgi

二、Ant配置

1. 在Ant安装之前需要安装好JDK，并配置好JAVA_HOME；
2. 新建环境变量ANT_HOME：值为ANT的主目录；
3. 在path中配置%ANT_HOME%/bin；
4. 配置完成之后，打开命令行，输入ant，当出现“Buildfile: build.xml does not exist! Build failed”时说明配置完成；

三、Ant入门

ant的默认生成文件为build.xml；
输入ant后，ant会在当前目录下搜索是否有build.xml，如果有，则执行；当然也可以自定义生成文件，通过ant -f a.xml即可指定a.xml为生成文件；
ant的生成文件是xml文件，整体结构为：

<?xml version="1.0" encoding="GBK"?>
<project default="targetname">
    <target name="name">
    </target>
</project>

project是生成文件的根元素，表示一个工程；
target是project的子元素，表示一个任务；一个project中可以定义多个target元素，表示多个任务；
default属性表示默认执行的target，如果ant命令没有指定target，则执行default的target；
ant targetname; 则会执行此target，而忽略default设置的target；targetname不能重复。

四、Ant的XML元素详解

<project>元素

Ant生成文件的根元素，一般形式如：

<project default="    "[ basedir="." ] [name="projectname"]>

default的值是默认执行的target名；
basedir是指定基准目录，一般都是basedir=”.”；
name是指工程名字。

<target>元素

是project元素的子元素，在project元素中能够有多个target；一般形式如下：

<target name="    "  [ depends="  A  "]  [ if ="  prop1 "] [ unless=" prop2"]>
</target>

name表示target的名称；
depends中填写其他target名称(可以有多个名称，用逗号分割)，表示只有targetA完成之后才能够做此target，如果执行此target，则会先执行A；
if的值表示一个属性名，只有设置了该属性名，才能执行此target；
unless的值表示一个属性名，只有没有设置该属性名，才能执行此target。

<property>元素

project的子元素，用于定义属性，一般形如：
<property name="pname" value="pvalue"/>
如果要使用此property，则需要${pname}，类似于表达式语言；
<property file="a.properties"/> 通过此属性文件导入属性；
如果单纯想使用$，则通过$$表示。

五、Task介绍

在Ant中Task是target的子元素，即一个target中可以有多个task；而Task分为：
(1)核心Task；
(2)可选Task；
(3)自定义Task；
下面介绍一些常用的核心Task。

<echo>

用于单纯输出，如：

<echo>hello</echo>

<javac>

用于编译java文件，一般形式如下：
<javac srcdir="src" destdir="class" [classpath=" "]/>
srcdir是编译此文件夹下或子文件夹下的全部java文件;
destdir是编译后的class文件放置路径；
classpath指定第三方类库；

<java>

运行java类，一般形式如下：

<Java classname="    " fork="yes">
    【<arg line="param1   param2   param3"/>】
</java>

classname用于指定运行的类名称；
fork=”yes”表示另起一个JVM来执行java命令，而不是中断ANT命令，因此fork必须为yes；

<jar>

打包成jar包；一般形式如下：

<jar destfile="main.jar" basedir=" ">
    <manifest>
        <attribute name="Main-Class" value="classname"/>  <!--指定主类-->
    </manifest>
</jar>

destfiie的值为jar包的名称，一般为${dest}/main.jar；
basedir的值是需要打成jar包的目录，一般为${classes}；
manifest表示设置META-INF；

<mkdir>

创建目录，可以多层创建，比如a\b\c，则可以连续创建，一般形式如下：

<mkdir dir="a\b"/>

<delete>

删除目录，一般形式如下：
<delete dir="a\b"/> 可以删除a目录下的b目录；
<delete file="1.txt"/>可以删除文件；

<tstamp>

时间戳，一般形式如下：

<tstamp />

接下来可以使用${DSTAMP}进行调用当前时间；

<copy>

复制文件，一般形式如下：

<copy file="file1" tofile="file2"/>

file是源文件；
tofile是目标文件；

<move>

移动文件，一般形式如下：

<move file="file1" tofile="file2"/>

file是源文件；
tofile是目标文件；

<replace>

用于替换字符串，类似于String的replace操作，一般形式如下：

<replace file="filename" token="old" value="new"/>

file表示要执行替换的文件；
token表示被替换的字符串；
value表示替换的字符串。

六、代码举例：一般项目中的ant结构

<project default="init">
    <property name="src" value="src"/>
    <property name="classes" value="classes"/>
    <property name="dest" value="dest"/>
    <path id="classpath">
        <pathelement path="${classes}"/>
    </path>
    <target name="help">
        <echo>help -打印帮助信息</echo>
        <echo>compile -编译java源文件</echo>
        <echo>run -运行程序</echo>
        <echo>build -打成jar包</echo>
        <echo>clean -清楚全部编译生成文件</echo>
    </target>
    <target name="compile">
        <delete dir="${classes}"/>
        <mkdir dir="${classes}"/>
        <javac srcdir="${src}" destdir="${classes}"/>
    </target>
    <target name="run" depends="compile">
        <java classname="org.xiazdong.Test" fork="yes">
            <classpath path="${classes}"/>
        </java>
    </target>
    <target name="build" depends="run">
        <delete dir="${dest}"/>
        <mkdir dir="${dest}"/>
        <jar destfile="${dest}/Test.jar" basedir="${classes}">
            <manifest>
                <attribute name="Main-Class" value="org.xiazdong.Test"/>
            </manifest>
        </jar>
    </target>
    <target name="clean">
        <delete dir="${classes}"/>
        <delete dir="${dest}"/>
    </target>
</project>  

<?xml version = "1.0" encoding="GBK"?>
<project name="Test" default="" basedir=".">
    <property name="src" value="${basedir}\src"/>
    <property file="${basedir}\a.properties"/>
    <!--
    path用法
        1.id属性表示编号，用于被引用
    -->
    <path id="classpath">
    <!--
    pathelement的用法
        1.path表示多个目录，用“;”隔开目录
        2.location表示一个目录
    -->
        <pathelement path="lib;src"/>
        <pathelement location="lib"/>
    <!--
    dirset的用法
        1.dir属性指定根目录
        2.子元素<include name="    "/>表示包含的目录
        3.子元素<exclude name="    "/>表示不包含的目录
    -->
        <dirset dir="lib">
            <include name="**/*Test*"/>
            <exclude name="**/class"/>
        </dirset>
    <!--
    filelist的用法
        1.dir属性指定根路径
        2.files属性指定文件名的列表，用","隔开
    -->
        <filelist dir="lib" files="a.xml,b.xml"/>
    <!--
    fileset用法
        1.dir属性指出根路径
        2.子元素<include name="   "/>指定包含的文件名
    -->
        <fileset dir="lib">
            <include name="**/*.jar"/>
        </fileset>
    </path>
    <!--
    target用法
        1.表示任务,子元素为各种task的集合;
    -->
    <target name="target1">
    <!--
    javac用法
        1.srcdir表示java文件的目录
        2.destdir表示class文件的保存目录
    -->
        <javac srcdir="src" destdir="bin">
    <!--
    classpath用法
        1.refid引用前面的path指定的路径
    -->
            <classpath refid="classpath"/>
        </javac>
    <!--
    java用法
        1.classname表示要运行的类
        2.fork="yes"一定要写上！！
    -->
        <java classname="Test" fork="yes">
            <classpath refid="classpath"/>
    <!--
        arg表示指定的参数
    -->
            <arg value="a b c"/>
        </java>
    <!--
    echo表示输出
    -->
        <echo>Hello world</echo>
    <!--
    copy表示复制文件
    delete表示删除文件
    mkdir表示创建目录
    move表示移动文件
    -->
        <copy file="src.txt" tofile="dest.txt"/>
        <delete dir="src"/>
        <mkdir dir="src"/>
        <move file="src.txt" tofile="dest.txt"/>
    </target>
</project>  

七、在Eclipse中使用Ant

在Eclipse中虽然没有内置创建Ant的生成文件，但是可以通过配置完成：
1. 点击 window–>preferences–>General–>editors–>file associations;
2. 在File types中创建一个build.xml，并将associated editor的默认项设置为ant editor即可；
当在项目中创建一个build.xml时，这个文件就是ant的生成文件。

八、模式匹配

在Ant中有一些基本的模式匹配的功能，比如：
*表示任意字符串，**表示任意数量的目录；
1. *.java表示任意的java文件。
2. */*.java表示当前目录的任意java文件。
3. **/*.java表示当前目录结构下的任意java文件。

<fileset dir="src">
    <include name="**/*.java"/>
    <include name="**/*.txt"/>
    <exclude name="**/*Test*"/>
</fileset>

表示包含src目录下的所有java和txt文件，排除文件名包含Test的文件。

举例：将java文件拷贝到dest文件夹下：

<copy todir="dest">
    <span style="white-space:pre"></span>
    <fileset dir=".">
        <span style="white-space:pre"></span>
            <include name="**/*.java"/>
        <span style="white-space:pre"></span>
    </fileset>
</copy>  

九、自定义任务

自定义任务类似于JSP中的自定义标签：
1. 继承org.apache.tools.Task;
2. 覆写public void execute()throws BuildException;
3. 在类中添加的属性即为任务标签的属性；
4. 在build.xml中声明任务<taskdef name=" " classname=" " classpath="bin"/>。

举例：复制文件：

package org.tools;  

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;  

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
public class SimpleTask extends Task{
    private File file;
    private File tofile;
    public File getFile() {
        return file;
    }
    public void setFile(File file) {
        this.file = file;
    }
    public File getTofile() {
        return tofile;
    }
    public void setTofile(File tofile) {
        this.tofile = tofile;
    }
    @Override
    public void execute() throws BuildException {
        try {
            PrintWriter out = new PrintWriter(new FileWriter(tofile));
            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String line = null;
            while((line=in.readLine())!=null){
                out.println(line);
            }
            out.close();
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

build.xml

<taskdef name="MyCopy" classname="org.tools.SimpleTask" classpath="bin"></taskdef>
<target name="mycopy">
    <MyCopy file="2.txt" tofile="output.txt"/>
</target>