LAB-4911: Refactoring Hello World Application using Spring Framework

This lab explores the motivation of Spring framework by exploring step-by-step refactoring processes for the good ol' "Hello World" sample application. It is highly recommended you do read and study the presentation slides of the "Refactoring HelloWorld Application using Spring Framework" along with this hands-on lab.

Expected duration: 200 minutes (excluding homework)

Software Needed

Before you begin, you need to install the following software on your computer.

Java Standard Development Kit (JDK™) version 6.0 (download)

If you already have installed JDK 5.0 or JDK 6.0, you can skip this.

NetBeans IDE 6.1 (download)

Download either "Web & Java EE" or "All" bundles.
When you install NetBeans IDE, it will ask you which JDK you want to use.

Spring framework

The Spring framework library jar files that are needed for building Spring applications of this lab are provided as part of the hands-on zip file under <LAB_UNZIPPED_DIRECTORY>/springhelloworld/lib directory so there is no need to download them yourself.
You can also use the NetBeans Spring framework plug-in's instead of the library jar files. The installation instruction of the NetBeans Spring framework plug-in's is described as part of LAB-4918: Spring MVC.

4911_springhelloworld.zip (download)

The zip file contains this document and the lab contents
Download it and unzip in a directory of your choice

OS platforms you can use

Windows
Solaris x86, Solaris Sparc
Linux
Mac OS X

Change Log

June 26th, 2007: Created
Aug. 26th, 2007: More explanations are added to the exercises. Things are cleaned up a bit. Homework is clarified a bit.
Jan. 4th, 2008: Uses Spring framework 2.5
July 26th, 2008: NetBeans 6.1 and GlassFish v2 are used

Things to do (by Sang Shin)

Add learning points to each exercise.

Lab Exercises

