JavaBeat » JSP

What is load on startup element in web.xml file

krishnas — Thu, 21 Feb 2013 04:33:47 +0000

specify the order in which we want to initialize various Servlets. Like first initialize Servlet1 then Servlet2 and so on.
This is accomplished by specifying a numeric value for the tag. tag specifies that the servlet should be loaded
automatically when the web application is started.

The value is a single positive integer, which specifies the loading order. Servlets with lower values are loaded before servlets with
higher values (ie: a servlet with a load-on-startup value of 1 or 5 is loaded before a servlet with a value of 10 or 20). When loaded, the init() method of the servlet is called. Therefore this tag provides a good way to do the following:

start any daemon threads, such as a server listening on a TCP/IP port, or a background maintenance thread perform initialisation of the application, such as parsing a settings file which provides data to other servlets/JSPs If no value is specified, the servlet will be loaded when the container decides it needs to be loaded – typically on it’s first access. This is suitable for servlets that don’t need to perform special initialisation.

I hope that clears all the doubts regarding in web.xml.

Core Tags in JSTL

JavaBeat — Sun, 22 May 2011 00:39:47 +0000

Connect to us ( @twitter | @facebook )

[ In the second part of this
tutorial on JSTL, the author explains how the tags in the core-group can be
used in JSP pages, with a number of simpleexamples.]

We are now ready toexperiment with all the tags in the
‘core’ library. The core tags have the following uniform‘uri’.

‘http://java.sun.com/jstl/core'

===============================

( However, in the book by Hans
Bergstentitled,"Java
Server Pages" ( third edition), (OReilly pub)the
uri is consistently given as :

'http://java.sun.com/jsp/jstl/core'.It looks as if there has been some
change in specification and grammar, after it was published.

This
appears to be wrong asthe server threwexception.The correct uri is :

'http://java.sun.com/jstl/core'.)

The
prefix is‘c:’

The following tags are available in the
‘core’ library.

( Remember them as a dozen!).

<c:set

<c ut

<c:iftest= “

<c:choose,<c:when ,<c:otherwise

<c:forEach

<c:forTokens

<c:import

<c:url

<c:redirect

<c:param

———————————————–

We
will now see simplest illustrations for the above tags.There
are a dozen demos, to bring out the features of each of these tags.

—————————————

demo1.jspuses<c:set&
<c:outtags.

:We create demo1.jspas:

e:tomcat5webappsrootdemo1.jsp

—————————————–

//demo1.jsp

<%@
page contentType="text/html" %>

<%@
taglibprefix="c"uri="http://java.sun.com/jstl/core"%>

<html>

bgcolor=lightblue>

method=postaction="demo1.jsp">

NAME <inputtype=textname="text1">

PLACE<inputtype=textname="text2">

NAME:<c:outvalue="${param.text1}"/>

PLACE:<c:outvalue="${param.text2}"/>

In all the
previous examples, we invoked the JSP file through a htmlfile. But, in demo1.jsp, we areposting the page
to itself.( in asp.net style!).( but there is no
'retention of data' , unlike asp.net).

We start
Tomcat5, and type the urlas :

‘http://localhost:8080/demo1.jsp’.in the browser.We get a form with two text boxes and a submit
button. We fill up the textboxes with ‘name’ and ‘place’ and submit.The demo1.jsp executes and displays thevalues entered by
the user.due to the JSTL tags

<c utvalue=”${param.text1}/>etc.

That is
about our first and introductory example.

———–
—————————————

The second example is very important. When
the user enters data in a number of fields, it is tedious to collect the data
and transfer it to jsp page for processing. In our
example, we are collecting data about a player,such as his name, place and game. We
can have much more but we are restricting for space considerations. JSP has an
action tag , known as 'jsp:setProperty'.
Using this along with a standard javabean, we can
extract data and transfer it to our program in a single step.

The syntax
is

<jsp:useBean

id="bean1"class="ourbeans.player">

<jsp:setProperty

name="bean1"property="*"/>

jsp:useBean>

the * sign denotes 'all').

—–

But, we should first create the 'player ' bean
with all the attributes and getter & setter methods, as shown.

