JSP Standard Actions

1. <jsp:useBean> tag
2. <jsp:setProperty> tag
3. <jsp:getProperty> tag
4. <jsp:include> tag
5. <jsp:forward> tag
6. <jsp:param> tag
7. <jsp:plug-in> tag
8. <jsp:params> tag
9. <jsp:fallback> tag
10. Summary of Standard actions
11. JSP Documentation

Introduction :

public class JspDemoServlet extends HttpServlet {

public void doGet(HttpServletRequest request, 
                      HttpServletResponse response)
			throws ServletException, IOException {
			
String uname=request.getParameter("userName");
request.setAttribute("UserName", uname);
RequestDispatcher rd=request.getRequestDispatcher("view.jsp");
rd.forward(request, response);
}
}

Welcome to : <%= (String)request.getAttribute("UserName") %>

OR

public class JspDemoServlet extends HttpServlet {
	
public void doGet(HttpServletRequest request, 
		HttpServletResponse response)
          throws ServletException, IOException {

String uname=request.getParameter("userName");
foo.Person p=new foo.Person();
p.setName(uname);
request.setAttribute("person",p);
RequestDispatcher rd=request.getRequestDispatcher("view1.jsp");
rd.forward(request, response);
}
}

Welcome to : 
<%@page import="foo.Person"%>
Welcome to : 
<% 
Person p=(Person)request.getAttribute("person");
out.println(p.getName());
%>

package foo;

public class Person {
 String name;
 public void setName(String name) {
  this.name=name;		
 }
 public String getName() {
  return name;
 }
}

<jsp:useBean id="person" class="foo.Person" scope="request" />
Welcome to : <jsp:getProperty property="name" name="person" />

<%!
public int squareIt(int n){
 return n*n;
}
%>
<h1>The square of 4 is : <%= squareIt(4) %></h1>
<h1>The square of 2 is : <%= squareIt(2) %></h1> 

• There is no clear separation of presentation logic and business logic. The person who is writing the jsp should have compulsory knowledge on both java & html which may not be possible always, this approach doesn't promote re-usability .
• It reduces readability.
• We can resolve these problem by separating entire business logic inside java bean.

package foo;
public class Calculator {
 public int squareIt(){
  return n*n;
 }
}

<jsp:useBean id="calc" class="foo.Calculator" scope="session" />
The square of 4 is : <%= calc.squareIt(4) %>

• Separation of presentation and business logic (presentation logic available in Jsp and business logic available in java bean) , so that readability is improved.
• Java developer can concentration on business logic where as Html developer can concentration on presentation logic as both can work simultaneously so that we can reduce development time and increases productivity.
• It promotes re-usability of the code i.e., where ever this squareIt() functionality is used we can reuse the same bean with rewriting.
• We can purchase bean for file uploading and we can start uploading of the file with in minutes.

Note : It is never recommended to write scriptlets, expressions, declarations and business logic with in the Jsp.

java bean : java bean is a simple java class

• Jsp engine is responsible to perform instantiation of Java bean for this always executes public no argument constructor otherwise <jsp:useBean> tag won't be work. (because it internally calls that setter method only)
• For every property bean class should contains public getter methods otherwise <jsp:getProperty> tag won't be work.(because it internally calls corresponding getter method only)
• It is highly recommended to keep bean class as part of some package.

Jsp Standard Actions :

<jsp:useBean> :

without body :

<jsp:useBean id="c" class="CustomerBean" />

with body :

<jsp:useBean id="c" class="CustomerBean" >
    ---------------------
<jsp:useBean>

Attribute list of <jsp:useBean> :

1. id
2. class
3. type
4. scope
5. beanName

id :

• This id attribute represents name of the reference variable of the bean object.
• By means of this id attribute only we can access bean in rest of the Jsp's
• This attribute is a mandatory attribute.

<jsp:useBean id="c" class="CustomerBean" />

  // the appropriate equivalent java code
  
CustomerBean c = new CustomerBean();

class :

• This attribute represents fully qualified name of the Java bean class, for this class only jsp engine perform instantiation hence the value of class attribute should be concrete class.
• abstract class and interfaces are not allowed.
• The bean class compulsory should contain public no-arg constructor otherwise we will get instantiation problem.
• This attribute is optional but when ever we are not specify class attribute compulsory we should specify type attribute.

type :

