Develop Reference

Why do we set classpath in ant

Below is the code for setting class path in ant.
<path id="build.classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>
<target name="compile" depends="clean">
<javac srcdir="${src.dir}" destdir="${build.dir}" classpathref="build.classpath" />
</target>
Why do we need to set classpath in ant ?

Think of ant as a framework to run your build tasks - compiling the code, running the (unit) tests, etc. In order to properly compile and execute your (test) code, java will need access to the third party libraries you may be using (e.g., JUnit for running unit tests). The classpath tells java where these JARs are located, so it can use them.

AspectJ does not weave JUnit classes when built with Ant

I have created an aspect with AspectJ, to build it and weave my classes during compile time with it I use ANT task. I have also created test class that is intended to test how that aspect works. Here is the problem: my test classes are not being weaved. And I do not why.
My source folder is src/main/java and my test folder is src/test/java
When I move my test class to the source folder everything works fine..
Update 1: I am not using AspectJ in conjunction with Spring. Also I am not using aop.xml, my aspects are being annotated.
Update 2: my ant compile-aspectj-tests target looks like this:
<target name="compile-aspectj-tests" depends="compile">
<taskdef resource="org/aspectj/tools/ant/taskdefs/aspectjTaskdefs.properties">
<classpath>
<pathelement location="${ivy.install.dir}/../cache/org.aspectj/aspectjtools/jars/aspectjtools-1.7.3.jar" />
</classpath>
</taskdef>
<iajc srcDir="${test.dir}/java" destDir="${compiled.tests}" debug="on" Xlintwarnings="true"
showWeaveInfo="true" source="${targetVersion}" target="${targetVersion}" >
<classpath>
<path refid="test.classpath" />
<pathelement location="${compiled.src}" />
</classpath>
<aspectpath location="${compiled.src}" />
</iajc>
</target>
This is what I see in the console:
compile-aspectj-tests:
[iajc] warning at com/.../cache/aspects/RetryJedisConnectionExceptionAspect.java::0 no match for this type name: RetryJedisConnectionException [Xlint:invalidAbsoluteTypeName]
Any help would be appreciated.

Enforce compilation dependencies with Ant compiler tasks

There are certain compiler dependencies that are not allowed in our (Java) environment. We have two servers, call them Application and Process. We have three root Java packages, call them Application, Process, and Shared. Application and Process are not allowed to reference each other, but they can each reference Shared. Shared can reference any class in any of the other two packages. How can I enforce these dependencies with Ant? The problem, as you might guess, is that in our Eclipse based environment everything compiles successfully, but we've come across runtime errors where a class is not there (since we have multiple servers).
I have attempted quite a few things but nothing has worked. See my current attempt below, where I have omitted irrelevant code for clarity. Comments are included.
<!--Compile the 'shared' directories. Since shared depends on Application and Process, we compile everything then delete Application and Process later. -->
<javac srcdir="${src.dir}" destdir="${build.dir}">
<classpath>
...
</classpath>
</javac>
<delete dir="${build.dir}/application" />
<delete dir="${build.dir}/process" />
<!--Compile the 'application' directories -->
<javac sourcepath="" srcdir="${src.dir}/application" destdir="${build.dir}">
<classpath>
<pathelement location="${build.dir}/shared" />
...
</classpath>
</javac>
<!--Compile the 'process' directories -->
<javac sourcepath="" srcdir="${src.dir}/process" destdir="${build.dir}">
<classpath>
<pathelement location="${build.dir}/shared" />
...
</classpath>
</javac>

you need to split shared into three parts, shared-standalone, shared-application and shared-process.
compile shared-standalone first,
compile shared-application together with application,
compile shared-process together with process.

Getting CLASSPATH from environment in ant build.xml

