Question

我正在开发一个将在多台计算机上执行的Java应用程序。我正在使用观察者模式使更改可见，而Hibernate使用持久化实体。如果我创建了Observer的多个实例（通过单击按钮）并且每个窗口都反映了更改，则观察者模式可以正常工作。但是如果我通过执行.jar文件创建了我的Observer的几个实例，则观察者模式不起作用。我认为这类似于在各种计算机上执行应用程序。

我想知道如何在远程计算机上看到更改。

这是我的服务器类

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Observable;

public class Server extends Observable{
    private ArrayList clients = new ArrayList();

    public Server() {
    }

    public void addClient(String name){
        this.clients.add(new Client(name, this));
        this.setChanged();
        this.notifyObservers();
    }

    public ArrayList getClients() {
        return clients;
    }

    public void setClients(ArrayList clients) {
        this.clients = clients;
    }

    public void sendMessage(Message message){
        Iterator iter = this.clients.iterator();
        while(iter.hasNext()){
            Client client = (Client)iter.next();
            if (message.getSender()!= client){
                client.recibirMensaje(message);
            }
        }
    }

    public Client searchClient(String name){
     Client auxClient = null;
     boolean state = false;
     Iterator iter = this.clients.iterator();
     while (iter.hasNext() && state == false){
         Client unCliente = (Client)iter.next();
         if (unCliente.getName().equals(name)){
             auxClient = unCliente;
             state = true;
         }
     }
        return auxClient;
    }
}

这是我的客户端类

import java.util.ArrayList;
import java.util.Observable;

public class Client extends Observable {
    private String name;
    private ArrayList messages = new ArrayList();
    private Server server = new Server();

    public Client() {
    }

    public Client(String name) {
        this.name = name;
    }

    public Client(String name, Server server) {
        this.name = name;
        this.server = server;
    }



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public ArrayList getMessages() {
        return messages;
    }

    public void setMessages(ArrayList messages) {
        this.messages = messages;
    }

    public Server getServer() {
        return server;
    }

    public void setServer(Server server) {
        this.server = server;
    }

    // Enviar mensaje al servidor
    public void enviarMensaje(String msg){
        this.server.sendMessage(new Message(msg, this));
    }

    // Enviar mensaje a un solo destinatario
    public void enviarMensaje(String msg, Client unDestinatario){
        unDestinatario.recibirMensaje(new Message(msg, this, unDestinatario));
    }

    public void recieveMessage(Message message){
        this.messages.add(message);
        this.setChanged();
        this.notifyObservers();
    }



    @Override
    public String toString() {
        return name;
    }


}

这是我的Message类

import java.util.Observable;

public class Message extends Observable {
    private String msg;
    private Client reciver;
    private Client sender;

    public Message() {
    }

    public Message(String msg, Client sender) {
        this.msg = msg;
        this.sender = sender;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Client getReciver() {
        return reciver;
    }

    public void setReciver(Client reciver) {
        this.reciver = reciver;
    }

    public Client getSender() {
        return sender;
    }

    public void setSender(Client sender) {
        this.sender = sender;
    }

    public Message(String msg, Client sender, Client reciver) {
        this.msg = msg;
        this.reciver = reciver;
        this.sender = sender;
        this.reciver = reciver;
    }

    @Override
    public String toString() {
        return sender.getName() + ": " + msg;
    }


}

观察者是两个JFrame，当从同一个JFrame中添加其中一个对象时，它们会显示一个对象列表（Clients和Messages）。

阿尔贝托。

Answer 1

不确定为什么近6年没有人回答这个问题。

但是对于分布式系统，执行此操作的一种方法是使用发布/订阅者模型。与传统的观察者模式有很多相似之处，只是现在您添加了所有计算机都可以访问的消息总线。在这里，观察对象（称为发布者）将更改信息发布到消息总线上通常称为“主题”的信息。订阅者可以通过订阅适当的主题而不是直接向观察的对象注册来获得有关更改消息的通知。

分布式应用程序中的观察者模式

1 个答案: