Html servlet example

HTML – SERVLET EXAMPLE
Servlets are the pure Java solution to handle web requests. Many application will use servlets instead
of JSP and others will use servlets in conjunction with JSP. Experienced JSP programmers use
servlets in conjunction with JSP to create clearer and simpler applications. The servlets handle Java
processing: form handing, calculation and database queries. JSP formats the results.

Servlets belong in WEB-INF/classes. On this machine, the source is in Java source in
/var/www/hosts/www.caucho.com/webapps/resin-3.0/servlet/tutorial/helloworld/WEB-INF/classes.
WEB-INF/classes is the standard location for servlets and other Java classes. Resin automatically
reloads and recompiles servlets, beans, and classes placed in WEB-INF/classes. You should make
some changes and add errors to become familiar with Resin's recompilation and the error reporting.

Create the following servlet in WEB-INF/classes/test/HelloServlet.java with your favorite text editor:
notepad, emacs, vi, or whatever. (On this machine, /var/www/hosts/www.caucho.com/webapps/resin-
3.0/servlet/tutorial/helloworld/WEB-INF/classes/test/HelloServlet.java)

WEB-INF/classes/test/HelloServlet.java
package test;

import java.io.*;

import javax.servlet.http.*;
import javax.servlet.*;

public class HelloServlet extends HttpServlet {
public void doGet (HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
PrintWriter out = res.getWriter();

out.println("Hello, world!");
out.close();
}

}

Now browse the servlet at /resin-3.0/servlet/tutorial/helloworld/hello. Resin will automatically
compiles the servlet for you. Browsing servlets differs from page browsing because you're executing
a servlet class, not looking at a page. The /hello URL is configured for the hello, world servlet below.

Configuration
Configuration for the servlet is in the WEB-INF/web.xml file.

The servlet needs to be configured and it needs to be mapped to a URL. The <servlet> tag configures
the servlet. In our simple example, we just need to specify the class name for the servlet.

The <servlet-mapping> tag specifies the URLs which will invoke the servlet. In our case, the /hello
URL invokes the servlet. Because the tutorial webapp is a sub-URL like
/doc/servlet/tutorial/helloworld, the actual URL to invoke the servlet is the combination of the two.

WEB-INF/web.xml
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" version="2.4"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http:/java.sun.com/dtd/web-app_2_3.dtd">
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>test.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>

Resin allows a short cut for the XML configuration in the example above; you can use XML
attributes in place of elements. The Servlet 2.4 standard uses only elements. So the servlet-mapping
configuration following the Servlet 2.4 standard would look like:

WEB-INF/resin-web.xml
<web-app xmlns="http://caucho.com/ns/resin">
<servlet servlet-name="hello"
servlet-class="test.HelloServlet"/>

<servlet-mapping url-pattern="/hello"
servlet-name="hello"/>
</web-app>

The two are entirely equivalent. For larger configurations, using attributes makes the resin.conf or
web.xml more readable.

tag meaning
web-app Web application top-level tag.

The xmlns="http://caucho.com/ns/resin" lets Resin validate the web.xml configuration. The validator
will catch most errors in the web.xml.

WEB-INF/classes/test/HelloServlet.java

package test;

import java.io.*;


/**
* Hello world servlet. Most servlets will extend
* javax.servlet.http.HttpServlet as this one does.
*/
public class HelloServlet extends HttpServlet {
/**
* Implements the HTTP GET method. The GET method is the standard

* browser method.
*
* @param request the request object, containing data from the browser
* @param repsonse the response object to send data to the browser
*/
public void doGet (HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
{
// Returns a writer to write to the browser
PrintWriter out = response.getWriter();

// Writes the string to the browser.
out.println("Hello, world!");
out.close();
}
}

WEB-INF/resin-web.xml

<web-app xmlns="http://caucho.com/ns/resin">
<servlet servlet-name="hello"
servlet-class="test.HelloServlet"/>

<servlet-mapping url-pattern="/hello"
servlet-name="hello"/>
</web-app>

1. Basic Servlet Structure
Here's the outline of a basic servlet that handles GET requests. GET requests, for those unfamiliar with
HTTP, are requests made by browsers when the user types in a URL on the address line, follows a
link from a Web page, or makes an HTML form that does not specify a METHOD. Servlets can also
very easily handle POST requests, which are generated when someone creates an HTML form that
specifies METHOD="POST". We'll discuss that in later sections.

import java.io.*;

public class SomeServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
throws ServletException, IOException {

// Use "request" to read incoming HTTP headers (e.g. cookies)
// and HTML form data (e.g. data the user entered and submitted)

// Use "response" to specify the HTTP response line and headers
// (e.g. specifying the content type, setting cookies).

// Use "out" to send content to browser
}}