———————————————

//player.java

packageourbeans;

public class player

{

Stringname;

Stringplace;

Stringgame;

public player()

{

name="";

place="
";

game="
";

}

//—————————

public voidsetName(String a)

{name=a; }

public void setPlace(String b)

{place=b; }

public void setGame(String c)

{game=c;}

//——————————

public StringgetName()

{ returnname; }

public StringgetPlace()

{ returnplace; }

public StringgetGame()

{ returngame; }

}

———————————

In demo2.jsp, we collect the data and then displaythe data
entered by the user.

Note that
instead of {param.text1}, we are using {bean1.name}. We should carefully name
the html form controls with the corresponding attribute names given in the
bean. We cannot name the controls as 'text1' etc, now!

—

We get correct result.

=============================================

//demo2.jsp

<%@
page contentType="text/html" %>

<%@
taglib prefix="c"

uri="http://java.sun.com/jstl/core"%>

<html>

<body>

method=postaction="demo2.jsp">

<jsp:useBean id="bean1"
class="ourbeans.player">

<jsp:setPropertyname="bean1"
property="*"/>

jsp:useBean>

Name
type=textname="name">

Place<inputtype=textname="place">

Gametype=textname="game">

type=submit>

Name:
<c utvalue="${bean1.name}"/>

Place:
<c ut
value="${bean1.place}"/>

Game:
<c ut
value="${bean1.game}"/>

=============================================

Once
again, it will be noticed that there is no java code in this example, as
everything is being done by tags, only..

***********************************************

We
are now ready to take up examples for 'condition'tags.

There are two types of 'condition tags'.

namely, <c:if>&<c:choose>.

In the
third demo, we learn how to use the <c:iftag.

———————————————-

//demo3.jsp

<%@
page contentType="text/html" %>

<%@
taglib prefix="c" uri="http://java.sun.com/jstl/core"%>

<html>

bgcolor=lightblue>

method=postaction=demo3.jsp>

name="combo1">

value="sam">sam

value="tom">tom

type=submit>

<c:setvar="s"value="${param.combo1}"/>

<c ut
value="${s}"/>

<c:iftest="${seq'sam'}">

c:if>

<c:iftest="${s=
='tom'}">

c:if>

—————————————–

There is a combo with two options, namely

'sam' and 'tom'. If the user
selects 'sam' and submits the form, he gets 'GoodMorning …SAM!". If he selects 'tom' instead, he
gets

'How
are you..TOM?'.

The above code is no ‘Rocket-Science’ as
Americanauthors say!But
, if we are carelessin typing the names
‘sam’ or ‘tom’ in the test condition, we could spend
hours together , trying to coax this code into functioning! We should not leave
space after the single quotein the 'test expression'. Second point worth noting in the above
example is that we can use either ==( double equal to) or eqto test equality.

***********************************************

In
the fourth example which follows, we take up <c:choose> tag.

The
syntax is:

<c:choose >

<c:whentest="">

<c therwise>somethingc:otherwise>

c:choose>

The
peculiarity to be noted here is thatunlike <c:if ,
where we had to explicitlyuse <c:out for printing , no such <c:out
has been used here., and yet the result is displayed,

because 'choose' includes 'displaying'..

When
we choose '7', "select between 1 & 5 " will be displayed!

———————————————–

//demo4.jsp

<%@
page contentType="text/html" %>

<%@
taglib prefix="c" uri="http://java.sun.com/jstl/core"%>

<html>

bgcolor=lightblue>

method=postaction="demo3.jsp">

<inputtype=submit>

<c:setvar="s"value="${param.combo1}"/>

Today
is

size=24 color=red>

<c:choose>

<c:whentest="${s==1}">Sunday
c:when>

<c:whentest="${s==2}">Mondayc:when>

<c:whentest="${s==3}">Tuesdayc:when>

<c:whentest="${s==4}">Wednesdayc:when>

<c:whentest="${s==5}">Thursdayc:when>

Accessing Portlet-specific Objects in JSP Pages

krishnas — Sat, 30 Apr 2011 00:18:09 +0000

Connect to us ( @twitter | @facebook )

This article is based on Portlets in Action, to be published June 2011. I t is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) ebooks and pbooks. MEAPs are sold exclusively through Manning.com. All print book purchases include an ebook free of charge. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information.

Accessing Portlet-specific Objects Using defineObjects Tag

Introduction

In a lot of cases, JavaServer Pages (JSPs) may rely on JSP implicit objects to achieve their functionality. It is perfectly fine to use JSP implicit variables in your JSP pages, but, on the downside, your JSP is dealing with servlet-specific objects (like HttpServletRequest and HttpSession) and not portlet-specific objects (like RenderRequest and PortletSession).

If we add an attribute to RenderRequest, it’s mirrored by HttpServletRequest and vice versa. The same applies to HttpSession and PortletSession. So what difference does it make if we use portlet-specific objects in JSPs? Subtle differences between servlet and portlet API can answer this question. For instance, in your JSP page, you can’t use HttpServletResponse to create a portlet URL (only a RenderResponse object provides methods to create portlet URLs). HttpServletRequest can’t provide the information about the portlet mode and the window state (PortletRequest provides methods to obtain the portlet mode and the window state). This is like rain and freezing rain—both are forms of precipitation with the only difference in what happens when raindrops hit the ground.

In general, your JSP pages will use a combination of portlet and servlet objects to generate content. For instance, if you want to set the expiration time for the content in the JSP page, you will use the RenderResponse portlet object. If you need to obtain the value of an APPLICATION_SCOPE portlet session attribute, you may prefer to use session (which refers to HttpSession object) or sessionScope (which is a java.util.Map of session attributes stored in HttpSession object) for a JSP implicit object to obtain its value.

NOTE

JSPs included by portlets have access to JSP implicit objects because portlet application is also a web application.

The name defineObjects gives the impression that it can be used by JSP developers to define custom objects in their JSP pages, but that’s not the case. The defineObjects tag of portlet tag library provides JSPs with access to portlet objects like RenderRequest, RenderResponse, PortletSession, and so on. Table 1 lists the scripting variables (and their type) that are available to JSP pages that use defineObjects tag.

Table 1 shows the scripting variables defined by the defineObject tag. As you can see, defineObjects provides JSP pages with all Portlet 2.0 API objects they’ll ever need to use portlet-specific features. In JSP pages, you’ll usually use a combination of JSP implicit objects and the implicit objects made available by defineObjects tag. You’ll probably never use actionRequest, actionResponse, eventRequest, and eventResponse objects in your JSP pages because the portlet container ignores the content written out to the response in action and event processing phases.

NOTE

defineObjects tag doesn’t define any attributes.

The sample Book Catalog portlet in this article uses scripting variables introduced by defineObjects tag to show the debugging information, as shown earlier in figure 1.

Listing 1 shows debug.jsp page and is included by all JSP pages in the Book Catalog portlet. The debug.jsp page prints the information about the portlet mode, the window state, the value of myaction attribute from request, the content expiration time, and so on, most of which is obtained using scripting variables introduced by defineObjects tag.

Listing 1 debug.jsp—Using variables introduced by defineObjects tag

<%@ taglib prefix="portlet" 						#1
		uri="http://java.sun.com/portlet_2_0"%> 			#1
	<%@ page contentType="text/html" isELIgnored="false"
		import="javax.portlet.PortletSession"%>
	 						#2
	....
	Value of myaction request attribute:
		${requestScope.myaction} 					#3
	Portlet mode of request:
		<%=renderRequest.getPortletMode()%> 				#4
	Window state of request:
		<%=renderRequest.getWindowState()%> 				#5
	Content Expiration time:
		<%=renderResponse.getCacheControl().getExpirationTime()%> 	#6
	seconds
	uploadFolder init parameter value:
		<%=portletConfig.getInitParameter("uploadFolder")%> 		#7
	myaction attribute value in PortletSession:
		${portletSessionScope.myaction} 				#8
	Search criteria stored in PortletSession:
		Book name –
		<%=portletSession.getAttribute("bookNameSearchField", 		#9
		PortletSession.APPLICATION_SCOPE)%> 				#9
		Author name –
		<%=session.getAttribute("authorNameSearchField")%> 		#10
 
		#1 Declare portlet tab library
		#2 defineObjects tag
		#3 myaction HttpRequest attribute
		#4 Portlet mode from RenderRequest
		#5 Window state from RenderRequest
		#6 Cache expiration time from RenderResponse
		#7 uploadFolder portlet initialization parameter
		#8 myaction PortletSession attribute
		#9 bookNameSearchField PortletSession attribute
		#10 authorNameSearchField HttpSession attribute

