Document Sample
javabeans Powered By Docstoc
					Introduction to Java Beans
by Anders Børjesson
     JavaBeans components
• JavaBeans are the components in the
  Java environment
  – COM / ActiveX are components in the
    Microsoft environment
• Many classes in J2SE are JavaBeans
  – Like the Java Swing classes

                 Introduction to JavaBeans   2
• Visibility
   – Some JavaBeans are visual
      • Buttons, TextFields, etc.
   – Some JavaBeans are “invisible”
      • Model components (worker classes)
• Size (granularity)
   – Some JavaBeans are small (in terms of features)
      • Buttons, TextFields, etc.
   – Some JavaBeans are big (in terms of features)
      • SMTP beans, entire applications

                         Introduction to JavaBeans     3
  Requirements for JavaBeans
• Must have a no-arg (no parameters) constructor
  – More constructors are allowed
  – Remember: If you add a constructor with parameters
    then the default no-arg constructor is gone.
• Must implements
• Data should no be public
  – Data should be accesses via get and set methods
• Should be thread safe
  – Use synchronized carefully

                   Introduction to JavaBeans             4
 Non-requirements for JavaBeans
• An applet must extend java.lang.Applet
• A servlet must extend javax.servlet.Servlet
• A thread must implement
• Beans does not need to extend or
  implement anything special
  – Except for
     • Which is only a marker interface

                    Introduction to JavaBeans   5
             JavaBeans terms
• Properties
  – To be read or set by other objects
     • Get and set methods
• Methods
  – To be called by other objects
     • Ordinary Java methods
• Events
  – Sent to other objects when something happens to the
    bean object
     • A property with a new value

                       Introduction to JavaBeans          6
                Access levels
• 3 access levels
  – Read-only
     • Make only a get method
  – Write-only
     • Make only a set method
        – Quite rare
  – Read / write
     • Make get and set methods
     • Most common

                       Introduction to JavaBeans   7
   Different kinds of properties
