Welcome to Day 10—yesterday, you took a look at using and creating custom tags, and today you'll get more of the story. Creating a custom tag is actually a very large topic in JSP, which is why two days are dedicated to them. Today, you'll learn how to:
Create a simple tag that inserts text into a Web page
Use the
pageContextobjectSupport custom tag attributes
Create iterator tags
Make custom tags cooperate, using
pageContextattributesWork with scripting variables to pass data between JSP code and custom tag code
Tip
There's even more to the topic of custom tags than there's room for here. You might want to track down more information online—a good place to start is Sun's custom tag tutorial at http://java.sun.com/webservices/docs/ea1/tutorial/doc/JSPTags.html.
That's the program for today. The first topic is about creating a simple tag that can insert text into a Web page.
This first example tag will be called <ch10:message>, and it will insert a message into a Web page. You can see this tag in Listing 10.1. It's an empty tag with no body, so you can condense the opening and closing tags together in this element, XML-style, as you've seen before: <ch10:message />.
You may remember from yesterday that to connect a custom tag to the supporting Java code, you need a TLD file. To let JSP find the TLD file, you saw that you can create a web.xml file with a <taglib> element in the WEB-INF subdirectory.
But there's also a shorter way to connect a custom tag to its TLD file. It turns out that you can simply use the relative URL of the TLD file in the taglib directive's uri attribute:
<%@ taglib prefix="ch10" uri="WEB-INF/ch10_02.tld" %>
That enables JSP to find the TLD file for this <ch10:message> custom tag, ch10_02.tld. But you still have to create that TLD file itself.
The TLD file that connects the <ch10:message> custom tag to its Java code is called ch10_02.tld, and you can start it off as you did yesterday, indicating that it's an XML file and using the standard <!DOCTYPE> element:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC
"-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
.
.
.
</taglib>
The specification for the tag library itself is stored in the <taglib> element. You were introduced to this element yesterday, but today you'll see a more systematic look at it. This element can contain a number of subelements—some of which you've already seen, and all of which you can see in Table 10.1.
Table 10.1. Subelements of the <taglib> Element
Subelement | Description |
|---|---|
| The tag library's version |
| The JSP version the tag library requires |
| Name that can be used by a JSP page authoring tool |
| URI that identifies the tag library |
| |
| Small icon that can be used by JSP authoring tools |
| Large icon that can be used by JSP authoring tools |
| Tag-specific description |
| Event listener classes that can help handle events |
| Creates a custom tag |
Here's how you might add the subelements of the <taglib> element in the TLD file for the <ch10:message> element:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC
"-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>TagExamples</short-name>
<description>Example tags.</description>
<tag>
.
.
.
</tag>
</taglib>
You describe each custom tag with a <tag> element, which itself can contain the subelements you see in Table 10.2. Note that each <tag> element must, at the very least, contain a <name> and a <tag-class> subelement.
Table 10.2. Subelements of the <tag> Element
Subelement | Description |
|---|---|
| The unique tag name |
| The fully qualified name of the tag's Java class |
| Any used class based on |
| |
| Name that can be displayed by JSP authoring tools |
| Small icon that can be used by JSP authoring tools |
| Large icon that can be used by JSP authoring tools |
| Tag-specific description |
| Scripting variable data |
| Tag attribute data |
You can see the resulting TLD file, ch10_02.tld, in Listing 10.2, where the file describes the message tag and connects it to the Java class taglib.ch10_03.
Example 10.2. The TLD File (ch10_02.tld)
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"> <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>TagExamples</short-name> <description>Example tags.</description> <tag> <name>message</name> <tag-class>taglib.ch10_03</tag-class> </tag> </taglib>
The next step is to create taglib.ch10_03.
You place the Java class taglib.ch10_03 in the taglib package in the file ch10_03.java (you can use any name for your Java packages, of course):
package taglib;
.
.
.
The new class, ch10_03, is based on the Java TagSupport class, which you indicate with the extends keyword, as you've already seen:
package taglib;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
public class ch10_03 extends TagSupport
{
.
.
.
}
You used the TagSupport class briefly yesterday, and it's time you saw the fields and methods of this class. You can see its fields in Table 10.3, and its members in Table 10.4.
Table 10.3. Fields of the TagSupport Class
Field | Means This |
|---|---|
| Holds an ID value. |
| Holds a |
Table 10.4. Methods of the TagSupport Class
Method | Does This |
|---|---|
| |
| Allows processing for a custom element's body. |
| Allows processing of the end tag returning |
| Allows processing of the start tag, returning |
| Gets the value of the |
| Gets the parent enclosing this tag. |
| |
| Enumerates the values kept by this tag handler. |
| |
| Sets the |
| Sets the page context to a particular |
| Sets the nesting tag of this tag. |
|
The TagSupport class is based on two Java interfaces (there will be more on interfaces tomorrow)—the javax.servlet.jsp.tagext.IterationTag and javax.servlet.jsp.tagext.Tag interfaces, so it also gives you access to the fields and methods in those interfaces.
The javax.servlet.jsp.tagext.IterationTag interface has only one field:
and only one method:
int doAfterBody()—. Called after the body of the element has been processed.
The javax.servlet.jsp.tagext.Tag interface is more substantial—you can see its fields in Table 10.5, and its methods in Table 10.6.
Table 10.5. Fields of the javax.servlet.jsp.tagext.Tag Interface
Field | Means This |
|---|---|
| Evaluate the custom element's body and put the result into the returned Web page. |
| Keep evaluating the page. |
| Skip evaluation of the body. |
in | Skip the rest of the page. |
Table 10.6. Methods of the javax.servlet.jsp.tagext.Tag Interface
Method | Does This |
|---|---|
| Processes the end tag for this custom element. |
| |
| Gets the parent for this tag handler. |
| Sets the current page context. |
| Sets the parent of this tag handler. |
To implement the <ch10:message> tag, you can insert a message into the Web page when the end tag (</ch10:message>) is processed. When that end tag is going to be processed, the TagSupport class's doEndTag method is called, and you can support that method in the Java code for this tag:
package taglib;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
public class ch10_03 extends TagSupport
{
public int doEndTag()
{
.
.
.
}
The next thing to do is display a message such as "Hello from JSP!" in the Web page. In JSP code, you just use the out.println method. So, how do you get access to that method in a custom tag? You use the TagSupport class's pageContext field, which gives you access to many of the built-in objects that you can use in JSP.
When you want to get access to the out object or exception object that's available in JSP pages, but you're in a custom tag's Java code, you can use methods of pageContext to get those objects. The pageContext object itself is an object of the PageContext class. You can see the fields of this class in Table 10.7, and its methods in Table 10.8.
Table 10.7. Fields of the PageContext Class
Table 10.8. Methods of the javax.servlet.jsp.tagext.Tag Interface
As you see in Table 10.8, you can use the pageContext object's getOut method to get access to the out object. With that object in hand, all you need is to use a method like print or println to send text to the Web page. You can also return a constant like EVAL_PAGE to indicate that you want the rest of the page evaluated:
package taglib;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
public class ch10_03 extends TagSupport
{
public int doEndTag() throws JspException
{
try {
pageContext.getOut().print("Hello from JSP!");
.
.
.
}
return EVAL_PAGE;
}
}
When you use methods of the out object in a custom tag's code, Java will insist that you handle any exceptions that can come up, so you can add some code to throw that exception back to the default JSP exception handler, as you see in Listing 10.3.
Example 10.3. Supporting a Simple Tag (ch10_03.java)
package taglib; import javax.servlet.jsp.tagext.*; import javax.servlet.jsp.*; public class ch10_03 extends TagSupport { public int doEndTag() throws JspException { try { pageContext.getOut().print("Hello from JSP!"); } catch (Exception e) { throw new JspException(e.toString()); } return EVAL_PAGE; } }
And that's all you need—take a look at ch10_01.jsp; you can see the results in Figure 10.1.
That gives you a start with a simple tag that is able to insert some text into a Web page, and covers the creation of a basic tag. However, there's a great deal more to creating custom tags—for example, you can also support attributes.
You can support attributes in custom tags; for example, you can add an attribute to the <ch10:message> element that enables you to set the text that the element will display. If you were to call this attribute text, using it might look like this, where you want to display the message “Hello there!”:
The text is: <ch10:message text="Hello there!"/>
How do you create and support such an attribute? You create it in the TLD file and support it in your Java code. In the TLD file, you use an <attribute> element, which has the subelements you see in Table 10.9 (note that of the subelements you see in that table, only <name> is required).
Table 10.9. Subelements of the <attribute> Element
Subelement | Does This |
|---|---|
| Gives the attribute a name. |
| Indicates whether an attribute is required to be present when you use the corresponding tag. Set to |
| Indicates whether the attribute can be assigned an expression's value at runtime. Set to |
| Gives a description of the attribute. |
| Sets the Java type of the attribute. Use a type fully qualified with package name, such as |
For example, Listing 10.4 shows the new version of the <ch10:message> element at work in a Web page that you can load to use this attribute.
Example 10.4. Supporting Attributes (ch10_04.jsp)
<%@ taglib prefix="ch10" uri="WEB-INF/ch10_05.tld" %>
<HTML>
<HEAD>
<TITLE>Supporting Attributes in Custom Tags</TITLE>
</HEAD>
<BODY>
<H1>Supporting Attributes in Custom Tags</H1>
The text is: <ch10:message text="Hello there!"/>
</BODY>
</HTML>
The next step is to create the text attribute, adding it to the <ch10:message> element in the TLD file. You can see how that works in Listing 10.5, which includes a new <attribute> element for the text attribute, specifying the attribute's name and type (if you don't specify a type, the default is java.lang.String).
Example 10.5. The TLD File for Supporting an Attribute (ch10_05.tld)
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"> <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>TagExamples</short-name> <description>Example tags.</description> <tag> <name>message</name> <tag-class>taglib.ch10_06</tag-class> <attribute> <name>text</name> <type>java.lang.String</type> </attribute> </tag> </taglib>
That adds a new attribute to the <ch10:message> element as far as JSP is concerned. So, how do you support the new attribute in Java code? You do it by treating it as a property, with a set method. For example, you can create a new String variable named text, and add a method named setText to your Java code:
public class ch10_06 extends TagSupport
{
String text;
public void setText(String s)
{
text = s;
}
public int doEndTag() throws JspException
{
try {
.
.
.
}
return EVAL_PAGE;
}
}
Now JSP will call the setText method automatically with the value of the text attribute at runtime. That's great in this case, because that attribute's value is then stored in the internal variable text, which you can then display in the Web page using the pageContext.getOut().print method, as you see in Listing 10.6.
Example 10.6. Supporting Attributes in Code (ch10_06.java)
package taglib;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
public class ch10_06 extends TagSupport
{
String text;
public void setText(String s) {
text = s;
}
public int doEndTag() throws JspException
{
try {
pageContext.getOut().print(text);
} catch (Exception e) {
throw new JspException(e.toString());
}
return EVAL_PAGE;
}
}
That's all you need—you can see the results in Figure 10.2, where the code has read the text attribute's value and displayed it in a Web page. You've made considerable progress working with custom tags.
There's another kind of tag besides the simple kind we've been working with here—iterating tags, which act like built-in loops. They're coming up next.
Suppose that you want to display a list of items, such as this one, in a Web page:
Cast member: Ralph Cast member: Alice Cast member: Ed Cast member: Trixie
This next example shows how this works. Here, you'll create a new element named <ch10:iterator> that will create the list you saw previously. You can place text in this element in a JSP page and that text will be repeated in each iteration, as you can see:
<ch10:iterator>
Cast member:
</ch10:iterator>
But what about the new text—the names of the various cast members—that this new element is to display? You can store them in an array called, say, names, and make that array an attribute of the pageContext object using the setAttribute method as you see in Listing 10.7. That will give the code for the <ch10:iterator> element access to those names.
Example 10.7. Using Iterating Tags (ch10_07.jsp)
<%@ taglib prefix="ch10" uri="WEB-INF/ch10_08.tld" %>
<HTML>
<HEAD>
<TITLE>Supporting Iterating Custom Tags</TITLE>
</HEAD>
<BODY>
<H1>Supporting Iterating Custom Tags</H1>
<%
String[] names = new String[]{ "Ralph", "Alice", "Ed", "Trixie" };
pageContext.setAttribute("names", names);
%>
<ch10:iterator>
Cast member:
</ch10:iterator>
</BODY>
</HTML>
The next step in implementing the <ch10:iterator> element is to add it to a TLD file, as you see in Listing 10.8.
Example 10.8. The TLD File for the Iterating Tag (ch10_08.tld)
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"> <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>TagExamples</short-name> <description>Example tags.</description> <tag> <name>message</name> <tag-class>taglib.ch10_06</tag-class> <attribute> <name>text</name> <type>javalang.String</type> </attribute> </tag> <tag> <name>iterator</name> <tag-class>taglib.ch10_09</tag-class> </tag> </taglib>
In the Java code for this new tag, you can use the pageContext object's getAttribute method to get and store this array. You can do that as soon as JSP starts evaluating the tag, in the doStartTag method:
package taglib;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
public class ch10_09 extends TagSupport
{
private String[] names = null;
public int doStartTag()
{
names = (String[]) pageContext.getAttribute("names");
return EVAL_BODY_INCLUDE;
}
.
.
.
Note
Note that this Java class is based on the TagSupport class, not on the IterationTag interface you saw earlier today that actually supports iterating tags. That's no problem, because the TagSupport class itself implements the IterationTag interface.
In this way, JSP pages can pass data items such as arrays (which cannot be stored in tag attributes) to Java code for custom tags—and as we'll see in a few pages, page context attributes can also let custom tags “cooperate” with each other by passing data back and forth.
Now that you have access to the names this element is supposed to display, you can display them by evaluating the body of the element several times. You can do that with the IterationTag interface's doAfterBody method, which is called after the body has been evaluated (and displays the element body's text, "Cast member:", in the Web page iteration).
If you return the IterationTag interface's constant EVAL_BODY_AGAIN from the doAfterBody method, the body is evaluated again, giving you the chance to print out another name. If you return the constant SKIP_BODY, on the other hand, JSP will no longer iterate over the body. To determine when to stop iterating, you can create a counter variable (just named counter here) and stop iterating when you've displayed all the names in the names array. Here's what that looks like in the doAfterBody method:
public class ch10_09 extends TagSupport
{
private int counter = 0;
private String[] names = null;
.
.
.
public int doAfterBody() throws JspException
{
try{
pageContext.getOut().print(" " + names[counter] + "<BR>");
} catch(Exception e){
throw new JspException(e.toString());
}
counter++;
if(counter >= names.length) {
return SKIP_BODY;
}
return EVAL_BODY_AGAIN;
}
}
}
}
You can see the complete Java support for this new iterating tag in Listing 10.9.
Example 10.9. Iterating Java Support (ch10_09.html)
package taglib; import javax.servlet.jsp.*; import javax.servlet.jsp.tagext.*; public class ch10_09 extends TagSupport { private int counter = 0; private String[] names = null; public int doStartTag() { names = (String[]) pageContext.getAttribute("names"); return EVAL_BODY_INCLUDE; } public int doAfterBody() throws JspException { try{ pageContext.getOut().print(" " + names[counter] + "<BR>"); } catch(Exception e){ throw new JspException(e.toString()); } counter++; if(counter >= names.length) { return SKIP_BODY; } return EVAL_BODY_AGAIN; } }
You can see the results of this new iterating element in Figure 10.3. As you can see, this element did indeed iterate over the data in the names array, displaying a new item from that array in each iteration.
Now you are able to build iterating custom tags. Note that iterating tags have also introduced the idea of passing data using the pageContext object's attributes. That's the subject of a whole new topic in custom tag work—creating cooperating tags, which can pass data back and forth using such attributes.
As you saw in the previous topic, you can pass data to custom tags by setting pageContext object attributes. Here's the way that worked when you set an attribute called names:
<%
String[] names = new String[]{ "Ralph", "Alice", "Ed", "Trixie" };
pageContext.setAttribute("names", names);
%>
However, you can also use custom tags themselves to set pageContext attributes that will be read by other custom tags. To see how that works, this next example will create a new custom tag, <ch10:createCast>, which will store the names the <ch10:iterator> tag needs using the names attribute. You can see this new tag, <ch10:createCast>, at work in a new JSP page, Listing 10.10. Note that all you have to do to set the names attribute is use the <ch10:createCast> tag—then the <ch10:iterator> tag can make use of that attribute.
You also have to add this new tag to the TLD file, as you see in Listing 10.11.
Example 10.11. The Cooperating Tags TLD (ch10_11.tld)
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC
"-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>TagExamples</short-name>
<description>Example tags.</description>
<tag>
<name>message</name>
<tag-class>taglib.ch10_06</tag-class>
<attribute>
<name>text</name>
<type>javalang.String</type>
</attribute>
</tag>
<tag>
<name>iterator</name>
<tag-class>taglib.ch10_09</tag-class>
</tag>
<tag>
<name>createCast</name>
<tag-class>taglib.ch10_12</tag-class>
</tag>
</taglib>
All this new tag, <ch10:createCast>, does is create the names array that the <ch10:iterator> tag will use and store that array in the names attribute. You can see how that works in Listing 10.12.
You can see the results in Figure 10.4—just like the previous example, except that this time, the data the iterating tag displays comes from a cooperating tag.
You've seen that you can supply data from a JSP page to a custom tag by setting a pageContext attribute—for example, you saw how to set an attribute called names that was used by the custom iterating tag:
<%
String[] names = new String[]{ "Ralph", "Alice", "Ed", "Trixie" };
pageContext.setAttribute("names", names);
%>
<ch10:iterator>
Cast member:
</ch10:iterator>
You can also go the other way—setting attributes in custom elements and reading them in JSP code. You can see an example in Listing 10.13, where the <ch10:createCast/> element assigns the names array to the names attribute, and the JSP code loops over that array and displays those names.
Example 10.13. Using the PageContext Object (ch10_13.jsp)
<%@ taglib prefix="ch10" uri="WEB-INF/ch10_11.tld" %> <HTML> <HEAD> <TITLE>Using the pageContext Object</TITLE> </HEAD> <BODY> <H1>Using the pageContext Object</H1> <ch10:createCast/> <% String[] names = (String [])pageContext.getAttribute("names"); %> <% for(int loopIndex = 0; loopIndex < names.length; loopIndex++) { out.println("Cast member: " + names[loopIndex] + "<BR>"); } %> </BODY> </HTML>
You can see this Web page at work in Figure 10.5, where the JSP code has read data from a custom tag using page context attributes.
Note that in this example, you have to use a scriptlet to get access to the names attribute and assign it to the names array:
<%
String[] names = (String [])pageContext.getAttribute("names");
%>
To support a scripting variable, you use the <variable> element in a TLD file. The <variable> element supports the subelements you see in Table 10.10—you need to use at least the <name-given> element or the <name-from-attribute> element, but the rest of the subelements are optional.
Table 10.10. Subelements of the <variable> Element
Subelement | Description |
|---|---|
| Gives the variable a name. |
| The name of an attribute whose value will give the name of the variable. |
| Fully qualified name of the class of the variable. The default is |
| Indicates whether the variable refers to a new object. Set to |
| The scope of the scripting variable. See Table 10.11; |
The possible values for the <scope> element you see in Table 10.8 appear in Table 10.11; this element enables you to set the scope of the scripting variable.
Table 10.11. The <variable> Element's Scope
Value | Scope | Available in Methods |
|---|---|---|
| Between the start tag and end tag |
|
| From start tag to end of page |
|
| After end tag to end of page |
|
For example, if you use a scripting variable for the names array, you don't have to pass that array from a custom tag to JSP code using pageContext attributes—that array will already be available to your JSP code.
To see how that works, you can implement the names scripting variable in the <ch10:createCast> tag. When you do, that variable will become available to your JSP code automatically—no use of attributes needed. The resulting JSP page appears in Listing 10.14—as you can see. Now the <ch10:createCast /> element fills the names variable automatically (you don't have to use getAttribute), and then you can use that variable in your code.
Example 10.14. Using Scripting Variables (ch10_14.jsp)
<%@ taglib prefix="ch10" uri="WEB-INF/ch10_15.tld" %> <HTML> <HEAD> <TITLE>Using Scripting Variables</TITLE> </HEAD> <BODY> <H1>Using Scripting Variables</H1> <ch10:createCast/> <% for(int loopIndex = 0; loopIndex < names.length; loopIndex++) { out.println("Cast member: " + names[loopIndex] + "<BR>"); } %> </BODY> </HTML>
How can you make the names array into a scripting variable available to your JSP scriptlets? All you need to do to create this scripting variable is declare it in the TLD file, as you see in Listing 10.15.
Example 10.15. The Scripting Variables TLD File (ch10_15.tld)
<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"> <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>TagExamples</short-name> <description>Example tags.</description> <tag> <name>message</name> <tag-class>taglib.ch10_06</tag-class> <attribute> <name>text</name> <type>javalang.String</type> </attribute> </tag> <tag> <name>iterator</name> <tag-class>taglib.ch10_09</tag-class> </tag> <tag> <name>createCast</name> <tag-class>taglib.ch10_12</tag-class> <variable> <name-given>names</name-given> <variable-class>java.lang.String []</variable-class> <declare>true</declare> <scope>AT_END</scope> </variable> </tag> </taglib>
And that's all you need—the names variable is filled automatically from the names array in the Java code for the <ch10:createCast> tag. You can see the results in Figure 10.6. Now you're communicating between custom tags and JSP code easily, using scripting variables.
You've seen that a great deal is possible with custom tags. (In fact, even more is possible with the advanced class BodyTag, but that's beyond the scope of this book.) If you want to provide your Java code to JSP users who aren't interested in using Java directly, custom tags offer an excellent alternative.
Today you learned how to create and work with custom tags. You learned that basing custom tags on the Java TagSupport class is a good choice for basic custom tags, including iterating tags.
You learned that various methods in classes based on the TagSupport class are called at various times when a custom tag is called. For example, when JSP first encounters a custom tag, the doStartTag method in that tag's Java code is called. You can return constants like SKIP_BODY or EVAL_BODY_INCLUDE to tell JSP how you want to process the custom element.
You also learned that you can support attributes in custom tags by adding an <attribute> element to the tag's TLD file. After creating an attribute in this way, you can support it in your Java code by adding a property to that code in the same way as you'd support a property in a JavaBean—you create a variable with the same name as the attribute and implement a set method for the attribute.
You can also create iterating tags using the doAfterBody method and returning the constant EVAL_BODY_AGAIN to iterate again, and the constant SKIP_BODY to stop iterating.
Finally, you learned how to transfer data from JSP code to Java custom tag code using both page context attributes and scripting variables. Tomorrow, you'll get some additional Java experience as you start creating more powerful JavaBeans.
This workshop tests whether you understand all the concepts you learned today. It's a good idea to master today's concepts by honing your knowledge here before starting tomorrow's material. You can find the answers to the quiz questions in Appendix A.
1: | Attributes can be required or not, depending on the |
2: | You can also nest custom tags. Give that a try by nesting |