Re: Binding to a POJO

On 3/4/2011 3:21 PM, Steve Sobol wrote:


You are at least partially re-inventing the wheel here. C.f.
java.lang.reflect.Proxy.

My critism of your technique would be the same as my critisim of my own
method. It requires inheritance to work. In your case, it requires
that you inherit from PCLBean. In my case, I can wrap arbirtary
objects, but they must inherit from a Java interface which the wrapped
object will use.

For example, given something simple like:

public class TestBean {

    public static enum Transaction {WITHDRAWAL, DEPSOIT}

    private long accountNumber;
    private Transaction transaction;
    private long amount; // in cents
.....

I have to create an interface to use:

public interface TestBeanInterface {
    long getAccountNumber();
    long getAmount();
    Transaction getTransaction();
    void setAccountNumber( long accountNumber );
    void setAmount( long amount );
    void setTransaction( Transaction transaction );
}

Then inherit from that explicitly:

public class TestBean implements TestBeanInterface {
.....

Only then can I work any magic on it. The following is intended to work
with Swing by taking POJO domain objects and wrapping them with property
change support, so that they could be then used as the model of an MVC
design.

Here's an example of using TestBean. First, make the concrete object.

   TestBeanInterface testBean = new TestBean();

Then you can add the property change support:

   testBean = (TestBeanInterface) ModelUtils.injectPropChangeListener(
               testBean, TestBeanInterface.class );

Now the bean magically supports PropertyChangeSupport:

   ((MyPropertySupport)testBean).addPropertyChangeListener(
           new PropertyChangeListener() {
               public void propertyChange( PropertyChangeEvent evt ) {
                  System.out.println( evt.getPropertyName()+": "+
                          evt.getOldValue()+" --> "+evt.getNewValue() );
               }
            } );

The bean can still be used normally, and the event listener added above
will fire each time a value is changed through the public interface:

       testBean.setAccountNumber( 123 );
       testBean.setTransaction( TestBean.Transaction.DEPSOIT );
       testBean.setAmount( 10000 ); // 100.00

results in the following output:

run:
setAccountNumber: 0 --> 123
setTransaction: null --> DEPSOIT
setAmount: 0 --> 10000

Whether this is really worth the effort or not, I don't know. I was
pretty disappointed that I couldn't find a way to not use an explicit
interface. Note that this version explicitly uses
SwingPropertyChangeSupport, so the event listener is called on the EDT.

Code follows for the curious:

/*
  *
  * COPYRIGHT 2008,2009,2010 by Brenden Towey
  * All rights reserved.
  *
  * No part of this document may be reproduced
  * by any means without the express written
  * consent of the author.
  *
  */
package test;

import java.beans.PropertyChangeListener;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.event.SwingPropertyChangeSupport;

/**
  *
  * @author Brenden
  */
public class ModelUtils
{

    private ModelUtils()
    {
    }

    static interface MyPropertySupport {
       void addPropertyChangeListener( PropertyChangeListener listener );
       void firePropertyChange( String property, Object oldValue, Object
newValue );
    }

    public static <T, U extends T> T injectPropChangeListener( U baseObject,
            Class<T> superType )
    {

       PropChangeInjector handler = new PropChangeInjector( baseObject );
       T newObject = superType.cast( Proxy.newProxyInstance(
               superType.getClassLoader(), new Class[]{superType,
               MyPropertySupport.class}, handler ) );
       return newObject;
    }

    private static class PropChangeInjector
            implements MyPropertySupport, InvocationHandler
    {
       final SwingPropertyChangeSupport beanPropChange;
       final Object baseObject;

       PropChangeInjector( Object base ) {
          beanPropChange = new SwingPropertyChangeSupport( base );
          baseObject = base;
       }

       public void firePropertyChange( String propertyName, Object oldValue,
               Object newValue )
       {
          beanPropChange.firePropertyChange( propertyName, oldValue,
newValue );
       }

       public void addPropertyChangeListener( PropertyChangeListener
listener )
       {
          beanPropChange.addPropertyChangeListener( listener );
       }

       public Object invoke( Object proxy, Method method, Object[] args )
               throws UnexpectedException
       {
          Class<?>[] pramTypes = method.getParameterTypes();
          Method supportMethod = null;
          try {
             supportMethod =
                     java.beans.PropertyChangeSupport.class.getMethod(
method.getName(),
                     pramTypes );
          } catch( NoSuchMethodException ex ) {
          } catch( SecurityException ex ) {
          }
          if( supportMethod != null ) {
             try {
                return supportMethod.invoke( beanPropChange, args );
             } catch( IllegalAccessException ex ) {
                throwException( ex );
             } catch( IllegalArgumentException ex ) {
                throwException( ex );
             } catch( InvocationTargetException ex ) {
                throwException( ex );
             }
          }
          // not a property change support method, look for other
          // methods...
          boolean propChange = false;
          String methodName = method.getName();
          String propNameUC = null;
          Object oldValue = null;
          if( args != null && args.length == 1 && methodName.length() > 3
                  && methodName.startsWith( "set" ) ) {
             propChange = true;
             propNameUC = methodName.substring( 3 );
             String getter = "get"+propNameUC;
             Method getterMethod = null;
             try {
                getterMethod = baseObject.getClass().getMethod( getter ); //
             } catch( NoSuchMethodException ex ) {
             } catch( SecurityException ex ) {
             }
             if( getterMethod == null ) {
                getter = "is"+propNameUC;
                try {
                   getterMethod = baseObject.getClass().getMethod(
getter ); //
                } catch( NoSuchMethodException ex ) {
                } catch( SecurityException ex ) {
                }
             }
             if( getterMethod != null ) {
                try {
                   oldValue = getterMethod.invoke( baseObject ); //
                } catch( IllegalAccessException ex ) {
                   throwException( ex );
                } catch( IllegalArgumentException ex ) {
                   throwException( ex );
                } catch( InvocationTargetException ex ) {
                   throwException( ex );
                }
             }
          }
          Object retVal = null;
          try {
             Method[] moreMethods = baseObject.getClass().getMethods();
             Method baseMethod = baseObject.getClass().getMethod(
methodName,
                     pramTypes );
             retVal = baseMethod.invoke( baseObject, args );
          } catch( NoSuchMethodException ex ) {
                   throwException( ex );
// Logger.getLogger( ModelUtils.class.getName() ).
// log( Level.SEVERE, "Not found: "+methodName+
// "("+Arrays.toString( pramTypes )+")", ex );
             return null;
          } catch( SecurityException ex ) {
             throwException( ex );
          } catch( IllegalAccessException ex ) {
             throwException( ex );
          } catch( IllegalArgumentException ex ) {
             throwException( ex );
          } catch( InvocationTargetException ex ) {
             throwException( ex );
          }
          if( propChange ) {
             firePropertyChange( method.getName(), oldValue, args[0] );
          }
          return retVal;
       }
    }

    /**
     * {@code UnexpectedException} is a local exception for
     * (@code ModelUtils}.
     */
    public static class UnexpectedException extends Exception {

       public UnexpectedException( Throwable cause )
       {
          super( cause );
       }
    }

    /**
     * Wraps an exception in an {@code UnexpectedException} and throws
     * {@code UnexpectedException}. The exception is logged also.
     *
     * @param ex The exception to wrap.
     */
    private static void throwException( Exception ex )
          throws UnexpectedException
    {
       Logger.getLogger( ModelUtils.class.getName() ).
               log( Level.SEVERE, null, ex );
       throw new UnexpectedException( ex );
    }
}