Bibliothèque de classes Java-Guava-EventBus

EventBus est le mécanisme de traitement d'événements de Guava et une implémentation élégante du modèle d'observateur (modèle de programmation producteur/consommateur) dans le modèle de conception. EventBus est une solution très élégante et simple pour les modèles d'écoute d'événements et de publication-abonnement. Nous n'avons pas besoin de créer des hiérarchies complexes de classes et d'interfaces.

Le modèle Observer est l'un des modèles de conception les plus couramment utilisés. Bien que parfois il ne soit pas nécessairement appelé ce nom dans le code spécifique, par exemple, il s'appelle Listener, mais le modèle est ce modèle. Implémenter manuellement un Observer n'est pas une affaire compliquée. Simplement parce que ce modèle de conception est si couramment utilisé, Java l'a intégré au JDK : Observable et Observer sont là depuis le JDK 1.0. Dans une certaine mesure, cela simplifie le développement du modèle Observer, au moins nous n'avons plus besoin de gérer manuellement notre propre liste d'Observateurs. Cependant, comme mentionné précédemment, l'Observer dans le JDK existe depuis la version 1.0. Jusqu'à Java 7, il n'a pas beaucoup changé, même les paramètres de notification sont toujours de type Object. Vous savez, Java 5 a déjà des génériques. Java 5 a nécessité une refonte massive de la syntaxe et de nombreuses bibliothèques ont depuis lors repensé leurs API pour les rendre plus simples et plus faciles à utiliser. Bien entendu, les bibliothèques qui ne répondent pas deviendront probablement obsolètes. C’est pourquoi la mise à jour des connaissances est abordée ici. Aujourd’hui, pour les applications ordinaires, que faire si l’on souhaite utiliser le pattern Observer ? La réponse est EventBus de Guava.

Utilisation de base d'EventBus :

Après avoir utilisé Guava, si vous souhaitez vous abonner aux messages, vous n'avez plus besoin d'hériter de l'interface spécifiée. Il vous suffit d'ajouter l'annotation @Subscribe au fichier. méthode spécifiée. Le code est le suivant :

Classe d'encapsulation de message :

[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;
    }
}

Classe d'acceptation de message :

[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;
    }
}

Classe de test et résultats de sortie :

[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

Utilisation de MultiListener :

Il vous suffit d'ajouter l'annotation @Subscribe à la méthode d'abonnement au message pour vous abonner à plusieurs messages. Le code est le suivant :

[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

Dead Event :

Si les messages envoyés par EventBus ne concernent pas les abonnés, on parle alors de Dead Event. L'exemple est le suivant

[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;  
    }  
}

Description : S'il n'y a aucun abonné au message qui écoute le message, EventBus enverra le message DeadEvent. À ce moment, nous pouvons enregistrer ce statut via le journal.

Héritage de l'événement :

Si l'auditeur A écoute l'événement A et que l'événement A a une sous-classe d'événement B, l'auditeur A recevra les messages d'événement A et B en même temps. L'exemple. est la suivante :

Classe Listener :

[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

Description : Dans cette méthode, on voit que le premier événement (nouvel entier (100)) est reçu par deux auditeurs, mais le second (new long(200l)) ne peut atteindre le NumberListener que sous forme d'entier - aucun événement n'est créé pour ce type. Vous pouvez utiliser cette fonctionnalité pour créer des auditeurs plus généraux qui écoutent un large éventail d'événements et des auditeurs plus détaillés qui écoutent des événements spéciaux spécifiques.

Une instance complète :

[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();
        }
    }
}

Instructions : Utilisez la commande telnet pour vous connecter : telnet 127.0.0.1 4444. Si vous vous connectez à plusieurs instances, vous verrez tous les messages envoyés en cours de transmission. Vers d'autres exemples

Ce qui précède est le contenu de Java-Class Library-Guava-EventBus Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !