Compile JAVA project (reproduced) using ANT

What is ANT?

Ant is a BUILD tool based on Java and XML.

2 download, install ANT

Install ANT

Download the .zip file, unzipped to C: /rant1.3 (later reference to% Ant_HOME%)

2.1 Do you need to do some configuration before you run Ant.

2.1.1 Add a bin directory to the PATH environment variable.

2.1.2 Set the ANT_HOME environment variable, point to the directory where you install Ant. On some OS, Ant's script can guess Ant_Home (UNIX and WindOS NT / 2000) - but it is best not to rely on this feature.

2.1.3 Optionally, set a Java_Home environment variable (refer to the following advanced sections), which should point to the directory of the JDK installed.

Note: Do not put the Ant.jar files of the Ant to the lib / ext directory of JDK / JRE. Ant is an application, and the lib / EXT directory is used for JDK extension (such as JCE, JSSE extension). And there will be security restrictions by extension.

2.2 Run Ant

Running Ant is very simple, when you correctly install Ant, just enter Ant.

n When you specify any parameters, Ant will query the build.xml file in the current directory. If you find it, use this file as buildfile. If you use the -find option. Ant will look for BuildFile in the superiors until the root of the file system is reached. To allow Ant to use other buildfiles, you can use the parameter -Buildfile file, where the file specifies the buildfile you want to use.

n You can specify whether one or more Targets can be performed. When Target is omitted, the ANT uses the target attribute specified by the Default property of the label .

Command line option summary:

Ant [options] [target [target2 [target3] ...]]]]]]]

Options:

-Help Print this Message

-ProjectHelp Print Project Help Information

-version print the version information and exit

-quiet be extra quiet

-verbose be extra verbose

-debug print debugging information

-emacs produpe logging information without adornments

-logfile file use Given File for log output

-logger classname the class thing is to perform logging

-Listener ClassName Add an Instance of Class As a Project Listener

-Buildfile File Use Specified BuildFile

-find file search for buildfile touth the root of the filesystem and use the first one found

-Dproperty = Value Set Property to Value

example

Ant

Use the build.xml in the current directory to run Ant, perform the default target.

Ant -buildfile Test.xml

Use the Test.xml in the current directory to run Ant, perform the default target.

Ant -Buildfile Test.xml Dist

Use the Test.xml under the current directory to run Ant, perform a target called DIST.

ANT -BUILDFILE TEST.XML -DBUILD = BUILD / CLASSES DIST Use the Test.xml in the current directory running Ant, perform a Target called Dist and set the value of the build property of the build property.

3 Write Build.xml

Ant's buildfile is written with XML. Each buildfile contains a Project.

Each Task element in BuildFile can have an ID attribute that can be used to reference the specified task with this ID value. This value must be unique. (For details, please refer to the Task section below)

3.1 PROJECTS

Project has the following properties:

Attribute DescriptionRequiredName project name .NodeFault When the default targetyesbasedir used when not specified Target is used to calculate the base path of all other paths. This property can be overwritten by BaseDir Property. This property is ignored when it is overwritten. If the attributes are not set, the parent directory of the buildfile file is used. NO

The description of the project appears in the form of a top element (see Description Section). A project can define one or more Targets. A Target is a series of what you want to do. When performing Ant, you can choose to execute that Target. When there is no Target, use the Target determined by the Project's Default property. 3.2 Targets A Target can depend on other Targets. For example, you may have a Target for compiler, a Target to generate an executable. You must compile the pass before generating an executable, so the target that generates executable files depends on compiling Targets. Ant will deal with this dependency. However, it should be noted that Ant's Depends attribute specifies the order of Target should be executed - if the dependent target cannot be run, this depends has no effect on target specified dependencies. Ant will perform each target in order (from left to right) in the order of Target in the Depends property. However, it is necessary to remember that as long as a Target relies on a Target, the latter will be executed first. Assume that we have to perform Target D. From its dependency properties, you may think that C, then B, and final A is executed. Wrong, C depends on B, B depends on A, so before the A, then B, then C, and final D is executed. A Target can only be executed once, and there are multiple Targets depending on it (see the above example). If (or if not) certain attributes are set, a Target is executed. In this way, the process of Build is allowed to better control the process of the system according to the status of the system (Java Version, OS, command line attribute, etc.). To make a target element, you should join the IF (or UNSS) property in the Target element, with the target of the determined attribute. For example: Target will always be executed if there is no IF or UNSS attribute. Optional Description attributes can be used to provide a line description for Target, which can be output by the -projecthelp command line option. Well your TSTamp Task is a good practice in a so-called initial Target, and other Targets rely on this initial Target. To ensure that the initialization Target is the first Target that appears in other Target rerequisites. Most of the initial Target in this manual is "init". Target has the following properties:

Attribute Description RequiredName Target's name YESDepends is a list of named Target with a comma, which is the dependent table. NOIF executes the name of the attribute that Target needs to be set. Nounless executes the Target to clear the set properties name. NodeScription About Target features a short description. NO3.3 TASKS A Task is an executable code. A Task can have multiple properties (if you like, you can call it as a variable). Attributes may only contain references to Property. These references will be parsed before TASK execution. Below is a general constructor of Task: This is the name of Task, attribute is the property name, VALUEN is the attribute value. There is a built-in Task, as well as some optional Task, but you can also write your own task. All Task has a Task name property. ANT uses attribute values ​​to generate log information. You can assign a ID attribute to Task: Here TaskName is the name of Task, and TaskID is the unique identifier of this task. With this identifier, you can reference the corresponding Task in the script. For example, in the script you can: