Creating Web Applications with the Eclipse Web Tools Project
In this article I'll show you how to develop and deploy a JSP Web application with WTP in less than an hour. I'll also cover the creation and deployment of a basic servlet and editing JSP with WTP. Let's develop the WTP application together but, first, we need to install the following software:
Our application will be a basic Web application implementing the following use cases:
Configuring MySQL Database and the Data Source
To configure MySQL database access in Tomcat, we have to add a separate file called Listing 1: DBTest.xml; the file follows a convention of "application_name.xml" under $TOMCAT\conf\catalina\localhost directory. The only problem with this file is that it may get deleted when the application is undeployed, so if you undeploy and redeploy the application, you have to place this file into the same folder again (so it's a good idea to save it somewhere else). Looking inside the DBTest.xml file, please note that in our case we are using "ODBC" for the username and don't provide any password.
Building Our Web Application Using Web Tools and a Database
We'll name the project DBTest, which will also become its context root. The Web module will be targeted to our default server: Tomcat. Click Finish and the DBTest Web project gets created. This project will contain all of our Web resources, such as HTML and JSP files, and servlets, and you'll be able to export it into a standard WAR file later, if needed.
Creating Supporting Domain Classes and Tables
Note that when creating Customer and Order classes, we define corresponding fields as their public instance variables and then can automatically generate getters and setters from those fields. This can be easily done by going to Outline view (appears after you double-click on an existing class name or create a new class), selecting a class, and selecting "Source - Generate Getters and Setters..." from the right-button menu (see Figure 3).
Along with the classes, we'd have to create corresponding database tables in a MySQL database:
CREATE TABLE CUSTOMER ( ID INT PRIMARY KEY, FIRST_NAME VARCHAR(50), LAST_NAME VARCHAR(50), ADDRESS VARCHAR(150)); CREATE TABLE ORDERS ( ID INT PRIMARY KEY, CUST_ID INT REFERENCES CUSTOMER, DATE_PLACED DATE, AMOUNT INT);Creating Database Command Classes
We'll create a special package with classes that implement a Command design pattern to perform necessary database updates. The Command pattern allows the classes to implement the common interface executing some particular command. Examples of the Command pattern in Java would be classes that implement the ActionListener interface with the actionPerformed() method. Our Command pattern interface for database integration is presented in Listing 2.
Classes implementing this command will be performing the actual database operations for reading and inserting rows into customer and order tables. The following use cases will be addressed:
public class CreateCustomer implements
Finally, in order to execute our command classes, we will need to create a class that would access the database datasource, obtain a SQL connection, and then execute a particular database command. This class will implement a Singleton design pattern, which we'll call CommandExecutor:
Object o =
The CommandExecutor class will perform the datasource lookup as follows:
InitialContext ctx = new InitialContext();
This finds the reference to the data-source we have defined in DBTest.xml by resolving its reference in a Web deployment descriptor (web.xml), which we'll define in a section below. Listing 7 has the complete code of the Command Executor class.
Creating Servlets and JSPs
Web Tools provides comprehensive wizards and editors for creating servlets and JSPs. We'll start by creating a package called "servlet" in our Eclipse project where all our servlets will reside. Next, we'll launch the wizard for creating a CreateCustomerServlet by selecting File-New-Other, and then Web-Servlet (see Figure 4).
On the screen in Figure 4, we can specify the Web Project and package where servlet should reside, and the next screen will look like Figure 5.
On this one, we can specify the optional description for the servlet, initialization parameters (that can be retrieved by the servlet in the init() method from its ServletConfig object), and URL mapping. Figure 6 shows the final screen for defining servlet.
At this point, we are presented with the capability to specify the interfaces that this servlet will implement (by default, all the servlets implement the javax.servlet.Servlet interface), and the methods that should be automatically generated when the servlet is created.
Just click on Finish and the servlet is generated. This also creates the following entry in the web.xml file:
<servlet> <description>Create Customers Servlet</description> <display-name>ListCustomers</display-name> <servlet-name>ListCustomers</servlet-name> <servlet-class>servlet.ListCustomersServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>ListCustomers</servlet-name> <url-pattern>/ListCustomers</url-pat-tern> </servlet-mapping>Another thing that must be added to web.xml is the resource reference to the datasource that has been configured in DBTest.xml:
<resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/TestDB</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> </resource-ref>This XML is necessary for the CommandExecutor datasource lookup code to work properly.
In the init() method of ListCustomers-Servlet, we will get the instance of the CommandExecutor (see Listing 8), which will retrieve the data source and cache it for future use to supply database connections. It's a good practice to cache a reference to JNDI data source, because retrieving it is a time-consuming operation.
In the doGet() method (see Listing 9), we will execute the database command and forward the list of registered customers to the JSP to display them.
In this doGet method, request attribute "customers" is set to the generic ArrayList and then RequestDispatcher object is used to forward a response to customers.jsp (see Listing 10).
Using some of the new features of J2SE 5.0 such as generics and enhanced "for" loop improves the JSP code by reducing the amount of Java code in it. Creating and editing JSP using WTP is simple. Select the Web content folder of your Web project, right-click, and select New - Other from the menu. From the dialog that appears, select Web - JSP, then specify the name of the JSP you want to create. WTP also allows you to select an existing template for your JSP to be based on. Three built-in templates are provided based on HTML, XHTML, and XML.
In a similar way, we can create other servlets and JSP pages in our application (see the source code), which is easy to import into Eclipse by using its File-Import menu. Figure 7 shows the Web site map of our simple Web application. As you can see, users initially get to index.html page from which they can perform all the other tasks, such as creating customers and orders, and listing existing customers and their orders.
Debugging Application in Eclipse with WPT
The server currently running in the debug mode will be automatically selected. After a couple of clicks, the embedded browser page should appear. From now on you can debug the Web application the same way as a regular Java program.
Deploying the Application to Tomcat
On the popup window you can check "Export source files" and "Overwrite existing file" if you wish to have your source contained within your WAR file (it may not be a good idea in production) and want to suppress a warning if the file with the same name (perhaps a previously exported version) already exists in the directory and you want to simply overwrite it.
Once the WAR file is exported, deploying it to Tomcat can be done through the Tomcat 5.0 administrative console, which in our case is located at http://localhost:8080/manager/html.
The console displays currently deployed applications and allows you to deploy new, undeploy, and reload existing applications.
Once deployed, we need to make sure that our DBTest.xml file is still there under $TOMCAT\conf\catalina\localhost with all the correct datasource definitions. If it's not, replace it with the correct one that have been saved by you before.
Now, our application is ready to run, so point your browser at http://localhost:8080/DBTest/.
Figure 9 shows what the list of orders for a registered customer will look like.
© 2005 SYS-CON Media Inc.
Questions or problems regarding this web site should be directed to email@example.com.
Copyright © 2008 Art Beckman. All rights reserved.
Last Modified: March 9, 2008