中介模式示例: chat

Question

我读到chat是使用Mediator模式的一个示例。我写了简单的模拟聊天，但我不知道如何在这种情况下使用中介模式。据我所知，我的所有对象都已经具有松散耦合，而且Server类与Mediator类似。有人能在我的样本上显示中介模式的使用吗？

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

public class Main1 {

    public static void main(String[] args) {
        final Server chatObserver = new Server();
        chatObserver.addObserver(new Client("User1", chatObserver));

        Timer t = new Timer();
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                chatObserver.addObserver(new Client("User2", chatObserver));
            }
        }, 5);
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                chatObserver.addObserver(new Client("User3", chatObserver));
            }
        }, 10);
    }

    static class Client extends Observable implements Observer {
        private String name;
        private List<Message> chatHistoryToDisplay; 
        private Timer timer = new Timer();
        private Random random = new Random();

        public Client(final String name, Observer o) {
            this.name = name;
            addObserver(o);         
            chatHistoryToDisplay = new ArrayList<Message>(((Server) o).getChatHistory());
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    int msg = random.nextInt(10);
                    String str = name + " writed " + msg;
                    System.out.println("\t"+str);
                    setChanged();
                    notifyObservers(new Message(name,String.valueOf(msg)));
                }
            }, 0, 10000);
        }

        @Override
        public void update(Observable o, Object msg) {
                chatHistoryToDisplay.add((Message) msg);
                System.out.println("----------- "+name+" screen -----------");
                for (int i=0;i<chatHistoryToDisplay.size();i++) {
                    Message m = chatHistoryToDisplay.get(i);
                    System.out.println(m.toString());
                }
        }
    }

    static class Server extends Observable implements Observer {
        private List<Message> chatHistory = new ArrayList<Message>();

        @Override
        public void update(Observable arg0, Object msg) {
            chatHistory.add((Message) msg);
            setChanged();
            notifyObservers(msg);
        }

        public Collection<Message> getChatHistory(){
            return chatHistory;
        }
    }


    static class Message {
        private String author;
        private String message;

        public Message(String author, String message) {
            this.author = author;
            this.message = message;
        }

        @Override
        public String toString() {
            return author + ": " + message;
        }
    }
}

控制台：

User1 writed 3
----------- User1 screen -----------
User1: 3
    User2 writed 9
----------- User2 screen -----------
User1: 3
User2: 9
----------- User1 screen -----------
User1: 3
User2: 9
    User3 writed 9
----------- User3 screen -----------
User1: 3
User2: 9
User3: 9
----------- User2 screen -----------
User1: 3
User2: 9
User3: 9
----------- User1 screen -----------
User1: 3
User2: 9
User3: 9

等等..。

Answer 1

不确定，你的问题是正确的。

但我认为，在这种情况下，您实际上不需要mediator模式。如果有很多不同的对象需要交换一些数据就好了。例如，ChatClient1实现、ChatClient2实现等。它们必须在mediator中注册并向mediator发送命令。中介知道其他注册类的所有情况，但每个ChatClient都不了解其他类。大多数情况下，这种模式用于UI。在您的例子中，由于您只有一种类型的ChatClient和一种类型的服务器，所以observer是合适的