Start with two classes in a single directory. One’s a mountain bike, and the other is a registry that holds bikes. Call it a façade. You’ll add bikes to the store within the façade constructor, and then print them all out using a third primitive class. (All of the classes shown in the book reside in a single package, com.springbook, unless otherwise specified.)

Example 1-1 shows the bike.

public class Bike {
    private String manufacturer;
    private String model;
    private int frame;
    private String serialNo;
    private double weight;
    private String status;

    public Bike(String manufacturer, String model, int frame, 
                String serialNo, double weight, String status) {

        this.manufacturer = manufacturer;
        this.model = model;
        this.frame = frame;
        this.serialNo = serialNo;
        this.weight = weight;
        this.status = status;
    }

    public String toString( ) {
        return "Bike : " +
                "manufacturer -- " + manufacturer +
                "
: model -- " + model +
                "
: frame -- " + frame +
                "
: serialNo -- " + serialNo +
                "
: weight -- " + weight +
                "
: status -- " + status +
                ".
";
    }
    
    public String getManufacturer( ) { return manufacturer; }

    public void setManufacturer(String manufacturer) {
        this.manufacturer = manufacturer;
    }

    public String getModel( ) { return model; }

    public void setModel(String model) { this.model = model; }

    public int getFrame( ) { return frame; }

    public void setFrame(int frame) { this.frame = frame; }

    public String getSerialNo( ) { return serialNo; }

    public void setSerialNo(String serialNo) { this.serialNo = serialNo; }

    public double getWeight( ) { return weight; }

    public void setWeight(double weight) { this.weight = weight; }

    public String getStatus( ) { return status; }

    public void setStatus(String status) { this.status = status; }
}

Example 1-2 is the façade.

import java.util.*;
public class RentABike {

    private String storeName;
    final List bikes = new ArrayList( );

    public RentABike(String storeName) {
        this.storeName = storeName;
        bikes.add(new Bike("Shimano", "Roadmaster", 20, "11111", 15, 
                           "Fair"));
        bikes.add(new Bike("Cannondale", "F2000 XTR", 18, "22222",12, 
                           "Excellent"));
        bikes.add(new Bike("Trek","6000", 19, "33333", 12.4, 
                           "Fair"));
    }

    public String toString( ) { return "RentABike: " + storeName; }

    public List getBikes( ) { return bikes; }

    public Bike getBike(String serialNo) {
        Iterator iter = bikes.iterator( );
        while(iter.hasNext( )) {
            Bike bike = (Bike)iter.next( );
            if(serialNo.equals(bike.getSerialNo( ))) return bike;
        }
        return null;
    }
}

Finally, Example 1-3 is the view.

import java.util.*;
public class CommandLineView {
    private RentABike rentaBike;
    public CommandLineView( ) {rentaBike = new RentABike("Bruce's Bikes"); }

    public void printAllBikes( ) {
        System.out.println(rentaBike.toString( ));
        Iterator iter = rentaBike.getBikes( ).iterator( );
        while(iter.hasNext( )) {
            Bike bike = (Bike)iter.next( );
            System.out.println(bike.toString( ));
        }
    }

    public static final void main(String[] args) {
        CommandLineView clv = new CommandLineView( );
        clv.printAllBikes( );
    }
}

Next, you’ll compile the application, like this:

C:RentABikeAppsrc> javac -d ../out *.java

Your output directory now contains the compiled class files.

Directory of C:RentABikeAppout

07/28/2004  10:12 AM    <DIR>          .
07/28/2004  10:12 AM    <DIR>          ..
07/28/2004  10:10 AM             1,753 Bike.class
07/28/2004  10:10 AM             1,431 RentABike.class
07/28/2004  10:10 AM               940 CommandLineView.class

Run the application like this:

C:RentABikeAppout> java CommandLineView

RentABike: Bruce's Bikes
Bike : manufacturer -- Shimano
: model -- Roadmaster
: frame -- 20
: serialNo -- 11111
: weight -- 15.0
: status -- Fair.

Bike : manufacturer -- Cannondale
: model -- F2000 XTR
: frame -- 18
: serialNo -- 22222
: weight -- 12.0
: status -- Excellent.

Bike : manufacturer -- Trek
: model -- 6000
: frame -- 19
: serialNo -- 33333
: weight -- 12.4
: status -- Fair.

