JavaFX：FXML控制器实例存入HashMap的类型选择问题

一、先解决controllerMap的数据类型问题 #

你的controllerMap可以用HashMap<String, Object>来存储不同的控制器实例——因为所有控制器类都是Object的子类，没有统一的业务父类，用Object能兼容所有控制器类型。为了避免每次获取控制器时手动强制类型转换，建议给getController方法加上泛型：

public class ScreenViews {
    private static HashMap<String, Node> viewMap = new HashMap<>();
    // 用Object作为值的类型，兼容所有控制器
    private static HashMap<String, Object> controllerMap = new HashMap<>();

    // ... 其他现有方法 ...

    public static void addController(String name, Object controller) {
        controllerMap.put(name, controller);
    }

    // 泛型方法，自动转换为目标类型
    @SuppressWarnings("unchecked")
    public static <T> T getController(String name) {
        return (T) controllerMap.get(name);
    }
}

这样在调用时就可以直接指定类型，不用手动强转：

// LoginController里的调用示例
public void frameSetUI(ActionEvent event) {
    // 直接获取FrameController类型的实例
    FrameController frameController = ScreenViews.getController("Frame");
    frameController.getFramePane().getChildren().add(ScreenViews.getView("Dashboard"));
}

二、更优的跨控制器通信方案 #

虽然静态类存储控制器的方式能快速实现需求，但它有几个明显的缺点：

• 耦合度极高：所有控制器都依赖ScreenViews，且必须知道其他控制器的名称和类型，后续修改或新增控制器时维护成本很高。
• 内存泄漏风险：静态集合持有控制器实例，即使对应的FXML视图已经被销毁，控制器也无法被GC回收。
• 不符合模块化设计：违背了依赖倒置原则，代码灵活性差。

下面推荐两种更优的方案：

方案1：使用事件总线（Event Bus）

通过发布/订阅事件的方式实现控制器间通信，控制器之间不需要直接持有引用，完全解耦。你可以用Guava的EventBus，或者自己实现一个简单的事件总线：

1. 定义事件类：

// 切换视图的事件
public class SwitchViewEvent {
    private String targetViewName;

    public SwitchViewEvent(String targetViewName) {
        this.targetViewName = targetViewName;
    }

    public String getTargetViewName() {
        return targetViewName;
    }
}

2. 创建全局事件总线实例：

public class EventCenter {
    private static final EventBus EVENT_BUS = new EventBus();

    public static EventBus getInstance() {
        return EVENT_BUS;
    }
}

3. 在FrameController中订阅事件：

public class FrameController implements Initializable {
    @FXML private AnchorPane framePane;

    @Override
    public void initialize(URL url, ResourceBundle rb) {
        // 订阅SwitchViewEvent事件
        EventCenter.getInstance().register(this);
    }

    // 处理切换视图的事件
    @Subscribe
    public void handleSwitchView(SwitchViewEvent event) {
        Node targetView = ScreenViews.getView(event.getTargetViewName());
        framePane.getChildren().clear();
        framePane.getChildren().add(targetView);
    }

    // 视图销毁时记得注销订阅，避免内存泄漏
    public void onDestroy() {
        EventCenter.getInstance().unregister(this);
    }
}

4. 在LoginController中发布事件：

public class LoginController implements Initializable {
    @FXML
    public void frameSetUI(ActionEvent event) {
        // 发布切换到Dashboard视图的事件
        EventCenter.getInstance().post(new SwitchViewEvent("Dashboard"));
    }
}

方案2：通过依赖注入传递引用

创建一个专门的ViewManager类负责管理视图和控制器，然后将这个管理器注入到需要的控制器中，替代静态类的方式：

1. 实现ViewManager类：

public class ViewManager {
    private HashMap<String, Node> viewMap = new HashMap<>();
    private HashMap<String, Object> controllerMap = new HashMap<>();

    public boolean loadFXML(String name, String resource) {
        try {
            FXMLLoader fxLoader = new FXMLLoader(getClass().getResource(resource));
            Parent loadedFXML = fxLoader.load();
            viewMap.put(name, loadedFXML);
            controllerMap.put(name, fxLoader.getController());
            
            // 如果控制器继承自BaseController，自动注入ViewManager
            if (fxLoader.getController() instanceof BaseController) {
                ((BaseController) fxLoader.getController()).setViewManager(this);
            }
            return true;
        } catch (IOException e) {
            System.out.println(e.getMessage());
            return false;
        }
    }

    public Node getView(String name) {
        return viewMap.get(name);
    }

    @SuppressWarnings("unchecked")
    public <T> T getController(String name) {
        return (T) controllerMap.get(name);
    }
}

2. 创建BaseController基类：

public abstract class BaseController implements Initializable {
    protected ViewManager viewManager;

    public void setViewManager(ViewManager viewManager) {
        this.viewManager = viewManager;
    }
}

3. 修改Main类，用ViewManager加载FXML：

public class Main extends Application {
    @Override
    public void start(Stage stage) throws Exception {
        ViewManager viewManager = new ViewManager();
        viewManager.loadFXML("Frame", "Frame.fxml");
        viewManager.loadFXML("Login", "Login.fxml");
        viewManager.loadFXML("Dashboard", "Dashboard.fxml");
        viewManager.loadFXML("Journal", "Journal.fxml");

        Scene scene = new Scene((Parent) viewManager.getView("Frame"));
        scene.setFill(Color.TRANSPARENT);
        stage.initStyle(StageStyle.TRANSPARENT);
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

4. 在LoginController中使用ViewManager：

public class LoginController extends BaseController {
    @FXML
    public void frameSetUI(ActionEvent event) {
        FrameController frameController = viewManager.getController("Frame");
        frameController.getFramePane().getChildren().add(viewManager.getView("Dashboard"));
    }
}

这种方式把静态依赖变成了实例依赖，更符合面向对象的设计原则，也方便后续扩展和测试。

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