Introduction to Java Bean

Remember: JSP Standard Actions Standard actions are well known tags that affect the run time behavior of the JSP and the response sent back to the client. Some commonly used tag actions types are: <jsp:useBean> <jsp:setProperty> <jsp:getProperty> <jsp:param> <jsp:include> <jsp:forward> <jsp:plugin>

Java Bean A Java Bean is a java class that should follow following conventions: It should have a no-arg constructor It should be Serializable It should provide methods to set and get the values of the properties, known as getter and setter methods Why use Java Bean? it is a reusable software component A bean encapsulates many objects into one object, so we can access this object from multiple places. Moreover, it provides the easy maintenance.

Simple example of java bean class //Employee.java   package mypack;   public class Employee implements java.io.Serializable{   private int id;   private String name;      public Employee(){}   public void setId(int id){this.id=id;}   public int getId(){return id;}   public void setName(String name){this.name=name;}   public String getName(){return name;}   }  //To access the java bean class, we should use getter and setter methods. package mypack;   public class Test{   public static void main(String args[]){      Employee e=new Employee();//object is created   e.setName("Arjun");//setting value to the object   System.out.println(e.getName());   }}  

jsp:useBean action tag The jsp:useBean action tag is used to locate or instantiate a bean class. If bean object of the Bean class is already created, it doesn't create the bean depending on the scope. But if object of bean is not created, it instantiates the bean. Syntax <jsp:useBean id= "instanceName" scope= "page | request | session | application"    class= "packageName.className" type= "packageName.className"   beanName="packageName.className | <%= expression >" >   </jsp:useBean> 

Attributes and Usage id: is used to identify the bean in the specified scope. scope: represents the scope of the bean. It may be page, request, session or application. The default scope is page. page: specifies that you can use this bean within the JSP page. The default scope is page. request: specifies that you can use this bean from any JSP page that processes the same request. It has wider scope than page. session: specifies that you can use this bean from any JSP page in the same session whether processes the same request or not. It has wider scope than request. application: specifies that you can use this bean from any JSP page in the same application. It has wider scope than session. class: instantiates the specified bean class (i.e. creates an object of the bean class) but it must have no-arg or no constructor and must not be abstract. type: provides the bean a data type if the bean already exists in the scope. It is mainly used with class or beanName attribute. If you use it without class or beanName, no bean is instantiated. beanName: instantiates the bean using the java.beans.Beans.instantiate() method.

Simple example of jsp:useBean action tag Calculator.java package com.javatpoint; public class Calculator{ public int cube(int n){return n*n*n;} } index.jsp <jsp:useBean id="obj" class="com.javatpoint.Calculator"/>      <%   int m=obj.cube(5);   out.print("cube of 5 is "+m);   %>  

Javabeans A Javabeans is a special type of the class that has a number of methods. The JSP page can call these methods so can leave most of the code in these Javabeans. For example, if you wanted to make a feedback form that automatically sent out an email. By having a JSP page with a form, when the visitors presses the submit button this sends the details to a JavaBeans that sends out the emails. This way there would be no code in the JSP page dealing with sending emails. To use a Javabean in a JSP page use the following syntax: <jsp:usebean id=“ id” scope=“application” class=“…….” />

Javabeans Scopes page request session application valid until page completes request bean instance lasts for the client request. session bean lasts for the client session application bean instance created and lasts until application ends.

A Greeting Bean package beans; public class Greeting { ???.java package beans; public class Greeting { private String greeting; // the property public Greeting() { greeting = "Hello World"; } public String getGreeting() { return greeting; } public void setGreeting(String g) greeting = (g == null) ? "Hello World" : g; }

Java Beans Naming convention If the property name is greeting The get method must have the name: getGreeting The set method must have the name: setGreeting

Creating a Bean/1 Create a bean and use default property <jsp:useBean id="hello" class="beans.Greeting" /> Create a bean and set its property when it is constructed <jsp:setProperty name="hello" property="greeting“ value="Hello JSP World" /> </jsp:useBean> Here <jsp:setProperty> is in the body of the <jsp:useBean> element.

Creating a Bean/2 Create a bean and set its property after it has been constructed <jsp:useBean id="hello" class="beans.Greeting" /> <jsp:setProperty name="hello" property="greeting“ value="Hello JSP World" /> The <jsp:setProperty> tag is now outside the <jsp:useBean> tag, so it will always set the property, not just when the bean is constructed

Example 1: Using Java Beans in JSP Files <jsp:useBean id="hello" class="beans.Greeting" /> <jsp:setProperty name="hello" property="greeting" value="Hello JSP World" /> <html> <head> <title>Greeting JSP that uses a Greeting bean</title> </head> <body> <h1>Greeting JSP that uses a Greeting bean</h1> <p><jsp.getProperty name="hello" property="greeting" /> </p> </body> </html>

Example 2: Using Java Beans in JSP Files Two Beans: One initialized explicitly and the other is initialized using a request parameter ???.java <jsp:useBean id="greet1" class="beans.Greeting" /> <jsp:useBean id="greet2" class="beans.Greeting" /> <jsp:setProperty name="greet1" property="greeting" value="Hello JSP World" /> <jsp:setProperty name="greet2" property="greeting" param="greeting" /> <html><head><title>Greeting JSP using two Greeting beans</title></head><body> <h1>Greeting JSP using two Greeting beans</h1> <p>1st bean: <jsp:getProperty name="greet1" property="greeting" /></p> <p>2nd bean: <jsp:getProperty name="greet2" property="greeting" /></p></body></html>

Example 3: Using Java Beans in JSP Files Three Beans: One initialized explicitly, one is initialized using a request parameter, and one is initialized using getParameter ???.java <jsp:useBean id="greet1" class="beans.Greeting" /> <jsp:useBean id="greet2" class="beans.Greeting" /> <jsp:useBean id="greet3" class="beans.Greeting" /> <jsp:setProperty name="greet1" property="greeting" value="Hello JSP World" /> <jsp:setProperty name="greet2" property="greeting" param="greeting" /> <%-- Following works but param method is better --%> <jsp:setProperty name="greet3" property="greeting" value="<%= request.getParameter(\"greeting\") %>" />