Servlet and JSP development with Eclipse WTP - Tutorial

 

Eclipse Web Tool Platform (WTP)

This article describes the development of servlets and JSPs with Eclipse WTP.

It starts by developing servlets which keeps track of the number of visitors of a website, including a servlet which stores this data into a file.

The creation of JavaServerPages and well as the creation of a war file to run the application in a web container is also explained.

This article assume that you have already basic Eclipse knowledge. The following uses the JDK 1.6, Eclipse 3.5 (Galileo) and Tomcat 6.0 for its examples.

 

Table of Contents

1. Eclipse Web Tool Platform
1.1. Overview of Eclipse WTP
1.2. Additional Eclipse WTP resources
1.3. Dynamic Web Project
2. Tomcat Installation
3. Installation of WTP
4. WTP Configuration
4.1. Server
5. Servlets
5.1. Overview
5.2. Project
5.3. Creating Data Access Object
5.4. Creating the Servlet
5.5. Run
6. JavaServer Pages (JSPs)
6.1. Overview
6.2. Create Project
6.3. Create the Controller (servlet)
6.4. Create the Views (JSP)
6.5. Run it
7. Web Archive - How to create a war file from Eclipse
8. Thank you
9. Questions and Discussion
10. Links and Literature
10.1. Source Code
10.2. Web development resources
10.3. Other Resources

 

1. Eclipse Web Tool Platform

1.1. Overview of Eclipse WTP

Tip

In case you are new to Java web development you may want to get a quick overview of webdevelopment with Java in the following short article: Introduction to Java Webdevelopment .

Eclipse WTP provides tools for developing standard Java web applications and Java EE applications. Eclipse WTP simplifies the creation of web artifacts and provides a runtime environment in which these artifacts can be deployed, started and debugged. Typical web artifacts in a Java environment are HTML pages, XML files, webservices, servlets and JSPs.

The following article will focus on the creation of servlets and JSP with Eclipse WTP and how to use the runtime environment of Eclipse to test them.

Eclipse WTP supports all mayor webcontainer, e.g. Jetty and Apache Tomcat as well as the mayor Java EE application server. This tutorial will be based on Apache Tomcat.

1.2. Additional Eclipse WTP resources

The development of webservices with Eclipse WTP is covered in Webservices with Axis2 and the Eclipse Web Tool Platform (WTP) - Tutorial .

The development of JavaServerFaces is covered in JavaServer Faces (JSF) development with Eclipse WTP JSF - Tutorial and JSF with Apache Myfaces Trinidad and Eclipse .

1.3. Dynamic Web Project

Eclipse uses builders which are responsible for working with the relevant artifacts. Eclipse WTP uses "Dynamic Web Projects". These projects provide the necessary builders to run, debug and deploy a Java web application. Therefore for the development of Java web application you create "Dynamic Web Projects" .

2. Tomcat Installation

Download the Tomcat server 6.0.x from the following webpage http://tomcat.apache.org/

Installing Tomcat (on windows) is very easy and self explaining as it comes with a standard installer. For an overview of the usage and configuration of Tomcat see Apache Tomcat - Tutorial . For a tomcat installation on other platform please use Google.

After the installation test if Tomcat in correctly installed by opening a browser to http://localhost:8080/.

This should open the Tomcat main page. If it works then Tomcat is correctly installed.

Stop now Tomcat before starting Eclipse. If Tomcat is still running Eclipse WTP will have problems using the installed Tomcat.

3. Installation of WTP

Depending on your Eclipse installation you also need to install the WTP tools. Use the update manager to install the all packages from "Web, XML, and Java EE Development" except "PHP Development" and "Eclipse RAP" from the standard Galileo site. Please see Using the Eclipse Update Manager

4. WTP Configuration

You have to configure WTP to use the Tomcat installation.

Select Windows -> Preferences -> Server -> Runtime Environments. Press Add.

