- Run Jar File Using Ant
- Execute Jar File From Command Line
- Execute Jar File Windows
- Execute Jar File With Library Path
- Execute Jar File Using Ant
- Execute Jar From Command Line
I am trying to create a runnable jar file from java classes using ant. The java classes use external jars. When I execute the build.xml its showing class not found exception while running the java program. How to create a bundled runnable jar using Ant. Ask Question 7. Which compiles the code just fine and creates a jar file, but when I try to run the jar by double clicking, i get a message saying 'Could not find main class: HttpController.java.' I need to generate an executable jar using Ant. With the java goal of maven exec plugin, you should use different settings, since this goal is designed to execute java command. Without this goal exec pluing may execute any command, for example some bash script or bat file, like mvn or ant for example. Build will compile all the Java code to.class and create the JAR file for the bank account manager. Note the declaration of the class that should run when the JAR is invoked. Now I can use ant from the command-line for build and test tasks instead of relying on IDE support.
A defined process is one of the most necessary but often least-used tools in software development. It is by nature an overhead task that accompanies a development effort. A defined build process ensures that the software in your development project is built in the exact same manner each time a build is executed. As the build process becomes more complex -- for example, with EJB builds or additional tasks -- it becomes more necessary to achieve such standardization. You should establish, document, and automate the exact series of steps as much as possible.
Why do I need a defined build process?
A defined build process is an essential part of any development cycle because it helps close the gap between the development, integration, test, and production environments. A build process alone will speed the migration of software from one environment to another. It also removes many issues related to compilation, classpath, or properties that cost many projects time and money.
What is Ant?
Ant is a platform-independent scripting tool that lets you construct your build scripts in much the same fashion as the 'make' tool in C or C++. You can use a large number of built-in tasks in Ant without any customization. Some of the most important tasks are shown in the following table but explained in more detail in the example that follows.
Here are some useful commands that are built in the Ant distribution.
Command | Description |
---|---|
Ant | Used to execute another ant process from within the current one. |
Copydir | Used to copy an entire directory. |
Copyfile | Used to copy a single file. |
Cvs | Handles packages/modules retrieved from a CVS repository. |
Delete | Deletes either a single file or all files in a specified directory and its sub-directories. |
Deltree | Deletes a directory with all its files and subdirectories. |
Exec | Executes a system command. When the os attribute is specified, then the command is only executed when Ant is run on one of the specified operating systems. |
Get | Gets a file from an URL. |
Jar | Jars a set of files. |
Java | Executes a Java class within the running (Ant) VM or forks another VM if specified. |
Javac | Compiles a source tree within the running (Ant) VM. |
Javadoc/Javadoc2 | Generates code documentation using the javadoc tool. |
Mkdir | Makes a directory. |
Property | Sets a property (by name and value), or set of properties (from file or resource) in the project. |
Rmic | Runs the rmic compiler for a certain class. |
Tstamp | Sets the DSTAMP, TSTAMP, and TODAY properties in the current project. |
Style | Processes a set of documents via XSLT. |
While other tools are available for doing software builds, Ant is easy to use and can be mastered within minutes. In addition, Ant lets you create expanded functionality by extending some of its classes. I will show this expansion in a following example.
What do I need to use Ant?
You must install three components on your machine to run Ant: JDK, XML parser, and Ant (see Resources for links).
In many cases, the XML parser is part of the lib files distributed with the Servlet runner or the Web Server. If not, the free XML parser from java.sun.com is sufficient.
Ant installation consists of downloading the files, adding the class libraries to the classpath, and adding the Ant binaries to the path.
Example scenario
This example scenario should help show you the value of Ant and provide insight into its benefits and how you can use it.
Because a large amount of the current Java development is focused on server-side Java, I have chosen a server-side application for the example. Developers working on server-side Java applications are typically interested in the compilation of servlets, deployment of JSP files, and deployment of HTML files, configuration files, or images.
A common scheme for doing this build would involve the development of small scripts in platform-specific languages based on the server's operating system. For example, a developer working on an NT machine could create a batch file that performs the compilation tasks and then runs the deployment. However, if the production environment had Unix or Linux, the developer would have to rewrite the script, ensuring that the scripts were in sync.
OK, show me how this works
So, I've hopefully convinced you of the need to use Ant and shown how simple it is to install. Now I'll show you how simple Ant is to use by stepping through an example that performs simple compilation and deployment.
Simple build process with Ant (simple.xml)
There's a lot to explain in the above example. First, you should understand the structure of the simple.xml file. It is a well-formatted XML file containing a project entity that is comprised of several target entities.
The first line contains information about the overall project that is to be built.
The most important elements of the project line are the
default
and the basedir
.The
default
attribute references the default target that is to be executed. Because Ant is a command-line build tool, it is possible to execute only a subset of the target steps in the Ant file. For example, I could perform the following command:That will execute the
ant
command and run through the simple.xml file until the init
target is reached. So, in this example, the default is deploy
. The Ant process invoked in the following line will run through the simple.xml
file until the deploy
command is reached:The
basedir
attribute is fairly self-explanatory as it is the base directory from which the relative references contained in the build file are retrieved. Each project can have only one basedir
attribute so you can choose to either include the fully qualified directory location or break the large project file into smaller project files with different basedir
attributes.The next line of interest is the target line. Two different versions are shown here:
The
target
element contains four attributes: name
, if
, unless
, and depends
. Ant requires the name
attribute, but the other three attributes are optional.Using
depends
, you can stack the Ant tasks so that a dependent task is not initiated until the task that it depends on is completed. In the above example, the clean task will not start until the init
task has completed. The depends
attribute may also contain a list of comma-separated values indicating several tasks that the task in discussion depends on.The
if
and unless
commands let you specify commands that are to be performed either if a certain property is set or unless that property is set. The if
will execute when the property value is set, and the unless
will execute if the value is not set. You can use the available
command to set those properties as shown in a following example, or you can set them via the command line.The
init
target from the simple example contains four lines of property
commands as shown here:These
property
lines let you specify commonly used directories or files. A property is a simple name value pair that allows you to refer to the directory or file as a logical entity rather than a physical one.If you wanted to reference the
sourceDir
variable later in the Ant file, you could simply use the following syntax to alert Ant to obtain the value for this tag: ${sourceDir}
.Two other commands present in the above buildfile are:
These commands are used to ensure that there are no extraneous files in the
outputDir
(or classes
directory when dereferenced as mentioned above). The first command removes the entire tree contained under the outputDir
. The second command creates the directory again.The last line of major interest to the developer is the following compilation line:
The
javac
command requires a source directory (the input location of the .java files) and a destination directory (the output location of the .classes file). It is important to note that all directories must either exist prior to the running of the ant
command or be created using the mkdir
command. Ant does not create directories based upon intuition, so you must create the outputDir
, using the mkdir
command prior to the compilation step above.After the
compile
task has completed, the deploy
task will perform the copy operation to move all JSP files from the source directory to a deployment directory. By using the copydir
command, you copy the entire JSP directory from one location to another. I used the copyfile
command to copy a single properties file as part of the build.While it took several lines to explain the example, it should be evident that Ant is an easy-to-use tool. Using this buildfile as a starting point, you should be able to incorporate Ant into your development effort. The
ant
commands shown in the above example have further functionality, some of which will be discussed in this article, the remainder is left to you along with references to the documentation.Run Jar File Using Ant
Important tasks
It is left to you to read through the built-in tasks included in the Ant distribution. See the user guide in Resources for information about each command. I have chosen two commonly used commands as examples of additional options available to the build manager without any customization.
Compiling code (including EJBs)
In the simple example discussed earlier, you saw a simple form of the
javac
command. Now, if you examine it in more detail, you see that you can specify the compilation flags such as deprecation, debug, or optimize as well as the files that will or will not be included in the compilation.You can use the
include/exclude
entities inside the javac
task to include/exclude files matching the pattern in the name
attribute from the compilation. From the above example, you want to include files contained in any directory ending in .java but, at the same time, you want to exclude files named Script.java unless a property bsf.present
is set to true.You set the
bsf.present
property using the following task that searches the classpath for the classname specified and sets bsf.present
according to the search results:The
javac
command will not include files called version.txt from the compilation based upon the exclude command above.Generating javadoc
Another task that Ant can help automate is the generation of javadoc. You can use the following command to generate the javadoc:
The packages specify the overall packages that the javadoc will include. The
sourcepath
attribute points towards the location of the source files. The javadoc
command also provides attributes allowing you to specify the title of the window and the document. You can also include a copyright notice at the bottom of each javadoc page, using the bottom
attribute.Can Ant do XYZ?
At this point, you have seen some of the possible tasks in your build process that Ant can automate. Those tasks are included out of the box in Ant. You might want to customize Ant to help you perform some more difficult tasks such as building EJBs and performing remote configuration management. Some of you may want to increase Ant's reporting capabilities or construct a user interface that can run the Ant process.
The simple answer to the question 'Can Ant do XYZ?' is 'Yes, but you may have to customize it.'
Extending Ant
Two Ant extensions are interesting to discuss at this point. They are increased reporting and the ability to distribute code remotely using Ant.
Reporting enhancements
Ant provides the facility to create the classpath container which can be used later in a task. Let us understand it with the below example.
In below example, we set classpath to “build.classpath” using path element. This classpath is used in the javac task of the compile target.
In build.xml file:
1. src.dir: It specify the project source folder.
2. build.dir: It specify the project compilation output folder.
3. lib.dir: It specify the folder of the jar files.
2. build.dir: It specify the project compilation output folder.
3. lib.dir: It specify the folder of the jar files.
Example explanation:
Execute Jar File From Command Line
When we run the build.xml file, control first go on the project element and look for the default target. In our example mainTarget is the default target so control go on the mainTarget. Then control looks for those targets on which mainTarget depends. The mainTarget depends on compile and docs target. The docs target depends on compile target which is further depends upon clean and makedir target. So first clean target will execute followed by makedir, compile, docs and mainTarget. The javadoc task in the docs target is responsible for creating the document.
Example:
Execute Jar File Windows
ArmstrongNumber.java
Execute Jar File With Library Path
build.xml
Execute Jar File Using Ant
Console:
Execute Jar From Command Line
Download this example.
Next Topic: How to create jar file using ant with example?
Previous Topic: How to create java document using ant in eclipse with example?
Next Topic: How to create jar file using ant with example?
Previous Topic: How to create java document using ant in eclipse with example?