JSP include - Action vs Directive

In one of our web projects, We have a jsp file for creating the main interface of the appication. As development progressed, requirements grew and accordingly our jsp got bigger and bigger. After sometime when we looked back, we could identify some repeating sections (similar layout). Around the same time, we also got a requirement to have a dynamic number of repeating section based on client. With these requirements in mind we started working towards splitting the existing jsp into multiple jsp files and including them either conditionally or always according to the requirements.

So we have two requirements - To conditionally include (and include repeatedly) certain jsp pages and always include other jsp pages, so we came across the classic question of when to use jsp include action vs directive !!

The JSP spec says - action is run-time and directive is compile/translation-time activities. One can expect individual servlet files for each jsp file included using action and all jsps included using directive get merged into the including jsp itself.

Being aware of this information, we divided our huge jsp into multiple small files and gave them an extention jspf (for jsp fragment). Then we used jsp include directive for all the pages that need to be included always and jsp include action for other case, where need to repetitively include certain number of times based on some conditions. When tested this setup, no dynamic behaviour is displayed by the jsp include action and to make the problem more interesting we ended up with only a single servlet at the server-side (tested on both JBOSS and Websphere). We tried various combinations and tried changing everywhere to use only include actions, only include directives and other meaningful combinations and ended up with same result.

We did extensive googling and listed out the key differences between jsp include directive and action as below:

JSP include directive:

1. Affects the process during compile/translation of including JSP and the result is - whole content gets copied into the including JSP.
2. JSP could be completely static (pure HTML) or completely dynamic (pure JSP) or a mix. The dynamic content (scriptlets, expressions etc) is handled properly while the including JSP is compiled into a servlet.
3. As it is straight content copy, any variables declared in the including JSP are available for use.
4. The included JSP need not be valid on its own as it never gets compiled alone, but always as part of the including JSP
5. The file attribute value has to be a static name

JSP include action:

1. Affects the process during run-time/execution of including JSP, which means the including JSP get only the result of its execution (through an explicit call).
2. With include action, we can pass parameters from the including JSP and make the content more dynamic.
3. As the including JSP gets only the result of included JSP, variables declared in the including JSP are not accessible.
4. The included JSP need to be completely valid on its own.
5. The page attribute value could be dynamic (an expression)

We understand all the above points, but still couldn't understand where the problem is ! Finally, we tried renaming all *.jspf files to *.jsp and tested and bingo !! multiple servlets got created as expected for each include action. The undocumented rule is - as long as the included file extention is not jsp, include action works exactly as if it is a directive without throwing any errors. We observed the same behaviour with JBOSS (Tomcat) and Websphere. Hope this saves some effort for others.

JavaScript frameworks

For a long time I was dying to put my hands into web application development and finally the day came. First thing I realized is that the foundations I have are sufficient only to make me feel at home, but are not at all sufficient to do some really useful stuff.

To start with we have put couple of servlets and a basic html and made the skeleton ready. Now its time to pick one javascript framework available for giving the web those special looks. I did googling for about couple of hours and got to know below frameworks:

• jquery - Probably this is one of the recent (I know there is nothing like latest in our domain) frameworks out there. It provides various ways of manipulating DOM and event handling. Along with comes jquery ui, which provides some special effects like sliding, tabbed interfaces etc.
  

• prototype - This is probably out there for quite some time. This also provides ways for manipulating DOM and handling events. There are other frameworks like scriptaculous/rico, developed over Prototype for developing special effects and animations.

• mootools - This is all-in-one framework providing support for handling events, manipulating DOM, special effects, sorting of tables etc.
  

