Now that we have dependency management with
Ivy
working along with everything else covered before, we’ve covered almost
everything required to start building real projects with Ant.
Another thing any real project should have, is unit tests. Thankfully, using the scaffolding already put in place in earlier parts of this series, integrating a JUnit testing task into our existing build script is really straight-forward.
So far, we’ve covered the basics of creating
a re-distributable .jar
package
suitable for use as a library, and building a Jar file which can be
run
by a user or server process.
A major part of any non-trivial application these days is the inclusion
and re-use of 3rd party libraries which implement functionality your
applications require. When a project starts, it’s probably easy enough
to manually drop the odd jar library into a lib directory and forget
about it, but maintaining a large application which depends on many
libraries, which in turn depend on additional libraries for their own
functionality, it can quickly turn into a nightmare to manage.
To solve this problem, many dependency management tools have been introduced, most notably, Apache Maven. Maven however, is so much more than just a dependency management tool, and is actually intended to manage your entire project structure. I believe however, the combination of Ant and Ivy provides far more flexibility, extensibility and control over your build and dependency management processes.
So, let’s integrate Apache Ivy into our Ant script as we left it in part 2.
In part 1, we went over the basics of using
Ant to create a redistributable .jar
file,
suitable for use as a library in other projects. A lot of the time
however, you’re probably going to want to be building things which can
actually be run as regular Java applications.
Once again, the code for this tutorial is available in GitHub. More usefully, you may want to see the diff between the part 1 script and the new one.
Here’s a quick explanation of what we’ve done to achieve an executable jar file:
Apache Ant is a
general-purpose build tool, primarily used for the building of Java
applications, but it is flexible enough to be used for various tasks.
In the Java world at least, Ant seems to be largely passed over for the immediate convenience and IDE support of Maven, however long term, I believe a good set of Ant scripts offer far more flexibility and room for tweaking your build processes. The downside is that there’s a lot of stuff you need to learn and figure out and build by hand.
In this series of tutorials, I’ll try to document the process of learning I’ve gone through building and maintaining Ant build files, from the most basic of “just compile my stuff” steps to automatic generation of JavaDoc output, dependency management using Ant’s companion, Ivy, unit testing using JUnit, and integrating with some additional tools I’ve been using, such as Checkstyle and FindBugs.
For part 1 of this tutorial, I’ve created a simple Hello World library.
It doesn’t have a main executable itself, the goal of this is to produce
a .jar file we can include in other projects, to start our Ant script
off fairly simply.
The source for this project can be found in GitHub. Here’s the breakdown of everything going on in this project:
So, being stuck without access to Photoshop and my regular Windows PC has taught me a little about GIMP – basically it’s exactly the same as Photoshop with a less slick UI :D.
Also, since I haven’t really written anything tutorial-ish in many many years, so this is as much about brushing up on those skills as anything else.
This is a guide for quick and simple photo enhancement using GIMP.
In case anyone’s arrived here looking for my UT, Tribes 2, etc maps, mods, utilities, tutorials and things, you’ll find those along with downloads and things over on my ‘gaming resources’ site: http://www.unreal.co.za/shrimp/.
Introduction to Ant Part 4: Unit Tests with JUnit
18 Sep 2015
Continue Reading ...