コード例 #1
0
  /**
   * Constructs a PropertyConnector that synchronizes the two bound bean properties as specified by
   * the given pairs of bean and associated property name. If <code>Bean1#property1Name</code>
   * changes it updates <code>Bean2#property2Name</code> and vice versa. If a bean does not provide
   * support for bound properties, changes will not be observed. If a bean property is read-only,
   * this connector will not listen to the other bean's property and so won't update the read-only
   * property.
   *
   * <p>In case you don't need the PropertyConnector instance, you better use the static method
   * {@link #connect(Object, String, Object, String)}. This constructor may confuse developers if
   * you just use the side effects performed in the constructor; this is because it is quite
   * unconventional to instantiate an object that you never use.
   *
   * @param bean1 the bean that owns the first property
   * @param property1Name the name of the first property
   * @param bean2 the bean that owns the second property
   * @param property2Name the name of the second property
   * @throws NullPointerException if a bean or property name is <code>null</code>
   * @throws IllegalArgumentException if the beans are identical and the property name are equal, or
   *     if both properties are read-only
   */
  public PropertyConnector(Object bean1, String property1Name, Object bean2, String property2Name) {
    if (bean1 == null) throw new NullPointerException("Bean1 must not be null.");
    if (bean2 == null) throw new NullPointerException("Bean2 must not be null.");
    if (property1Name == null) throw new NullPointerException("PropertyName1 must not be null.");
    if (property2Name == null) throw new NullPointerException("PropertyName2 must not be null.");
    if ((bean1 == bean2) && (property1Name.equals(property2Name)))
      throw new IllegalArgumentException(
          "Cannot connect a bean property to itself on the same bean.");

    this.bean1 = bean1;
    this.bean2 = bean2;
    this.bean1Class = bean1.getClass();
    this.bean2Class = bean2.getClass();
    this.property1Name = property1Name;
    this.property2Name = property2Name;

    property1Descriptor = getPropertyDescriptor(bean1Class, property1Name);
    property2Descriptor = getPropertyDescriptor(bean2Class, property2Name);

    // Used to check if property2 shall be observed,
    // i.e. if a listener shall be registered with property2.
    boolean property1Writable = property1Descriptor.getWriteMethod() != null;

    // Used to check if property1 shall be observed,
    // i.e. if a listener shall be registered with property1.
    boolean property2Writable = property2Descriptor.getWriteMethod() != null;
    // Reject to connect to read-only properties
    if (!property1Writable && !property2Writable)
      throw new IllegalArgumentException("Cannot connect two read-only properties.");

    boolean property1Observable = BeanUtils.supportsBoundProperties(bean1Class);
    boolean property2Observable = BeanUtils.supportsBoundProperties(bean2Class);
    // We do not reject the case where two unobservable beans
    // are connected; this allows a hand-update using #updateProperty1
    // and #updateProperty2.

    // Observe property1 if and only if bean1 provides support for
    // bound bean properties, and if updates can be written to property2.
    if (property1Observable && property2Writable) {
      property1ChangeHandler =
          new PropertyChangeHandler(bean1, property1Descriptor, bean2, property2Descriptor);
      addPropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
    } else {
      property1ChangeHandler = null;
    }

    // Observe property2 if and only if bean2 provides support for
    // bound bean properties, and if updates can be written to property1.
    if (property2Observable && property1Writable) {
      property2ChangeHandler =
          new PropertyChangeHandler(bean2, property2Descriptor, bean1, property1Descriptor);
      addPropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
    } else {
      property2ChangeHandler = null;
    }
  }
コード例 #2
0
 /**
  * Looks up, lazily initializes and returns a <code>PropertyDescriptor</code> for the given Java
  * Bean and property name.
  *
  * @param beanClass the Java Bean class used to lookup the property from
  * @param propertyName the name of the property
  * @return the descriptor for the given bean and property name
  * @throws PropertyNotFoundException if the property could not be found
  */
 private static PropertyDescriptor getPropertyDescriptor(Class beanClass, String propertyName) {
   try {
     return BeanUtils.getPropertyDescriptor(beanClass, propertyName);
   } catch (IntrospectionException e) {
     throw new PropertyNotFoundException(propertyName, beanClass, e);
   }
 }
コード例 #3
0
 private void setValueSilently(
     Object sourceBean,
     PropertyDescriptor sourcePropertyDescriptor,
     Object targetBean,
     PropertyDescriptor targetPropertyDescriptor,
     Object newValue) {
   if (property1ChangeHandler != null) {
     removePropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
   }
   if (property2ChangeHandler != null) {
     removePropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
   }
   try {
     // Set the new value in the target bean.
     BeanUtils.setValue(targetBean, targetPropertyDescriptor, newValue);
   } catch (PropertyVetoException e) {
     // Silently ignore this situation here, will be handled below.
   }
   // The target bean setter may have modified the new value.
   // Read the value set in the target bean.
   Object value = BeanUtils.getValue(targetBean, targetPropertyDescriptor);
   // If the new value and the value read differ,
   // update the source bean's value.
   // This ignores that the source bean setter may modify the value again.
   // But we won't end in a loop.
   if (!BindingUtils.equals(value, newValue)) {
     boolean sourcePropertyWritable = sourcePropertyDescriptor.getWriteMethod() != null;
     if (sourcePropertyWritable) {
       try {
         BeanUtils.setValue(sourceBean, sourcePropertyDescriptor, value);
       } catch (PropertyVetoException e) {
         // Ignore. The value set is a modified variant
         // of a value that had been accepted before.
       }
     }
   }
   if (property1ChangeHandler != null) {
     addPropertyChangeHandler(bean1, bean1Class, property1ChangeHandler);
   }
   if (property2ChangeHandler != null) {
     addPropertyChangeHandler(bean2, bean2Class, property2ChangeHandler);
   }
 }
コード例 #4
0
 /**
  * A property in the observed bean has changed. First checks, if this listener should handle the
  * event, because the event's property name is the one to be observed or the event indicates
  * that any property may have changed. In case the event provides no new value, it is read from
  * the source bean.
  *
  * @param evt the property change event to be handled
  */
 public void propertyChange(PropertyChangeEvent evt) {
   String sourcePropertyName = sourcePropertyDescriptor.getName();
   if ((evt.getPropertyName() == null) || (evt.getPropertyName().equals(sourcePropertyName))) {
     Object newValue = evt.getNewValue();
     if (newValue == null) {
       newValue = BeanUtils.getValue(sourceBean, sourcePropertyDescriptor);
     }
     setValueSilently(
         sourceBean, sourcePropertyDescriptor, targetBean, targetPropertyDescriptor, newValue);
   }
 }
コード例 #5
0
 /**
  * Used to remove this class' PropertyChangeHandler from the given bean if it is not <code>null
  * </code>.
  *
  * @param bean the bean to remove the property change listener from
  * @param listener the property change listener to be removed
  * @throws PropertyUnboundException if the bean does not support bound properties
  * @throws PropertyNotBindableException if the property change handler cannot be removed
  *     successfully
  */
 private static void removePropertyChangeHandler(
     Object bean, Class beanClass, PropertyChangeListener listener) {
   if (bean != null) {
     BeanUtils.removePropertyChangeListener(bean, beanClass, listener);
   }
 }
コード例 #6
0
 /**
  * Reads the value of the first bean property and sets it as new value of the second bean
  * property.
  *
  * @see #updateProperty1()
  */
 public void updateProperty2() {
   Object property1Value = BeanUtils.getValue(bean1, property1Descriptor);
   setValueSilently(bean1, property1Descriptor, bean2, property2Descriptor, property1Value);
 }