How to bind Hibernate domain objects to the UI layer

Question

Dear All,
I am trying to bind FX UI controls to properties of a Hibernate Domain object. Is there any good example to refer to for this purpose?
Thanks & Regards,
Nitin Gupta

Answer 1

Assuming you do not formulate your hibernate objects as pojos with javafx properties directly, if the hibernate object is a pojo with or without PCL, you can convert the properties of the pojo to observable values (or properties) directly. These are used in a bind statement.
Check out what jgoodies does with BeanAdapter or PresentationModel. You need the same concept. I've attached a class that does this for a pojo already (its an incomplete port of jgoodies PresentationModel). It will work for any pojo. It does not have setter support as it was just a demonstration. Its efficient for a pojo with a large number of properties. You could also write a very short property connector to produce one observable value per property. The value of the class below is to be able to swap out the bean being observed without having to change or reset the property observable values each time. Bind once and then just reset the bean (think master detail).
package scenegraphdemo;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.ObjectPropertyBase;
import javafx.beans.property.Property;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.beans.value.WritableValue;
* An object binding object that creates object bindings based on property names
* specified as strings. This is a convenience class to avoid having observable
* values directly dependent on the underlying bean. The actual bean the
* properties connect can be changed dynamically using the channel or
* <code>setBean</code>. This allows you to setup binding when you don't have
* the bean to bind to or the bean to bind to will change as in the detail part
* of a master-detail screen. Generally, the return values from
* <code>getProperty()</code> should be used for binding not the factory itself.
* The object should be a domain object bean with bean methods to get or set the
* value using java bean naming conventions OR it should use javafx property
* definition conventions. The factory will automatically listen for standard
* java bean changes using <code>PropertyChangeListener</code> approaches unless
* you indicate to not to.
* <p>
* When the bean itself changes, the properties fire to indicate that their
* values may have changed and the observing object should update itself. This
* object allows you to integrate your javafx/POJOs into the binding
* infrastructure without being dependent on the actual underlying bean. If you
* are familiar with jgoodies <code>BindingAdapter</code> this is a similar
* class.
* <p>
* This only handles reading bean properties. Need to add set() logic.
* <p>
* TODO: Make this work better. Many corner cases to cover.
* <p>
* TODO: Instead of just method calls on POJOs, also check for PCL. Note that
* javafx properties won't work easily they are always tied to the underlying
* object so I would have to write another CaptiveObjectProperty object that is
* essentially a delegator.
public class BeanPropertyFactory<T> extends ObjectProperty<T> {
     ObservableValue<T> channel;
     Map<String, CaptiveObjectProperty> properties = new HashMap<String, CaptiveObjectProperty>();
     boolean listenForBeanPCLEvents = true;
     public boolean isListenForBeanPCLEvents() {
          return listenForBeanPCLEvents;
     public void setListenForBeanPCLEvents(boolean listenForBeanPCLEvents) {
          this.listenForBeanPCLEvents = listenForBeanPCLEvents;
          if (getBean() != null)
               removeBeanPCLListener(getBean());
      * The bean channel where the bean is obtained.
      * @return
     public ObservableValue<T> getChannel() {
          return channel;
     public BeanPropertyFactory() {
          setChannel(new ObjectProperty());
     public BeanPropertyFactory(ObservableValue<T> channel) {
          if (channel == null)
               setChannel(new ObjectProperty());
          else
               setChannel(channel);
     protected void setChannel(ObservableValue<T> channel) {
          if (this.channel != null) {
               removeBeanChangeListener(this.channel);
          this.channel = channel;
          if (this.channel != null) {
               addBeanChangeListener(this.channel);
               updateStringProperty(getBean());
          invalidateProperties();
          fireValueChangedEvent();
     protected StringProperty stringProperty = new StringProperty();
      * The string property is an observable toString property. It cannot be set.
      * @return
     public StringProperty beanStringProperty() {
          return stringProperty;
     public String getBeanString() {
          return beanStringProperty().getValue();
      * A listener that listens to changes in the bean channel. This only fires
      * when the bean changes not when the properties on the bean change. The
      * default actions updates the "string" property representation of this
      * object as well as attaches property change listeners.
      * @author Mr. Java
     protected class BeanChangeListener implements ChangeListener {
          @Override
          public void changed(ObservableValue arg0, Object arg1, Object arg2) {
               if (arg1 != null) {
                    BeanPropertyFactory.this.removeBeanPCLListener(arg1);
               if (arg2 != null) {
                    BeanPropertyFactory.this.addBeanPCLListener(arg2);
               updateStringProperty(arg2);
     protected void updateStringProperty(Object obj) {
          if (obj != null)
               beanStringProperty().setValue(obj.toString());
          else
               beanStringProperty().setValue("null");
     protected void removeBeanChangeListener(ObservableValue<T> obj) {
          if (beanChangeListener == null)
               beanChangeListener = createBeanChangeListener();
          if (obj != null) {
               obj.addListener(beanChangeListener);
     protected void addBeanChangeListener(ObservableValue<T> obj) {
          if (beanChangeListener == null)
               beanChangeListener = createBeanChangeListener();
          if (obj != null)
               obj.removeListener(beanChangeListener);
      * The instance of a change listener for detecting when the bean in the bean
      * channel changes.
     ChangeListener beanChangeListener = new BeanChangeListener();
      * Subclass can override to create their bean change listener.
      * @return
     protected ChangeListener createBeanChangeListener() {
          return new BeanChangeListener();
     public BeanPropertyFactory(T bean) {
          setChannel(new ObjectProperty(bean));
     public Property getProperty(String property) {
          if (property == null || property.isEmpty())
               throw new IllegalArgumentException("Property cannot be null");
          if (properties.containsKey(property))
               return properties.get(property);
          CaptiveObjectProperty p = new CaptiveObjectProperty(this, property);
          properties.put(property, p);
          return p;
     @Override
     public T getValue() {
          return getBean();
      * A listener that listens for property change events on the bean. When the
      * bean changes, the listener must be removed then attached to the new bean
      * but can use the same instance of this class. The action is to inform any
      * existing property objects that the property has changed. The detection of
      * property changes is centralized in the factory class for efficiency.
     protected class BeanPropertyListener implements PropertyChangeListener {
          @Override
          public void propertyChange(PropertyChangeEvent evt) {
               if (properties.containsKey(evt.getPropertyName())) {
                    CaptiveObjectProperty p = properties.get(evt.getPropertyName());
                    p.propertyChanged();
               updateStringProperty(getBean());
      * The cached listener instance to listen to the bean (in the bean channel)
      * property change events if it supports PCL.
     PropertyChangeListener beanPropertyListener;
      * Subclasses can override to implement their own behavior. Its best to
      * extend from <code>BeanPropertyListiner</code> to include the default
      * behavior.
      * @return
     protected PropertyChangeListener createBeanPropertyListener() {
          return new BeanPropertyListener();
      * Add a listener only if the PCL methods exist. This listens for property
      * changes on the bean's property not changes in the actually bean held by
      * the bean channel.
     protected void addBeanPCLListener(Object obj) {
          if (!isListenForBeanPCLEvents())
               return;
          if (obj != null) {
               if (BeanPropertyUtils.hasPCL(obj.getClass())) {
                    if (beanPropertyListener == null)
                         beanPropertyListener = createBeanPropertyListener();
                    BeanPropertyUtils.addPCL(obj, beanPropertyListener, null);
      * Remove a listener only if the PCL methods exist.
      * @see #attachBeanPCLListener
     protected void removeBeanPCLListener(Object obj) {
          if (obj != null) {
               if (BeanPropertyUtils.hasPCL(obj.getClass())) {
                    if (beanPropertyListener == null)
                         beanPropertyListener = createBeanPropertyListener();
                    BeanPropertyUtils.removePCL(obj, beanPropertyListener, null);
      * Invalidate the properties in the property cache. Then changed the bean in
      * the bean channel. Then fire a value changed event.
      * @param bean
     public void setBean(T bean) {
          invalidateProperties();
          if (getChannel() instanceof WritableValue) {
               ((WritableValue) getChannel()).setValue(bean);
          } else {
               throw new IllegalArgumentException(
                         "Could not set bean value into a non-writable bean channel");
          fireValueChangedEvent();
      * Called to indicate that the underlying bean changed.
     protected void invalidateProperties() {
          for (CaptiveObjectProperty p : properties.values()) {
               p.invalidate();
     public T getBean() {
          return getChannel().getValue();
      * Lazily get the method representing the property prior to getting or
      * setting. Because this is a property, it can also be bound to.
      * @author Mr. Java
      * @param <T>
     protected static class CaptiveObjectProperty<T> extends
               ObjectPropertyBase<T> {
           * The string name of the property.
          String readPropertyName, writePropertyName;
           * If the property is really a javafx property, it is stored here.
          Property<T> enhancedProperty;
           * Used if the property is not an enhanced property.
          Method readMethod, writeMethod;
           * The factory that holds the bean we obtain values against.
          BeanPropertyFactory factory;
          public CaptiveObjectProperty(BeanPropertyFactory factory,
                    String property) {
               this.readPropertyName = property;
               this.factory = factory;
          public CaptiveObjectProperty(BeanPropertyFactory factory,
                    String property, String writePropertyName) {
               this.readPropertyName = property;
               this.writePropertyName = writePropertyName;
               this.factory = factory;
          @Override
          public Object getBean() {
               if (factory == null || factory.getBean() == null)
                    return null;
               return factory.getBean();
          @Override
          public void store(T value) {
               if (writeMethod == null && enhancedProperty == null) {
                    getWriteMethod(value.getClass());
               if (writeMethod == null && enhancedProperty == null) {
                    return;
               try {
                    if (enhancedProperty != null) {
                         enhancedProperty.setValue(value);
                         return;
                    if (getBean() == null)
                         return;
                    writeMethod.invoke(getBean(), value);
                    return;
               } catch (Exception e) {
                    e.printStackTrace();
          @Override
          public T getValue() {
               if (readMethod == null && enhancedProperty == null) {
                    getReadMethod();
               if (readMethod == null && enhancedProperty == null)
                    return null;
               try {
                    if (enhancedProperty != null)
                         return enhancedProperty.getValue();
                    if (factory.getBean() == null)
                         return null;
                    Object rval = readMethod.invoke(getBean());
                    return (T) rval;
               } catch (Exception e) {
                    e.printStackTrace();
               return null;
          @Override
          public String getName() {
               return readPropertyName;
           * Invalidate the method. Perhaps the bean changed to another object and
           * we should find the method on the new object. This is called prior to
           * the <code>getBean()</code> being changed.
          public void invalidate() {
               readMethod = null;
               fireValueChangedEvent();
           * This is used to externally signal that the property has changed. It
           * is quite possible that this object does not detect those changes and
           * hence, an external object (in all cases the BeanPropertyFactory) will
           * signal when a change occurs. Property change detection is centralized
           * in the factory for efficiency reasons.
          public void propertyChanged() {
               fireValueChangedEvent();
          protected Property getJavaFXReadProperty(String propertyName) {
               if (factory.getBean() == null)
                    return null;
               String methodName = getName() + "Property";
               try {
                    Method mtmp = factory.getBean().getClass()
                              .getMethod(methodName, new Class<?>[0]);
                    enhancedProperty = (Property) mtmp.invoke(factory.getBean(),
                              new Object[0]);
                    return enhancedProperty;
               } catch (Exception e) {
                    // e.printStackTrace();
                    // silently fail here
               return null;
          protected void getWriteMethod(Class<?> argType) {
               if (factory == null || factory.getBean() == null)
                    return;
               if (enhancedProperty == null)
                    enhancedProperty = getJavaFXReadProperty(getName());
               if (enhancedProperty != null)
                    return;
               writeMethod = getPojoWriteMethod(getName(), argType);
           * Sets the method, either an enhanced property or the POJO method via
           * reflection.
           * @return
          protected void getReadMethod() {
               if (factory == null || factory.getBean() == null)
                    return;
               enhancedProperty = getJavaFXReadProperty(getName());
               if (enhancedProperty != null)
                    return;
               // Look for standard pojo method.
               readMethod = getPOJOReadMethod(getName());
           * Return a get method using reflection.
           * @param propertyName
           * @return
          protected Method getPOJOReadMethod(String propertyName) {
               if (factory.getBean() == null)
                    return null;
               // Look for standard pojo method.
               String methodName = getGetMethodName();
               try {
                    Method mtmp = factory.getBean().getClass()
                              .getMethod(methodName, new Class<?>[0]);
                    return mtmp;
               } catch (Exception e) {
                    // silently fail here
                    // e.printStackTrace();
               return null;
          protected String getGetMethodName() {
               String methodName = "get"
                         + Character.toUpperCase(getName().charAt(0));
               if (getName().length() > 1)
                    methodName += getName().substring(1);
               return methodName;
           * Return a set method using reflection.
           * @param propertyName
           * @param argType
           * @return
          protected Method getPojoWriteMethod(String propertyName,
                    Class<?> argType) {
               if (factory.getBean() == null)
                    return null;
               String methodName = getSetMethodName();
               try {
                    Method mtmp = factory.getBean().getClass()
                              .getMethod(methodName, argType);
                    return mtmp;
               } catch (Exception e) {
                    // silently fail here
                    // e.printStackTrace();
               return null;
          protected String getSetMethodName() {
               String methodName = "set"
                         + Character.toUpperCase(getName().charAt(0));
               if (getName().length() > 1)
                    methodName += getName().substring(1);
               return methodName;
      * Obtain a property using the binding path. The binding path should be
      * simple property names separated by a dot. The bean has to specified
      * because the return value is a property that can be used directly for
      * binding. The first property specified in the binding path should be a
      * property on the bean.
      * <p>
      * The difference between this and <code>Bindings.select()</code> is not
      * much other that it uses the bean factory machinery and the path can be
      * specified as a string. Of course, the bean can be a plain pojo.
      * @param bindingPath
      * @return
     public static Property propertyFromBindingPath(Object bean,
               String bindingPath) {
          if (bindingPath == null || bindingPath.isEmpty())
               return null;
          BeanPropertyFactory lastFactory = null;
          Property lastProperty = null;
          String[] parts = bindingPath.split("\\.");
          if (parts.length > 0) {
               for (int i = 0; i < parts.length; i++) {
                    if (parts.length() <= 0 || parts[i].isEmpty()) {
                         throw new IllegalArgumentException("Binding path part " + i
                                   + " has no length");
                    BeanPropertyFactory newFactory;
                    if (i == 0)
                         newFactory = new BeanPropertyFactory(bean);
                    else
                         newFactory = new BeanPropertyFactory(
                                   (WritableValue) lastProperty);
                    lastProperty = newFactory.getProperty(parts[i].trim());
                    lastFactory = newFactory;
          return lastProperty;
     * Alot like <code>Bindings.select</code> but also handles pojos.
     * @param bean
     * @param path
     * @return
     public static Property propertyFromBindingPath(Object bean, String... path) {
          String tmp = "";
          for (int i = 0; i < path.length; i++) {
               tmp += path[i];
               if (i <= path.length - 1)
                    tmp += ".";
          return propertyFromBindingPath(bean, tmp);
and a supporting classpackage scenegraphdemo;
import java.beans.PropertyChangeListener;
* Static methods for manipulating PCL for standard java beans.
* @author Mr. Java
public class BeanPropertyUtils {
     protected final static Class<?>[] NO_ARGS = new Class<?>[] { PropertyChangeListener.class };
     protected final static Class<?>[] ARGS = new Class<?>[] { String.class,
               PropertyChangeListener.class };
     protected final static String pclAddMethodName = "addPropertyChangeListener";
     protected final static String pclRemoveMethodName = "removePropertyChangeListener";
     * Return true if the class has PCL methods. Does not check for remove.
     * <p>
     * addPropertyChangeListener(PropertyChangeListener)
     * <p>
     * addPropertyChangeListener(String, PropertyChangeListener)
     * @param bean
     * @return
     public static boolean hasPCL(Class<?> clazz) {
          try {
               if (clazz.getMethod(pclAddMethodName, NO_ARGS) != null) {
                    return true;
          } catch (Exception e) {
               // silently fail
          try {
               if (clazz.getMethod(pclAddMethodName, ARGS) != null) {
                    return true;
          } catch (Exception e) {
               // silently fail
          return false;
     * Add a listener.
     * @param bean
     * @param listener
     * @param propertyName
     public static void addPCL(Object bean, PropertyChangeListener listener,
               String propertyName) {
          try {
               if (propertyName == null) {
                    bean.getClass().getMethod(pclAddMethodName, NO_ARGS)
                              .invoke(bean, new Object[] { listener });
               } else {
                    bean.getClass()
                              .getMethod(pclAddMethodName, ARGS)
                              .invoke(bean,
                                        new Object[] { propertyName, listener });
          } catch (Exception e) {
               e.printStackTrace();
     * Remove a listener.
     * @param bean
     * @param listener
     * @param propertyName
     public static void removePCL(Object bean, PropertyChangeListener listener,
               String propertyName) {
          try {
               if (propertyName == null) {
                    bean.getClass().getMethod(pclRemoveMethodName, NO_ARGS)
                              .invoke(bean, new Object[] { listener });
               } else {
                    bean.getClass()
                              .getMethod(pclRemoveMethodName, ARGS)
                              .invoke(bean,
                                        new Object[] { propertyName, listener });
          } catch (Exception e) {
               e.printStackTrace();