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:

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: