Java Beans Overview

Java Bean Benefits

JavaBeans bring the benefits of modularization and separation
of presentation from implementation. While scriptlets are fine,
and one can even enjoy their directness, a popular goal of
modern developers is to separate the presentation code from
code that supplies processing. This allows each to easily be
modified independently. This facilitates division of labor.

The JSP component model is based on the JavaBean.
Components attempt to 'black box' functionality where it's
inputs and outputs are all a user has to know to use the
component.

JavaBean Background

The JavaBean API provides a strict specification that a Java
class has to adhere to in order for it to be called a bean. This
specification dictates how properties, behaviour and events
need to be configured. The predictability of the patterns used
allows bean containers to access, query and modify the state
of a bean.

The API uses a process called 'reflection' to determine what
a beans properties are. The API also uses the process of
serialization to store a bean in a stateful condition.

Builder tools, more recently called containers are able to load,
configure and query a bean based on the expected syntax
dictated by the JavaBean API. These tools usually supply visual
GUIs that allow beans to be dragged and dropped onto a screen
where they can be composed into whole applications without the
need to code Java.

Generally speaking there is a difference between the type
of JavaBeans that is used with JSPs and with GUIs. Beans
may be described as having evolved in three or four
categories.

Visual Component JavaBeans

All AWT and Swing visual components are JavaBeans and take
advantage of the full specification. Tools like the bean box expect
these components to be fully compliant with the API with respect
to their properties, method patterns  and event coding.  Java's
JFrame is an example of this variety of JavaBean.

Data & Service Beans

These sorts of bean, are used to carry data or to provide some
function, are the sort of bean that are described as auxillary
components to be used in the J2EE specification. They can be
used in conjunction with JSPs, servlets or Enterprise JavaBeans.
While nothing stops them technically from using the different
aspects of the JavaBean specification, in practice they make
simple use of the JavaBean patterns.
.
Data beans will typically be comprised of read-only properties
or a mix of read-only and read-write properties that are accessible
through public methods.Service beans are behavioural in nature,
having evolved to supply a service such a database access or a
financial calculation.

Enterprise JavaBeans

Although they are described as JavaBeans because they do
use similar get set naming patterns they are really quite unique.
They run in the context  supplied by a container, have life cycle
methods and are built largely on RMI or The Java Remote
Method API. They have little obvious similarity to the JavaBeans
we popularly think of when thinking of Java Server Pages or
visual components for that matter.

JSPs Use Data or Service Beans

Bean Properties

Simple properties are those that can be described by a
get/set method pair as shown in the following forms. The
first shows the patterns used for read-write properties.
Notice how the actual property name is inserted after the
set or get prefix. Java naming conventions apply where the
name of the method starts lowercase and subsequent full
 words are started in caps. Set methods take the property
as an argument and return void while get methods take no
arguments and return the property type. Note, a read-write
property is created by supplying both get and set methods.
Read-only properties are created by simply providing the
getter method for the property.

Method Form Used for Simple Properties

public void  setPropertyName
                  ( Property_type,  property_value )

Property_type  getPropertyName( )

Accessor Mutators Examples For a String property Called 'description'

public void setDescription(String description ){
           this.description=description;
           }
 
public String  getDescription( ){
              return this.description;
              }                                   

For boolean properties a variation is allowed using
the prefix 'is' in the getter form of a method that returns
boolean. This allows the reading 'isSomething true'.
The following form shows this.

Method Form Used for Simple Properties Returning 'boolean'
 

boolean  isPropertyName( ){ /*body*/  }

Accessor Mutators Examples For a boolean property Called 'confirmed'

Indexed Properties

Indexed properties are plural versions of the simple form
methods where instead of a simple value an array is taken
or returned. The JavaBean specification allows creating
indexed property methods that set and return whole arrays
r set and return single values of the array using an index.

The index is specified as a second parameter to the set
method and as the single parameter to the get method.
Following are the forms of the indexed methods.

Method Form of an Indexed Property

public void setPropertyName
                (<PropertyType>[ ] value)
public PropertyType[]  getPropertyName( )

 
// Methods to access individual values

public void setPropertyName
                 (int index, PropertyType_value)
public <PropertyType> getPropertyName(int index)

 

Form of the jsp:useBean Tag