At #1, the JSP page declares the portlet tag library using the taglib directory. The value of the uri attribute is http://java.sun.com/portlet_2_0 if you want to use Portlet 2.0 tag library. If you are using Portlet 1.0 tag library, specify the value of uri as http://java.sun.com/portlet. The defineObjects tag in Portlet 2.0 introduced additional variables like portletSessionScope, portletSession, and so on, which makes it easy to develop portlets using JSP as the view technology. At #2, the defineObjects tag is used to introduce scripting variables in the JSP page. At #3, the requestScope JSP implicit variable is used to obtain the value of the myaction attribute. At #4, the renderRequest variable is used to obtain the current portlet mode. At #5, the renderRequest variable is used to obtain the window state information. At #6, the renderResponse variable is used to obtain CacheControl object, which, in turn, is used to obtain the expiration time for the generated content. At #7, the portletConfig object is used to obtain the uploadFolder portlet initialization parameter. At #8, the portletSessionScope variable is used to obtain the value of the myaction attribute from PortletSession. At #9, the portletSession variable is used to obtain the value of the bookNameSearchField attribute from APPLICATION_SCOPE of PortletSession. At #10, the session JSP implicit variable is used to obtain the value of the authorNameSearchField attribute from HttpSession. We see here that using the session JSP implicit variable makes it easy to retrieve the APPLICATION_SCOPE attribute stored in PortletSession.

Listing 1 shows that we’ll usually use JSP implicit variables and variables introduced by the defineObjects tag to create JSP pages. If you browse through the pages of the Book Catalog portlet, the debugging information will change to reflect the current value of various attributes displayed by the debug.jsp page.

Summary

In this article, we saw how the portlet tag library tags can be used to simplify development of JSP pages used by portlets. Specifically, we learned how to use JSP implicit variables and variables introduced by the defineObjects tag to create JSP pages.

JSTL Function in JSP 2.0

JavaBeat — Tue, 03 Mar 2009 04:40:16 +0000

Connect to us ( @twitter | @facebook )

In JSP 2.0 we can perform string operations in JSP without using any java code inside scriptlets. This is possible with the latest release of JSTL 1.1. The new library called Functions with prefix as fn allows us to perform string operations in JSP 2.0.

The following example explains all the string operation which we can perform with the new fn tags.
Note:

You will need the following files to run this example :
jstl.jar and standard.jar inside /WEB-INF/lib
fn.tld, c.tld inside any location under any lcation under WEB-INF

JSP 2.0 Function : Example

1) File Name : firstPage.jsp

2) File Name : functionsUsage.jsp

<%@ page contentType="text/html" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

	
	
		
			Source String : california
			

			UpperCase	  : ${fn:toUpperCase('california')}
		
		
			Source String : CALIFORNIA
			

			Lowercase	  : ${fn:toLowerCase('CALIFORNIA')}
		
		
			Source String : California
			

			Substring	  : ${fn:substring('California',4,7)}
		
		
			Source String : California
			

			Substring After	"Cali" : ${fn:substringAfter('California','Cali')}
		
		
			Source String : California
			

			Substring Before "fornia" : ${fn:substringBefore('California','fornia')}
		
		
			Source String : California
			

			Trim the string " California " : ${fn:trim(' California ')}
		
		
			Source String : California
			

			Replace : ${fn:replace('California','a','A')}
		
		
			Source String : Cali;fornia
			

			Split Separator : ";"
			

			After Split an array is created with two items:
			

			Item at index 0 : ${fn:split('Cali;fornia ',';')[0]}
			

			Item at index 1 : ${fn:split('Cali;fornia ',';')[1]}
		
		
			Source String : Cali;fornia
			

			Split Separator : ";"
			

			Join Separator : "|"
			

			Join :
			
			
		
		
			${fn:escapeXml('California')}
		
		
			Source String : California
			

			Index Of "for" : ${fn:indexOf('California','for')}
			

		
		
			Source String : California
			

			Starts With "Cal" : ${fn:startsWith('California','Cal')}
		
		
			Source String : California
			

			Ends With "nia" : ${fn:endsWith('California','nia')}
		
		
			Source String : California
			

			Contains "FOR" : ${fn:contains('California','FOR')}
		
		
			Source String : California
			

			Contains IgnoreCase "FOR" : ${fn:containsIgnoreCase('California','FOR')}
		
		
			Source String : California
			

			Length of the string : ${fn:length('California')}
		
		
			Please make a selection to perform an operation
		
	
 
	


	<< Back

3) Output

Source String : Cali;fornia
Split Separator : “;”
Join Separator : “|”
Join : Cali|fornia

<< Back

JSP 2.0 Function : Explanation

In this example we can see the usage of the string functions defined as part of the new JSTL 1.1 tag library.
The functions are part of the new Function library and they needs to be prefixed with fn as we can see in the examples. This reduces lot of development effort and our jsps look a lot cleaner as we dont have to mix java code inside jsp.

The Functions library includes the following string functions : toUpperCase, toLowerCase, substring, substringAfter, substringBefore, trim, replace, split, join, indexOf, startsWith, endsWith, contains, containsIgnoreCase and length

Dynamic Attributes in Tag File in JSP 2.0

JavaBeat — Thu, 26 Feb 2009 04:39:21 +0000

Connect to us ( @twitter | @facebook )

As we know that we can develop custom tag library as a simple tag file in JSP 2.0 and these tag files can accept attributes from the invoking JSP page. But one drawback of this approach is that we need to declare all the attributes in the tag file. JSP 2.0 provides a feature called dynamic attributes by using which we need not
declare the attributes in the tag file using the attribute directive.

1) File Name : firstPage.jsp

<%@ page contentType="text/html" %>
<%@ taglib prefix="my" tagdir="/WEB-INF/tags/mytags" %>


Headers

2) File Name : person.tag

<%@ tag body-content="empty" dynamic-attributes="dynattrs" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 

	
	
		${a.key}
		${a.value}

3) Output

EmployeeId	74852
Name	Bruce Wayne
Age	28

Explantion:

In the file firstPage.jsp I invoke a custom tag named person with three attributes : employee id, age and name.

The file person.tag holds the code to handle the person tag invocation. In this file I use the tag directive to declare a page scope attribute named dynattrs. This attribute is a Map of all the attributes and attribute values passed from the JSP page tag invocation. Next, I iterate through each item of dynattrs using c:forEach jstl tag. The property: key returns the map key and the property : value returns the key’s value. I use Expression language syntax ${} to display each key and value stored in the map.

JSP 2.0 Custom Tags Reference

Variable Directive in JSP 2.0 Custom Tags

JavaBeat — Wed, 25 Feb 2009 04:49:36 +0000

Connect to us ( @twitter | @facebook )

This tips explains how to use the variable directive in the custom tags in JSP 2.0. There is time when JSP page needs to
access the variable declared inside the Tag files. In the previous version we have to extend the tag library to declare the variables
and need the special handling for those variables. In JSP 2.0, it is done very easily using the variable directive. Syntax for the
variable directive is as follows:

1	<%@ variable (attribute="value")* %>

1	<@ variable attribute1="value1" attribute2="value2" ... %>

The following are the list of attributes in variable directive:

name-given
name-from-attribute
alias
variable-class
declare
scope
description

Look into the following example:

index.jsp

	<%@ taglib prefix="print" tagdir="/WEB-INF/tags/" %>
	
		
			
				${testValue}

varTag.jsp

	<%@ variable name-given="testValue" %>
	<%
		jspContext.setAttribute("testValue", "testValue");
	%>

