Javafx 自定义可观察列表实现，通知消费者更改

我已经为树元素列表创建了一个自定义ObservableList实现。我的自定义实现可以从我的应用程序内部侦听各种通知（使用OSGi EventAdmin），并相应地更新自身。然后，我期望它的消费者（一个TreeView小部件）随着列表的变化而更新。然而，我不知道如何通知消费者

在ObservableList子类中，我实现了addListener（ListChangeListener），我希望在将对象添加到小部件时调用它。然而，它从未被称为；我没有听众，因此当名单发生变化时，我显然无法通知任何人。我一定错过了什么

下面是我的TreeItem实现的一个片段，它返回我的ObservableList的一个实例以响应getChildren调用：

    @Override
    public ObservableList<TreeItem<DataObject>> getChildren() {
        if (needChildren) {
            needChildren = false;
            children = new MyObservableList();
        }
        return children;
    }

@覆盖
公共观察列表getChildren（）{
如有需要（儿童）{
需要孩子=错误；
children=新的MyObservableList（）；
}
返回儿童；
}

这里是我的自定义ObservalElist实现的一个简化版本，它简单地包装了一个FXCollections.ObservalArrayList并添加了一个OSGi事件处理程序。我监听内部列表上的更改，以便将这些更改传递给我的侦听器

    public class MyObservableList implements ObservableList<TreeItem<DataObject>>, EventHandler {
    private List<ListChangeListener<? super TreeItem<DataObject>>> changeListeners = new ArrayList<>();
    private List<InvalidationListener> invalidationListeners = new ArrayList<>();
    private ObservableList<TreeItem<DataObject>> theList;
    private int size;

    public MyObservableList() {
        theList = FXCollections.observableArrayList();

        theList.addListener(new ListChangeListener<TreeItem<DataObject>>() {
            @Override
            public void onChanged(Change<? extends TreeItem<DataObject>> change) {
                fireValueChangedEvent(change);
            }
        });
    }

    @Override
    public int size() {
        return theList.size();
    }

    @Override
    public boolean isEmpty() {
        return (size == 0);
    }

    @Override
    public boolean contains(Object o) {
        return theList.contains(o);
    }

    @Override
    public Iterator iterator() {
        return theList.iterator();
    }

    @Override
    public boolean remove(Object o) {
        return theList.remove(o);
    }

    @Override
    public boolean addAll(Collection c) {
        return theList.addAll(c);
    }

    @Override
    public boolean addAll(int index, Collection c) {
        return theList.addAll(index, c);
    }


    @Override
    public void clear() {
        theList.clear();
    }

    @Override
    public TreeItem<DataObject> get(int index) {
        return theList.get(index);
    }

    @Override
    public int indexOf(Object o) {
        return theList.indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return theList.lastIndexOf(o);
    }

    @Override
    public ListIterator listIterator() {
        return theList.listIterator();
    }

    @Override
    public ListIterator listIterator(int index) {
        return theList.listIterator(index);
    }


    @Override
    public List<TreeItem<DataObject>> subList(int fromIndex, int toIndex) {
        return theList.subList(fromIndex, toIndex);
    }

    @Override
    public Object[] toArray(Object[] a) {
        return theList.toArray(a);
    }

    @Override
    public void addListener(ListChangeListener<? super TreeItem<DataObject>> listChangeListener) {
        changeListeners.add(listChangeListener);
    }

    @Override
    public void removeListener(ListChangeListener<? super TreeItem<DataObject>> listChangeListener) {
        changeListeners.remove(listChangeListener);
    }

    @Override
    public boolean addAll(TreeItem<DataObject>... treeItems) {
        return theList.addAll(treeItems);
    }

    @Override
    public boolean setAll(TreeItem<DataObject>... treeItems) {
        return theList.setAll(treeItems);
    }

    @Override
    public boolean setAll(Collection<? extends TreeItem<DataObject>> treeItems) {
        return theList.setAll(treeItems);
    }

    @Override
    public boolean removeAll(TreeItem<DataObject>... treeItems) {
        return theList.removeAll(treeItems);
    }

    @Override
    public boolean retainAll(TreeItem<DataObject>... treeItems) {
        return theList.retainAll(treeItems);
    }

    @Override
    public void remove(int i, int i2) {
        theList.remove(i, i2);
    }

    @Override
    public Object[] toArray() {
        return theList.toArray();
    }

    @Override
    public boolean add(TreeItem<DataObject> dataObjectTreeItem) {
        return theList.add(dataObjectTreeItem);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return theList.containsAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return theList.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return theList.retainAll(c);
    }

    @Override
    public TreeItem<DataObject> set(int index, TreeItem<DataObject> element) {
        return theList.set(index, element);
    }

    @Override
    public void add(int index, TreeItem<DataObject> element) {
        theList.add(index, element);
    }

    @Override
    public TreeItem<DataObject> remove(int index) {
        return theList.remove(index);
    }

    @Override
    public void addListener(InvalidationListener invalidationListener) {
        invalidationListeners.add(invalidationListener);
    }

    @Override
    public void removeListener(InvalidationListener invalidationListener) {
        invalidationListeners.remove(invalidationListener);
    }

    private void fireValueChangedEvent(ListChangeListener.Change<? extends TreeItem<DataObject>> change) {
        for (ListChangeListener<? super TreeItem<DataObject>> listener : changeListeners) {
            listener.onChanged(change);
        }
    }

    @Override
    public void handleEvent(Event event) {
        // Here I add or remove TreeItem<DataObject> instances to the list based on event.
        //
        // At this point, onChanged() gets called above in my listener, but my changeListeners list is empty. There is
        // no one to pass the Change on to.
    }
}

