JavaBeans and JSP

1. JavaBeans and JSP CS-422

2. JavaBeans • The Java component technology • originally intended for the creation and management of “pluggable” GUI components; Java’s answer to Visual Basic’s VBX/OCXs • becoming more popular for encapsulating business logic for server-side applications (especially Java Server Pages • many Java GUI Development tools have been modified to allow application development of server-side applications (Visual Café, Jbuilder, VisualAge for Java) along with the development tools being delivered with application servers (SilverStream, BEA Weblogic) • A JavaBean is nothing more than a class that maintains some state data (called properties) and follows a certain set of coding conventions. Along with certain Java runtime support (reflection and introspection) can JavaBeans can be easily added to and maintained by most of the Java GUI Development Tools .

3. API requires that: • Must implement java.io.Serializable or java.io.Externalizable • Beans must be able to support their own persistence • this allows the bean to be saved and restored consistently • provide a no-arguments constructor • provides a single way for the Bean to be instantiated • insures consistent bean creation and initialization • private properties must have corresponding get/set methods that follow the appropriate naming patterns • each piece of state data to be exposed is called a property • made public via accessor and mutators (setters and getters) • accessor methos names must start with “get” • for property int color the accessor would be getcolor() • mutator methods names must start with “set” • for property fuelCapacity the mutator would be setfuelCapacity()

4. Environmental Support • To use JavaBeans with JSP no environmental support is needed, but for a better understanding of JavaBeans in the whole we’ll take a look… • Introspection ( java.beans.Introspector) defines the resources that allow the programatic construction of information on the Bean • facilitates the discovery of properties and methods by inspecting the .class file • can be done two ways : the reflection APIs or by providing a java.beans.BeanInfo class with the bean to describe the public methods and properties, • Reflection (java.lang.reflect) a set of resources that allows a program to discover the public properties and methods of classes that have been loaded by the class loader • this is facilitated by the naming convention for accessors and mutators (i.e. the names must start with “get” or “set”) • don’t need to need to knownames of properties as long as we know the names of the accessor and mutators • These environmental support mechanisma allow the JavaBeans to be cleanly integrated into GUI based, Java Development tools like VisualCafe, VisualAge and Jbuilder.

5. Example: a Stock bean import java.io.Serializable; public class Stock implements Serializable { Stock( ) { } // no argument constructor (just creates the object) private String name = null; private String tickerSymbol = null; private double tradingPrice = 0.0; private double sharesOwned = 0.0; public void setName(String n) { name = n; } public String getName( ) { return name;} public void setTickerSymbol( String s ) { tickerSymbol = s; } public String gettickerSymbol( ) { return tickerSymbol; } public void settradingPrice( double d ) { tradingPrice = d; } public double gettradingPrice( ) { return tradingPrice; } public void setsharesOwned( double v ) { sharesOwned = v; } public double getsharesOwned( ) { return sharesOwned; } }

6. jsp:useBean Tag • jsp:useBean does the following: • If the object is found within the specified scope it is retrieved and assigned to the object • if not found it is instantiated • if newly instantiated it executes the code specified in the body ( one or more jsp:setProperty tags or a scriptlet) • if newly instantiated it is saved into the scope via setAttribute( ) method • jsp:useBean also makes the bean visible to the JSP; there may be other objects in the context that were put there by other JSPs or servlets; jsp:useBean can make them visible to the current JSP

7. jsp:useBean Tag (more) • Attributes : • id • scope • class • beanName • type • <jsp:useBean id = today class = “java.util.Date”> • instantiates a bean called today of class java.util.Date( ) • <jsp:useBean id = “count” class = “java.lang.Integer” type = “java.lang.Number”> • essentially does : Number = count ; count = new Integer( ) • <jsp:useBean id = “count” class = “<%= request.getParameter(“beanName”)%> type = “Number” /> • essentiallt does: Number count; count = java.beans.Beans.instantiate(request.getParameter(“beanName”));

8. jsp:useBean Tag (more) • In general the syntax is: <jsp:useBean id = “name” {scope = “page | request | session | application”} { class = “class name” | class = “class name” type = “type name” | beanName = “bean name” type = “type name” | type = “type name” } />