Servlets and JSP: An Overview|
Servlets are Java technology's answer to CGI programming. They are programs
that run on a Web server and build Web pages. Building Web pages on the fly
is useful (and commonly done) for a number of reasons:
Java servlets are more efficient, easier to use, more powerful, more
portable, and cheaper than traditional CGI and than many alternative CGI-like
technologies. (More importantly, servlet developers get paid more than
Perl programmers :-).
- The Web page is based on data submitted by the user. For example
the results pages from search engines are generated this way,
and programs that process orders for e-commerce sites do this as well.
- The data changes frequently. For example, a weather-report or
news headlines page might build the page dynamically, perhaps
returning a previously built page if it is still up to date.
- The Web page uses information from corporate databases or other such
sources. For example, you would use this for making a Web page at an
on-line store that lists current prices and number of
items in stock.
Java Server Pages (JSP) is a technology that lets you mix regular, static
HTML with dynamically-generated HTML. Many Web pages that are built by
CGI programs are mostly static, with the dynamic part limited to a few
small locations. But most CGI variations, including servlets, make you
generate the entire page via your program, even though most of it is
always the same. JSP lets you create the two parts separately. Here's
- Efficient. With traditional CGI, a new process is started for
each HTTP request. If the CGI program does a relatively fast operation,
the overhead of starting the process can dominate the execution
time. With servlets, the Java Virtual Machine stays up, and each
request is handled by a lightweight Java thread, not a heavyweight
operating system process. Similarly, in traditional CGI, if there are
N simultaneous request to the same CGI program, then the code for the CGI
program is loaded into memory N times. With servlets, however, there are N
threads but only a single copy of the servlet class. Servlets also have more alternatives
than do regular CGI programs for optimizations such as
caching previous computations, keeping database connections open,
and the like.
- Convenient. Hey, you already know Java. Why learn Perl too?
Besides the convenience of being able to use a familiar language, servlets
have an extensive infrastructure for automatically parsing and decoding HTML
form data, reading and setting HTTP headers, handling cookies, tracking
sessions, and many other such utilities.
- Powerful. Java servlets let you easily do several things that are
difficult or impossible with regular CGI. For one thing, servlets can
talk directly to the Web server (regular CGI programs can't). This
simplifies operations that need to look up images and other data stored
in standard places. Servlets can also share data among each other, making
useful things like database connection pools easy to implement. They
can also maintain information from request to request, simplifying
things like session tracking and caching of previous computations.
- Portable. Servlets are written in Java and follow a
well-standardized API. Consequently, servlets written for, say
I-Planet Enterprise Server can run virtually unchanged on Apache,
Microsoft IIS, or WebStar. Servlets are supported directly or via
a plugin on almost every major Web server.
- Inexpensive. There are a number of free or very inexpensive
Web servers available that are good for "personal" use or low-volume
Web sites. However, with the major exception of Apache, which
is free, most commercial-quality Web servers are relatively expensive.
Nevertheless, once you have a Web server, no matter the cost of that server,
adding servlet support to it (if it doesn't come preconfigured to
support servlets) is generally free or cheap.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HEAD><TITLE>Welcome to Our Store</TITLE></HEAD>
<H1>Welcome to Our Store</H1>
<!-- User name is "New User" for first-time visitors -->
<% out.println(Utils.getUserNameFromCookie(request)); %>
To access your account settings, click
Regular HTML for all the rest of the on-line store's Web page.
- vs. Active Server Pages (ASP). ASP is a similar technology from
Microsoft. The advantages of JSP are twofold. First, the dynamic
part is written in Java, not Visual Basic or other MS-specific
language, so it is more powerful and easier to use. Second, it is
portable to other operating systems and non-Microsoft Web servers.
- vs. Pure Servlets. JSP doesn't give you anything that you couldn't
in principle do with a servlet. But it is more convenient to write
(and to modify!) regular HTML than to have a zillion println statements
that generate the HTML. Plus, by separating the look from the content
you can put different people on different tasks: your Web page design
experts can build the HTML, leaving places for your servlet programmers
to insert the dynamic content.
- vs. Server-Side Includes (SSI). SSI is a widely-supported technology
for including externally-defined pieces into a static Web page. JSP is
better because it lets you use servlets instead of a separate program
to generate that dynamic part. Besides, SSI is really only intended
for simple inclusions, not for "real" programs that use form data,
make database connections, and the like.
This is a useful capability, but only handles situations where the
dynamic information is based on the client's environment. With the
exception of cookies, HTTP and form submission data is not available to
server-side resources like databases, catalogs, pricing information,
and the like.
- vs. Static HTML. Regular HTML, of course, cannot contain dynamic
information. JSP is so easy and convenient that it is quite feasible
to augment HTML pages that only benefit marginally by the insertion
of small amounts of dynamic data. Previously, the cost of using dynamic
data would preclude its use in all but the most valuable instances.