Nothing good. The current design is simple, but it’s also hardwired. You can immediately see several problems:

But we’re willing to take some short cuts to get the Java base working, and the underpinnings of the application under way. We’ll decouple and automate in the next example.

...rolling up the whole burrito all at once? You might decide to install Spring, Hibernate, Java, Ant, and JUnit all at the same time. It’s been my experience that if you control one variable at a time, you actually save time, especially as you’re establishing your foundation. Once you’ve got all of your tools installed and working, then you can collect many of these steps into one.

You don’t have to use a lightweight container to use this design pattern. To decouple with dependency injection, there are three steps:

The first step is to extract the interface. We’ll rename the RentABike file, class definition, and constructor to ArrayListRentABike (Example 1-4), and create an interface (Example 1-5).

import java.util.*;

public class ArrayListRentABike implements RentABike {
    private String storeName;
    final List bikes = new ArrayList( );

    public ArrayListRentABike( ) { initBikes( ); }

    public ArrayListRentABike(String storeName) {
        this.storeName = storeName;
        initBikes( );
}

public void initBikes( ) {
    bikes.add(new Bike("Shimano", "Roadmaster", 20, "11111", 15, "Fair"));
    bikes.add(new Bike("Cannondale", "F2000 XTR", 18, "22222", 12, "Excellent"));
    bikes.add(new Bike("Trek", "6000", 19, "33333", 12.4, "Fair"));
}

public String toString( ) { return "RentABike: " + storeName; }

public List getBikes( ) { return bikes; }

public Bike getBike(String serialNo) {
    Iterator iter = bikes.iterator( );
    while(iter.hasNext( )) {
        Bike bike = (Bike)iter.next( );
        if(serialNo.equals(bike.getSerialNo( ))) return bike;
    }
        return null;
    }
}

import java.util.*;
interface RentABike {
    List getBikes( );
    Bike getBike(String serialNo);
}

Next, Example 1-6 gives the view. Note that we’ve extracted the methods that print out the bikes to the command line. We also add a property to the view, which uses the RentABike interface.

import java.util.*;
public class CommandLineView {
    private RentABike rentaBike;
    public CommandLineView( ) { }

    public void setRentaBike(RentABike rentaBike) {
        this.rentaBike = rentaBike;
    }

    public RentABike getRentaBike( ) { return this.rentaBike;}

    public void printAllBikes( ) {
        System.out.println(rentaBike.toString( ));
        Iterator iter = rentaBike.getBikes( ).iterator( );
        while(iter.hasNext( )) {
            Bike bike = (Bike)iter.next( );
            System.out.println(bike.toString( ));
        }
    }
}

Finally, we have an assembler that creates each object, and sets the property (Example 1-7).

public class RentABikeAssembler {
    public static final void main(String[] args) {
        CommandLineView clv = new CommandLineView( );
        RentABike rentaBike = new ArrayListRentABike("Bruce's Bikes");
        clv.setRentaBike(rentaBike);
        clv.printAllBikes( );
    }
}

Next, you’ll compile the application like this:

C:RentABikeAppsrc> javac -d ../out *.java

Your output directory now contains the compiled class files.

Directory of C:RentABikeAppout

07/28/2004  10:12 AM    <DIR>          .
07/28/2004  10:12 AM    <DIR>          ..
07/28/2004  10:50 AM             1,475 ArrayListRentABike.class
07/28/2004  10:50 AM             1,753 Bike.class
07/28/2004  10:50 AM               186 RentABike.class
07/28/2004  10:50 AM               495 RentABikeAssembler.class
07/28/2004  10:50 AM               944 CommandLineView.class

Run the application like this:

C:RentABikeAppout>java RentABikeAssembler

RentABike: Bruce's Bikes
Bike : manufacturer -- Shimano
: model -- Roadmaster
: frame -- 20
: serialNo -- 11111
: weight -- 15.0
: status -- Fair.

Bike : manufacturer -- Cannondale
: model -- F2000 XTR
: frame -- 18
: serialNo -- 22222
: weight -- 12.0
: status -- Excellent.

Bike : manufacturer -- Trek
: model -- 6000
: frame -- 19
: serialNo -- 33333
: weight -- 12.4
: status -- Fair.