Exercise 1: Build and run "HelloWorld" sample application (10 minutes)
Exercise 2: Build and run "HelloWorldWithCommandLineArguments" sample application (20 minutes)
Exercise 3: Build and run "HelloWorldDecoupled" sample application (20 minutes)
Exercise 4: Build and run "HelloWorldDecoupledInterface" sample application (20 minutes)
Exercise 5: Build and run "HelloWorldDecoupledInterfaceWithFactory" sample application (20 minutes)
Exercise 6: Build and run "HelloWorldSpring" sample application (20 minutes)
Exercise 7: Build and run "HelloWorldSpringWithDI" sample application (20 minutes)
Exercise 8: Build and run "HelloWorldSpringWithDIXMLFile" sample application (20 minutes)
Exercise 9: Build and run "HelloWorldSpringWithDIXMLFileConstructorArgument" sample application (20 minutes)
Homework Exercise (for people who are taking Sang Shin's "Java EE Programming online course")

Exercise 1: Build and run "HelloWorld" sample application

In this exercise, you are going to build the good ol' HelloWorld application you typically do. This sample application will be the base for the several refactorings you will do in the subsequent exercises initially without using Spring framework's Dependency Injection (DI) - Exercises from 2 to 5 - and then with DI - exercises from 6 to 10.

(1.1) Open, build, and run "HelloWorld" sample application

Select File->Open Project (Ctrl+Shift+O).

Observe that he Open Project dialog box appears.
Browse down to <LAB_UNZIPPED_DIRECTORY>/springhelloworld/samples directory.

Windows: If you unzipped the 4911_springhelloworld.zip file under C:\handsonlabs directory, the directory to which you want to browse down should be C:\handsonlans\springhelloworld\samples.
Solaris/Linux: If you unzipped the 4911_springhelloworld.zip file under $HOME/handsonlabs directory, the directory to which you want to browse down should be $HOME/handsonlabs/springhelloworld/samples.

Select HelloWorld.
Click Open Project.

Observe that the HelloWorld project node appears under Projects tab window.

(1.2) Look under the hood of the "HelloWorld" sample application

Summary

In this exercise, you have built and run "HelloWorld" sample application in the simplest possible way.

Exercise 2: Build and run "HelloWorldWithCommandLineArguments" sample application

You are going to do your first but still obvious refactoring, in which you are going to pass command line arguments to the program.

(2.1) Open, build, and run "HelloWorldWithCommandLineArguments" sample application

(2.2) Look under the hood of the "HelloWorldWithCommandLineArguments" sample application

1. Study HelloWorldWithCommandLineArguments.java

public class HelloWorldWithCommandLineArguments {

    public static void main(String[] args) {
        if(args.length > 0) {
            System.out.println(args[0]);
        } else {
            System.out.println("Hello World!");
        }
    }
}

Code-2.21: HelloWorldWithCommandLineArguments.java

2. Observe that the project passes an argument.

Right click HelloWorldWithCommandLineArguments project node and select Properties.

Select Run on the left under Categories.
Observe that the Arguments field is set with "Hello, Peace!". (Figure-2.22 below)
Click OK.

Figure-2.22: Runtime argument

Summary

In this exercise, you have built and run a ready-to-build-and-run sample application.

Exercise 3: Build and run "HelloWorldDecoupled" sample application

(3.1) Open, build, and run "HelloWorldDecoupled" sample application

(3.2) Look under the hood of the "HelloWorldDecoupled" sample application

2. StandardOutMessageRenderer.java

public class StandardOutMessageRenderer {

    private HelloWorldMessageProvider messageProvider = null;

    public void render() {
        if (messageProvider == null) {
            throw new RuntimeException(
                    "You must set the property messageProvider of class:"
                    + StandardOutMessageRenderer.class.getName());
        }

        System.out.println(messageProvider.getMessage());
    }

    public void setMessageProvider(HelloWorldMessageProvider provider) {
        this.messageProvider = provider;
    }

    public HelloWorldMessageProvider getMessageProvider() {
        return this.messageProvider;
    }

}

Exercise 4: Build and run "HelloWorldDecoupledInterface" sample application

(4.1) Open, build, and run "HelloWorldDecoupledInterface" sample application

(4.2) Look under the hood of the "HelloWorldDecoupledInterface" sample application

1. HelloWorldDecoupledInterface.java

public class HelloWorldDecoupledInterface {

    public static void main(String[] args) {
        MessageRenderer mr = new StandardOutMessageRenderer();
        MessageProvider mp = new HelloWorldMessageProvider();
        mr.setMessageProvider(mp);
        mr.render();
    }
}

2. StandardOutMessageRenderer.java

public class StandardOutMessageRenderer implements MessageRenderer {

    private MessageProvider messageProvider = null;

    public void render() {
        if (messageProvider == null) {
            throw new RuntimeException(
                    "You must set the property messageProvider of class:"
                    + StandardOutMessageRenderer.class.getName());
        }

        System.out.println(messageProvider.getMessage());
    }

    public void setMessageProvider(MessageProvider provider) {
        this.messageProvider = provider;
    }

    public MessageProvider getMessageProvider() {
        return this.messageProvider;
    }
}

3. MessageRenderer.java

public interface MessageRenderer {

    public void render();

    public void setMessageProvider(MessageProvider provider);
    public MessageProvider getMessageProvider();
}

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldDecoupledInterface" sample application.

Exercise 5: Build and run "HelloWorldDecoupledInterfaceWithFactory" sample application

(5.1) Open, build, and run "HelloWorldDecoupledInterfaceWithFactory" sample application

(5.2) Look under the hood of the "HelloWorldDecoupledInterface" sample application

1. HelloWorldDecoupledWithFactory.java

public class HelloWorldDecoupledWithFactory {

    public static void main(String[] args) {
        MessageRenderer mr = MessageSupportFactory.getInstance().getMessageRenderer();
        MessageProvider mp = MessageSupportFactory.getInstance().getMessageProvider();
        mr.setMessageProvider(mp);
        mr.render();
    }
}

2. MessageSupportFactory.java

import java.io.FileInputStream;
import java.util.Properties;

public class MessageSupportFactory {

    private static MessageSupportFactory instance = null;
    private Properties props = null;
    private MessageRenderer renderer = null;
    private MessageProvider provider = null;

    private MessageSupportFactory() {
        props = new Properties();

        try {
            props.load(new FileInputStream("msf.properties"));

            // get the implementation classes
            String rendererClass = props.getProperty("renderer.class");
            String providerClass = props.getProperty("provider.class");

            renderer = (MessageRenderer) Class.forName(rendererClass).newInstance();
            provider = (MessageProvider) Class.forName(providerClass).newInstance();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    static {
        instance = new MessageSupportFactory();
    }

    public static MessageSupportFactory getInstance() {
        return instance;
    }

    public MessageRenderer getMessageRenderer() {
        return renderer;
    }

    public MessageProvider getMessageProvider() {
        return provider;
    }

}

3. msf.properties

# msf.properties
renderer.class=StandardOutMessageRenderer
provider.class=HelloWorldMessageProvider

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldDecoupledInterfaceWithFactory" sample application.

Exercise 6: Build and run "HelloWorldSpring" sample application

This exercise is the first time you are going to do refactoring using Dependency Injection (DI) feature of the Spring framework.

(6.1) Open, build, and run "HelloWorldSpring" sample application

2. Add Spring framework library jar files and commons logging library files to the project.

(6.2) Look under the hood of the "HelloWorldSpring" sample application

1. HelloWorldSpring.java

import java.io.FileInputStream;
import java.util.Properties;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;

public class HelloWorldSpring {

    public static void main(String[] args) throws Exception {

        // get the bean factory
        BeanFactory factory = getBeanFactory();

        MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");
        MessageProvider mp = (MessageProvider) factory.getBean("provider");

        mr.setMessageProvider(mp);
        mr.render();
    }

    private static BeanFactory getBeanFactory() throws Exception {
        // get the bean factory
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        // create a definition reader
        PropertiesBeanDefinitionReader rdr = new PropertiesBeanDefinitionReader(
                factory);

        // load the configuration options
        Properties props = new Properties();
        props.load(new FileInputStream("beans.properties"));

        rdr.registerBeanDefinitions(props);

        return factory;
    }
}

2. beans.properties

# beans.properties
renderer.class=StandardOutMessageRenderer
provider.class=HelloWorldMessageProvider

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldSpring" sample application.

Exercise 7: Build and run "HelloWorldSpringWithDI" sample application

(7.1) Open, build, and run "HelloWorldSpringWithDI" sample application

(7.2) Look under the hood of the "HelloWorldSpringWithDI" sample application

1. HelloWorldSpringWithDI.java

import java.io.FileInputStream;
import java.util.Properties;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;

public class HelloWorldSpringWithDI {

    public static void main(String[] args) throws Exception {

        // get the bean factory
        BeanFactory factory = getBeanFactory();

        MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");
        mr.render();
    }

    private static BeanFactory getBeanFactory() throws Exception {
        // get the bean factory
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        // create a definition reader
        PropertiesBeanDefinitionReader rdr = new PropertiesBeanDefinitionReader(
                factory);

        // load the configuration options
        Properties props = new Properties();
        props.load(new FileInputStream("beans.properties"));

        rdr.registerBeanDefinitions(props);

        return factory;
    }
}

2. beans.properties

#Message renderer
renderer.class=StandardOutMessageRenderer
# Ask Spring to assign provider bean to the MessageProvider property
# of the Message renderer bean
renderer.messageProvider(ref)=provider

#Message provider
provider.class=HelloWorldMessageProvider

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldSpringWithDI" sample application.

Exercise 8: Build and run "HelloWorldSpringWithDIXMLFile" sample application

(8.1) Open, build, and run "HelloWorldSpringWithDIXMLFile" sample application

2. Add Spring framework library files as described above.
3. Build and run HelloWorldSpringWithDIXMLFile project.

(8.2) Look under the hood of the "HelloWorldSpringWithDIXMLFile" sample application

1. HelloWorldSpringWithDIXMLFile.java

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;

public class HelloWorldSpringWithDIXMLFile {

    public static void main(String[] args) throws Exception {

        // get the bean factory
        BeanFactory factory = getBeanFactory();
        MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");
        mr.render();
    }

    private static BeanFactory getBeanFactory() throws Exception {
        // get the bean factory
        BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
                "beans.xml"));

        return factory;
    }
}

2. beans.xml

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="renderer" class="StandardOutMessageRenderer">
        <property name="messageProvider">
            <ref local="provider"/>
        </property>
    </bean>
    <bean id="provider" class="HelloWorldMessageProvider"/>
</beans>

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldSpringWithDIXMLFile" sample application.

Exercise 9: Build and run "HelloWorldSpringWithDIXMLFileConstructorArgument" sample application

(9.1) Open, build, and run "HelloWorldSpringWithDIXMLFileConstructorArgument" sample application

(9.2) Look under the hood of the "HelloWorldSpringWithDIXMLFileConstructorArgument" sample application

1. HelloWorldSpringWithDIXMLFileConstructorArgument.java

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;

public class HelloWorldSpringWithDIXMLFileConstructorArgument {

    public static void main(String[] args) throws Exception {

        // get the bean factory
        BeanFactory factory = getBeanFactory();
        MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");
        mr.render();
    }

    private static BeanFactory getBeanFactory() throws Exception {
        // get the bean factory
        BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
                "beans.xml"));

        return factory;
    }
}

