doAfterBody()

[Kanishka Ajwani]

In which of the following cases will the method doAfterBody() of a tag handler be invoked?


(a) This method will always be called when the body of the tag is not empty.
(b) This method will be called only when the body of the tag IS empty.
(c) This method will be called only when doStartTag() returns Tag.EVAL_BODY_INCLUDE or BodyTag.EVAL_BODY_BUFFERED.
(d) This method will be called only when doEndTag() returns Tag.EVAL_BODY_INCLUDE or BodyTag.EVAL_BODY_BUFFERED.
(e) This method will be called if doAfterBody() returns IterationTag.EVAL_BODY_AGAIN.


According to the author, the correct answer is only "e". However, I think it should be "c and e", since doAfterBody() will be called only if doStartTag() does not return SKIP_BODY (which means it either returns EVAL_BODY_INCLUDE or EVAL_BODY_BUFFERED).

Can anyone please explain this to me. Thanks.

[Abimaran Kugathasan]

QuoteYourSources Please!

[Kanishka Ajwani]

This is a question from topic discussions on www.enthuware.com. I do not know if I am allowed to share the link. If yes, I would love to.

[Christophe Verré]

Kanishka Ajwani wrote:I do not know if I am allowed to share the link. If yes, I would love to.

Questions coming from Enthuware are allowed in this forum.

[Kanishka Ajwani]

This question is from the link :
http://www.enthuware.com/forum/viewtopic.php?f=31&t=13

Check out question no 22.

[Frits Walraven]

Hi Kanishka,

I think it should be "c and e", since doAfterBody() will be called only if doStartTag() does not return SKIP_BODY (which means it either returns EVAL_BODY_INCLUDE or EVAL_BODY_BUFFERED).

These questions are always a bit tricky. The thing here is that you should know in which interface the static fields (like BodyTag.EVAL_BODY_BUFFERED) are declared.

EVAL_BODY_INCLUDE is declared in the IterationTag interface and not in the Tag interface. Conclusion: Tag.EVAL_BODY_INCLUDE doesnot exist and therefore answer "c" is incorrect

Regards,
Frits

[Kanishka Ajwani]

But the question does not tell you which interface/class is the tag handler implementing/extending. When you call a class "tag handler", does it mean that it is implementing the Tag interface?

I could be wrong here.

[Frits Walraven]

But the question does not tell you which interface/class is the tag handler implementing/extending. When you call a class "tag handler", does it mean that it is implementing the Tag interface?

Not always, you have to look at the methods they are giving you in the question. In this question they are only mentioning doStartTag() and no doTag() so you question is only about the "Classic" Custom Tags. (which all implement the Tag interface though). The Simple Custom Tag, doesnot implement the Tag interface.

Regards,
Frits

[Piotr Nowicki]

Howdy guys!

I've got a similar problem with the Classic Tags and doAfterBody() method.

I mean, according to this question (answer e.) as well as the K&B Head First book (page 595, question 10),

Assuming no exceptions occur, doAfterBody() is called after doStartTag() for any tag that implements IterationTag and returns EVAL_BODY_INCLUDE from doStartTag().

My question is - is this enough for the doAfterBody() to execute? Doesn't the tag itself has to be used with the body?
I mean, I can have:
- a body-content set to "scriptless" in the TLD,
- Tag handler can extend IterationTagSupport,
- implemented the doAfterBody() method,
- doStartTag() method can return EVAL_BODY_INCLUDE or EVAL_BODY_BUFFERED,

but the doAfterBody() won't be executed if I have something like:

<pedro:myClassicTag />

Am I missing something, or the question here and in the K&B Head First book is slighly imprecise?

Thanks in advance!

Cheers!

[Frits Walraven]

Hi Pedro,

Maybe a bit late with replying, but I am just catching up after a two weeks holiday

My question is - is this enough for the doAfterBody() to execute? Doesn't the tag itself has to be used with the body?

Yes it is enough, have a look at my notes (ScwcdLinks, rancher notes ch 8.5). According to the specs, the body of the tag is evaluated after the doStartTag() method returns a EVAL_BODY_INCLUDE.

a body-content set to "scriptless" in the TLD

the returncode of the method doStartTag() determines whether the body is evaluated, if there is no scriptlet or EL evaluation the body evaluation is just outputing the text in between the starting en ending tag. If there even is no text between beginning and ending tag it just returns from the method (with returncode SKIP_BODY)

Tag handler can extend IterationTagSupport

You mean TagSupport, yes there is no difference with the previous explanation. If you are extending the TagSupport class you don't even have to implement a doAfterBody() method as the default implementation returns SKIP_BODY (see my flow diagram on 8.5.2. The bold returncodes are the ones provided by the TagSupport default implementation)

implemented the doAfterBody() method,

Then it will run your implementation and you have to make sure you are continuing the flow (by returning SKIP_BODY)

doStartTag() method can return EVAL_BODY_INCLUDE or EVAL_BODY_BUFFERED

The EVAL_BODY_BUFFERED is only returned from the BodyTagSupport class (and it was not mentioned in the K&B statement). However, as the BodyTagSupport extends the TagSupport class it also implements the IterationTag and you can see from my flow diagram on ch 8.5.3 that it also works there: the doAfterBody() is called when the doStartTag() returns EVAL_BODY_INCLUDE.

but the doAfterBody() won't be executed if I have something like:
<pedro:myClassicTag />

It will unless you return SKIP_BODY from the doStartTag() method.

Make sure you learn the flows by heart for your exam and you also have to know it which interface the statics are defined!

Regards,
Frits

[Piotr Nowicki]

Thank a lot Frits for your time! I've got your learning guide downloaded already but didn't go through it, as I want to finish the HF first (sounds weird - Head First first ;-)

But, I'm still not convinced.

Assume following directory structure and files:

javaranchTags/ |-- index.jsp `-- WEB-INF |-- classes | `-- com | `-- example | `-- PedroClassicTag.class |-- pedroTags.tld `-- web.xml

web.xml
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <welcome-file-list> <welcome-file>index.jsp</welcome-file> </welcome-file-list> </web-app>

pedroTags.tld
<taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0"> <tlib-version>1.2</tlib-version> <uri>http://mytests.com/pedroTags</uri> <tag> <name>pedroClassicTag</name> <body-content>JSP</body-content> <tag-class>com.example.PedroClassicTag</tag-class> </tag> </taglib>

PedroClassicTag.java

package com.example;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class PedroClassicTag extends BodyTagSupport {

	public int doStartTag() {
		System.out.println("Tag: START!");

		return EVAL_BODY_INCLUDE;
	}

	public int doAfterBody() {
		System.out.println("Tag: AFTER BODY!");

		return SKIP_BODY;
	}

	public int doEndTag() {
		System.out.println("Tag: END!");

		return EVAL_PAGE;
	}
}

index.jsp

<%@ page import="java.util.*" %>
<%@ taglib uri="http://mytests.com/pedroTags" prefix="pedro" %>

<pedro:pedroClassicTag />

My result is:

Tag: START!
Tag: END!

When I change the index.jsp to the following one:

<%@ page import="java.util.*" %>
<%@ taglib uri="http://mytests.com/pedroTags" prefix="pedro" %>

<pedro:pedroClassicTag>!!!</pedro:pedroClassicTag>

The result is:

Tag: START!
Tag: AFTER BODY!
Tag: END!

So I still think that:
- a body-content set to something else than "empty" in the TLD,
- Tag handler extending TagSupport (or BodyTagSupport),
- implementing the doAfterBody() method,
- doStartTag() method returning EVAL_BODY_INCLUDE (or EVAL_BODY_BUFFERED in case of BodyTagSupport)

is not enought to execute doAfterBody(), as the tag itself cannot be empty.

Did I miss something?

Cheers!

[Frits Walraven]

My result is:
Tag: START!
Tag: END!

I am surprised here.....

Let me dig some what deeper into the jsp2.0 specs. The lifecycle transition diagram (jsp2.0, JSP.13.1.3) shows the possible transitions.

A little bit further the following is specified:

Empty and Non-Empty Action
If the TagLibraryDescriptor file indicates that the action must always have an empty element body, by a <body-content> entry of "empty", then the doStartTag() method must return SKIP_BODY.

Note that which methods are invoked after the doStartTag() depends on both the return value and on if the custom action element is empty or not in the JSP page, not on how it's declared in the TLD.

If SKIP_BODY is returned the body is not evaluated, and then doEndTag() is invoked.

If EVAL_BODY_INCLUDE is returned, and the custom action element is not empty, the body is evaluated and "passed through" to the current out, then doAfterBody() is invoked and, after zero or more iterations, doEndTag() is invoked.

Conclusion: You where right!!!

I am still learning things , this certification is full of subtle details...

Regards,
Frits

[Piotr Nowicki]

Thanks Frits, now I guess my question can be treated as solved :-)

Cheers!

[Rohini Sahuji]

The result is:

Tag: START!
Tag: AFTER BODY!
Tag: END!

THis may sound stupid....
But my question is...
what happened to "!!!"
why its not printed?

[Piotr Nowicki]

Well, it is, but in the rendered JSP page.

I've posted only the System.out.println(-) statements, which prints to the TOMCAT_HOME/logs/catalina.out file.

[Rohini Sahuji]

Ohhhh...
Got It.
Sorry I dint see,
System.out.....

Thank you!

[Benjamin En]

Hey Guys!

I got hooked on the same question as pedro, and also assumed, that NONE of the given answers is right.
The spec seems to give him and me right.
So is it correct, that answer E shouldn't be checked?
And if yes, why isn't it listed in the errata yet?

Hope you can help me ;)

[Frits Walraven]

Hi !

So is it correct, that answer E shouldn't be checked?

We came to the conclusion that answer "e" is questionable. There is a possiblity that a Tag doesn't have a body and in that case the doAfterBody() won't be called at all... However from all the answers this one is the best....

And if yes, why isn't it listed in the errata yet?

I have no idea if somebody has mentioned it to the authors... maybe you want to do it

Regards,
Frits

[Benjamin En]

Well actually after thinking about it, Option E is correct.
Because if doAfterBody() is reached - which is the assumption of option E - returning EVAL_BODY_AGAIN will definitely let
doAfterBody() get invoked again.

So actually it is rather tricky than wrong.

[Frits Walraven]

Well actually after thinking about it, Option E is correct.
Because if doAfterBody() is reached - which is the assumption of option E - returning EVAL_BODY_AGAIN will definitely let
doAfterBody() get invoked again.

I agree, but if your tag doesn't have a body it will never execute the first doAfterBody()... so to make the question less ambigious there could be a note that you have to assume that the tag is invoked from a jsp and has a body.

Regards,
Frits

[Ankur Gargg]

Frits Walraven wrote:

But the question does not tell you which interface/class is the tag handler implementing/extending. When you call a class "tag handler", does it mean that it is implementing the Tag interface?

Not always, you have to look at the methods they are giving you in the question. In this question they are only mentioning doStartTag() and no doTag() so you question is only about the "Classic" Custom Tags. (which all implement the Tag interface though). The Simple Custom Tag, doesnot implement the Tag interface.

Regards,
Frits

Firstly the EVAL_BODY_INCLUDE is declared in "Tag" interface not the iterationtag interface.
Can you now say the answer to this question?
It can be c) as well as e)

[Frits Walraven]

Firstly the EVAL_BODY_INCLUDE is declared in "Tag" interface not the iterationtag interface.
Can you now say the answer to this question?
It can be c) as well as e)

Well spotted

I agree, c could be a good answer as well as long as your tag has a body when using it, so like:

<pedro:pedroClassicTag>This tag has a body</pedro:pedroClassicTag>

when you use your tag like Pedro was saying without a body:

<pedro:pedroClassicTag />

then the doAfterBody() is not called. Therefore a well designed question will say that the tag under question has a body when used. Now it makes the answers questionable.

Regards,
Frits