In this four-part tutorial on JSTL, the author introduces the concept of tag-based programming and discusses its merits and demerits, with some simple illustrations.




(  published in DeveloperIQ  magazine?Oct-2004)
( comments on this article may be sent to:  [email protected] )

In this four-part tutorial on JSTL, the author  introduces the concept of tag-based programming and  discusses its merits and demerits,  with some simple illustrations.  

JSP Tutorials HomeTutorial Home | Part 1 | Part 2Part 3 | Part 4

Part-1  - JSTL   Basics.  
In the first part of this tutorial on JSTL, the author gives a brief introduction to JSTL and shows why and how it evolved .    

As J2EE programmers, we are familiar with Servlets , JSP   and JavaBeans.  Any JSP page should encapsulate the business logic in a bean and invoke it by using <jsp:useBean>  tag.  Till recently, a combination of Servlets, JSP and beans was the standard practice. But, the JCP released an API for enabling programmers to create custom tags and use them in their JSP pages. The difference between javabean and java custom tags was that, though both made use of java classes,  tags can be used by non-programmers also without  knowledge of Java programming, just as they would use html tags.( From a programmer's perspective,however, a much more important distinction is that tags are specific to the page in which they are created while javabeans are general. )

{{{  Back in  1998, a Web-Server Technology , known as ColdFusion , created by Allaire of Allaire Corporation, was very much in demand!. It was a purely tag-based language, using which page-authors can turn into programmers overnight. The tags were so powerful and simple to use! There is a separate lesson on using ColdFusion for typical web-based database operations, elsewhere in this edition, just to indicate the source of inspiration of the tag library idea, of the JSTL. To this day, ColdFusion is unbeatable, in its power,speed, ease of use and productivity. However, among the various web-server technologies ( namely

ASP, Servlets, JSP,Perl,PHP , ColdFusion &, CF is the only technology that is not free!And perhaps for this reason, it is no longer popular in Indian environment, though it is said to be very much in vogue still, in US!

MacroMedia of 'Flash fame' purchased ColdFusion .There was even a tutorial on MacroMedia ColdFusion Exprsess in DeveloperIQ., a few months back.It is interesting to make a comparison of the CF tags approach and the JSTL approach., especially , in DataBase operations.Readers are requested to read the lesson on ColdFusion,in this edition, after covering sql tags in JSTL , in the fourth part of this tutorial..}}}

   To resume,the release of the TagLibrary API, triggered   a lot of   activity and hundreds of tags were introduced by the java community, some of them 'open' and a few 'proprietary'.  This led to a lot of confusion in code maintenance, because knowledge of Java was no longer sufficient to understand and interpret a given jsp page using non-standard tags .The JCP had unwittingly   introduced elements of confusion by the JSP-Custom-Tag specification.

   To correct this problem, Sun and JCP, initiated   the JSP-Standard Tag Library (JSTL) project.  Though there are a number of popular and powerful tag-libraries, it is always better for j2ee coders to  adopt the JCP standard because, it is likely to be merged into the core specification of Java langauage itself , in future. (That yardstick may be valid for all creations, in Java world. Splintering of the Java platform due to' hyper-active creativity'  without the corresponding discipline to get it through a standards body ,is the greatest threat, looming large in the Java-horizon.

Too frequent revisions and additions, that too without caring for backward compatibility,are not conducive to programmer productivity  and the net result is that programmers spend ,in learning new twists in grammar,  their  precious time  which should have been spent more usefully in applying that grammar in solving business-logic problems and acquiring proficiency in the chosen application-domain. While, tag library is sometimes very elegant and simple to use, it defeats the very purpose if the tags  are not standard tags and if there is proliferation of non-standard tags.It is for this reason that JSTL merits our serious study and adoption.

JSTL is a quite recent  development. It was only in 2003, that the official version 1.1 was released and now incorporated into  JSP-2.

   According to the latest position, the JCP is suggesting that a JSP page should be completely free from any trace of Java code!  So, programmers who were writing their JSP using Javabeans and scriptlets , may not be able to carry on in their old style as,  to prevent programmers from introducing scripting sections in their pages, there is a  provision  for turning off scriptlets altogether from a jsp page. If that happens ,all our knowledge of Java coding will be of little use in creating a jsp page, though such knowledge may be useful in creating beans and other types of java programs.

  It is thus very important for  J2EE students, to understand the trend and get to know the techniques, advantages and limitations of  tag libraries...In a way, a study of JSTL is almost synonymous  with a study of the latest version of JSP (ie) JSP2.0 .


  Without an introductory demo for each of these types, it may be difficult to appreciate the significance of the above lines. So we will now give simplest illustration.


[It is presumed that readers are conversant with basic Servlets & JSP techniques and executing them in Tomcat environment. In case of any difficulty, they can refer to back issues of this magazine ( from Oct-2003  onwards) and gain access to a number of lessons for illustrations.]

Servlets are full-fledged java-classes and so are very powerful. But, when we want to create a dynamicalay-generated web-page using servlets, it becomes difficult and clumsy.Let us consider a very simple example.

The user fills up text in html form with his name and submits the form,to the servlet. The servlet reads the data , appends a greeting and sends it back to the user.


  We begin with a simple html form;

  //   greeting.htm


  <html>  <body>

  <form   method=post 
action= 'http://localhost:8080/servlet/greeting'>
<input   type=text   name='text1'> 
<input   type=submit> 

  (relevant section of servlet)
// ( code-snippet only)
 public void doPost(HttpServletRequest  req,
    HttpServletResponse  resp) 
throws  ServletException,IOException {

  PrintWriter  out = resp.getWriter();  
  String  s = req.getParameter("text1");
  out.println("<html><body  bgcolor=yellow>");  
  out.println("we  welcome"+",<br>");  
  out.println (s);  
  out.println("</body> </html>");  


It will be noticed that  we have to write so many 'out.println' statements. This makes the page unreadable.( If String-buffer is used , we can do it with just a single out.println , but  forming the correct string may pose difficulties).

  It is to solve this problem   that JSP was developed five years back(1999).While a servlet   interposes HTML   in java code, JSP interposes java-code in HTML, as some authors correctly observe..( in this case, we have to modify the action field in html form, so that it refers to the following  greeting1.jsp).Student readers will know about 'delimiters' ( <%).in ASP.

This is the same as in  JSP. Only the syntax is slightly different.In JSP parlance, the code within delimiters is known as 'scriptlet'.( see greeting1.jsp)


//  greeting1.jsp


  <body   bgcolor=yellow> 
String   s = request.getParameter("text1"); 
out.println("we welcome"+<br>); 


 Some coders prefer to use expressions.

What is an 'expression'? It is a method of sustituting request-time values in html page. ( see greeting2.jsp). Carefully note that there is no semi-colon after ("text1").

-----------------------------------------------  //  greeting2.jsp

   <body  bgcolor=yellow>    
  we  welcome <br> 
  <%=  request.getParameter("text1") %>     


The third variant is to use a javabean to encapsulate the business-logic. We  develop a jsp-bean as follows:



package  ourbeans;

public class  greeter {

  public greeter()  {  } 
public  String   greetme(String  s)   { 
return  "we welcome..."+s; 

This source file is compiled and the class-file is copied to :



(Carefully note that WEB-INF folder name should be in capital letters).

( Anytime, a new class is placed in Tomcat, we should remember to restart the server).
We can now   write our JSP code as follows:

// greeting3.jsp


<jsp:useBean  id='bean1'  class='ourbeans.greeter'> 


   String  s = request.getParameter ("text1");  
   String  r =   bean1.greeteme(s);  

We are now entering    JSTL  zone.  

   How exactly we should proceed to  instal   JSTL, we will take up shortly. For the moment, we are just getting familiar with the required syntax.   We begin with taglib directive.

<%@  taglib  prefix="c"   uri=""  %>      

The directive says that we are using 'core' tags and the prefix will be 'c'.  If we want to assign the value 'sam' to a variable 'a' and then print it, the JSTL code will be

 <c:set  var="a"   value="sam" />

 <c:out   value="${a}"   />


The Dollar sign  & brace will be familiar ground for Perl programmers.   In JSTL & JSP-2, it is  known as EL ( Expression Language).


To consider another example,  In servlet & jsp, we write:

 String s = request.getParameter("text1");

to collect the input from the user.

The same job is done in  JSTL   by:
<c:set  var="s" value="${param.text1}" >


 With these brief hints, it should not be difficult to understand the

following   JSP  page written  by   using JSTL core-tags.


//   greeting4.jsp   (  uses  JSTL)


<%@  taglib   prefix="c" uri=""  %> 
<c:set var=s  value="${param.text1}" />  
We welcome<br>  
<c:out  value="${s}" />  


In the previous  examples, there was java code in a few lines atleast. But, in the  JSTL  example, we find that there are only tags and no java  scriptlets. This is the avowed objective of the JSTL  initiative,

under the auspices of Java Community Project! Why?   This enables , clean separation of  Page author's role and Logic programmers' role. Thus maintenance becomes easy.


  There are five groups under which the JSTL tags have been organized.

   They are as follows:

  1)   core

  2)   xml

  3)   sql

  4)   formatting

  5)   functions.

-----------------------------------------------   The most difficult part is  to set up Tomcat  so that it executes JSTL.   There are some basic requirements, before we can experiment and study the use of JSTL.All that we have studied in using Tomcat for servlets and JSP may not be sufficient to learn JSTL, because, jstl library is not built into Tomcat5  even, as yet.

  Without hands-on experimention, JSTL could be confusing and strange,because of the   fact that it is very  recent  . But in coming months, support will be built into Tomcat and we won't have to worry about installing the JSTL  libraries inside Tomcat. But, as it is, we have to learn how to set up the necessary development environment..

   So , how do we go about , placing the JSTL libraries in tomcat?

------------------------------------------------   The best solution is to get JWSDP1.3.

   This is Java Web Service Development' Pack.

( Carefully note the version , however!).

   It is good to start with this because, it contains a lot of valuable software , including the latest and greatest from  JCP, (ie) JSF

(Java Server Faces).... which may soon replace Struts. 
We unzip   the jwsdp1.3  and install   it in C: drive. There   are  a number of folders like JAXP, JAXR, JAXB,JAX-RPC, JSF, JSTL etc. in the JWSDP pack.

 For the present, we are interested in JSTL folder only. If we expand the JSTL folder, we find  four   sub folders :

   a)  docs

   b)  lib

   c)  samples

   d)  tld  (  tag library descriptors)

   When we look into the 'lib' folder, we find  two jar files:

  a)  standard.jar

  b)   jstl.jar