• Different kinds of properties
  – Simple or indexed (array) properties
  – Bound properties
     • Event after a new value is set on the property
     • To update other components (e.g. visual
  – Constrained properties
     • Event before a new value is set on the property
     • To check if the new value is legal according to the
       current business rules

                    Introduction to JavaBeans                8
               Simple properties
• Represents a single value
• A simple property has
  – 1 name
  – 1 type
       • Primitive data type   or
       • Class based data type
• Example: size
  –   Name: size      Type: int
  –   Public void setSize(int size)
  –   Public int getSize()
                         Introduction to JavaBeans   9
      Example bean: JButton
• Some properties of javax.swing.JButton
  – Text: setText(String), getText()
  – Font: setFont(Font), getFont()
  – Icon: setIcon(Icon), getIcon()
  – Enabled: setEnabled(boolean), isEnabled()

                 Introduction to JavaBeans      10
         Exercise: Car bean
• You are supposed to program parts of a
  system for car registration
  – Program a Car bean
    • Properties: Registration number, color, etc.
    • Methods: toString, equals
    • Constructors: No-arg constructor + maybe other
  – Make a JUnit test to test the Car bean

                  Introduction to JavaBeans            11
           Indexed properties
• Represents an array of values
• Example: Property: address Type: Address
  – Public void setAddress(int index, Address addr)
  – Public Address getAddress(int index)

  – Bulk operations:
     • Public void setAddresses(Address[] addr)
     • Public Address[] getAddresses()

                       Introduction to JavaBeans      12
    Programming JavaBeans
• JavaBeans can be programmed using
  – Ordinary text editors
     • TextPad, even Notepad
  – Builder tools
     • NetBeans, Eclipse, JBuilder, etc.
     • Builder tools often have special features that
       makes programming JavaBeans easier.

                     Introduction to JavaBeans          13
       Exercise: Owner bean
• Additional classes for the car registration
  – Program a (car) owner bean
     • Properties: Name, address, etc.
     • Indexed property: Cars
        – One owner may have several cars
  – Make a JUnit test to test the Owner and Car

                     Introduction to JavaBeans    14
           Bound properties
• Sends an event to another object after the
  property is assigned a new value.
  – The other object is sometimes called:
    Observer, listener, etc.
• The other object may react on the event
  – Update its own state
• Content of an event
  – propertyName, oldValue, newValue, source

                  Introduction to JavaBeans    15

               Introduction to JavaBeans   16
                          Observer pattern

                                                             0..n            PropertyChangeListener

#pcs : PropertyChangeSupport
+addPropertyChangeListener(l : PropertyChangeListener)
                                                                    +propertyChange(evt : PropertyChangeEvent)
+removePropertyChangeListener(l : PropertyChangeListener)



                                                                    +propertyChange(evt : PropertyChangeEvent)

                                        Introduction to JavaBeans                                        17
             Sequence diagram: Firing a
               property change event

        :Account             :PropertyChangeSupport      :PropertyChangeListener   :PropertyChangeListener





                                          Introduction to JavaBeans                                     18
   Sequence diagram: Adding a
 property change listener to a bean
:PropertyChangeListener                   :Account                  :PropertyChangeSupport



                                 Introduction to JavaBeans                              19
      Classes and interfaces
• Package java.beans
  – Class PropertyChangeEvent
    • extends EventObject
  – Interface PropetyChangeListener
    • Extends EventListener
  – Class PropertyChangeSupport
    • Helps you to make bound properties

                  Introduction to JavaBeans   20
• Interface PropertyChangeListener extends
  – EventListener is a marker interface
     • No methods to implement
• PropertyChangeListener methods
  – void propertyChange(PropertyChangeEvent evt)

                   Introduction to JavaBeans       21
• Af changing the value of a property
  – firePropertyChange(propertyChangeName, oldValue,
• Listener called
  – propertyChange(PropertyChangeEvent ev)
• PropertyChangeEvent methods:
  –   String getPropertyName()
  –   Object getOldValue()
  –   Object getNewValue()
  –   Object getSource()

                     Introduction to JavaBeans     22
• Helps you to make bound properties
• Constructor
   – PropertyChangeSupport(Object sourceBean)
• Some methods
   – addPropertyChangeListener(PropertyChangeListener listener)
   – removePropertyChangeListener(PropertyChangeListener listener)
   – addPropertyChangeListener(String propertyName,
     PropertyChangeListener listener)
   – removePropertyChangeListener(String propertyName,
     PropertyChangeListener listener)
   – firePropertyChange(String propertyName, Object oldValue,
     Object newValue)
   – firePropertyChange(String propertyName, int oldValue,
     int newValue)

                         Introduction to JavaBeans               23
  Exercises: Car bean with bound
• Program a car bean with bound properties
  – You may either change your “old” car bean or make a
    new car bean.
• Program a PropertyChangeListener
  – LogListener implements PropertyChangeListener
  – Every time a property changes the listener writes to
    the screen the data in the propertyChangeEvent
     • Source, property name, old value, new value.
• Make a JUnit test to test the bound properties.
• Extra (if you have time): Make a more general
  log listener that writes to a general stream.
                       Introduction to JavaBeans           24
                   Event loops
• Problem
  – 2 beans sends propertyChangeEvents to each other
     • Example: User interface objects events a model objec, and
       vice versa
  – The 2 beans might event each other forever.
• Solution
  – Check if the new value is really a new value
     • i.e. newValue != oldValue
     • PropertyChangeSupport.firePropertyChange() does the

                      Introduction to JavaBeans                    25
      Example bean: JButton
• Javax.swing.JButton is a bean
  – Doesn’t use ProperChangeEvent, etc.
  – addActionListener(ActionListener l)
    • Listens for button presses
  – addChangeListener(ChangeListener l)
    • Listens for changes in the button’s state
       – Size, font, text, etc.

                       Introduction to JavaBeans   26
        Constrained properties
• A bean object asks one (or more) observers if an
  update of a property is legal
  – Observer may throw PropertyVetoException
  – Example: account.setBalance(-100)
  – A property is often bound and constrained
• Examples
  – +

                    Introduction to JavaBeans   27
     Exercise: Car with constrained
• Program a car bean with bound properties
    – You may either change your “old” car bean or make a new car bean.
• Program a few VetoableChangeListeners
    – ColorChecker
        • Checks if a color is illegal
             – Pink, orange, etc. are considered illegal colors of a car
    – RegistrationNumberChecker
        • Checks if the registration number is legal
             – A proper registration number must have the structure AB12345, i.e. 2 letter
               followed by 5 digits.
• Make a JUnit test to test the Car bean with the new listeners.
• Extra (if you have time)
    – Program a configurable ColorChecker as a bean +
        • Illegal colors is an indexed property

                                  Introduction to JavaBeans                                  28
 Dynamic vs. static characteristics
          on properties
• Static characteristic
  – Follows the object for its life time.
• Dynamic characteristic
  – Changes over time during the objects life time
  – Characteristics may be (de)aggregated using
    constrained properties.

                   Introduction to JavaBeans     29
                Low coupling
• The event mechanism in JavaBeans
  provides low coupling
  – The bean object doesn’t know much about the
    • Except that listeners must implement
      PropertyChangeListener or PropertyVetoListener
  – The listeners doesn’t know much about the
    • It’s just an Object
       – Which we sometimes have to typecast to the Bean class
         (which is very bad)

                     Introduction to JavaBeans               30
 Using JavaBeans in builder tools
• JavaBeans can be used in a builder tool
  – NetBeans
  – Eclipse
  – Borland JBuilder
  – etc.
• The bean must be “installed” in the builder
  – The builder usually helps you to during

                  Introduction to JavaBeans   31
Packing JavaBeans in JAR files
• JAR = Java Archive
  – The standard package format in Java
  – JAR = ZIP file with a manifest
  – A JAR file may contain
    • Class files
    • Icons, etc.
    • Manifest file describing the contents of the JAR file

                    Introduction to JavaBeans             32
• The builder tool unzip’s the JAR file to get the
  class files.
• The builder tool “learns” about the beans’
  properties, methods, and events using the
  introspection API
   – Package java.beans
      •   Class Introspector
      •   Interface BeanInfo
      •   Interface PropertyDescriptor
      •   Interface MethodDescriptor
      •   Interface EventSetDescriptor
   – Example:

                         Introduction to JavaBeans   33
             Using JavaBeans
• JavaBeans can be used as ordinary classes
  – Java applications, applets, servlets
  – JSP (JavaServer Pages)
     • special tags to manipulated JavaBeans
        – <jsp:useBean id="cart" class="shop.cart.ShoppingCart"
          scope="session" />
        – <jsp:getProperty name="cart" property="numberOfItems" />
        – <jsp:setProperty name="cart" property="... " value="... " />

                       Introduction to JavaBeans                   34
         JavaBeans vs. Enterprise
• JavaBeans
  – Are relatively simple
  – Part of Java Standard Edition (J2SE)
  – Can be used in an ordinary Java application / applet
• Enterprise JavaBeans
  –   More advanced
  –   Part of Java Enterprise Edition (J2EE)
  –   Middle tier: Between (web)application and database.
  –   Can only be used in an enterprise Java application
       • Requires an J2EE server to run the application
                         Introduction to JavaBeans          35
      Job types using JavaBeans
     and other types of components
• Designing components
• Programming components
• Documenting components
    – Technical writer
•   Design using components
•   Programming using components
•   Marketing / selling components
•   Testing components
    – Correctness, performance, security [Trojan horses,
                         Introduction to JavaBeans         36

Shared By: