JavaFX ObservableList 更改不更新 ListView

Question

所以我正在为服务器 Controller 创建一个带有 JavaFX 的 UI，它是什么并不重要，重要的是 server.getClients();返回 IClients 的 ArrayList。

我希望在 ListView 中显示这些客户端(它们由 IP 表示，但再一次，这似乎不相关)。然而，客户端可能会在任何给定的时间点连接，当这种情况发生时，它们会被添加到服务器的 IClient ArrayList 中。更新此列表时，我希望 ListView 刷新并显示新客户端。出于某种原因，我根本无法让它工作。

我是 JavaFX 的新手，我想我可能正在监督一些事情。 如果这是重复的或明显的，我很抱歉，过去几天我搜索了很长时间，但我可能忽略了一个解决方案。

以下代码是我的 JavaFX 应用程序的 FXMLController 的缩写版本:

/*imports*/

public class FXMLController implements Initializable {//serverUI.FXMLController

@FXML private ListView clientListView;
/*some more (irrelevant) code*/

private IServer server;
/*some more (irrelevant) code*/
private ObservableList<IClient> serverClientsObservableList;

@Override
public void initialize(URL url, ResourceBundle rb) {
    System.out.println("initialization...");
    /*some more (irrelevant) code*/
    //the server was started here

    // FXML Controls
    initClientListView();

    /*some more (irrelevant) code*/
    System.out.println("initialized");
}    

/*some more (irrelevant) code*/


private void initClientListView() {
        System.out.println("clientListView");            
        serverClientsObservableList = FXCollections.observableList(server.getClients());
        serverClientsObservableList.addListener(new ListChangeListener<IClient>() {
            @Override
            public void onChanged(ListChangeListener.Change<? extends IClient> change) {
                System.out.println("list change detected");
                //is any of the followin three lines really necessary to update the ListView content?
                serverClientsObservableList.setAll(server.getClients());
                clientListView.setItems(null);
                clientListView.setItems(serverClientsObservableList);
            }
        });
        clientListView.setItems(serverClientsObservableList);
}



/*some more (irrelevant) code*/
}

编辑:

我不想在 IClients 中的某些内容发生变化时刷新 ListView，因为它们没有任何变化。当新的 IClient 添加到服务器的客户端列表时，我想刷新 ListView。 ListView 应该显示新的 IClient

编辑2:

根据建议的副本，我尝试了以下操作，但我并不真正理解它在做什么以及它是如何工作的。这并没有解决问题，当我尝试创建新的 Observable[] 时它给了我一个错误

Callback<IClient, Observable[]> extractor = new Callback<IClient, Observable[]>() {
            @Override
            public Observable[] call(IClient c) {
                return new Observable[] {c.getNameProperty()};
            }
        };
        ObservableList<IClient> clientOList = FXCollections.observableArrayList(extractor);

另外:我将客户端添加到服务器的代码。 长话短说，这是一个任务，我们必须以相反的方式使用 RMI，服务器命令客户端。客户端将自己注册到服务器的列表，这就是它们被添加到 IClient 列表的地方。

    package serviceImplementation;

import commandService.ICommand;
import commandServiceImplementation.CommandResult;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import service.IClient;
import service.IServer;


public class ServerService extends UnicastRemoteObject implements IServer {

    private ArrayList<IClient> clients;

    public ServerService() throws RemoteException {
        clients = new ArrayList<>();
    }

    @Override
    public boolean register(IClient client) throws RemoteException {
        if(!clients.contains(client)) {
            clients.add(client);
            return true;
        }
        return false;
    }

    @Override
    public boolean unRegister(IClient client) throws RemoteException {
        if(clients.contains(client)) {
            clients.remove(client);
            return true;
        }
        return false;
    }

    @Override
    public String ping() throws RemoteException {
        long arrival = System.currentTimeMillis();
        System.out.println("Got pinged at [" + arrival + "]");
        return ("server ponged [" + arrival + "]");
    }

    @Override
    public CommandResult sendCommand(ICommand command, IClient targetClient) throws RemoteException {
        if(clients.contains(targetClient)) {
            return clients.get(clients.indexOf(targetClient)).executeCommand(command);
        }
        return null;
    }

    @Override
    public ArrayList<IClient> getClients() {
        return clients;
    }
}

Answer 1

您的可观察列表被创建为 ServerService 中基础列表的包装器使用 FXCollections.observableList(...) .由此返回的可观察列表只是包装了底层列表，因此它始终包含与底层列表相同的元素。但是，如文档中所述:

mutation operations made directly to the underlying list are not reported to observers of any ObservableList that wraps it.

当客户端在服务器服务中注册或注销时，您将它们添加到基础列表中。由于底层列表不是可观察列表，因此不会触发任何通知，因此 ListView不知道刷新自己。

一个可能的解决方案可能是使用 ObservableList在ServerService :

public class ServerService extends UnicastRemoteObject implements IServer {

    private ObservableList<IClient> clients;

    public ServerService() throws RemoteException {
        clients = FXCollections.observableArrayList();
    }

    // ...

    @Override
    public ObservableList<IClient> getClients() {
        return clients;
    }
}

然后你做

private void initClientListView() {
        clientListView.setItems(server.getClients());
}

请注意，这会耦合您的 ServerService到 JavaFX API；这可能还不算太糟糕，因为 JavaFX Collections API 根本不依赖于任何 UI 元素。

但是，如果您的客户端在后台线程(即不在 FX 应用程序线程)上注册/注销，则上述代码将不起作用，这几乎可以肯定是这种情况。因此，您需要进行以下更改才能使其正常工作:

@Override
public boolean register(IClient client) throws RemoteException {
    FutureTask<Boolean> register = new FutureTask<>(() ->
        if(!clients.contains(client)) {
            clients.add(client);
            return true;
        }
        return false;
    );
    Platform.runLater(register);
    return register.get();
}

@Override
public boolean unRegister(IClient client) throws RemoteException {
    FutureTask<Boolean> unRegister = new FutureTask<>(() ->
        if(clients.contains(client)) {
            clients.remove(client);
            return true;
        }
        return false;
    );
    Platform.runLater(unRegister);
    return unRegister.get();
}

现在您的 ServerService对 JavaFX 的依赖性更强，因为它假定 FX 应用程序线程正在运行。您没有说明如何使用它，但您很可能不想要这种耦合。

另一种方法是在 ServerService 中支持回调.您可以使用 Consumer<IClient> 非常简单地表示这些.这看起来像:

public class ServerService extends UnicastRemoteObject implements IServer {

    private ArrayList<IClient> clients;

    private Consumer<IClient> registerCallback = client -> {} ;
    private Consumer<IClient> unregisterCallback = client -> {} ;


    public ServerService() throws RemoteException {
        clients = new ArrayList<>();
    }

    public void setRegisterCallback(Consumer<IClient> registerCallback) {
        this.registerCallback = registerCallback ;
    }

    public void setUnregisterCallback(Consumer<IClient> unregisterCallback) {
        this.unregisterCallback = unregisterCallback ;
    }

    @Override
    public boolean register(IClient client) throws RemoteException {
        if(!clients.contains(client)) {
            clients.add(client);
            registerCallback.accept(client);
            return true;
        }
        return false;
    }

    @Override
    public boolean unRegister(IClient client) throws RemoteException {
        if(clients.contains(client)) {
            clients.remove(client);
            unregisterCallback.accept(client);
            return true;
        }
        return false;
    }

    @Override
    public String ping() throws RemoteException {
        long arrival = System.currentTimeMillis();
        System.out.println("Got pinged at [" + arrival + "]");
        return ("server ponged [" + arrival + "]");
    }

    @Override
    public CommandResult sendCommand(ICommand command, IClient targetClient) throws RemoteException {
        if(clients.contains(targetClient)) {
            return clients.get(clients.indexOf(targetClient)).executeCommand(command);
        }
        return null;
    }

    @Override
    public ArrayList<IClient> getClients() {
        return clients;
    }
}

现在在您的 UI 代码中

private void initClientListView() {
        System.out.println("clientListView");            
        serverClientsObservableList = FXCollections.observableArrayList(server.getClients());
        server.setRegisterCallback(client -> Platform.runLater(() -> 
            serverClientsObservableList.add(client)));
        server.setUnregisterCallback(client -> Platform.runLater(() ->
            serverClientsObservableList.remove(client)));
        clientListView.setItems(serverClientsObservableList);
}