• yui & ext - Both very rich in features, but could not understand what they are and how they work as my understanding of javascript is very limited as of now :-(
  

• dojo - Yet another framework for DOM manipulation, dijit is developed over dojo for providing special effects.

Deciding on any of these frameworks would be a challenge, but fortunately other my job became simpler as there were other existing applications developed earlier using prototype/scriptaculous.

As I am skeptical about following practices (even standard ones, till I see the benefits), I did some research on jquery as an alternative to prototype. My understanding is that the way one collects a group of elements for special handling is different.

Jquery feels like a scripting language by the looks of its (non-object) syntax, uses CSS notations for forming collections and applying special effects whereas Prototype goes for object oriented notation. I also read some review which mentioned that Prototype also offers Jquery like syntax so it is all hazy at the moment for me. With this I am starting to learn Prototype/scriptaculous.

forward vs include of request dispatcher

Recently I was analyzing a web application along with my colleagues and came across an issue, which required us to be clear on the concepts of forward and include methods of RequestDispatcher. A brief on the application setup before I explain the problem and solution.

We have a filter, a servlet and a jsp. All requests coming for jsp shall go through the filter. Filter does a forward to servlet and then call the next one in the chain, which is jsp. With this setup we are getting the IllegalStateException when we invoke the jsp.

This issue helped to clear my basic understanding of forward & include. I always thought that with forward control does not come back to the invoker !! Wrong, control does come back.

Forward - control comes back to the invoker, but response shall be committed even if the invoked did not write anything to the output.

Include - control comes back to the invoker, but response shall not be committed. The invoked might add something to the response, to which invoker might add more.

Redirect - control does not come back to the invoker.

In our case the problem was after the forward call to the servlet from filter, response is committed. Then when the control reaches jsp, it is trying to create a session (we haven't disabled session creation) which is not allowed. To correct this we are creating the session before forwarding the request to the servlet so that when the control reaches the jsp, session shall be available.

DOCTYPE - syntax and purpose

!DOCTYPE is required and be the first line in HTML/XHTML documents as per the validation constraints of HTML 4.2 or XHTML 1.0. Below is the syntax:

Typical HTML DOCTYPE statement:

<!DOCTYPE	HTML	PUBLIC	"-//	W3C//	DTD	HTML 4.0 Transitional//	EN"	"http://www.w3.org/TR/html4/loose.dtd">
	(1)	(2)	(3)	(4)	(5)	(6)	(7)	(8)

Annotated syntax:

<!DOCTYPE	[Top Element]	[Availability]	"[Registration]//	[Organization]//	[Type]	[Label]//	[Language]"	"[URL]">
	(1)	(2)	(3)	(4)	(5)	(6)	(7)	(8)

Explanation:

General: A pair of forward slash characters ("//") is used as delimiters between keyword fields in the FPI declaration.

(1):[Top Element] - Indicates the top level element type declared in the DTD; for HTML it is <html>.

(2): [Availability] - field indicates whether the identifier is a publicly accessible object (PUBLIC) or a system resource (SYSTEM) such as a local file or URL. HTML/XHTML DTDs are specified by PUBLIC identifiers.

(3): [Registration] - Indicated by either a plus ("+") or minus ("-"). A plus symbol indicates that the organization name that follows is ISO-registered. A minus sign indicates the organization name is not registered. The IETF and W3C are not registered ISO organizations and thus use a "-".

(4): [Organization] - This is the "OwnerID" - a unique label indicating the name of the entity or organization responsible for the creation and/or maintenance of the artifact (DTD, etc.) being referenced by the DOCTYPE. The IETF and W3C are the two originating organizations of the official HTML/XHTML DTDs.

(5): [Type] - This is the "Public Text Class" - the type of object being referenced. There are many different keywords possible here, but in the case of an HTML/XHTML DTD, it is "DTD" - a Document Type Definition.

(6): [Label] - This is the "Public Text Description" - a unique descriptive name for the public text (DTD) being referenced. If the public text changes for any reason, a new Public Text Description string should be created for it.

(7): [Language] - This is the "Public Text Language"; the natural language encoding system used in the creation of the referenced object. It is written as an ISO 639 language code (uppercase, two letters.) HTML/XHTML DTDs are usually (always?) written in English ("EN".)

(8): [URL] - This is the optional explicit URL to the DTD being referenced.

Here are the links for more information:

http://www.blooberry.com/indexdot/html/tagpages/d/doctype.htm

http://www.searchwin.net/doctype.htm

http://www.freebsd.org/doc/en_US.ISO8859-1/books/fdp-primer/sgml-primer-doctype-declaration.html