• We can use type attribute to specify the type of reference variable.
• The value of type attribute can be concrete class or abstract class or interface.
• This attribute is optional but when ever we are not specify type attribute compulsory we should specify class attribute.

<jsp:useBean id="p" type="foo.Person" class="foo.Student" />

  // equivalent java code
  
foo.Person p = new foo.Student();

scope :

• This attribute specifies in which scope jsp engine has to search for the required bean object, in that scope if the bean object is not already available then Jsp engine creates a bean object and store into specified scope for the future purpose.
• The allowed values for the scope attributes are page, request, session, application.
• This attribute is optional and default scope is "page".

<jsp:useBean id="c" class="CustomerBean" scope="session" />

//equivalent java code

CustomerBean c=null;
syncronized(session){
c=(CustomerBean)pageContext.getAttribute("c",
                     pageContext.SESSION_SCOPE);
 if(c==null){
 c=new CustomBean();
 pageContext.setAttribute("c",c,pageConext.SESSION_SCOPE);
   ----------------
 }
}

<jsp:useBean id="c" type="CustomerBean" scope="session" />

<%@page session="false" %>
<jsp:useBean id="c" class="CustomerBean" scope="session" />

exception: Illegal for useBean to use session scope when jsp page declare that it doesn't participate into the session.

package foo;

public class CalculatorBean {
 static int i=0;
 public CalculatorBean(){
 System.out.println("calculator bean object created"+
                                       (++i)+"times");
 }
 public int squareIt(int n){
	return n*n;
 }
}

<jsp:useBean id="calc" class="foo.CalculatorBean" scope="session" />
The square of 4 is : <%= calc.squareIt(4) %>
The square of 5 is : <%= calc.squareIt(5) %>
<a href="beanTest.jsp">Click Here</a>

<jsp:useBean id="calc" type="foo.CalculatorBean" scope="session" />
The square of 8 is : <%= calc.squareIt(8) %>
The square of 9 is : <%= calc.squareIt(9) %>

<jsp:useBean id="calc" type="foo.CalculatorBean" scope="session" >
The square of 8 is : <%= calc.squareIt(8) %>
The square of 9 is : <%= calc.squareIt(9) %>
</jsp:useBean>

<jsp:useBean id="c" type="foo.CalculatorBean" scope="session" >
The square of 8 is : <%= calc.squareIt(8) %>
The square of 9 is : <%= calc.squareIt(9) %>
</jsp:useBean>

package foo;

public abstract class Person {
 public abstract String getMessage(); 
}

package foo;

public  class Student extends Person{
 public  String getMessage(){
	 return "Ashok";
 }
 public String getName(){
	 return "Aggidi";
 }
}

<jsp:useBean id="p" type="foo.Person" class="foo.Student"
                                   scope="session" />
The person name is : <%= p.getMessage() %>
<a href="beanTest.jsp">Click Here</a>

<jsp:useBean id="person" class="foo.Student" scope="session" />
The student name is : <%= person.getName() %>

beanName :

Conclusions for <jsp:useBean> :

1. 'id' attribute is mandatory
2. 'scope' attribute is optional and default scope is page.
3. The attributes class, type, beanName can be used in the following combinations
   1. class
   2. type
   3. class and type
   4. type and beanName
4. beanName is always associated with type attribute but not class attribute.
5. If we are using class attribute whether we are using type attribute or not compulsory it should be concrete class and it should contains public no-arg constructor.
6. If we are using only type attribute without class attribute then the specified bean object compulsory should be available specified scope otherwise this tag won't create new bean object and raises instantiation exception.

package pack1;
public class CustomerBean {
  -----------------
}

Assume that no CustomerBean object is already created then which of the following standard actions create a new bean object and store in request scope ?

1. <jsp:useBean id="c" class="pack1.CustomerBean" /> //invalid
2. <jsp:useBean id="c" type="pack1.CustomerBean" scope="request" /> //invalid
3. <jsp:useBean name="c" class="pack1.CustomerBean" scope="request" /> //invalid
4. <jsp:useBean id="c" class="pack1.CustomerBean" scope="request" /> //valid

<jsp:getProperty> :

<%
CustomerBean c= new CustomerBean();
out.println(c.getName());
%>

//equalant jsp

<jsp:useBean id="c" class="CustomerBean" />
<jsp:getProperty name="c" property="name" />

1. name
2. property

name :

property :

Note : both attributes are mandatory attributes.

