1

チャットは Mediator パターンの使用例であると読みました。チャットの簡単な模倣を書きましたが、この状況でメディエーター パターンを使用する方法がわかりません。私が理解しているように、すべてのオブジェクトはすでに疎結合であり、Server クラスは Mediator に似ています。サンプルで 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

等々...

4

1 に答える 1

2

Not sure, that understand your question correctly.

But I think, in this case, you don't actually need mediator pattern. If only there will be a lot of different objects that have to exchange some data. For example, ChatClient1 implementation, ChatClient2 implementation etc. They have to register themselves in mediator and send commands to mediator. Mediator knows everything about other registered classes, but every ChatClient know nothing about others. Most of the times, this patter is using for UI. In your case, since you only have 1 type of ChatClient and one type of Server, observer is appropriate

于 2012-02-13T21:21:22.080 に答える