公共类MyObservableList实现了ObservableList、EventHandler{
private List在查看JavaFX源代码后，我发现这里发生了什么

事实证明，对ObservableList中的子对象的监听都是在TreeItem本身中设置的，而不是我之前假设的TreeView。这意味着任何重写getChildren（）的TreeView子类都必须调用super.getChildren（）并将其子项添加到结果列表中。这意味着不可能使用自定义ObservableList实现，因为TreeItem已硬编码为使用FXCollections.observableArrayList（）创建列表

我现在采取了一种不同的方法，调用super.getChildren（），添加我的子对象，然后实例化另一个对象，该对象包含对该列表的引用，并执行我应用程序的所有事件处理业务，根据需要对该列表进行操作。因此，我的getChildren（）方法现在看起来像这样

private MyEventHandler eventHandler;
private ObservableList<TreeItem<DataObject>> children;

@Override
public ObservableList<TreeItem<DataObject>> getChildren() {
    if (needChildren) {
        needChildren = false;
        children = super.getChildren();
        eventHandler = new MyEventHandler(children); // handles app events
    }
    return children;
}

私有MyEventHandler事件处理程序；
私家医生子女；
@凌驾
公共观察列表getChildren（）{
如有需要（儿童）{
需要孩子=错误；
children=super.getChildren（）；
eventHandler=new MyEventHandler（子项）；//处理应用程序事件
}
返回儿童；
}
只是为了确定，您确定您的
树项
不是叶（即其
isLeaf（）
方法不会返回
true
）？还有，其子项正在更新的树项是否已展开？最后，我看不出在您自己的实现中包装一个可观察列表的好理由。您也可以在
TreeItem
实现中处理事件，并相应地修改子项列表。是的，它肯定不是叶子。我已经弄清楚了哦，至于你的第二个问题，为什么要这样做呢？这是一个好问题。我们正试图将业务逻辑作为一般规则排除在GUI级小部件之外，让我们的业务逻辑组件生成一个封装事件处理逻辑的可观察列表很有吸引力，因为它可以ULD打开了一个更通用的解决方案的可能性，它也可以被其他组件使用。然而，根据我现在所知道的，也许我需要考虑BL的树项部分并将其移到该组件中。