package foo;

public class CustomerBean{
 private String name="ashok";
 private String mail="ashok@jobs4times.com";

public String getName() {
	return name;
}

public String getMail() {
	return mail;
}
}

<%@page import="foo.CustomerBean" %>
<%
CustomerBean c=new CustomerBean();
out.println("The customer name is :"+c.getName());
out.println("The customer mail is :"+c.getMail());
 %>
 
 (OR)
 
<jsp:useBean id="c" class="foo.CustomerBean"/>
The Customer name is : <jsp:getProperty property="name" name="c"/>
The Customer mail is : <jsp:getProperty property="mail" name="c"/>

<jsp:setProperty> :

We can use this tag to set the properties of bean object , <jsp:setProperty> tag contains the following forms

<jsp:setProperty property="age" name="c" value="30" />
       (OR)
  c.setAge("30");

<jsp:setProperty property="age" name="c" param="age" />
       (OR)
  c.setAge(request.getParameter("age"));

<jsp:setProperty property="age" name="c"  />
       (OR)
  c.setAge(request.getParameter("age"));

<jsp:setProperty property="*" name="c"  />
 // "*" specifies all the properties of java bean

<jsp:setProperty> contains the following attributes

1. name
2. property
3. value
4. param

name :

property :

value :

param :

package foo;

public class CustomerBean{
 private String name=null;
 private String mail=null;
 private String age=null;
 
 public String getName() {
	return name;
 }
 public void setName(String name) {
	this.name = name;
 }
 public String getMail() {
	return mail;
 }
 public void setMail(String mail) {
	this.mail = mail;
 }
 public String getAge() {
	return age;
 }
 public void setAge(String age) {
	this.age = age;
 }
}

<form action="test.jsp" method="post">
<h2>Enter Your Details :</h2>
Enter Name : <input type="text" name="uname">
Enter Email : <input type="text" name="mail">
Enter Age : <input type="text" name="age">
 <input type="submit" value="submit">
</form>

<h1>Set Property Example : </h1>

<jsp:useBean id="c" class="foo.CustomerBean" />
<jsp:setProperty property="*" name="c"/>

Entered Name is : 
<jsp:getProperty property="name" name="c" />
Entered Mail is : 
<jsp:getProperty property="mail" name="c" />
Entered Age is : 
<jsp:getProperty property="age" name="c" />

Case 1 :

<h1>Set Property Example : </h1>

<jsp:useBean id="c" class="foo.CustomerBean" />

<jsp:setProperty property="mail" name="c" 
  value="<%= request.getParameter("mail") %>" /> //valid
<jsp:setProperty property="mail" name="c" 
  value="<%= request.getParameter("age") %>" /> //invalid

Entered Name is : 
<jsp:getProperty property="name" name="c" />
Entered Mail is : 
<jsp:getProperty property="mail" name="c" />
Entered Age is : 
<jsp:getProperty property="age" name="c" />

<jsp:useBean id="c" class="foo.CustomerBean" />

<jsp:setProperty property="*" name="c" /> //valid
<jsp:setProperty property="empId" name="c" param="empId" /> //valid
<jsp:setProperty property="empId" name="c"  /> //valid
<jsp:setProperty property="empId" name="c" value="1123" /> //valid

<jsp:useBean id="c" class="foo.CustomerBean" />
<jsp:setProperty property="empId" name="c" 
  value="<%= request.getParameter("empId") %>" /> //invalid

Developing reusable web-components :

1. <jsp:include>
2. <jsp:forward>
3. <jsp:param>

<jsp:include> :

This tag representation of pageContext.include("header.jsp");

1. page
2. flush

• page : page attribute represents name of the included page and it is mandatory.
• flush : It specifies whether the response will be flushed before inclusion or not , it is an optional attribute and default value is false.

<jsp:include page="header.jsp" />
<h2>Welcome to Jobs4Times.com</h2>
<jsp:include page="footer.jsp" />

<h2> We are Master in Java Certification </h2>

 <h4>copyright © www.jobs4times.com </h4>

Following 4 possible ways to implement include mechanism in JSP's :

1. By using include directive :

   <%@include file="header.jsp" %>
   

2. By using include action :

   <jsp:include page="header.jsp" flush="true" />
     // by default flush is false
   

3. By using pageContext implicit object :

   <% pageContext.include("header.jsp");  %> 
   

