Build systems

Build systems are not necessary for building web applications with Spring Web Flow, but they greatly assist a developer by resolving dependencies between packages and automating the build process. In this article, we will show you how to build your projects with Apache Ant and Apache Maven.

Ant

Ant is a powerful and very flexible build tool. You can write Extensible Markup Language (XML) files, which tell Ant how to build your application, where to find your dependencies, and where to copy the compiled files. Often, you won’t find the need to download Ant, as it is already built-in into popular IDEs such as Eclipse and NetBeans. Ant does not provide you with an automatic dependency resolving mechanism. So you will have to manually download all the libraries your application needs. Alternatively, you can use a third-party dependency resolving system such as Apache Ivy, which we will describe later in this article. When you have obtained a copy of Ant, you can write a build.xml file as shown in the following code.

<?xml version="1.0" encoding="UTF-8"?>
<project name="login.flow" default="compile">
   <description>
      login.flow
   </description>
   <property file="loginflow.properties"/>
   <path id="classpath">
      <fileset dir="lib/">
         <include name="*.jar" />
      </fileset>
   </path>
   <target name="init">
      <mkdir dir="${build}" />
      <mkdir dir="${build}/WEB-INF/classes" />
   </target>
   <target name="assemble-webapp" depends="init">
      <copy todir="${build}" overwrite="y">
         <fileset dir="${webapp-src}">
            <include name="**/*/" />
         </fileset>
      </copy>
   </target>
   <target name="compile" depends="assemble-webapp">
      <javac srcdir="${src}" destdir="${build}/WEB-INF/classes">
         <classpath refid="classpath" />
      </javac>
      <echo>Copying resources</echo>
      <copy todir="${build}/WEB-INF/classes" overwrite="y">
         <fileset dir="${resources}">
            <include name="**/*/" />
           </fileset>
      </copy>
      <echo>Copying libs</echo>
      <copy todir="${build}/WEB-INF/lib" overwrite="y">
         <fileset dir="lib/">
            <include name="*.jar" />
         </fileset>
      </copy>
   </target>
</project>

First of all, we will specify that we have defined a few required folders in an external PROPERTIES file. The loginflow.properties, stored in your project’s root folder, looks like this:

src = src/main/java
webapp-src = src/main/webapp
resources = src/main/resources
build = target/chapter02

These define the folders where your source code lies, where your libraries are located, and where to copy the compiled files and your resources. You do not have to declare them in a PROPERTIES file, but it makes re-using easier. Otherwise, you will have to write the folder names everywhere. This would make the build script hard to maintain if the folder layout changes.

In the init target, we create the folders for the finished web application. The next is the assemble-webapp target, which depends on the init target. This means that if you execute the assemble-webapp target, the init target gets executed as well. This target will copy all the files belonging to your web application (such as the flow definition file and your JSP files) to the output folder.

If you want to build your application, you will have to execute the compile target. It will initialize the output folder, copy everything your application needs to it, compile your Java source code, and copy the compiled files, along with the dependent libraries.

If you want to use Apache Ivy for automatic dependency resolution, first, you have to download the distribution from http://ant.apache.org/ivy. This article refers to Version 2.0.0 Release Candidate 1 of Ivy. Unpack the ZIP file and put the ivy-2.0.0-rc1.jar file in your %ANT_HOME%lib folder. If you are using the Eclipse IDE, Ant is already built into the IDE. You can add the JAR file to its classpath by right-clicking on the task you want to execute and choosing Run As | Ant Build…

In the appearing dialog, you can add the JAR file on the Classpath tab, either by clicking on Add JARs… and selecting a file from your workspace, or by selecting Add External JARs…, and looking for the file in your file system.

Afterwards, you just have to tell Ant to load the required libraries automatically by modifying your build script. We have highlighted the important changes (to be made in the XML file) in the following source code:

<project 
 
   name="login.flow" 
   default="compile">
...
<target name="resolve"
 description="--> retrieve dependencies with ivy">
      <ivy:retrieve />
   </target>
...
</project>