<jsp: useBean id=" beanInstanceName "
scope=" page | request | session | application"
{
class=" package. class " [ type=" package. class "] |
beanName="{ package. class | <%= expression %>}"
type=" package. class "|  type=" package. class "
}

{/>  | > other elements   </ jsp: useBean>   }

// Reference: JSP tags that use the jsp prefix are the
// same for both XML & HTML JSPs

To provide a concrete example, ConferenceBean above,
would be referenced into a JSP page with the following
useBean tag.

// once tested the main( ) method can be removed

Example 

<jsp:useBean id="conference" class=" ConferenceBean"  />

Quick Tour of <jsp:useBean> Attributes

The 'id' Attribute

The 'id' attribute is assigned a name that is a unique value
inside the JSP page. There are constraints on this identifier.
It must be unique, case-sensitive, the first letter must be a
character and subsequent letters must be letters, numbers
or underscores. // no $ symbols as in Java

The class Attribute

You specify the Java class name to this attribute. This
name has to be fully qualified and include it's classpath
through it's packages. By convention authors may use
their domain names as top level packaging units.

Example 

<jsp:useBean id="translator" class="form.TranslatorBean" />

The type Attribute

The type attribute allows specifying the type the class will be
instantiated to. This accomodates the Java idea that you can
instantiate a class object to the type of a parent or interface
that the class implements. This attribute is unlikely to be used
much in JSPs. Assume a generic Translator was parent of a
FrenchTranslator. It could be instantiated as follows.

The beanName Attribute

As an alternative to specifying a value to the class attribute,
the 'beanName' can be used. This is tag is not seen much.
It passes a name to the JSP engine which will in turn pass
the name to the instantiate( )  method of the java.beans.Beans
class. This attribute can be assigned at run-time so a resource
can be specified via a request parameter.

The <jsp:useBean> tag can also optionally include a body,
such as is shown in the following Magelang Institute example.

Magelang Institute Example

<jsp:useBean id="user" class="com.jguru.Person"  scope="session" >
<%
  user.setDate(new Date( ).toString( ));
  //etc..
%>
</jsp:useBean>

// the body in this form is only executed when the bean is instantiated. 

One Time Initialization

The body section of the useBean is roughly analogous to the
action of the class constructor. Any scriptlet or <jsp:setProperty>
tags present within the body of a <jsp:useBean> tag is executed
only once when the bean is instantiated, acting as an initializer
for bean's properties.

The <jsp:getProperty > & <jsp:setProperty > Actions

Once you have declared a JavaBean component, you have
access to its properties to customize it. The jsp:getProperty
and jsp:setProperty tags are the tag equivalent of using the
JavaBean get and set methods.

A bean property value is accessed using the <jsp:getProperty>
tag. With the <jsp:getProperty> tag, you specify bean's id to
the name attribute and the name of the property whose value
you are interested in to the property attribute. The actual value
is then directly printed to the output. In this way the action of the
jsp:getProperty action is similar to the actions of a expression
tag.

Example

<jsp:getProperty name="conference" property="name" />

// the value of jsp:getProperty is written directly to output similar to how
// expression tags send results directly to output

The <jsp:setProperty > tag changes the property value of a
JavaBean component.When using this tag,  the bean and the
property are identified and the value that the property will be
changed to is assigned to the 'value' attribute.

Magelang Institute Example

<jsp:setProperty name="user" property="name" value="jGuru" />

Initializing JavaBeans With Form Parameters
From <jsp:setProperty>

First we create a JavaBean that will service our property
queries. Following is a JavaBean class called MemberBean.
We follow convention and name it with a Bean suffix.

Example of a MemberBean

public class MemberBean{
  
      private String last;
     private String first;
      private int   num;
 
/* Bean no-args constructor */

      public MemberBean( ){
             last="name please";
              first="name or initial";
             // int set to 0 by default       
              }   

// public accessor mutator methods

public void setLast(String last ){    //last
           this.last=last;
           }
 
public String  getLast( ){
              return this.last;
              }   

public void setFirst(String first ){  // first
           this.first=first;
              }

public String getFirst(){
              return this.first;
              } 
 
public void setNum(int num ){  // num
            this.num=num;
           }
 
public int  getNum( ){
              return this.num;
              }  
 } 

Pitfalls To Watch For!

Two significant pitfalls were encountered in using
the JavaBean.

First, while documentation to say so, is not common, it
appears that it is expected that JavaBeans be housed
in a declared package.