How can I get the CLASSPATH from the environment in a build.xml?
I've tried
<property environment="env"/>
<path id="classpath">
<pathelement location="${env.CLASSPATH}"/>
</path>
<target name="compile">
<javac includeantruntime="false">
<src path="${src}"/>
<classpath refid="classpath"/>
</javac>
</target>
I have a feeling this is failing because ${env.CLASSPATH} is a colon-separated list.
How then, can I get my classpath? I was surprised when ant didn't use my environment's CLASSPATH.
EDIT:
I've found a quick solution, but the preferred method is to use a separate properties file like the example here http://www.java2s.com/Code/Java/Ant/Useseparatepropertyfile.htm
Solution is, add
<property name="build.sysclasspath" value="first"/>
to the top of the build.xml

Yes, it's failing because it's a colon-separated list. In general, it's considered a bad idea to specify the class-path externally and use it within Ant. This is because running the same Ant script on different machines may yield different results. Instead, you're better of specifying the class-path from within Ant.

How can I exclude sources in a javac task in ant?

I have the following in my build.xml:
<target name="compile.baz" depends="init">
<javac destdir="${build.dir}/classes" debug="on">
<compilerarg value="-Xlint:deprecation"/>
<src>
<pathelement location="${src.dir}/com/foo/bar/baz/" />
<pathelement location="${src.dir}/com/foo/bar/quux/" />
<!-- Need to exclude ${src.dir}/com/foo/bar/quux/dontwant/ -->
</src>
<classpath refid="classpath.jars" />
</javac>
...
</target>
This mostly does what I want, except that (as the comment says) I do not want the files in
${src.dir}/com/foo/bar/quux/dontwant/ to be compiled by this task (but I do want everything else under ${src.dir}/com/foo/bar/quux/ to be compiled in this task).
I'm a complete ant n00b, and the documentation hasn't been much help to me. I see several places where it says there are various exclude/excludes elements/attributes, but every variation I can think of either has no effect or results in an error like "blah doesn't support the 'exclude' attribute".

A couple of people suggested using <exclude>. This didn't work with the way my task was specified. trashgod's answer linked to the sixth example on this page which gave me an idea of how to restructure my task specification.
It looks like my problem was related to the way I was specifying the source files. Rather than using <pathelement> elements in a <src>, like this:
<src>
<pathelement location="${src.dir}/com/foo/bar/baz/" />
<pathelement location="${src.dir}/com/foo/bar/quux/" />
</src>
I switched to using a single <src> with a path and then a set of <include> elements, like this:
<src path="${src.dir}" />
<include name="com/foo/bar/baz/**" />
<include name="com/foo/bar/quux/**" />
This appears to be functionally identical, but is compatible with the use of <exclude>:
<exclude name="${src.dir}/com/foo/bar/quux/dontwant/**"/>
(Actually, I'm surprised that what was there in the first place worked at all.)

From my experiments you should not include full path for file you want to exclude.
This one doesn't work:
<javac>
(...>
<exclude name="${src.dir}/com/foo/blah/blah1/FILENAME.java"/>
(...)
</javac>
but this one does:
<javac>
(...>
<exclude name="com/foo/blah/blah1/FILENAME.java"/>
(...)
</javac>

Try
<javac>
(...>
<exclude name="${src.dir}/com/foo/bar/quux/dontwant/*" />
(...)
</javac>

I'm not sure about the rest, but the <exclude/> nested element should work in the Javac task. See the sixth example down.
Addendum: Patterns, including the ** notation, are discussed in Directory-based Tasks.
<target name="compile.baz" depends="init">
<javac destdir="${build.dir}/classes" debug="on">
<compilerarg value="-Xlint:deprecation"/>
<src>
<pathelement location="${src.dir}/com/foo/bar/baz/" />
<pathelement location="${src.dir}/com/foo/bar/quux/" />
</src>
<exclude name="${src.dir}/com/foo/bar/quux/dontwant/**"/>
...
</javac>
...
</target>

If you are trying to exclude Java classes but Ant is still trying to compile them then this may be due to references to these classes in your code.
If A.java has a reference to B.java and you try to exclude B.java then compiling A.java will require that B.java is compiled too.
This is one reason for interfaces in Java, so you can compile the interface without needing to compile the implementations.

try
folder "test" under {source.dir} would not be complied
<javac destdir="${compile.dir}" ...>
<src path="${source.dir}" />
<exclude name="test/**"/>
</javac>