chapter 11 javabeans

Chapter 11JavaBeans

Process Phases Discussed in This ChapterRequirementsAnalysis

Design

Implementation

ArchitectureFramework Detailed Design

xKey: = secondary emphasisx = main emphasis

Adapted from Software Design: From Programming to Architecture by Eric J. Braude (Wiley 2003), with permission.

Learning Goals for This Chapter

… what JavaBeans (“Beans”) are

… the life-cycle of a Bean

… Bean containers

… create JavaBeans

… connect Beans in BeanBox

… create applications that use Beans

Be able to …

Understand …


Java Beans Design Goals 1

Create a component technology within Javao capitalize on Java portability

Include GUI componentso but not limited to GUI (e.g. server bean)

Compete with other visual programming and

component systemso (which are often specific to an O.S.)

o usually Windows

o require installation of some kind

Beans Design Goals 2

“Light weight” for Internet applications

Secure

o use Java security model

Easy & efficient to distribute

Provide mechanism which enables development

environment (“container”) to determine methods,

properties & events


Design Goal At Work: Reusability

Facilitate the easy reuse of Java code.


Output Of Chair Maker Estimator


Phase 1. Create Bean Classes

Source subject to rules

Phase 3. Create Bean Instance

Instantiate object(s), usually in a Bean environment (container)

Phase 4a. Combine Beans in Bean Container to Make Application

Combine with other Beans to produce application

Bean Phases

Phase 2. Create Bean from Multiple Bean Classes

Combine Bean classes to make new Beans; create manifest; compile

Phase 4b. Deploy Bean and Use in Applications

Place application, Beans and required software on target platform

- or -

Design / implementation time.

Instance creation time.

Assembly time.

Deployment time.

--------


Key Concept: Ways to use Beans

-- within environments; connected to other Beans; within applications.


Amenities Afforded by Bean Environments

Detection of the Bean’s properties

Read only – or-

Writeable

Detection of listeners supported

So events on the Bean can be handled

Ability to easily create instances

and display an image if an awt or swing object

Set property values visually

Ability to store instances


Required Bean Rules 1 of 2

Java source consists of Java classes

-containing null constructor

… MyClass() { … }

- implementing Serializable interface

- obeying standards shown below for …

o … accessor methods

o … Listener registration

o … Event classes


To have property myProp, include methods:

<type> getMyProp(){ … } // to access myProp

void setMyProp( <type> p ) // to change

For boolean property:

boolean isMyProp()

Name for event classes to be XXXEvent

o extends Event

Listeners must implement java.util.EventListenero Name must end in Listener as in XXXListener

o added with public void addXXXListener(...)

o removed with public void removeXXXListener(...)

Required Bean Rules

2 of 2


List all .class files to be included

JAR’ing a Bean

jar cfm Bean0.jar manifest.txt Bean0.class

Second argument is name of manifest file

First argument is name of the new JAR file

Creating a JAR file


BeanBox Environment

Adding a Bean to the BeanBox


Bean1


Setting Color



Be able to use Chairmaker Bean alone. Avoid having it refer to any other non-API class.


Initial Form of Properties Panel

(green in color)



Utilize Chairmaker with TicTock events. This avoids compromising either Bean.


Beginning to Use ChairMaker


Setting ChairMaker to Add a Chair Leg


An Output Of ChairMaker Bean


Output Of ChairMaker Bean From Button Action


Using a Bean in an Application: Output



We want to associate Beans even when there is no external event such as a mouse click.


Property Change Event Demonstration


Property Change Event Demonstration #2


Bound Property Demonstration


Key Concept: Bound Properties

-- causes a Beans to react when a property in another Bean changes value.

<jsp:useBean id="object name" 1

scope="page|request|session|application" 2

class="fully qualified classname" 3 </ jsp:useBean >

1 Bean instance name as in MyClass myName = ….2 // Choose one; when instance is destroyed; optional; default is page3 // e.g., a.b.MyClass

Embedding Beans in JSP


Scope of a Bean in a JSP

• page - new object created and destroyed for every page view.

• request - the newly created object created and bound to the request object.

• session - the newly created object bound to the session object. -- every visitor coming to the site will have a separate session for it, so you will not have to create a new object every time for it -- can retrieve that object later again from the session object when wanted

• application - object will stay as long as the application remains loaded. E.g., you want to count page views or daily sessions for your site. Source: http://stardeveloper.com:8080/articles/072001-1.shtml

Setting and Getting a Bean Property in a JSP:

Introduction

<jsp:setProperty name=“account17" property=“bal" value=“3211“

/>

<jsp:getProperty name=“account17" property=“bal"

/>

Summary of This Chapter

A Java Bean is a compiled collection

of Java classes and required files o JAR’d to reduce to a single file

Beans are used at various phases,

often in a Bean containero Creating from scratch

o Creating instances of

o Connecting

o Deploying as part of an applicationAdapted from Software Design: From Programming to Architecture by Eric J. Braude (Wiley 2003), with permission.

chapter 11 javabeans

Documents

software design

bean bean containers

braude wiley

bean instance

server bean

bean environmentsdetection

bean phasesphase

bean rules2