This chapter is from the book
This chapter is from the book
This chapter is from the book
The ability to use a bean to control a tag is certainly powerful, but often such values must be shown to the user rather than used by a tag. A standard tag, c:out, renders values to the page, and the use of this tag is quite straightforward. Listing 4.5 revisits the example from Listing 3.1, which displayed various values from a bean. Listing 4.5 use the same bean but now displays values using the new tag.
Listing 4.5 The out tag
<%@ taglib prefix="c"
uri="http://java.sun.com/jstl/core" %>
<jsp:useBean
id="bean1"
class="com.awl.jspbook.ch03.Bean1"/>
<p>Here is some data that came from bean1:</p>
<ul>
<li>The name of this bean is:
<c:out value="${bean1.name}"/>
<li>The 7th prime number is:
<c:out value="${bean1.seventhPrimeNumber}"/>
<li>The current time is:
<c:out value="${bean1.currentTime}"/>
</ul>
Because this does exactly the same thing as Listing 3.1, it may not be immediately clear why anyone would use the c:out tag instead of the jsp:getProperty tag. Although c:out is somewhat shorter, the real reason to use it is that it has many advantages, all of which are derived from the fact that what is being shown is the result of a script, not a simple property.
The expression language allows page developers to manipulate properties in many ways. For example, it is possible to write an expression that will add two numbers right in the page, without needing to rely on the bean to do it. Listing 4.6 shows another version of our calculator from Listing 3.6, only doing the addition in the page.
Listing 4.6 Addition in the expression language
<%@ taglib prefix="c"
uri="http://java.sun.com/jstl/core" %>
<jsp:useBean
id="calc"
class="com.awl.jspbook.ch04.CalcBean"/>
<jsp:setProperty name="calc" property="*"/>
The sum is:
<c:out value="${calc.value1 + calc.value2}"/>
It is now possible to extend this easily to do more complex calculations, such as finding the average of the two numbers or raising one to the power of the other, and so on.
Note that although this is very powerful, it also breaks the model/view/controller paradigm, as the model is now being manipulated directly from the view. Sometimes, this is worth doing, but as a general rule of thumb, it is better to leave such calculations in the bean.
Another advantage to the c:out tag is that it can display things other than beans. Every JSP has available a number of implicit objects, that is, objects that the system provides without the developer’s needing to load or name them explicitly. One of these is the pageContext object, which contains a great deal of information about the action currently being performed, such as the name of the page being generated, the name of the computer from which the request came, and so on. Listing 4.7 uses the pageContext object to display some of the available information.
Listing 4.7 The request object
<%@ taglib prefix="c"
uri="http://java.sun.com/jstl/core" %>
<ul>
<li>Your computer is called
<c:out value="${pageContext.request.remoteHost}"/>
<li>This page came from server
<c:out value="${pageContext.request.serverName}"/>
<li>This page came from port
<c:out value="${pageContext.request.serverPort}"/>
</ul>
This example illustrates a new kind of syntax: expressions with multiple dots. This will make more sense following the discussion of compound data later in this chapter.
Another important implicit variable is param, and it holds all the values that have been sent to a page by a form. This variable acts like a special bean in that it does not have a predefined set of properties but instead has a property for every value in the form.2 Suppose, for example, that a form has an input like this:
<input type="text" name="color">
The user’s response could be displayed on a page using the following:
<c:out value="${param.color}"/>
This feature of the expression language provides a fix for a problem with the Java News Today site. Recall that the page title appears in top.jsp, which is shared by every page, but this title really should change to identify each page. This can be accomplished as follows:
<title>
Java News Today: <c:out value="${param.title}"/>
</title>
Here, the parameter title will not come from a form but instead can be passed in through a variation of the jsp:include tag. For example, the index page will now include the top portion of the page with
<jsp:include page="top.jsp"> <jsp:param name="title" value="Welcome!"/> </jsp:include>
The availability of param also means that the bean isn’t needed in Listing 4.4 at all! The whole page can be reduced to
<awl:maybeShow show="${param.shouldShow}">
The time is:
<awl:date format="hh:mm:ss MM/dd/yy"/>
</awl:maybeShow>
Likewise, the calculator could do without its bean, reducing the page to
The sum is:
<c:out value="${param.value1 + param.value2}"/>
Errors to Watch For
Most of the comments about possible errors when using the jsp:getProperty tag also apply to c:out and other tags that use expressions. In particular, trying to reference a property that the bean does not possess will result in an error.
In addition, trying to reference a bean that does not exist, such as c:out value="${someBean.someProperty}" if someBean has not been loaded, will not result in an error but simply in nothing being displayed. This can result in problems that may be difficult to find and fix, for example, if the name of a bean is simply misspelled.
Because c:out acts like an enhanced version of jsp:getProperty, it is not surprising that an equivalent of the jsp:setProperty tag is in the standard library. This tag, c:set, looks like this:
<c:set
target="bean"
property="property name"
value="property value"/>
This tag sets the property called property name in the bean identified as bean name to value. Unlike the jsp:setProperty tag, the c:set tag can not set all the properties in a bean at once by using the special property *. However, each of the parameters to c:set may be a script, which allows properties to be set with dynamic values.
Errors to Watch For
When using the c:set tag, it is very important to mind the distinction between something like target="bean" and target="${bean}". The former is a name that has no properties; the latter is a bean obtained from the name by the expression language. This can be a natural source of confusion, as the jsp:setProperty tag does use the name. Even if the reason is not completely clear at this point, remember that the target should always take an expression, not simply a name.