JavaFX如何实现特定类型Group？3D视图分层设计优化咨询

问题背景 #

我用SubScene创建了一个简单的3D查看器，最初将3D对象直接添加到顶层根节点中，代码如下：

public class Viewer extends AnchorPane { 
    private final PerspectiveCamera camera = new PerspectiveCamera(true); 
    private final Group root = new Group(camera); 

    public Viewer() { 
        SubScene scene = new SubScene(root, 300, 300, true, SceneAntialiasing.BALANCED); 
    } 

    public Group getRoot() { 
        return root; 
    } 
}

调用代码可以获取根节点并添加3D对象，运行效果没问题。

但根据需求，我把根节点拆成了三个独立分组：

private final Group cameraGroup = new Group(camera); 
private final Group lightGroup = new Group(); 
private final Group objectsGroup = new Group(); 
private final Group root = new Group(cameraGroup, lightGroup, objectsGroup);

现在的问题是：如果给调用代码提供各分组的getter，调用方需要频繁将分组内的Node转换为对应类型（比如cameraGroup中的Camera）；而且由于JavaFX大量类继承自Node，调用方可能不小心向分组中添加非对应类型的节点。但如果提供针对各类型的getter、setter、移除方法，又会让接口变得复杂。请问有没有特定类型的Group？或者其他优化设计的方案？

解决方案 #

1. 自定义类型安全的容器类（推荐） #

你可以创建继承自Group的自定义容器类，内部维护特定类型的ObservableList，并将其绑定到Group的children列表。这样外部只能添加对应类型的节点，无需手动转换，也避免了类型错误。

比如针对相机的容器类：

public class CameraGroup extends Group {
    private final ObservableList<Camera> cameras = FXCollections.observableArrayList();

    public CameraGroup(Camera initialCamera) {
        cameras.add(initialCamera);
        // 自动同步列表到Group的子节点
        Bindings.bindContent(getChildren(), cameras);
    }

    // 对外暴露类型安全的列表
    public ObservableList<Camera> getCameras() {
        return cameras;
    }

    // 可选：添加便捷操作方法
    public void addCamera(Camera camera) {
        cameras.add(camera);
    }

    public void removeCamera(Camera camera) {
        cameras.remove(camera);
    }
}

同理，你可以创建LightGroup和Shape3DGroup（针对3D对象）：

public class LightGroup extends Group {
    private final ObservableList<Light> lights = FXCollections.observableArrayList();

    public LightGroup() {
        Bindings.bindContent(getChildren(), lights);
    }

    public ObservableList<Light> getLights() {
        return lights;
    }

    public void addLight(Light light) {
        lights.add(light);
    }
}

然后在Viewer中使用这些自定义容器：

public class Viewer extends AnchorPane {
    private final PerspectiveCamera camera = new PerspectiveCamera(true);
    private final CameraGroup cameraGroup = new CameraGroup(camera);
    private final LightGroup lightGroup = new LightGroup();
    private final Group objectsGroup = new Group(); // 如果需要限制3D对象，也可以创建Shape3DGroup
    private final Group root = new Group(cameraGroup, lightGroup, objectsGroup);

    public Viewer() {
        SubScene scene = new SubScene(root, 300, 300, true, SceneAntialiasing.BALANCED);
        getChildren().add(scene);
    }

    // 对外暴露类型安全的getter
    public ObservableList<Camera> getCameras() {
        return cameraGroup.getCameras();
    }

    public ObservableList<Light> getLights() {
        return lightGroup.getLights();
    }

    public ObservableList<Node> get3DObjects() {
        return objectsGroup.getChildren();
    }
}

调用方使用时，直接操作类型安全的列表，完全不需要类型转换：

Viewer viewer = new Viewer();
viewer.getCameras().add(new PerspectiveCamera(false));
viewer.getLights().add(new PointLight(Color.WHITE));

2. 封装操作方法，隐藏内部分组结构 #

