Developing Applications With Tomcat -- Processes

Previous | Top | Next
Create Configure Develop Build Test Deploy

# 5. Development Processes

Although application development can take many forms, this manual proposes a fairly generic process for creating web applications using Tomcat. The following sections highlight the commands and tasks that you, as the developer of the code, will perform. The same basic approach works when you have multiple programmers involved, as long as you have an appropriate source code control system and internal team rules about who is working on what parts of the application at any given time.

The task descriptions below assume that you will be using CVS for source code control, and that you have already configured access to the appropriate CVS repository. Instructions for doing this are beyond the scope of this manual. If you are using a different source code control environment, you will need to figure out the corresponding commands for your system.

## 5.1 Create Project Source Directory

The first step is to create a new project source directory, and customize the `build.xml` and build script you will be using. The directory structure is described in Section 4, or you can use the sample application as a starting point.

Create your project source directory, and define it within your CVS repository. This might be done by a series of commands like this, where `{project}` is the name under which your project should be stored in the CVS repository, and {username} is your login username:

    	cd {my home directory}
    	mkdir myapp	<-- Assumed "project source directory"
    	cd myapp
    	mkdir etc
    	mkdir lib
    	mkdir src
    	mkdir web
    	cvs import -m "Initial Project Creation" {project} \
    		{username} start

Now, to verify that it was created correctly in CVS, we will perform a checkout of the new project:

    	cd ..
    	mv myapp myapp.bu
    	cvs checkout {project}

Next, you will need to create and check in an initial version of the `build.xml` and `build` or `build.bat` script to be used for development. You can base `build.xml` on the basic build.xml file, or code it from scratch.

    	cd {my home directory}
    	cd myapp
    	emacs build.xml		<-- if you want a real editor :-)
    	cvs add build.xml
    	emacs build		<-- or build.bat on Windows
    	chmod +x build		<-- on Unix, make it executable
    	cvs add build		<-- or build.bat on Windows
    	cvs commit

So far, all the editing you've done to the `build.xml` file, and the corresponding build script, is local to your development directory. Committing the changes makes them visible to other developers.

Now, create the initial version of the web application deployment descriptor. You can base `web.xml` on the basic web.xml file, or code it from scratch.

    	cd {my home directory}
    	cd myapp/etc		<-- Ultimate destination will be WEB-INF
    	emacs web.xml
    	cvs add web.xml
    	cvs commit

## 5.2 Configure Tomcat To Recognize Your Application

In order for Tomcat to recognize your application, you must integrate it as described in Section 3.4. Any of the proposed techniques can be used. For our purposes, we will assume that you are using the first approach (unpacked hierarchy), because we set the deployment home to be an appropriate directory under the `$TOMCAT_HOME/webapps` directory. With multiple developers, it is easiest to install Tomcat separately for each of them, so that they can have their own TOMCAT_HOME (as well as start and stop Tomcat) independently.

## 5.3 Edit Source Code and Pages

The edit/build/test tasks will generally be your most common activities during development and maintenance. The following general principles apply. As described in Section 4, newly created source files should be located in the appropriate subdirectory, under your project source directory.

Whenever you wish to refresh your development directory to reflect the work performed by other developers, you will ask CVS to do it for you:

    	cd {my home directory}
    	cd myapp
    	cvs update -d		<-- -d means create dirs if necessary

To create a new file, go to the appropriate directory, create the file, and register it with CVS. When you are satisfied with it's contents (after building and testing is successful), commit the new file to the repository. For example, to create a new JSP page:

    	cd {my home directory}
    	cd myapp/web		<-- Ultimate destination is document root
    	emacs mypage.jsp
    	cvs add mypage.jsp
    	... build and test the application ...
    	cvs commit

Java source code that is defined in packages should be organized in a directory hierarchy (under the src/ subdirectory) that matches the package names. For example, a Java class named `com.mycompany.mypackage.MyClass.java` should be stored in file `src/com/mycompany/mypackage/MyClass.java` under your project source directory. Whenever you create a new subdirectory, don't forget to register it with CVS.

To edit an existing source file, you will generally just start editing and testing, then commit the changed file when everything works. Although CVS can be configured to required you to "check out" or "lock" a file you are going to be modifying, this is generally not used.

## 5.4 Build The Web Application

When you are ready to compile the application, issue the following commands (generally, you will want a shell window open that is set to the project source directory, so that only the last command is needed):

    	cd {my home directory}
    	cd myapp		<-- Normally leave a window open here
    	build			<-- (Windows) Defaults to "build compile"
    	./build.sh		<-- (Unix) Defaults to "build compile"

The Ant tool will be utilized to compile any new or updated Java code. If this is the first time you compile after a "build clean", it will cause everything to be recompiled.

To force the recompilation of your entire application, do this instead:

    	cd {my home directory}
    	cd myapp
    	build all                <-- (Windows)
            ./build.sh all           <-- (Unix)

This is a very good habit immediately before checking in changes, to make sure that you have not introduced any subtle problems that Javac's conditional checking did not catch.

## 5.5 Test Your Web Application

To test your application, you will want to execute it under Tomcat. Assuming you have integrated your application as described earlier, this is very simple. Under Unix, simply execute:

    	$TOMCAT_HOME/bin/startup.sh

or, under Windows, execute:

    	%TOMCAT_HOME%\bin\startup

This command starts Tomcat as a background process. Now, point your web browser at the home page for your application, by opening the following URL (where "/myapp" is the context path you have assigned to it):

    	http://localhost:8080/myapp

Now, you can exercize your application to verify that it operates correctly. When you discover something that needs to change, fix it as follows:

- To change a JSP page, modify it in the source directory and then re-execute the `build` script. The updated page will be recopied, and Tomcat will recognize this the next time that page is accessed -- the page will then be recompiled automatically.
- Changing a servlet or other Java class is similar, but the effort required depends on whether you selected the "autoreload" attribute for this context when you integrated with Tomcat. First, edit the file in its source directory, and re-execute the `build` script. The updated Java class will be recompiled. If autoreloading is selected, Tomcat will notice this change the next time this class is referenced, and will automatically unload and reload your application. Otherwise, you will need to manually stop and restart Tomcat before continuing.

Using a debugger on servlets and JSP pages is currently outside the scope of this document. Enhancements to describe these procedures is requested.

Do not forget to commit your changes to the source code repository when you have completed your testing!

## 5.6 Deploy Your Web Application

When you are through adding new functionality, and you've tested everything (you DO test, don't you :-), it is time to create the distributable version of your web application that can be deployed on the production server. The following general steps are required:

- Issue the command `build all` from the project source directory, to rebuild everything from scratch one last time.
- Issue the command `build dist` to create a distributable web application archive (WAR) file, as well as a JAR file containing the corresponding source code.
- Give the WAR file to the system administrator of your production server environment, so that he or she can install it.