You just saw an example of dependency injection, outside of a lightweight container. The lightweight container community makes a whole lot of noise, but the ideas behind the movement are simple. Program using interfaces, and let a third party inject the dependency instead of setting it yourself.

You’re going to eventually replace the assembler with Spring. When that happens, Spring will actually fire the constructors for our objects and set the dependencies. But first, you’ll need to give this build a little attention.

...service locators, or factory objects? Of course, dependency injection is not the only way to manage dependencies. In fact, it’s not the only good way. J2EE users tend to use service locators. Using that pattern (shown in Figure 1-2), you take a dependency, wrap it in an interface, register it in a dictionary, and then look it up using a helper class called a locator. It’s not a bad approach.

Figure 1-2. J2EE applications manage dependencies with service locators

The dependency injection strategy lets you pick a consistent approach, and separate the dependency completely from your application. You’ll see how this approach will help you test, and help you build applications that are easy to customize and configure.

In fact, earlier lightweight containers, like Avalon, used this approach. Most modern containers provide dependency lookup, but prefer other types of dependency resolution.

You’ll need to download an Ant distribution. You may as well use the one that comes with Spring (http://springframework.org/ ). To run all of the examples for this book, you’ll want to get Spring version 1.1, or later. Follow all of the directions for your platform.

Next, you’ll organize the directory structure in a way that’s friendly for web applications and Spring. I recommend that you use the organization that you’ll find with the Spring sample applications, so that you’ll have a working example. These are the directories that you’ll use:

To start with, place the source files like this:

Finally, you’ll need an Ant build script, which we’ll place in the root folder of our project. Example 1-8 is the one that we’ll use to start with.

<?xml version="1.0"?>
<project name="RentABike" default="compile" basedir=".">

    <property name="src.dir" value="src"/>
    <property name="test.dir" value="test"/>
    <property name="war.dir" value="war"/>
    <property name="class.dir" value="${war.dir}/classes"/>

    <target name="init">
        <mkdir dir="${class.dir}"/>
    </target>

    <target name="compile" depends="init"
            description="Compiles all source code">
        <javac srcdir="${src.dir}"
               destdir="${class.dir}"
        />
    </target>

    <target name="clean" description="Erases contents of classes dir">
        <delete dir="${class.dir}"/>
    </target>

</project>

To run a build, switch to the directory called C:RentABikeApp> and type:

[1]C:RentABikeApp>ant
Buildfile: build.xml

init:
    [mkdir] Created dir: C:RentABikeAppwarWEB-INFclasses

compile:
    [javac] Compiling 5 source files to C:RentABikeAppwarWEB-INFclasses

BUILD SUCCESSFUL
Total time: 2 seconds

Ant built the system in one automated step. That’s not such a big deal now, but it will be increasingly important as the build steps get more sophisticated. You’ll want the system to run unit tests, add any precompilation steps such as JDO’s byte code enhancement in Chapter 5, or copy configuration files to the appropriate place. You can also have special tasks to initialize a database or deploy our war file to an application server.

...the fact that some integrated development environments don’t need Ant at all? If you want to work with these without Ant, you’ll need to make sure that:

From here on out, we’ll tell you when you need to add a new directory, execute the application, or make a new library available. We won’t tell you how. We assume you know how to use your own IDE, or Ant directly.

You’ll first have to download Spring. Go get it at http://www.springframework.org. That will point you to sourceforge, where you’ll get the best version for your platform. We used Version 1.1. You will need to add a new folder to your project, warWEB-INFlib, and put the Spring libraries there (everything in the dist folder of your Spring distribution).

Moving a well-designed plain-ordinary-Java-object (POJO) application to Spring is straightforward. It only takes three steps:

Since our individual parts are already built to take advantage of dependency injection, moving to Spring is an easy exercise. We simply replace our assembler with a Spring version, and provide a configuration file which will go in the warWEB-INF folder.

Example 1-9 shows the configuration file.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

    <bean id="rentaBike" class="ArrayListRentABike">
        <property name="storeName"><value>"Bruce's Bikes"</value></property>
    </bean>

    <bean id="commandLineView" class="CommandLineView">
        <property name="rentaBike"><ref bean="rentaBike"/></property>
    </bean>

</beans>

And Example 1-10 is the new assembler that replaced the old RentABikeAssembler.

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class RentABikeAssembler {
    public static final void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new 
           ClassPathXmlApplicationContext("RentABikeApp-context.xml");
        CommandLineView clv = 
           (CommandLineView)ctx.getBean("commandLineView");
        clv.printAllBikes( );
    }
}