2. beans.xml

3. ConfigurableMessageProvider.java

public class ConfigurableMessageProvider implements MessageProvider {

    private String message;

    public ConfigurableMessageProvider(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

}

Summary

In this exercise, you have built and run a ready-to-build-and-run "HelloWorldSpringWithDIXMLFileConstructorArgument" sample application.

Homework Exercise (for people who are taking Sang Shin's "Java EE Programming online course")

1. The homework is to modify the HelloWorldSpringWithDIXMLFile project as described below. (You might want to create a new project by copying the HelloWorldSpringWithDIXMLFile project. You can name the homework project in any way you want but here I am going to call it MyHelloWorldSpringWithDIXMLFile.)

GreetingProvider interface, which has a single method called getGreeting() method
MyGreetingProvider class which implements the GreetingProvider interface - its getGreeting() method returns "Good Morning, World!".
Modify MessageProvider interface to have setGreetingProvider(GreetingProvider provider) and getGreetingProvider() methods
Modify HelloWorldMessageProvider class so that its getMessage() method gets a message from the getGreeting() method of the GreetingProvider object.
Modify beans.xml accordingly
When you build and run the project, it displays "Good Morning, World!"

2. Send the following files to j2eehomeworks@sun.com with Subject as J2EEHomework-springhelloworld.

Zip file of the the MyHelloWorldSpringWithDIXMLFile NetBeans project. (Someone else should be able to open and run it as a NetBeans project.) You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.

cd <parent directory that contains MyHelloWorldSpringWithDIXMLFile directory> (assuming you named your project as MyHelloWorldSpringWithDIXMLFile)
jar cvf MyHelloWorldSpringWithDIXMLFile.zip MyHelloWorldSpringWithDIXMLFile (MyHelloWorldSpringWithDIXMLFile should contain nbproject directory)

Captured output screen - name it as J2EEHomework-springhelloworld.gif orJ2EEHomework-springhelloworld.jpg (or J2EEHomework-springhelloworld.<whatver graphics format>)

Any screen capture that shows that your program is working is good enough.

If you decide to use different IDE other than NetBeans, the zip file should contain all the files that are needed for rebuilding the project - war file with necessary source files is OK.