Java-Klassenbibliothek-Guava-EventBus

EventBus ist der Ereignisverarbeitungsmechanismus von Guava und eine elegante Implementierung des Beobachtermusters (Produzenten-/Konsumenten-Programmiermodell) im Entwurfsmuster. EventBus ist eine sehr elegante und einfache Lösung für Event-Listening und Publish-Subscribe-Muster. Wir müssen keine komplexen Klassen- und Schnittstellenhierarchien erstellen.

Das Observer-Muster ist eines der am häufigsten verwendeten Entwurfsmuster. Obwohl es im spezifischen Code manchmal nicht unbedingt so genannt wird, wird es beispielsweise als Listener bezeichnet, aber das Muster ist dieses Muster. Das manuelle Implementieren eines Observers ist keine komplizierte Angelegenheit, und Java hat es in das JDK aufgenommen: Observable und Observer. Sie sind dort seit JDK 1.0. In gewissem Maße vereinfacht es die Entwicklung des Observer-Musters, zumindest müssen wir unsere eigene Observer-Liste nicht mehr manuell pflegen. Allerdings gibt es den Observer im JDK, wie bereits erwähnt, seit 1.0. Bis Java 7 hat sich nicht viel geändert. Auch die Parameter der Benachrichtigung sind immer noch vom Typ Object. Wissen Sie, Java 5 verfügt bereits über Generika. Java 5 war eine umfassende Überarbeitung der Syntax und viele Bibliotheken haben seitdem ihre APIs neu gestaltet, um sie einfacher und benutzerfreundlicher zu machen. Natürlich werden die Bibliotheken, die nicht antworten, wahrscheinlich veraltet sein. Aus diesem Grund wird hier auf die Wissensaktualisierung eingegangen. Was sollten wir heute für normale Anwendungen tun, wenn wir das Observer-Muster verwenden möchten? Die Antwort ist Guavas EventBus.

Grundlegende Verwendung von EventBus:

Wenn Sie nach der Verwendung von Guava Nachrichten abonnieren möchten, müssen Sie die angegebene Schnittstelle nicht mehr erben. Sie müssen nur die Annotation @Subscribe hinzufügen angegebene Methode. Der Code lautet wie folgt:

Nachrichtenkapselungsklasse:

[code]public class TestEvent {
    private final int message;
    public TestEvent(int message) {        
        this.message = message;
        System.out.println("event message:"+message);
    }
    public int getMessage() {
        return message;
    }
}

Nachrichtenakzeptanzklasse:

[code]public class EventListener {
    public int lastMessage = 0;

    @Subscribe
    public void listen(TestEvent event) {
        lastMessage = event.getMessage();
        System.out.println("Message:"+lastMessage);
    }

    public int getLastMessage() {      
        return lastMessage;
    }
}

Testklasse und Ausgabeergebnisse:

[code]public class TestEventBus {
    @Test
    public void testReceiveEvent() throws Exception {

        EventBus eventBus = new EventBus("test");
        EventListener listener = new EventListener();

        eventBus.register(listener);

        eventBus.post(new TestEvent(200));
        eventBus.post(new TestEvent(300));
        eventBus.post(new TestEvent(400));

        System.out.println("LastMessage:"+listener.getLastMessage());
        ;
    }
}

//输出信息
event message:200
Message:200
event message:300
Message:300
event message:400
Message:400
LastMessage:400

Verwendung von MultiListener:

Sie müssen der Methode zum Abonnieren der Nachricht nur die Annotation @Subscribe hinzufügen, um mehrere Nachrichten zu abonnieren. Der Code lautet wie folgt:

[code]public class MultipleListener {
    public Integer lastInteger;  
    public Long lastLong;  

    @Subscribe  
    public void listenInteger(Integer event) {  
        lastInteger = event; 
        System.out.println("event Integer:"+lastInteger);
    }  

    @Subscribe  
    public void listenLong(Long event) {  
        lastLong = event; 
        System.out.println("event Long:"+lastLong);
    }  

    public Integer getLastInteger() {  
        return lastInteger;  
    }  

    public Long getLastLong() {  
        return lastLong;  
    }  
}

[code]public class TestMultipleEvents {
    @Test  
    public void testMultipleEvents() throws Exception {  

        EventBus eventBus = new EventBus("test");  
        MultipleListener multiListener = new MultipleListener();  

        eventBus.register(multiListener);  

        eventBus.post(new Integer(100));
        eventBus.post(new Integer(200));  
        eventBus.post(new Integer(300));  
        eventBus.post(new Long(800)); 
        eventBus.post(new Long(800990));  
        eventBus.post(new Long(800882934));  

        System.out.println("LastInteger:"+multiListener.getLastInteger());
        System.out.println("LastLong:"+multiListener.getLastLong());
    }   
}

