10. 1. 1 Iteration example: SimpleForeachTag
Now that you know how to implement iteration in your tags, we will take a look at
a sample iterative tag and the code that performs iteration.
Our first iteration tag, SimpleForeachTag, will take a tag attribute that specifies a
list of strings, walk over the string list, and, one by one, export an iterator object that
contains the current string value for that iteration round. The following JSP fragment
shows a sample usage of this tag:
<iter:foreach id=" item"
elements=" 1, 2,3,4">
The selected item is <%= item %> <br>
</ iter:foreach>
Executing the above JSP fragment generates the following content:
The selected item is 1 <br>
The selected item is 2 <br>
The selected item is 3 <br>
The selected item is 4 <br>
Let's look at the code for the SimpleForeachTag's handler (listing 10.1).
Listing 10. 1 Source code for the SimpleForeachTag handler class
package book.iteration;
import java. util. StringTokenizer;
import java. util. LinkedList;
import java. util. List;
import java.util.Iterator;
import book.util.LocalStrings;
import book.util. ExBodyTagSupport;
import javax.servlet.jsp.JspException;
public class SimpleForeachTag extends ExBodyTagSupport {
static LocalStrings ls =
LocalStrings.getLocalStrings( SimpleForeachTag. class);
Iterator elementsList = null;
protected String elements = null;
public void setElements( String elements)
{
this. elements = elements;
}
public int doStartTag()
throws JspException
{
parseElements(); 
if( elementsList. hasNext()) { 
return EVAL_ BODY_ TAG;
}
return SKIP_ BODY;
}
public void doInitBody()
throws JspException
{
pageContext. setAttribute( id, elementsList. next()); 
}
protected void parseElements()
throws JspException
{
List l = new LinkedList();
StringTokenizer st = new StringTokenizer( elements, ","); 
while( st. hasMoreTokens()) {
l. add( st. nextToken());
}
elementsList = l. iterator();
}
public int doAfterBody()
throws JspException
{
try {
getBodyContent(). writeOut( getPreviousOut()); 
getBodyContent(). clear();
} catch( java.io.IOException ioe) {
// User probably disconnected ...
log( ls. getStr( Constants. IO_ ERROR), ioe);
throw new
JspTagException( ls. getStr( Constants. IO_ ERROR));
}
if( elementsList. hasNext()) { 
pageContext. setAttribute( id, elementsList. next());
return EVAL_ BODY_ TAG;
}
return SKIP_ BODY;
}
protected void clearProperties()
{
id = null;
elements = null;
super. clearProperties();
}
protected void clearServiceState()
{
elementsList = null;
}
}
Parses the list of strings into a Java list and creates an enumerator.
If we have an element in the list, continues the body evaluation; otherwise skips the
body (empty iteration).
Sets the iterator variable with the first element in the list.
Breaks the string list into a Java list.
Writes the results of this iteration back to the user and clears the body buffer.
If we have more elements in the list, exports a new iterator value and repeats evaluating the body.
The work in SimpleForeachTag takes place in three designated locations:
- The service phase initialization in
doStartTag(). The tag initializes the set of objects on which we plan to iterate, and determines if we need to process the body. This is not necessary if the list of objects is empty.
- The loop initialization in
doInitBody(). The tag exports the needed iterator
object by calling pageContext.setAttribute() with the name of the
object and the object itself. In doing so, we publish the iterator as a scripting
variable, so that it ends up in the scope in the JSP (a practice we first came
across with JavaBean tags in chapter 8). By exporting the iterator object, other
tags and scriptlets can take advantage of it. .
- The loop termination/ repeating in
doAfterBody(). The tag writes the results of the last loop into the previous writer (usually the writer that goes to
the user) and then clears the body content to prepare it for the next iteration. In the final step, if there are additional items to iterate, the tag exposes a new
iterator value and signals the JSP environment to repeat the execution by returning EVAL_BODY_TAG.
NOTE When implementing iterations using tags, you do not have to write the results
of each loop separately. You may instead wait for the body execution to finish (no more elements on which to iterate) and then write the complete
result. Doing so usually results in improved performance, but it may also cause a delay in the user's receipt of the results. For example, consider reading
a substantial amount of data from a database and presenting it to the user with some iteration on the result set. Since we are working with a data-base,
completing the iteration may take a while and writing the response only on completion may cause the user to leave the page. Writing the result
of each loop incrementally would (depending on buffer size) cause the results to return to the user incrementally, instead of in a large chunk.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