You may be scratching your head and wondering what the big deal is all about. These tiny improvements in architecture will have profound implications throughout the lifecycle of this application. You’ll see the benefits almost immediately. I won’t harp on them here. Instead, let’s talk about what’s happening under the covers.

...Pico, Hive Mind, and Avalon? These are all lightweight containers. Each of them has strengths and weaknesses. Neither Avalon nor Hive Mind have the critical mass that you’ll want out of a container, especially if you want services that interoperate. Right now, Spring and Pico have the most market share. People tend to use Pico if they want a standalone container, but Spring has the most comprehensive support for additional services, such as declarative transactions and a rich persistence strategy.

Think of a unit test as another client of your application. The test makes assertions about what should be true should the application be working correctly. For example, if you add an object to a list, the size should increase by one. Then, you can run the test standalone while you’re building a new feature or debugging an old one. You can also run the tests as part of the overall build. If the tests fail, then the build fails.

Each test case is a subclass of TestCase. In Example 1-11, the test will be a client of the façade.

public class RentABikeTest extends TestCase{

    private RentABike rentaBike;

    public void setUp( ) {
        rentaBike = new ArrayListRentABike("Bruce's Bikes");
    }
    
    public void testGetName( ) {
        assertEquals("Bruce's Bikes", rentaBike.getStoreName( ));
    }

    public void testGetBike( ) {
        Bike bike = rentaBike.getBike("11111");
        assertNotNull(bike);
        assertEquals("Shimano", bike.getManufacturer( ));
    }

    public void testGetBikes( ) {
        List bikes = rentaBike.getBikes( );
        assertNotNull(bikes);
        assertEquals(3, bikes.size( ));
    }
}

Next, you’ll need to modify Ant to run the tests. Example 1-12 gives the additional task to compile the test (note that you’ll have to modify PATH_TO_JUNIT to be appropriate for your environment).

<property name="test.class.dir" value="${test.dir}/classes"/>
<path id="bikestore.class.path">
     <fileset dir="${spring.dir}/dist">
          <include name="*.jar"/>
     </fileset>
     <pathelement location="${spring.dir}/lib/jakarta-commons
            /commons-logging.jar"/>
     <pathelement location="${spring.dir}/lib/log4j/log4j-1.2.8.jar"/>
     <pathelement location="${spring.dir}/lib/j2ee/servlet.jar"/>
     <dirset dir="${basedir}"/>
     <dirset dir="${class.dir}"/>
</path>
<path id="junit.class.path">
     <path refid="bikestore.class.path"/>
     <pathelement location="PATH_TO_JUNIT"/>
</path>
<target name="compile.test" depends="init"
            description="Compiles all unit test source">
        <javac srcdir="${test.dir}"
               destdir="${test.class.dir}"
               classpathref="junit.class.path"/>
</target>

Example 1-13 is the task to run the tests.

<target name="test" depends="compile.test, compile"
            description="Runs the unit tests">
        <junit printsummary="withOutAndErr" haltonfailure="no" 
               haltonerror="no" fork="yes">
            <classpath refid="junit.class.path"/>
            <formatter type="xml" usefile="true" />
            <batchtest todir="${test.dir}">
                <fileset dir="${test.class.dir}">
                    <include name="*Test.*"/>
                </fileset>
            </batchtest>
        </junit>
    </target>

Here’s the result of the test:

Buildfile: build.xml

init:

compile:

compile.test:

test:
    [junit] Running RentABikeTest
    [junit] Tests run: 3, Failures: 0, Errors: 0, Time elapsed: 0.36 sec

BUILD SUCCESSFUL
Total time: 2 seconds

Ant just built the entire application, including the tests. Then, Ant ran the tests. All succeeded. If a test case had failed, then you’d have to make it pass before the build could be successful. In this way, you catch small errors before they become larger ones.

In the next chapter, we’ll really start to exercise Spring. We’ll build a true user interface for this application using Spring’s WebMVC. We’ll also show you how to integrate existing user interface components into Spring.