In the above example it declares one simple variable named testValue and it is access from the JSP page. This example is only very simple and the purpose is to explain how the variable directive is working. Like this you can declare asmany variables in the Tag Files and can be used in the JSP file. at the end of tag file is important to execute the tag body.

Custom Tags in JSP 2.0

JavaBeat — Wed, 25 Feb 2009 04:49:01 +0000

Connect to us ( @twitter | @facebook )

Tag Files in JSP 2.0

This tips explains about what are the advantages in the Custom Tags in JSP 2.0. It also compares it with the previous JSP versions.
Lets look into the tips for more detail.

Developing custom tags in the previous JSP versions are tedious and it is considered as one of the complex task for the JSP developers. Because inorderto write a simple custom tag you have to learn many things and should have good knowledge on Java also. Apart from that you have to use Tag APIs to create a complete tag library. Any small mistake will cause the error and tag files will not work. To make the things easy for the JSP developers, JSP 2.0 has the advanced features for creating JSP custom tag libraries.

The following are the mandatory for writing the custom tags in previous versions:

Writing and compiling a tag handler.
Defining the tag that is associated with the tag handler.
Creating the TLD(Taglib Descriptor) files.

What is Tag Files?

JSP 2.0 has introduced the concept called tag files, which are nothing but the simple files works like a JSP file. They define all the
functionalities required for a custome tag. You are no longer required to write the Java file and compile it. These tag files are compiled dynamically by the JSP container. Even though, it is simple file, JSP container will convert these files into a Tag Library. But developers need not worry about them.

Tag files just work like an JSP pages, it has the following implicit objects:

request -> javax.servlet.http.HttpServletRequest
response -> javax.servlet.http.HttpServletResponse
out -> javax.servlet.jsp.JspWriter
session -> javax.servlet.http.HttpSession
application -> javax.servlet.ServletContext
config -> javax.servlet.ServletConfig
jspContext -> javax.servlet.jsp.JspContext

All the abobe objects are available in the normal JSP files also.

All the tag files must be put under the folder WEB-INF/tags or you can create the sub directory under it. The directory name must be specified while importing the tags in JSP file as follows:

1 2	<%@ taglib prefix="tagFiles" tagdir="/WEB-INF/tags" %>

Tag Files Example

This tips explains only the very basic points about the new features in custom tags and Tag Files. You can find simple example on writing the custome tags in JSP 2.0.

Custom Tag Libraries and Tag Files in JSP 2.0

JavaBeat — Wed, 25 Feb 2009 04:38:35 +0000

Connect to us ( @twitter | @facebook )

With previous versions of JSP developing custom tag libraries was possible only by writing Java classes. As a result knowledge of Java was a must. JSP 2.0 introduces a new way of developing custom tag library
using plain JSP. This enables JSP developers, who dont know Java, to develop custom tag libraries as Tag files. JSP 2.0 also provided added features of passing parameters to tag files. I will demonstrate this in the following examples.

1) File Name : firstPage.jsp

<%@ page contentType="text/html" %>
<%@ taglib prefix="my" tagdir="/WEB-INF/tags/myCustomTags" %>

	
		Random Number :

2) File Name : generateRandomNum.tag

<%@ tag body-content="empty" %>
<%
	out.println(java.lang.Math.random());
%>

3) Output

1	Random Number : 0.029871659130147776

Explantion:

In my first example I use a tag file to generate random numbers. I will first explain the code in generateRandomNum.tag file. This is just a simple file with a .tag extension and a tag directive. In this file I write the logic to generate random numbers using the java.lang.Math class. Once this file is ready place the file under any location below WEB-INF directory. I have placed it inside /WEB-INF/tags/myCustomTags directory.

Now in the firstPage.jsp I use a taglib directive. In the taglib directive I set the value for two attributes : prefix and tagdir. The prefix sets a prefix to invoke the custom tag and the tagdir attribute
tell the container that the tag file is placed at the location specified. Next I invoke the tag file simply by using
the prefix and the name of the tag file, without the .tag extension

4) File Name : secondPage.jsp

<%@ page contentType="text/html" %>
<%@ taglib prefix="my" tagdir="/WEB-INF/tags/myCustomTags" %>

	
		Sum of two numbers :