//输出信息
event Integer:100
event Integer:200
event Integer:300
event Long:800
event Long:800990
event Long:800882934
LastInteger:300
LastLong:800882934

Totes Ereignis:

Wenn die von EventBus gesendeten Nachrichten für Abonnenten kein Problem darstellen, spricht man von einem toten Ereignis. Das Beispiel lautet wie folgt:

[code]public class DeadEventListener {
    boolean notDelivered = false;  

    @Subscribe  
    public void listen(DeadEvent event) {  

        notDelivered = true;  
    }  

    public boolean isNotDelivered() {  
        return notDelivered;  
    }  
}

[code]public class DeadEventListener {
    boolean notDelivered = false;  

    @Subscribe  
    public void listen(DeadEvent event) {  

        notDelivered = true;  
    }  

    public boolean isNotDelivered() {  
        return notDelivered;  
    }  
}

Beschreibung: Wenn keine Nachrichtenabonnenten die Nachricht abhören, sendet EventBus die DeadEvent-Nachricht. Zu diesem Zeitpunkt können wir diesen Status über das Protokoll aufzeichnen.

Vererbung von Ereignis:

Wenn Listener A auf Ereignis A lauscht und Ereignis A eine Unterklasse von Ereignis B hat, empfängt Listener A gleichzeitig Nachrichten von Ereignis A und B. Das Beispiel lautet wie folgt:

Listener-Klasse:

[code]public class NumberListener {  

    private Number lastMessage;  

    @Subscribe  
    public void listen(Number integer) {  
        lastMessage = integer; 
        System.out.println("Message:"+lastMessage);
    }  

    public Number getLastMessage() {  
        return lastMessage;  
    }  
}  

public class IntegerListener {  

    private Integer lastMessage;  

    @Subscribe  
    public void listen(Integer integer) {  
        lastMessage = integer; 
        System.out.println("Message:"+lastMessage);
    }  

    public Integer getLastMessage() {  
        return lastMessage;  
    }  
}

[code]public class TestEventsFromSubclass {
    @Test  
    public void testEventsFromSubclass() throws Exception {  

        EventBus eventBus = new EventBus("test");  
        IntegerListener integerListener = new IntegerListener();  
        NumberListener numberListener = new NumberListener();  
        eventBus.register(integerListener);  
        eventBus.register(numberListener);  

        eventBus.post(new Integer(100));  

        System.out.println("integerListener message:"+integerListener.getLastMessage());
        System.out.println("numberListener message:"+numberListener.getLastMessage());

        eventBus.post(new Long(200L));  

        System.out.println("integerListener message:"+integerListener.getLastMessage());
        System.out.println("numberListener message:"+numberListener.getLastMessage());        
    }  
}

//输出类
Message:100
Message:100
integerListener message:100
numberListener message:100
Message:200
integerListener message:100
numberListener message:200

Beschreibung: Bei dieser Methode sehen wir, dass das erste Ereignis (neue Ganzzahl (100)) von zwei Listenern empfangen wird. aber der zweite (new long(200l)) kann den NumberListener nur als Ganzzahl erreichen – für diesen Typ wurde kein Ereignis erstellt. Mit dieser Funktion können Sie allgemeinere Listener erstellen, die eine breite Palette von Ereignissen abhören, und detailliertere Listener, die bestimmte Sonderereignisse abhören.

Eine umfassende Instanz:

[code]public class UserThread extends Thread {
    private Socket connection;
    private EventBus channel;
    private BufferedReader in;
    private PrintWriter out;

    public UserThread(Socket connection, EventBus channel) {
        this.connection = connection;
        this.channel = channel;
        try {
            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            out = new PrintWriter(connection.getOutputStream(), true);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    @Subscribe
    public void recieveMessage(String message) {
        if (out != null) {
            out.println(message);
            System.out.println("recieveMessage:"+message);
        }
    }

    @Override
    public void run() {
        try {
            String input;
            while ((input = in.readLine()) != null) {
                channel.post(input);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        //reached eof
        channel.unregister(this);
        try {
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        in = null;
        out = null;
    }
}

[code]mport java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import com.google.common.eventbus.EventBus;

public class EventBusChat {
    public static void main(String[] args) {
        EventBus channel = new EventBus();
        ServerSocket socket;
        try {
            socket = new ServerSocket(4444);
            while (true) {
                Socket connection = socket.accept();
                UserThread newUser = new UserThread(connection, channel);
                channel.register(newUser);
                newUser.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Anleitung: Verwenden Sie zum Anmelden den Telnet-Befehl: Telnet 127.0.0.1 4444. Wenn Sie eine Verbindung zu mehreren Instanzen herstellen, werden alle gesendeten Nachrichten angezeigt Zu anderen Beispielen

Das Obige ist der Inhalt der Java-Class Library-Guava-EventBus. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).