java - 完全支持 POJO 中的 JavaFX 属性

Question

关于向现有 POJO 类添加 JavaFX 属性支持，存在相当多的问题。这些类的属性可以通过使用 javafx.beans.property.adapter 中的适配器来创建。包裹。但是，以这种方式创建的属性不会反射(reflect)使用 POJO 类的 setter 方法所做的更改，除非PropertyChangeSupport添加到 POJO 类中。

更改现有类有时是不可能的，即使可以，如果您有很多类，添加 PropertyChangeSupport 也可能会非常乏味。所以我想分享一种不需要更改现有类的方法。

Answer 1

该解决方案的灵感来自 article作者:Ben Galbraith，并使用 AspectJ 。它绝对不需要对现有模型类进行任何更改。安装 AspectJ 超出了本教程的范围，可以说所有主要 IDE 都支持它(在 Eclipse 中安装它很简单)。

此示例假设所有模型类都扩展一个基类，在本例中称为 BaseEntity。如果您的实现与此不同，您当然需要调整该方面。

首先，我们将创建一个定义 PropertyChangeSupport 所需方法的接口(interface)。

package com.mycompany.myapp;

import java.beans.PropertyChangeListener;

public interface ChangeSupport {
    // Add listener for all properties
    public void addPropertyChangeListener(PropertyChangeListener listener);
    // Remove listener for all properties
    public void removePropertyChangeListener(PropertyChangeListener listener);
    // Add listener for specific property
    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener);
    // Remove listener for specific property
    public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener);
    // Fire change event for specific property
    public void firePropertyChange(String propertyName, Object oldValue, Object newValue);
    // Check if property has any listeners attached
    public boolean hasListeners(String propertyName);
}

接下来，我们将创建该接口(interface)的实现。

package com.mycompany.myapp;

import com.mycompany.myapp.model.BaseEntity;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

public class ChangeSupportImpl implements ChangeSupport {
    // Declared transient as there is no need to serialize these fields
    private transient PropertyChangeSupport propertyChangeSupport;
    private final transient Object source;

    public ChangeSupportImpl() {
        super();
        this.source = this;
    }

    // Needed for annotation-style aspect
    public ChangeSupportImpl(final BaseEntity baseEntity) {
        super();
        this.source = baseEntity;
    }

    @Override
    public void addPropertyChangeListener(final PropertyChangeListener listener) {
        // PropertyChangeSupport is loaded lazily
        if (this.propertyChangeSupport == null)
            this.propertyChangeSupport = new PropertyChangeSupport(this.source);
        this.propertyChangeSupport.addPropertyChangeListener(listener);
    }

    @Override
    public void removePropertyChangeListener(final PropertyChangeListener listener) {
        if (this.propertyChangeSupport != null)
            this.propertyChangeSupport.removePropertyChangeListener(listener);
    }

    @Override
    public void addPropertyChangeListener(final String propertyName, final PropertyChangeListener listener) {
        // PropertyChangeSupport is loaded lazily
        if (this.propertyChangeSupport == null)
            this.propertyChangeSupport = new PropertyChangeSupport(this.source);
        this.propertyChangeSupport.addPropertyChangeListener(propertyName, listener);
    }

    @Override
    public void removePropertyChangeListener(final String propertyName, final PropertyChangeListener listener) {
        if (this.propertyChangeSupport != null)
            this.propertyChangeSupport.removePropertyChangeListener(propertyName, listener);
    }

    @Override
    public void firePropertyChange(final String propertyName, final Object oldValue, final Object newValue) {
        if (this.propertyChangeSupport != null)
            this.propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue);
    }

    @Override
    public boolean hasListeners(final String propertyName) {
        return this.propertyChangeSupport != null && (this.propertyChangeSupport.hasListeners(propertyName)
                || this.propertyChangeSupport.hasListeners(null));
    }
}

最后，我们将创建一个方面，将 PropertyChangeSupport 添加到 BaseEntity 类。该方面使用自定义类 ReflectUtils 来获取属性的旧值。您可以使用任何您喜欢的实用程序，或者普通的旧式 Java 反射(不过，这可能会影响性能)。

package com.mycompany.myapp;

import com.mycompany.myapp.model.BaseEntity;
import com.mycompany.myapp.util.ReflectUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareMixin;

import java.util.Objects;

@Aspect
public class BaseEntityObservabilityAspect {
    @DeclareMixin("com.mycompany.myapp.model.BaseEntity")
    public static ChangeSupport createChangeSupportImplementation(final BaseEntity baseEntity) {
        return new ChangeSupportImpl(baseEntity);
    }

    // Intercept setters in all BaseEntity objects in order to notify about property change
    @Around("this(baseEntity) && execution(public void set*(*))")
    public void firePropertyChange(final BaseEntity baseEntity,
            final ProceedingJoinPoint joinPoint) throws Throwable {
        // Get property name from method name
        final String setterName = joinPoint.getSignature().getName();
        final String property = setterName.substring(3, 4).toLowerCase() + setterName.substring(4);
        final ChangeSupport support = (ChangeSupport)baseEntity;
        if (support.hasListeners(property)) {
            // Get old value via reflection
            final Object oldValue = ReflectUtils.invokeGetter(baseEntity, property);

            // Proceed with the invocation of the method
            joinPoint.proceed();

            // New value is the first (and only) argument of this method
            final Object newValue = joinPoint.getArgs()[0];
            // Fire only if value actually changed
            if (!Objects.equals(oldValue, newValue))
                support.firePropertyChange(property, oldValue, newValue);
        } else {
            // No listeners have been registered with BaseEntity, so there is no need to fire property change event
            joinPoint.proceed();
        }
    }
}

如果由于某种原因无法使用注释样式，这里使用 AspectJ 代码样式也是如此。

package com.mycompany.myapp;

import java.util.Objects;

import com.mycompany.myapp.model.BaseEntity;
import com.mycompany.myapp.util.ReflectUtils;

public aspect BaseEntityObservabilityAspect {
    declare parents: BaseEntity extends ChangeSupportImpl;

    // Intercept setters in all BaseEntity objects in order to notify about property change
    void around(final BaseEntity entity, final ChangeSupport support):
            this(entity) && this(support) && execution(public void BaseEntity+.set*(*)) {
        // Get property name from method name
        final String setterName = thisJoinPoint.getSignature().getName();
        final String property = setterName.substring(3, 4).toLowerCase() + setterName.substring(4);
        if (support.hasListeners(property)) {
            final Object oldValue;
            try {
                // Get old value via reflection
                oldValue = ReflectUtils.invokeGetter(entity, property);
            } catch (final Throwable e) {
                // Should not happen
                proceed(entity, support);
                return;
            }

            // Proceed with the invocation of the method
            proceed(entity, support);

            // New value is the first (and only) argument of this method
            final Object newValue = thisJoinPoint.getArgs()[0];
            // Fire only if value actually changed
            if (!Objects.equals(oldValue, newValue))
                support.firePropertyChange(property, oldValue, newValue);
        } else {
            // No listeners have been registered with BaseEntity, so there is no need to fire property change event
            proceed(entity, support);
        }
    }
}