OL314: Developing and Using JavaBeans Components

Description:

 

The JavaBeans™ component architecture is the platform-independent architecture for the Java application environment. It’s the ideal choice for developing or assembling client-side GUI and application components for heterogeneous hardware and operating system environments. In fact, it’s the only component architecture you should consider if you’re developing for the Java platform, extending the "Write Once, Run Anywhere™" capability to reusable component development.

This course, designed for Java programmers, allows you to take full advantage of JavaBeans, the reusable software component architecture. Minimally, developing Java beans means adopting several simple design patterns in your code. However, that’s only the beginning. To take full advantage of the JavaBeans architecture, you should understand how to write classes that are serializable, use events for communication between classes, know when and how to provide BeanInfo classes that give graphical environments more information about your components, and provide property editors and customizers that let graphical tools work with more complex Java beans.

This hands-on course is composed of comprehensive lectures, practical project illustrations, and independent programming sessions.

Note: Enterprise JavaBeans technology is covered in our OL317 course.

 

Objectives: 

At the end of the course, the participant will be able to:

1. Understand the JavaBeans component technology.
2. Create Java beans.
3. Incorporate existing Java beans into an application.

Audience:

This course is designed for Java programmers who want to be able to create portable, reusable software components.

Prerequistes:

The course assumes familiarity with the Java language, in particular:

• An overall understanding of Java program structure,
• An in-depth understanding of object-oriented programming,
• Some background in Java GUI - AWT or Swing (JFC), and
  
• A basic understanding of the Client-Server architecture.

Students should have taken OL310 or have equivalent Java Programming experience.

Duration:  2 days

 

Outline of Contents:

Unit 1: Introduction to JavaBeans Components Understand the features offered by JavaBeans architecture. Learn what a JavaBeans component (or bean) is. Use the BeanBox to manipulate and execute beans. Unit 2: Archiving Beans Explore what a JAR file is and how a bean packaged in a JAR is distingushed from an arbitary class. Learn what information a manifest file contains. Learn to package a bean into a JAR. Unit 3: Bean Properties Identify and define read-write, read-only and write-only properties. Understand the conventions for simple and indexed properties. Implement simple and indexed properties of different types. Unit 4: Java Event Model Learn the various features of the Java Event Model. Implement Event Listeners and extend Adapters to recieve events. Define and create custom events. Create beans that support the firing and receipt of events. Use events in BeanBox to communicate between beans. Unit 5: Reflection and Introspection Identify methods and classes used to report all the methods of an object whose type in known. Analyze code that implements reflection. Describe how reflection and introspection are used by builder tools to find out the properties and events of a bean. Use the BeanBox to introspect a bean.

Unit 6: More on Bean Properties Learn to distingush between a bound and constrained property. Implement a bound property. Implement a constrained property. Use the helper classes supplied in the JDK to aid in the coding of beans with bound or constrained properties. Unit 7: Serialization Learn how serialization provides persistence to objects. Serialize and deserialize a bean (or any object) from a persistent storage place. Learn how to customize the serialization and deserialization process for an object. Unit 8: Customizing Beans Learn how bean builders analyze beans using a two step introspection process. Code and JAR a BeanInfo class which returns various descriptor objects describing the bean. Unit 9: Customizing Bean Behavior Learn about the localization of beans. Learn about the difference between a text based property editor, a graphics based property editor, and a customizer. Set a customizer for design-time configuration of a bean. Unit 10: Advanced JavaBeans Concepts Learn what a BeanContext is and why it is used. Learn about other concepts and APIs introduced in Java 2 for beans development. Experience the Java Activation framework.