To be a servlet, a class should extend HttpServlet and override doGet or doPost (or both), depending on
whether the data is being sent by GET or by POST. These methods take two arguments: an
HttpServletRequest and an HttpServletResponse. The HttpServletRequest has methods that let you find
out about incoming information such as FORM data, HTTP request headers, and the like. The
HttpServletResponse has methods that lets you specify the HTTP response line (200, 404, etc.), response
headers (Content-Type, Set-Cookie, etc.), and, most importantly, lets you obtain a PrintWriter used to
send output back to the client. For simple servlets, most of the effort is spent in println statements that
generate the desired page. Note that doGet and doPost throw two exceptions, so you are required to
include them in the declaration. Also note that you have to import classes in java.io (for PrintWriter,
etc.), javax.servlet (for HttpServlet, etc.), and javax.servlet.http (for HttpServletRequest
and HttpServletResponse). Finally, note that doGet and doPost are called by the service method, and
sometimes you may want to override service directly, e.g. for a servlet that handles both GET and POST
request.

2. A Simple Servlet Generating Plain Text
Here is a simple servlet that just generates plain text. The following section will show the more usual case
where HTML is generated.

2.1 HelloWorld.java
You can also download the source or try it on-line.

package hall;

import java.io.*;

public class HelloWorld extends HttpServlet {
out.println("Hello World");
}
}

2.2 Compiling and Installing the Servlet
Note that the specific details for installing servlets vary from Web server to Web server. Please refer to your
Web server documentation for definitive directions. The on-line examples are running on Java Web Server
(JWS) 2.0, where servlets are expected to be in a directory called servlets in the JWS installation hierarchy.
However, I placed this servlet in a separate package (hall) to avoid conflicts with other servlets on this server;
you'll want to do the same if you are using a Web server that is used by other people and doesn't have a good
infrastructure for "virtual servers" to prevent these conflicts automatically. Thus, HelloWorld.java actually goes
in a subdirectory called hall in the servlets directory. Note that setup on most other servers is similar, and the
servlet and JSP examples in the tutorial have also been tested using BEA WebLogic and IBM WebSphere 3.0.

WebSphere has an excellent mechanism for virtual servers, and it is not necessary to use packages solely to
prevent name conflicts with other users.

If you've never used packages before, there are two main ways to compile classes that are in
packages.

One way is to set your CLASSPATH to point to the directory above the one actually containing your
servlets. You can them compile normally from within the directory. For example, if your base
directory is C:JavaWebServerservlets and your package name (and thus subdirectory name) is
hall, and you were on Windows, you'd do:

DOS> set CLASSPATH=C:JavaWebServerservlets;%CLASSPATH%
DOS> cd C:JavaWebServerservletshall
DOS> javac YourServlet.java

The first part, setting the CLASSPATH, you probably want to do permanently, rather than each time you
start a new DOS window. On Windows 95/98 you'd typically put the "set CLASSPATH=..." statement
in your autoexec.bat file somewhere after the line that set the CLASSPATH to point to servlet.jar
and jsp.jar. On Windows NT, you'd go to the Start menu, select Settings, select Control Panel,
select System, select Environment, then enter the variable and value. Note also that if your package
were of the form name1.name2.name3 rather than simply name1 as here, you'd still have the
CLASSPATH point to the top-level directory of your package hierarchy (the one containing name1).

A second way to compile classes that are in packages is to go to the directory above the one
containing your servlets, and then do "javac directoryYourServlet.java" (Windows; note the
backslash) or "javac directory/YourServlet.java" (Unix; note the forward slash). For example,
suppose again that your base directory is C:JavaWebServerservlets and your package name (and
thus subdirectory name) is hall, and you were on Windows. In that case, you'd do the following:
DOS> cd C:JavaWebServerservlets
DOS> javac hallYourServlet.java
Note that, on Windows, most JDK 1.1 versions of javac require a backslash, not a forward slash,
after the directory name. This is fixed in JDK 1.2, but since many Web servers are configured to use
JDK 1.1, many servlet authors stick with JDK 1.1 for portability.

Finally, another advanced option is to keep the source code in a location distinct from the .class files,
and use javac's "-d" option to install them in the location the Web server expects.

2.3 Running the Servlet

With the Java Web Server, servlets are placed in the servlets directory within the main JWS installation
directory, and are invoked via http://host/servlet/ServletName. Note that the directory is
servlets, plural, while the URL refers to servlet, singular. Since this example was placed in the hall
package, it would be invoked via http://host/servlet/hall.HelloWorld. Other Web servers may
have slightly different conventions on where to install servlets and how to invoke them. Most servers also let
you define aliases for servlets, so that a servlet can be invoked via http://host/any-path/any-
file.html. The process for doing this is completely server-specific; check your server's documentation for
details.

3. A Servlet that Generates HTML
Most servlets generate HTML, not plain text as in the previous example. To do that, you need two additional
steps: tell the browser that you're sending back HTML, and modify the println statements to build a legal
Web page. The first step is done by setting the Content-Type response header. In general, headers can be
set via the setHeader method of HttpServletResponse, but setting the content type is such a common
task that there is also a special setContentType method just for this purpose. Note that you need to set
response headers before actually returning any of the content via the PrintWriter. Here's an example:

3.1 HelloWWW.java
You can also download the source or try it on-line.

package hall;

import java.io.*;

public class HelloWWW extends HttpServlet {
response.setContentType("text/html");
out.println("<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 " +
"Transitional//EN">n" +
"<HTML>n" +
"<HEAD><TITLE>Hello WWW</TITLE></HEAD>n" +
"<BODY>n" +
"<H1>Hello WWW</H1>n" +
"</BODY></HTML>");
}}

3.2 HelloWWW Result

4. Simple HTML-Building Utilities
It is a bit cumbersome to generate HTML with println statements. The real solution is to use Java Server
Pages (JSP), which is discussed later in this tutorial. However, for standard servlets, there are two parts of the
Web page (DOCTYPE and HEAD) that are unlikely to change and thus could benefit from being incorporated
into a simple utility file.

The DOCTYPE line is technically required by the HTML spec, and although most major browsers
ignore it, it is very useful when sending pages to formal HTML validators. These validators compare
the HTML syntax of pages against the formal HTML specification, and use the DOCTYPE line to
determine which version of HTML to check against. Their use is very highly recommended both for
static HTML pages and for pages generated via servlets, so the use of DOCTYPE is well worth the
effort, especially if it can be easily incorporated into a servlet utilities class.

In many Web pages, the HEAD line contains nothing but the TITLE, although advanced developers
may want to include META tags and style sheets. But for the simple case, I'll create a method that takes
a title as input and returns the DOCTYPE, HEAD, and TITLE entries as output. Here's the code:

4.1 ServletUtilities.java (Download source code)
package hall;

public class ServletUtilities {
public static final String DOCTYPE =
"<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">";

public static String headWithTitle(String title) {
return(DOCTYPE + "n" +
"<HTML>n" +
"<HEAD><TITLE>" + title + "</TITLE></HEAD>n");
}

// Other utilities will be shown later...
}

4.2 HelloWWW2.java (Download source code)
Here's a rewrite of the HelloWWW class that uses this.

package hall;

import java.io.*;

public class HelloWWW2 extends HttpServlet {
response.setContentType("text/html");
out.println(ServletUtilities.headWithTitle("Hello WWW") +
"<BODY>n" +
"<H1>Hello WWW</H1>n" +
"</BODY></HTML>");
}
}

Html servlet example

More Related Content

What's hot (20)

Similar to Html servlet example (20)

Recently uploaded (20)

Html servlet example