We should copy  these two jar files into  :



( Remember to restart the Tomcat server). That is all that is required to use   JSTL. !  

The included taglibrary descriptors do not have to be placed in the WEB-INF folder.These files are already  included in the /META-INF folder of the jstl.jar and so will be automatically loaded by Tomcat, when it is restarted.


 ( we are using tomcat5 & jdk1.4.2)

 ( the results are not  ensured   for other environments.).( however, we adopted the same method in Tomcat4.1 with jdk1.41 and got correct functioning.)


  The JSTL  folder contains a sub-folder named 'tld'.  There will be a number of tld files there such as

c.tld,  ( core)

x.tld,  (xml)

fmt.tld,  (format)

sql.tld &  (sql)

fn.tld.  (functions)


Some authors say that we should copy these tld files  to ..

..:\tomcat5\webapps\root\WEB-INF   folder.

 A few others , say that there is automatic detection and so it is  not necessary. We  chose not to copy the tld files into

e:\tomcat5\webapps\root\WEB-INF   folder !

We found that the programs works well. No problem!  

When we study the web.xml file in e:\tomcat\webapps\root\WEB-INF   folder, we find that it follows  DTD and not Schema.

( DTD  stands for Document -Type- Definition).

( Schema  serves the same purpose but is in XML format and is more powerful). ( The default is DTD ).

   This point is very important. The default allows us to use EL,(Expression Language) but by using <c:out   value="${s}" syntax.

If we modify the DTD into the prescribed J2EE schema , we can directly print as   ${s}. This requires very careful handling and we take it up later.

   For the present , let us not tamper with the DTD. or the web.xml file.

In the next part of this tutorial, we study the tags available in the JSTL-core library.

JSP Tutorials HomeTutorial Home | Part 1 | Part 2Part 3 | Part 4