The last step, before we can actually build the project, involves specifying which libraries you want Ivy to download automatically. Therefore, we will now have to compose an ivy.xml file, stored in your project’s root folder, which looks like this:

<ivy-module version="2.0">
     <info organisation="com.webflow2book" module="login.flow"/>
   <dependencies>
      <dependency org="org.springframework.webflow" 
         name="org.springframework.binding" rev="2.0.5.RELEASE" />
      <dependency org="org.springframework.webflow" 
         name="org.springframework.js" rev="2.0.5.RELEASE" />
      <dependency org="org.springframework.webflow" 
         name="org.springframework.webflow" rev="2.0.5.RELEASE" />
   </dependencies>
...
</ivy-module>

To keep the example simple, we only showed the Spring Web Flow entries of the file we just mentioned. In order to be able to build your whole project with Apache Ivy, you will have to add all other required libraries to the file. The org attribute corresponds to the groupId tag from Maven, as does the name attribute with the artifactId tag. The rev attribute matches the version tag in your pom.xml.

Maven

Maven is a popular application build system published by the Apache Software Foundation. You can get a binary distribution and plenty of information from the project’s web site at http://maven.apache.org. After you have downloaded and unpacked the binary distribution, you have to set the M2_HOME environment variable to point to the folder where you unpacked the files. Additionally, we recommend adding the folder %M2_HOME%bin (on Microsoft® Windows system) or $M2_HOME/bin (on Unix or Linux systems) to your PATH variable.

Maven has a configuration file called settings.xml, which lies in the M2_HOMEconf folder. Usually, you do not edit this file, unless you want to define proxy settings (for example, when you are in a corporate network where you have to specify a proxy server to access the Internet), or want to add additional package repositories.

There are several plug-ins for the most popular IDEs around, which make working with Maven a lot easier than just using the command line. If you do not want to use a plug-in, you have to at least know that Maven requires your projects to have a specific folder layout. The default folder layout looks like this:

The root folder, directly below your projects folder, is the src folder. In the main folder, you have all your source files (src/main/java), additional configuration files, and other resources you need (src/main/resources), and all JSP and other files you need for your web application (src/main/webapp). The test folder can have the same layout, but is used for all your test cases. Please see the project’s website for more information on the folder layout.

To actually build a project with Maven, you need a configuration file for your project. This file is always saved as pom.xml, and lies in the root folder of your project. The pom.xml for our example is too long to be included in this article. Nevertheless, we want to show you the basic layout. You can get the complete file from the code bundle uploaded on http://www.packtpub.com/files/code/5425_Code.zip.

<project

xsi_schemaLocation=”http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd”>
<modelVersion>4.0.0</modelVersion>
<groupId>com.webflow2book</groupId>
<artifactId>chapter02</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>chapter02 Maven Webapp</name>
<url>http://maven.apache.org</url>

This is a standard file header where you can define the name and version of your project. Further, you can also specify how your project is supposed to be packaged. As we wanted to build a web application, we used the war option. Next, we can de?ne all the dependencies our project has to the external libraries:

<dependencies>
    <dependency>
       <groupId>org.springframework.webflow</groupId>
       <artifactId>org.springframework.binding</artifactId>
       <version>2.0.5.RELEASE</version>
    </dependency>
    <dependency>
       <groupId>org.springframework.webflow</groupId>
       <artifactId>org.springframework.js</artifactId>
       <version>2.0.5.RELEASE</version>
    </dependency>
    <dependency>
       <groupId>org.springframework.webflow</groupId>
       <artifactId>org.springframework.webflow</artifactId>
       <version>2.0.5.RELEASE</version>
    </dependency>
...
</dependencies>

As you can see, defining a dependency is pretty straightforward. If you are using an IDE plug-in, the IDE can do most of this for you. To build the application, you can either use an IDE or open a command-line window and type commands that trigger the build. To build our example, we can enter the projects folder and type:

mvn clean compile war:exploded

This cleans up the target folder, compiles the source files, and compiles all necessary files for our web application in the target folder. If you use Tomcat, you can point your context docBase to the target folder. The application will be automatically deployed on the startup of Tomcat, and you can test your application.