在CellFactory中有条件地提供不同的TreeCell

Question

我有一个树视图，其中单元格必须根据TreeItem值的实际实现显示不同的信息。

我的域模型如下所示：

在我看来，将“如何在单元格中显示任务”或“如何在单元格中显示组”的行为分为两个不同的类是很自然的。

public abstract class ComponentTreeCell<T extends Component> extends TreeCell<T>
{
    @Override
    protected void updateItem(T item, boolean empty)
    {
        //Some common logic...
    }
}

public class GroupTreeCell extends ComponentTreeCell<Group>
{
    @Override
    protected void updateItem(Group item, boolean empty)
    {
        super.updateItem(item, empty);

        //Some group-specific-logic
    }    
}

public class TaskTreeCell extends ComponentTreeCell<Task>
{
    @Override
    protected void updateItem(Task item, boolean empty)
    {
        super.updateItem(item, empty);

        //Some task-specific-logic
    }    
}

下面的控制器类包含一个树视图，我在其中设置CellFactory。

public class Controller implements Initializable
{
    @FXML
    private TreeView<Component> treeview;

    @Override
    public void initialize(URL url, ResourceBundle bundle)
    {
        treeview.setCellFactory(new Callback<TreeView<Component>, TreeCell<Component>>()
        {
            @Override
            public TreeCell<Component> call(TreeView<Component> arg0)
            {
                if(/* stuck */ instanceof Group)
                {
                    return new GroupTreeCell();
                }
                else if(/* stuck */ instanceof Task)
                {
                    return new TaskTreeCell();
                }
                else
                {
                    return new DefaultTreeCell();
                }
            }
        });
    }
}

但现在我被困在这里，无法决定我必须返回哪种类型的牢房。事实上，我只有相关的TreeView参数，而没有相关的TreeItem！

在我看来，这似乎是JavaFX的一种弱点。为什么JavaFX给用户完整的TreeView，而你只需要检索一个TreeCell？

有没有一种方法可以这样做，或者我必须在同一个自定义TreeCell实现中实现两种不同的行为？

public class ComponentTreeCell extends TreeCell<Component>
{
        @Override
        protected void updateItem(Component item, boolean empty)
        {
            //Some common logic...

            if(item instanceof Group)
            {
                //Group-specific logic...
            }
            else if(item instanceof Task)
            {
                //Task-specific logic...
            }
            else
            {
                //Default logic...
            }
       }
}

Answer 1

为什么JavaFX给用户完整的TreeView，而你只需要检索一个TreeCell？

因为TreeItem和TreeCell之间没有1-1的关系：TreeView只会创建少量的TreeCell（即使树有非常多的项）。TreeCells被重用来显示不同的TreeItems，例如，如果一些节点被展开/折叠，或者如果用户滚动。

这样做是为了性能。提供渲染的实际单元是相当大的对象：它们是用户界面组件，带有CSS样式等。显示的实际数据，即TreeItem相对较轻；它们通常只是String的简单包装。因此，这种机制允许使用具有大量数据的TreeView，而不会给性能带来巨大负担。为每个TreeItem创建一个TreeCell将不允许这样做。

因此，您从工厂提供的TreeCell必须能够处理任何可能由TreeView提供给它的TreeItem。例如，当用户更改显示的项目时（通过展开/折叠或滚动），以前显示任务的TreeCell实例可能用于显示Group。这是updateItem（...）方法的目的；当重用TreeCell时调用它。

这意味着您的设置根本无法工作。你基本上需要TreeCell

public class ComponentTreeCell extends TreeCell<Component>
{
    @Override
    protected void updateItem(Component item, boolean empty)
    {
        super.updateItem(item, empty);
        CellConfiguratorFactory.getConfigurator(item).configure(this, item, empty);
    }

}

工厂：

public class CellConfiguratorFactory {

    private static CellConfigurator<Task> taskCellConfigurator ;
    private static CellConfigurator<Group> groupCellConfigurator ;
    private static CellConfigurator<Component> defaultCellConfigurator ;

    private static CellConfigurator getConfigurator(Component item) {
        if (item instanceof Task) {
            if (taskCellConfigurator == null) {
                taskCellConfigurator = new TaskCellConfigurator();
            }
            return taskCellConfigurator ;
        } else if (item instanceof Group) {
            if (groupCellConfigurator == null) {
                groupCellConfigurator = new GroupCellConfigurator();
            }
            return groupCellConfigurator ;
        } else {
            if (defaultCellConfigurator == null) {
                defaultCellConfigurator = new DefaultCellConfigurator();
            }
            return defaultCellConfigurator ;
        }
    }
}

（注意，您可以假设工厂仅从单个线程使用，因为一切都将发生在FX应用程序线程上。）

然后呢

public interface CellConfigurator<T extends Component> {
    public void configureCell(ComponentTreeCell cell, T item, boolean empty);
}

比如,，

public class TaskCellConfigurator implements CellConfigurator<Task> {
    public void configureCell(TreeCell<Component> cell, Task item, boolean empty) {
        // task-specific implementation...
    }
}

然而，我不确定额外的结构是否值得在这里付出努力。