| Previous | Top | Next |
| Create Configure Develop Build Test Deploy | ||
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.
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
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.
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.
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.
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:
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.
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!
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:
build all from the project source
directory, to rebuild everything from scratch one last time.
build dist to create a distributable
web application archive (WAR) file, as well as a JAR file containing
the corresponding source code.