Second, with respect to using Eclipse,  the IDE expects
you to create first a new package for any classes that
will be declared as belonging to that package. You will
find the package icon, under File --> New --> Other as
you have for other components you have built.

Consider the following form with three parameters called lastName,
firstName and number.

Member HTML Submission Class

If the form names match the JavaBean property names, JSP
supplies a short cut where the engine will parse all the incoming
values from the HTML form elements that are part of the request
object and assign them to the corresponding set of bean properties.
The following single statement achieves this.  

<jsp:setProperty name="user" property="*"/>

The developer should be careful to consider making sensitive values read-only

class simple{
public static void main(String[]args){
  String url =  "jdbc:odbc:myDSN" ;
  String query = "SELECT  * FROM  Customers"
                        + " WHERE CustomerID = 'QUICK' ";
  try{
           // Load the jdbc-odbc bridge driver
      Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
           // Attempt to connect to a driver
      Connection con = DriverManager.getConnection( url," "," " );
          // Create a Statement object so we can submit SQL statements to the driver
     Statement stmt = con.createStatement( );
          // Submit a query, creating a ResultSet object
     ResultSet rs = stmt.executeQuery(query);
          // Display all columns and rows from the result set
     printResultSet(rs);
     rs.close( );
     stmt.close( );
     con.close( );
     }
     catch(SQLException ex){
            while (ex != null){
               System.out.println("SQL Exception: " + ex.getMessage( ));
                                            ex = ex.getNextException();
                      }
              }
      catch(java.lang.Exception ex){
            ex.printStackTrace( );
            }
    }

private static void printResultSet(ResultSet rs) throws SQLException{
         int numCols = rs.getMetaData( ).getColumnCount( );
             while( rs.next( ) ){
                     for ( int i = 1; i < numCols; i ++ ){
                           System.out.print(rs.getString(i) + "  |  " );
                           }
                    System.out.println( );
                    }
          }
} 

Setting Up an MS Data Source Name  // just for reference

Note on how ResultSet query can be used to Load JavaBean

One of the commonest actions when using JavaBeans with
databases is the loading of JavaBeans with row data that is
subsequently displayed or utilized inside a JSP page. With
JSP pages, as a result set is iterated, instead of sending
code to console as occurs in the above standalone program,
a Javabean's setMethods(  ) can be called to load row data
directly into the JavaBean.

Example

<% page import ="java.sql.*" %>
<jsp:useBean id=member class MemberBean >
<%  
// more JDBC code
            
if (result.next( ) ){
     member.setLastName(results.getString("LastName"));
     member.setFirstName(results.getString("FirstName"));
     member.setNumber(results.getInt("No");
     }
// closing JDBC code
%>
/jsp:useBean>

The DataSource interface which was introduced with JDBC 2.0
and is the suggested replacement for the DriverManager class
shown in the above example.  While it provides many advantages
when used in the Enterprise Java context such as compliance with
JNDI and support for connection pooling and distributed transactions.
Within the context of JSPs, which model is used in our example is
not important as the access mechanics are hidden away in the bean.
Accordingly we will just use classic JDBC in the JSP examples
below.

<%@ page import="java.sql.*,com.taglib.wdjsp.databases.*"
  errorPage="error.jsp" %>
<jsp:useBean id="connection" class="ConnectionBean"
 scope="session"/>

<html>
<body>
<center>
<font size="+2" face="arial"><b>Conference Registration</b></font>
<form action="shuttle.jsp" method="post">
<table border=1 bgcolor="tan" width="50%" align="center">
<tr><td>
<table border="0" bgcolor="white" cellspacing=0 width="100%">
<tr bgcolor="tan">
<th>&nbsp;</th><th>City</th><th>Tickets Remaining</th></tr>
<%
  String sql = "SELECT * FROM CONFERENCES";
  ResultSet results = connection.executeQuery(sql);
  while (results.next()) {
    if (results.getInt("seats") > 0) {
%>
<td>
<input type="radio" name="show"
value="<%= results.getString("id") %>">
</td>
<% } else { %>
<td>&nbsp;</td>
<% } %>
<td><%= results.getString("city") %></td>
<td align="center"><%= results.getString("seats") %></td>
</tr>
<% } %>
</table>
</td></tr></table>

<p>
<input type="submit" value="Next (Choose Shuttle)">
</form>
</center>

</body>
</html>