Page II
JavaServer Pages
Chapter 5
Generating Dynamic
Content
Click to Buy:
By Hans Bergsten
Printer Friendly Version
Using JSP Directives
The first line in Example
5-1 is a JSP directive element. Directives are
used to specify attributes of the page itself, primarily those that affect how
the page is converted into a Java servlet. There are three JSP directives:
page, include, and taglib. In this example, we're using only the page directive. We'll see the others later.
JSP pages typically start with a page
directive that specifies the scripting language and the content type for the
page:
<%@ page language="java" contentType="text/html" %>
A JSP directive element starts with a directive-start identifier
(<%@) followed by the directive name (e.g.,
page) and directive attributes, and ends with %>. A directive contains one or more attribute
name/value pairs (e.g., language="java"). Note that
JSP element and attribute names are case-sensitive, and in most cases the same
is true for attribute values. For instance, the language attribute value must be java, not Java. All attribute
values must also be enclosed in single or double quotes.
The page directive has many possible
attributes. In Example
5-1, two of them are used: language and contentType.
The language attribute specifies the
scripting language used in the page. The JSP reference implementation (the
Tomcat server) supports only Java as a scripting language. java is also the default
value for the language attribute, but for clarity
you may still want to specify it. Other JSP implementations support other
languages besides Java, and hence allow other values for the language attribute. For instance, both JRun (http://www.allaire.com/) and
Resin (http://www.caucho.com/)
support JavaScript in addition to Java.
The contentType attribute specifies
the type of content the page produces. The most common values are text/html for HTML content and text/plain for preformatted, plain text. But you can also
specify other types, such as text/xml for browsers
that support XML or text/vnd.wap.wml for devices
like cellular phones and PDAs that have built-in Wireless Markup Language
(WML) browsers. If the content generated by the page includes characters
requiring a charset other than ISO-8859-1 (commonly known as Latin-1), you
need to specify that charset with the contentType
attribute. We'll look at the details of charsets in Chapter 11, Internationalization.
Using Template Text
Besides JSP elements, notice that the page shown in Example
5-1 contains mostly regular HTML:
...
<html>
<body bgcolor="white">
...
The current time at the server is:
<ul>
<li>Date: ...
<li>Month: ...
<li>Year: ...
<li>Hours: ...
<li>Minutes: ...
</ul>
</body>
</html>
In JSP parlance, this is called template
text. Everything that's not a JSP element, such as a directive, action,
or scripting element, is template text. Template text is sent to the browser
as-is. This means you can use JSP to generate any type of text-based output,
such as XML, WML, or even plain text. The JSP container doesn't care what the
template text is.
Using JavaBeans
There is also some dynamic content in this example. Step back a
moment and think about the type of dynamic content you see on the Web every
day. Common examples might be a list of web sites matching a search criteria
on a search engine site, the content of a shopping cart on an e-commerce site,
a personalized news page, or messages on a bulletin board. Dynamic content is
content generated by some server process, for instance the result of a
database query. Before it is sent to the browser, the dynamic content needs to
be combined with regular HTML elements into a page with the right layout,
navigation bars, the company logo, and so forth. In a JSP page, the regular
HTML is the template text described earlier. The result of the server
processing--the dynamic content--is commonly represented by a JavaBeans component.
A JavaBeans component, or just a bean
for short, is a Java class that follows certain coding conventions, so it can
be used by tools as a component in a larger application. In this chapter, we
discuss only how to use a bean, not how to develop one. (If you're a
programmer and not already familiar with JavaBeans, you may want to skip ahead
to Chapter 15, Developing JavaBeans for JSP, to
learn about these coding conventions.) A bean is often used in JSP as the
container for the dynamic content to be displayed by a web page. Typically, a
bean represents something specific, such as a person, a product, or a shopping
order. A bean is always created by a server process and given to the JSP page.
The page then uses JSP elements to insert the bean's data into the HTML
template text.
The type of element used to access a bean in a page is called a
JSP action element. JSP action elements are executed
when a JSP page is requested (this is called the request processing phase, as
you may recall from Chapter 3). In other words, JSP actions represent dynamic
actions that take place at runtime, as opposed to JSP directives, which are
used only during the translation phase (when the JSP page is turned into Java
servlet code). JSP defines a number of standard actions and also specifies how
you can develop custom actions. For both standard and custom action elements,
use the following notation:
<action_name attr1="value1" attr2="value2">
action_body
</action_name>
Action elements, or tags as they are sometimes called, are grouped into libraries (known as tag libraries). The action name is composed of two parts:
a library prefix and the name of the action within the library, separated by a
colon (i.e., jsp:useBean). All actions in the JSP
standard library use the prefix jsp, while custom
actions can use any prefix except jsp, jspx, java, javax, servlet, sun, or sunw. You specify
input to the action through attribute/value pairs in the opening tag. The
attribute names are case-sensitive, and the values must be enclosed in single
or double quotes. For some actions, you can also enter data that the action
should process in the action's body. It can be any text value, such as a SQL
statement, or even other nested JSP action elements. You will see examples of
action elements with a body later.
Before you use a bean in a page, you must tell the JSP container
which type of bean it is and associate it with a name. The first JSP action in
Example
5-1, <jsp:useBean>, is used for this
purpose:
<jsp:useBean id="clock" class="java.util.Date" />
The id attribute is used to give the
bean a unique name. It must be a name that is a valid Java variable name: it
must start with a letter and cannot contain special characters such as dots,
plus signs, etc. The class attribute contains the
fully qualified name of the bean's Java class. Here, the name clock is associated with an instance of the class java.util.Date. Note that we don't specify a body for
this action. When you omit the body, you must end the opening tag with />, as in this example. In this case, when the JSP
container encounters this directive, there is no bean currently available with
the name clock, so the <jsp:useBean> action creates a bean as an instance
of the specified class and makes it available to other actions in the same
page. In Chapter 8, Sharing Data Between JSP Pages,
Requests, and Users, you will see how <jsp:useBean> can also be used to locate a bean
that has already been created.
Incidentally, the <jsp:useBean>
action supports three additional attributes: scope,
type, and beanName. The
scope attribute is described in detail in Chapter
8, and the other two attributes are covered in Appendix A, JSP Elements Syntax Reference. We don't need to worry
about those attributes here.
Events
[
Home | Discussion Forum | How Do I... |
Lotus Notes Intranets |
Microsoft SharePoint |
Products |
Shopping
]