5) File Name : addNumbers.tag

<%@ tag body-content="empty" %>
<%@ attribute name="firstNum" required="true"%>
<%@ attribute name="secondNum" required="true"%>
 
${firstNum + secondNum}

6) Output

1	Sum of two numbers : 30

Explantion:

In this second example I explain the usage of passing attributes to tag files. In the file addNumbers.tag I have used a directive called attribute. This is basically used to tell the web container that this tag file expects an attribute and whether the attribute is mandatory or optional.
We should use the attribute directive for each attribute passed from the invoking jsp file. I declare two attributes and use them to perform an add operation using Expressions Langauge (EL).

In the file secondPage.jsp I invoke the tag and pass attributes with some values. The values will be received
by the attributes declared in the tag file and will be used to perform the addition.

Error Pages in JSP 2.0

JavaBeat — Tue, 24 Feb 2009 04:38:04 +0000

Connect to us ( @twitter | @facebook )

We can configure error pages in jsp and servlets to direct the control to a custom error page, showing
a friendly error message to the user when an exception is thrown in the page. But tracking or logging the exception information is not very easy in JSP 1.2.

JSP 2.0 fixes this problem by switching to the servlet specification: javax.servlet.error.exception. In addition, a new property of the implicit EL pageContext variable, named errorData, exposes other information about the problem. The errorData property is an instance of the javax.servlet.jsp.ErrorData class that can be used as a bean with the following properties:

Property	Java Type	Description
requestURI	String	The URI for the request that failed.
servletName	String	The name of the servlet or JSP page that failed.
statusCode	int	The failure status code.
throwable	Throwable	The exception that caused the error page to be invoked.

1) File Name : firstPage.jsp

<%@page errorPage="/jsp/errorpage.jsp" contentType="text/html" %>


	Error Pages in JSP 2.0

	
	<%
		String s = null;
		out.println(s.trim());
	%>

2) File Name : errorpage.jsp

<%@page isErrorPage="true" contentType="text/html" %>

	
		Request that failed: ${pageContext.errorData.requestURI}
		

		Status code: ${pageContext.errorData.statusCode}
		

		Exception: ${pageContext.errorData.throwable}
		

		${pageContext.errorData.servletName}

3) Output

Request that failed: /TestWebApp/jsp/firstPage.jsp
Status code: 500
Exception: java.lang.NullPointerException
jsp

Explantion:

In the first page I declare a null string and I call a function on it. The JSP engine will encounter faulty code and will throw a NullPointerException. As I have configured an error page in the page directive the control is taken to the errorpage.jsp.

In the error page I use properties of errorData to display useful information about the exception. This information is useful for the developer to track down the problem quickly and efficiently as he will know
exactly which page threw the exception and what was the type of exception.

Ternary Operator in JSP 2.0 Expression Language(EL)

JavaBeat — Mon, 23 Feb 2009 04:36:39 +0000

Connect to us ( @twitter | @facebook )

A very common need in a JSP page is to include a piece of template text only if a certain condition is true.
With JSP 1.2 and JSTL 1.1, this is typically done using a block, but that’s a very verbose solution.

JSP 2.0 adds a new conditional operator to the Expression Language(EL) to deal with this case in a more elegant way.The
conditional operator exists in many programming languages (for instance, in Java, C, and JavaScript), so you
may have seen it before. It takes a Boolean condition and one result to use if the condition is true and another
if it’s false. I use a very simple example to demonstrate the usage :

1) File Name : firstPage.jsp


	
	
	
	
		
			Please enter a number between 1 and 5 and press the Ok button :

2) File Name : secondPage.jsp

Explantion:

In the first page I enter a number between 1 and 5 and click the submit button. The request is submitted to the second page. In the second page I have used a drop down list to display some names. Out of these names one of them gets selected depending on what value is entered in the first page.

I use the param expressions language implicit object,which contains a map of request parameters, to
fetch the value of numberTxt parameter. The value is compared with fixed constants for each option tag. If an expression returns true, the string selected is replaced in its place. In case the expression
retuns false blank string is replaced.