In our next example, we'll demonstrate how to build a simple Java
library. You will find the Java example in
basic/java-library
. The files here are
analogous to those in our C++ library example. First, here is a
Java implementation of our BasicLibrary
class:
basic/java-library/src/java/com/example/basic/BasicLibrary.java
package com.example.basic; public class BasicLibrary { private int n; public BasicLibrary(int n) { this.n = n; } public void hello() { System.out.println("Hello. This is BasicLibrary(" + n + ")."); } }
Next, look at Abuild.conf
:
basic/java-library/Abuild.conf
name: java-library platform-types: java
This is essentially identical to our C++ library except that the
platform-types key has the value
java instead of the value
native. This is always true for Java build
items. Next, we'll look at the
Abuild.groovy
file:
basic/java-library/Abuild.groovy
parameters { java.jarName = 'java-library.jar' abuild.rules = 'java' }
Java build items have this file instead of
Abuild.mk
. The contents are very similar.
The Abuild.groovy
file contains Groovy code
that is executed inside a particular context provided by
abuild. Most Abuild.groovy
files will
simply set parameters that describe what
will be built. In this file, we set the
java.jarName
parameter to the name of the JAR
file we are creating, and we set the
abuild.rules
parameter to the value
'java'
to indicate that we are using the
java
rules. For Java build items, we don't
explicitly list the source files. Instead abuild automatically
finds sources in a source directory which is, by default,
src/java
. There are many more parameters
that can be set, and you have considerable flexibility about how
to arrange things and how to get files into your Java archives.
Abuild aims to allow you to build by
convention, but it gives you the flexibility to do
things your own way when you want to. We provide detailed
information about the directory structure for Java builds in
Section 19.3, “Directory Structure for Java Builds”.
Finally, look at the Abuild.interface
file.
This file provides information to other build items about what
they should add to their classpaths in order to make use of the
JAR file created by this build item:
basic/java-library/Abuild.interface
declare java-library.archiveName string = java-library.jar declare java-library.archivePath filename = \ $(ABUILD_OUTPUT_DIR)/dist/$(java-library.archiveName) abuild.classpath = $(java-library.archivePath) abuild.classpath.manifest = $(java-library.archivePath)
You'll notice here that we are actually setting four different
variables. Not all of these are required, but the pattern here
is one that you may well wish to adopt, especially if you are
working in a Java Enterprise environment. The first statement in
the interface file declares a variable called
java-library.archiveName
as a string and
initializes it to the value java-library.jar
.
This syntax of declaring and initializing an interface variable
was introduced into abuild with version 1.1. Here we adopt a
convention of using the build item name as the first field of the
variable name, and the literal string
archiveName
as the second field. By including
the name of the build item in the name of the interface variable,
we reduce the possibility of creating a name clash. By providing
a variable to hold the name of the archive provided by this build
item, we allow other build items to refer to this JAR file by
name without having to know what it is called. The second
interface variable, java-library.archivePath
,
contains the full path to the archive. (Notice that abuild
puts the JAR file in the dist
subdirectory
of the abuild output directory.) This enables other build
items to refer to this archive by path without knowing any
details beyond this naming convention and the name of the
providing build item. Making this type of information available
in this way is not necessarily a straight Java “SE”
environment, but it can be very useful in a Java “EE”
environment where build items that create EAR files may have to
reach into other build items to package their artifacts in higher
level archives. Experience has shown that adopting a convention
like this and following it consistently will pay dividends in the
end.
After setting these two build-item-specific variables, we assign
to two built-in variables: abuild.classpath
,
and abuild.classpath.manifest
. Most simple
JAR-providing build items will do this. Abuild actually
provides multiple classpath variables, each of which is intended
to be used in a particular way. For a discussion, please see
Section 17.5.3, “Interface Variables for Java Items”.
As with the C++ library, it is possible to build this item by
running abuild from the
basic/java-library
directory.