如果不想创建多个自定义容器类，你可以在Viewer中封装所有针对相机、灯光和3D对象的操作，不直接暴露分组本身。这样调用方无需关心内部结构，接口更简洁，也能避免类型错误。

示例代码：

public class Viewer extends AnchorPane {
    private final PerspectiveCamera camera = new PerspectiveCamera(true);
    private final Group cameraGroup = new Group(camera);
    private final Group lightGroup = new Group();
    private final Group objectsGroup = new Group();
    private final Group root = new Group(cameraGroup, lightGroup, objectsGroup);

    public Viewer() {
        SubScene scene = new SubScene(root, 300, 300, true, SceneAntialiasing.BALANCED);
        getChildren().add(scene);
    }

    // 相机相关操作
    public void addCamera(Camera camera) {
        cameraGroup.getChildren().add(camera);
    }

    public void removeCamera(Camera camera) {
        cameraGroup.getChildren().remove(camera);
    }

    public ObservableList<Camera> getCameras() {
        // 返回过滤后的Camera列表，避免直接操作Node列表
        return cameraGroup.getChildren()
                .filtered(node -> node instanceof Camera)
                .map(node -> (Camera) node)
                .collect(FXCollectors.toObservableList());
    }

    // 灯光相关操作
    public void addLight(Light light) {
        lightGroup.getChildren().add(light);
    }

    public void removeLight(Light light) {
        lightGroup.getChildren().remove(light);
    }

    public ObservableList<Light> getLights() {
        return lightGroup.getChildren()
                .filtered(node -> node instanceof Light)
                .map(node -> (Light) node)
                .collect(FXCollectors.toObservableList());
    }

    // 3D对象相关操作（可添加类型校验）
    public void add3DObject(Node object) {
        // 可选：限制仅添加3D相关节点
        if (object instanceof Shape3D || object instanceof Group) {
            objectsGroup.getChildren().add(object);
        } else {
            throw new IllegalArgumentException("仅支持添加3D相关节点");
        }
    }

    public void remove3DObject(Node object) {
        objectsGroup.getChildren().remove(object);
    }

    public ObservableList<Node> get3DObjects() {
        return objectsGroup.getChildren();
    }
}

调用方使用时，直接调用封装好的方法：

Viewer viewer = new Viewer();
viewer.addCamera(new PerspectiveCamera(false));
viewer.addLight(new AmbientLight(Color.GRAY));
viewer.add3DObject(new Sphere(50));

3. 使用泛型包装类复用代码 #

如果多个类型的分组逻辑类似，可以创建一个泛型的类型安全Group，避免重复代码：

public class TypedGroup<T extends Node> extends Group {
    private final ObservableList<T> items = FXCollections.observableArrayList();

    public TypedGroup() {
        Bindings.bindContent(getChildren(), items);
    }

    public TypedGroup(T initialItem) {
        this();
        items.add(initialItem);
    }

    public ObservableList<T> getItems() {
        return items;
    }

    public void addItem(T item) {
        items.add(item);
    }

    public void removeItem(T item) {
        items.remove(item);
    }
}

然后在Viewer中使用这个泛型类：

public class Viewer extends AnchorPane {
    private final PerspectiveCamera camera = new PerspectiveCamera(true);
    private final TypedGroup<Camera> cameraGroup = new TypedGroup<>(camera);
    private final TypedGroup<Light> lightGroup = new TypedGroup<>();
    private final TypedGroup<Node> objectsGroup = new TypedGroup<>();
    private final Group root = new Group(cameraGroup, lightGroup, objectsGroup);

    public Viewer() {
        SubScene scene = new SubScene(root, 300, 300, true, SceneAntialiasing.BALANCED);
        getChildren().add(scene);
    }

    public ObservableList<Camera> getCameras() {
        return cameraGroup.getItems();
    }

    public ObservableList<Light> getLights() {
        return lightGroup.getItems();
    }

    public ObservableList<Node> get3DObjects() {
        return objectsGroup.getItems();
    }
}

内容的提问来源于stack exchange，提问作者koolbanana