4. By using RequestDispatcher :

   <%
   RequestDispatcher rd=request.getRequestDispatcher("header.jsp");
   rd.include(request,response);
   %>
   

<jsp:forward> :

Syntax :

<jsp:forward page="second.jsp" />

It contains only one attribute, i.e., page , and it is a mandatory attribute.

<h2>This is first Jsp page </h2>
<jsp:forward page="second.jsp" />
<h2>This is after forwarding </h2>

<h2>This is second Jsp page </h2>

Following 3 possible ways to implement forward mechanism in JSP's :

1. By using forward action :

   <jsp:forward page="second.jsp" />
   

2. By using pageContext implicit object :

   <% pageContext.forward("second.jsp");  %> 
   

3. By using RequestDispatcher :

   <%
   RequestDispatcher rd=request.getRequestDispatcher("header.jsp");
   rd.forward(request,response);
   %>
   

<jsp:param> :

1. name : It represents name of the parameter.
2. value : It represents value of the Parameter.

Note : The parameters which are sending by using <jsp:param> tag are available as form parameters in target Jsp.

<jsp:include page="second.jsp">
 <jsp:param value="ashok" name="username"/>
 <jsp:param value="25" name="age"/>
</jsp:include>

<%@page isELIgnored="false" %>
<h2>Hi i'm getting the values from Jsp param</h2>
The UserName is : <%=request.getParameter("username") %>
The Age is : <%=request.getParameter("age") %>

Conclusions :

case 1 :

<jsp:forward page="http://localhost:2020/jspApp/second.jsp"/>
                                                 //invalid
<jsp:include page="http://localhost:2020/jspApp/second.jsp"/>
                                                  //invalid
<%@include file="http://localhost:2020/jspApp/second.jsp"%>
                                                 //invalid

case 2 :

<jsp:forward page="/test" /> //valid
<jsp:include page="/test" /> //valid
<%@include file="/test" %>  //invalid

case 3 :

<jsp:forward page="/test?name=ashok" />    //valid
<jsp:forward page="second.jsp?name=ashok" /> //valid
<jsp:include page="second.jsp?name=ashok" /> //valid
<%@include file="second.jsp?name=ashok" %> //invalid

<jsp:plugin> :

• Using <jsp:plugin> action provides the support for including java applet in a jsp page,
  If we have java applets that are part of your web-applications.
• While it's possible to have appropriate html code embedded in your Jsp page, the use of <jsp:plugin> allows the functionality to the browser is neutral.

<jsp:params> :

<jsp:fallback> :

A translation time error will occurs if we use <jsp:params> , <jsp:fallback> any other context other than child of <jsp:plugin>.

 <jsp:plugin code="classFileName .class extention" 
   codebase="The directory of class file name" type="applet/bean" >
   {align="alignment"}
   {height=""}
   {width=""}
   
{ <jsp:params>
  { <jsp:param value="pvalue" name="pname"/> }
</jsp:params> }

<jsp:fallback>  Arbitrary test </jsp:fallback>
</jsp:plugin>

  {} ---->optional attributes 

type :

code : (class="ClassFileName")

codeBase : (codeBase="ClassFileDirectoryName")

<jsp:forward page="plugIn.jsp"></jsp:forward>

<h2>Welcome to Jsp Application</h2>

First Applet :
<jsp:plugin code="ClockApplet.class" codebase="applets"
               type="applet"  width="260"  height="150">
 <jsp:fallback>Plug in tag not supported ..... </jsp:fallback>
</jsp:plugin>

Second Applet :
<jsp:plugin code="edu.com.MessageApplet.class" 
    codebase="applets" type="applet" width="500"  height="100">
 <jsp:params>
   <jsp:param value="Welcome to SCWCD" name="msg"/>
 </jsp:params>
 <jsp:fallback>No support to this Applet ..... </jsp:fallback>
</jsp:plugin>

public class ClockApplet extends Applet implements Runnable{
	
String time;
	
public void init(){
 Thread t=new Thread(this);
 t.start();
}

public void Paint(Graphics g){
g.setColor(Color.lightGray);
g.fill3DRect(40, 40, 150, 100, true);
g.setFont(new Font("monotypeCorsiva",Font.ITALIC,35));
g.setColor(Color.red);

g.drawString(time, 60, 100);

}

public void run() {

while(true){
 time=String.valueOf(
     new SimpleDateFormat("hh:mm:ss").format(new Date()));
 repaint();

try{
	Thread.sleep(1000);
}catch (InterruptedException e) {
	e.printStackTrace();
}

}//run
}
}//class	

package edu.com;

public class MessageApplet extends Applet implements Runnable{
	
String message;
	
public void init(){
 message=getParameter("msg");//available in applet class
 if(message==null){
	 message="This is default message";
 }
}

public void Paint(Graphics g){
g.setColor(Color.BLUE);
g.setFont(new Font("monotype Corsiva",Font.ITALIC,40));
g.drawString(message, 20, 50);
}

public void run() {
}

}

<h2>This is first Jsp Page</h2>
<%! String nextPage="second.jsp"; %>
<jsp:forward page="<%= nextPage %>" /> //valid
               // static or dynamic
<h2>This is after forwarding</h2>

<h2>This is second Jsp Page</h2>

Summary of Standard actions :

JSP Documentation :

1. Jsp Standard syntax
2. Xml based syntax

• Jsp Standard Syntax : If we are writing a Jsp by using Jsp standard syntax such type of Jsp's are called Jsp pages.
• Xml based syntax : If we are writing Jsp by using Xml based syntax such type of Jsp's are called Jsp document.

directives :

<jsp:root xmlns:mime="www.jobs4times.com" version="4.3" />
  //version is mandatory attribute
  //xmlns:mime is an optional attribute 
   //and we can take any no.of xml name spaces 

Standard actions :

Comments :

Template text :

How the web-container identifies Jsp document ?

1. Save the jsp file with .jspx extension.
2. Enclose entire Jsp with in <jsp:text> tag.
3. Use <jsp-config> element in web.xml as follows

   <web-app>
   <jsp-config>
     <jsp-property-group>
       <url-pattern>/jspx/*</url-pattern>
       <is-xml>true</is-xml>
     </jsp-property-group>
   </jsp-config>
   </web-app>
   

Write a Jsp document to print hit count of the Jsp ?

<jsp:directive.page isELIgnored="false" />
<!--
including header.jsp to current  jsp
-->
<jsp:directive.include file="header.jsp" />
<jsp:declaration> int count=0; </jsp:declaration>
<jsp:scriptlet>  count++; </jsp:scriptlet>
<jsp:text>The hit count of this page is : </jsp:text>
<jsp:expression> count </jsp:expression>

• It is never recommended to use both standard and Xml based syntax simultaneously.
• The main advantage of Xml based syntax is we can use Xml editors like Xml-spy for writing and debugging jsp's
• All xml based tags and attributes are case-sensitive and attributes enclosed either single single quote('') or double quote("").

Which of the following valid way of importing java.util.ArrayList in our Jsp ?

<jsp:page import="java.util.ArrayList" /> //invalid

<jsp:page.directive import="java.util.ArrayList" /> //invalid

<jsp:directive  page import="java.util.ArrayList" /> //invalid

<jsp:directive.page import="java.util.ArrayList" /> //valid

package foo;

public class Person {
 private String name;
 private Dog dog;

public String getName() {
 return name;
}
public void setName(String name) {
 this.name = name;
}
public Dog getDog() {
 return dog;
}
public void setDog(Dog dog) {
 this.dog = dog;
}
}

package foo;

public class Dog {
 private String name;

public String getName() {
 return name;
}
public void setName(String name) {
 this.name = name;
} 
}

public class JspDemoServlet extends HttpServlet {
	
public void doGet(HttpServletRequest request, 
		HttpServletResponse response)
          throws ServletException, IOException {
foo.Person p=new Person();
p.setName("ashok");

foo.Dog d=new Dog();
d.setName("spike");

p.setDog(d);

request.setAttribute("person", p);
RequestDispatcher rd=request.getRequestDispatcher("view.jsp");
rd.forward(request, response);
}
}

The Person's Dog name is : 
<%=((foo.Person)request.getAttribute("person")).getDog().getName()%>

<jsp:useBean id="person" class="foo.Person" scope="request" />
The Person's Dog name is : 
<jsp:getProperty property="dog" name="person" />

output:
The Person's Dog name is : foo.Dog@1234...
//If request scope is not specified the output is null

The <Jsp:getProperty> tag lets you access only property of bean attributes, there is no capability for nested properties, where you want a property of property rather than property of attribute.

Limitations of Standard Actions :