Select your version of Tomcat.

Tip

To compile the JSP into servlets you need to use the JDK. In my case the "Workbench default JRE" is pointing to the JDK. You can check you setup by clicking on "Installed JRE".

Press Finish and then Ok. You are now ready to use Tomcat with WTP.

4.1. Server

During development you will create your server. You can manager you server via the server view. To see if you data was persisted stop and restart the server. You can do this via the Windows -> Show View -> Servers -> Servers

The following shows where you can start, stop and restart your server.

5. Servlets

5.1. Overview

We will create a servlet which works as a webpage counter. This servlet will keep track of the number of visitors of a webpage. The servlet will persists the number of visitors in a text file.

5.2. Project

Create a new dynamic web project called "de.vogella.wtp.filecounter" by selecting File -> New -> Other -> Web -> Dynamic Web Project.

Press finished. If asked if you want to switch to the Java EE Perspective answer yes.

A new project has been created with the standard structure of a Java web application. The WEB-INF/lib directory will later hold all the JAR files that the Java web application requires.

5.3. Creating Data Access Object

Create a new package "de.vogella.wtp.filecounter.dao" .

Create the Java class which will provide the number of visitors write this value to a file.

				
package de.vogella.wtp.filecounter.dao;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileDao {

	public int getCount() {
		int count = 0;
		// Load the file with the counter
		FileReader fileReader = null;
		BufferedReader bufferedReader = null;
		PrintWriter writer = null ; 
		try {
			File f = new File("FileCounter.initial");
			if (!f.exists()) {
				f.createNewFile();
				writer = new PrintWriter(new FileWriter(f));
				writer.println(0);
			}
			if (writer !=null){
				writer.close();
			}
			
			fileReader = new FileReader(f);
			bufferedReader = new BufferedReader(fileReader);
			String initial = bufferedReader.readLine();
			count = Integer.parseInt(initial);
		} catch (Exception ex) {
			if (writer !=null){
				writer.close();
			}
		}
		if (bufferedReader != null) {
			try {
				bufferedReader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return count;
	}

	public void save(int count) throws Exception {
		FileWriter fileWriter = null;
		PrintWriter printWriter = null;
		fileWriter = new FileWriter("FileCounter.initial");
		printWriter = new PrintWriter(fileWriter);
		printWriter.println(count);

		// Make sure to close the file
		if (printWriter != null) {
			printWriter.close();
		}
	}

}
			

Tip

This Java class is not a servlet, it is a normal Java class.

5.4. Creating the Servlet

Create a servlet. Right click on the folder Webcontent and select New-> Other. Select Web -> Servlet. Maintain the following data.

Press finish.

Tip

You could also create a servlet without the wizard. The wizard creates a Java class which extends javax.servlet.http.HpptServlet and add the servlet settings to the web.xml description file.

Maintain the following code for the servlet.

				
package de.vogella.wtp.filecounter.servlets;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import de.vogella.wtp.filecounter.dao.FileDao;

/**
 * Servlet implementation class FileCounter
 */
public class FileCounter extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
	int count;
	private FileDao dao;

	public void init() throws ServletException {
		dao = new FileDao();
		try {
			count = dao.getCount();
		} catch (Exception e) {
			getServletContext().log("An exception occurred in FileCounter", e);
			throw new ServletException("An exception occurred in FileCounter"
					+ e.getMessage());
		}
	}
	
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		// Set a cookie for the user, so that the counter does not increate
		// everytime the user press refresh
		HttpSession session = request.getSession(true);
		// Set the session valid for 5 secs
		session.setMaxInactiveInterval(5);
		response.setContentType("text/plain");
		PrintWriter out = response.getWriter();
		if (session.isNew()) {
			count++;
		}
		out.println("This site has been accessed " + count + " times.");
	}

	public void destroy() {
		super.destroy();
		try {
			dao.save(count);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

			

This code will read the counter from a file on the server and return plain text to the browser. The servlet will increase the counter if the user was 5 seconds inactive.

5.5. Run

Select your servlet, right-click on it and select Run As -> Run on Server.

Select your server and include your servlet so that is runs on the server.

Press finish. You should see the Eclipse internal web browser displaying your the count number. If you wait 5 seconds and refresh the number should increase.

Congratulations. You created your first working servlet with Eclipse WTP!

6. JavaServer Pages (JSPs)

6.1. Overview

The following demonstrate the usage of JSPs. We will JSPs for the display and a servlet as the controller for a web application. The servlet will dispatch the request to the correct JSP.

6.2. Create Project

Create the Dynamic Web Project "de.vogella.wtp.jsp". Create also the package "de.vogella.wtp.jsp"

6.3. Create the Controller (servlet)

Create a new servlet "Controller" in the package "de.vogella.wtp.jsp.controller".

				
package de.vogella.wtp.jsp.controller;

import java.io.IOException;
import java.util.Map;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class Controller
 */
public class Controller extends HttpServlet {
	private static final long serialVersionUID = 1L;
	private static String DELETE_JSP = "/Delete.jsp";
	private static String EDIT_JSP = "/Edit.jsp";
	private static String SHOWALL_JSP = "/ShowAll.jsp";

	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		String forward="";
		// Get a map of the request parameters
		@SuppressWarnings("unchecked")
		Map parameters = request.getParameterMap();
		if (parameters.containsKey("delete")){
			forward = DELETE_JSP;
		} else if (parameters.containsKey("edit")){
			forward = EDIT_JSP;
		} else {
			forward = SHOWALL_JSP;
		}
		RequestDispatcher view = request.getRequestDispatcher(forward);
		view.forward(request, response);
	}
}

			

This controller will check which parameters has been passed to the servlet and then forward the request to the correct JSP.

6.4. Create the Views (JSP)

Select the folder "WebContent", right-mouse click -> New -> JSP. Call the new JSP "ShowAll". Select the "New JSP File (html)" template.

Create the following coding.

				
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Show all names</title>
</head>
<body>


<form method="GET" action='Controller' name="showall">
<table>
	<tr>
		<td><input type="checkbox" name="id1" /></td>
		<td>Jim</td>
		<td>Knopf</td>
	</tr>
	<tr>
		<td><input type="checkbox" name="id2" /></td>
		<td>Jim</td>
		<td>Bean</td>
	</tr>
</table>

<p><input type="submit" name="delete" value="delete" />&nbsp; 
   <input type="submit" name="edit" value="edit" />&nbsp; 
	<input type="reset"
	value="reset" /></p>
</form>



</body>
</html>
			

Create the JSP "Delete.jsp".

				
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>

Delete successful
<form method="GET" action='Controller' name="delete_success"><input
	type="submit" value="back"></form>
</body>
</html>

			

Create the JSP "Edit.jsp".

				
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>


<form method="GET" action='Controller' name="edit">
<table>
	<tr>
		<td>First name:</td>
		<td><input type="text" name="firstName"></td>
	</tr>
	<tr>
		<td>Last name:</td>
		<td><input type="text" name="lastName"></td>
	</tr>
	<tr>
		<td><input type="submit" value="save"> <input
			type="reset" value="reset"> <input type="submit" value="back">
		</td>
	</tr>
</table>
</form>

</body>
</html>
			

6.5. Run it

Run your new application by running "ShowAll.jsp" on the server. You should be able to navigate between the pages.

7. Web Archive - How to create a war file from Eclipse

´The following describes how to create a Web Archive (war) from Eclipse.

Right click on the project and select "Export".

Specify the target directory and press finish.

Import now the War file to your production Tomcat system and test the web application.

8. Thank you

Thank you for practicing with this tutorial.

Please note that I maintain this website in my private time. If you like the information I'm providing please help me by donating.