Guava学习笔记：EventBus

EventBus基本用法：

使用Guava之后, 如果要订阅消息, 就不用再继承指定的接口, 只需要在指定的方法上加上@Subscribe注解即可。代码如下：

消息封装类：

1public class TestEvent {    
2        private final int message;    
3        public TestEvent(int message) {        
4        this.message = message;
5        System.out.println("event message:"+message);
6    }    
7    public int getMessage() { 
8        return message;
9    }
10}

消息接受类：

1public class EventListener {
2    public int lastMessage = 0;
3
4    @Subscribe    
5    public void listen(TestEvent event) {
6        lastMessage = event.getMessage();
7        System.out.println("Message:"+lastMessage);
8    }    
9    public int getLastMessage() {      
10        return lastMessage;
11    }
12}

测试类及输出结果：

1public class TestEventBus {
2    @Test    
3    public void testReceiveEvent() throws Exception {
4
5        EventBus eventBus = new EventBus("test");
6        EventListener listener = new EventListener();
7
8        eventBus.register(listener);
9
10        eventBus.post(new TestEvent(200));
11        eventBus.post(new TestEvent(300));
12        eventBus.post(new TestEvent(400));
13
14        System.out.println("LastMessage:"+listener.getLastMessage());
15
16    }
17}
18//输出信息
19event message:200
20Message:200
21event message:300
22Message:300
23event message:400
24Message:400
25LastMessage:400

MultiListener的使用：

只需要在要订阅消息的方法上加上@Subscribe注解即可实现对多个消息的订阅，代码如下：

1public class MultipleListener {
2    public Integer lastInteger;  
3    public Long lastLong;  
4   
5    @Subscribe  
6    public void listenInteger(Integer event) {  
7        lastInteger = event; 
8        System.out.println("event Integer:"+lastInteger);
9    }  
10   
11    @Subscribe  
12    public void listenLong(Long event) {  
13        lastLong = event; 
14        System.out.println("event Long:"+lastLong);
15    }  
16   
17    public Integer getLastInteger() {  
18        return lastInteger;  
19    }  
20   
21    public Long getLastLong() {  
22        return lastLong;  
23    }  
24}

测试类：

1public class TestMultipleEvents {
2    @Test  
3    public void testMultipleEvents() throws Exception {  
4       
5        EventBus eventBus = new EventBus("test");  
6        MultipleListener multiListener = new MultipleListener();  
7       
8        eventBus.register(multiListener);  
9       
10        eventBus.post(new Integer(100));
11        eventBus.post(new Integer(200));  
12        eventBus.post(new Integer(300));  
13        eventBus.post(new Long(800)); 
14        eventBus.post(new Long(800990));  
15        eventBus.post(new Long(800882934));  
16       
17        System.out.println("LastInteger:"+multiListener.getLastInteger());
18        System.out.println("LastLong:"+multiListener.getLastLong());
19    }   
20}
21
22//输出信息
23event Integer:100
24event Integer:200
25event Integer:300
26event Long:800
27event Long:800990
28event Long:800882934
29LastInteger:300
30LastLong:800882934

Dead Event：

如果EventBus发送的消息都不是订阅者关心的称之为Dead Event。实例如下：

1public class DeadEventListener {
2    boolean notDelivered = false;  
3       
4    @Subscribe  
5    public void listen(DeadEvent event) {  
6        
7        notDelivered = true;  
8    }  
9   
10    public boolean isNotDelivered() {  
11        return notDelivered;  
12    }  
13}

测试类：

1public class TestDeadEventListeners {
2    @Test  
3    public void testDeadEventListeners() throws Exception {  
4       
5        EventBus eventBus = new EventBus("test");               
6        DeadEventListener deadEventListener = new DeadEventListener();  
7        eventBus.register(deadEventListener);  
8
9        eventBus.post(new TestEvent(200));         
10        eventBus.post(new TestEvent(300));        
11       
12        System.out.println("deadEvent:"+deadEventListener.isNotDelivered());
13
14    }  
15}
16
17//输出信息
18event message:200
19event message:300
20deadEvent:true

说明：如果没有消息订阅者监听消息， EventBus将发送DeadEvent消息，这时我们可以通过log的方式来记录这种状态。

Event的继承：

如果Listener A监听Event A, 而Event A有一个子类Event B, 此时Listener A将同时接收Event A和B消息，实例如下：

Listener 类：

1public class NumberListener {  
2       
3    private Number lastMessage;  
4   
5    @Subscribe  
6    public void listen(Number integer) {  
7        lastMessage = integer; 
8        System.out.println("Message:"+lastMessage);
9    }  
10   
11    public Number getLastMessage() {  
12        return lastMessage;  
13    }  
14}  
15
16public class IntegerListener {  
17       
18    private Integer lastMessage;  
19   
20    @Subscribe  
21    public void listen(Integer integer) {  
22        lastMessage = integer; 
23        System.out.println("Message:"+lastMessage);
24    }  
25   
26    public Integer getLastMessage() {  
27        return lastMessage;  
28    }  
29}

测试类：

1public class TestEventsFromSubclass {
2    @Test  
3    public void testEventsFromSubclass() throws Exception {  
4       
5        EventBus eventBus = new EventBus("test");  
6        IntegerListener integerListener = new IntegerListener();  
7        NumberListener numberListener = new NumberListener();  
8        eventBus.register(integerListener);  
9        eventBus.register(numberListener);  
10       
11        eventBus.post(new Integer(100));  
12       
13        System.out.println("integerListener message:"+integerListener.getLastMessage());
14        System.out.println("numberListener message:"+numberListener.getLastMessage());
15              
16        eventBus.post(new Long(200L));  
17       
18        System.out.println("integerListener message:"+integerListener.getLastMessage());
19        System.out.println("numberListener message:"+numberListener.getLastMessage());        
20    }  
21}
22
23//输出类
24Message:100
25Message:100
26integerListener message:100
27numberListener message:100
28Message:200
29integerListener message:100
30numberListener message:200

说明：在这个方法中,我们看到第一个事件(新的整数(100))是收到两个听众,但第二个(新长(200 l))只能到达NumberListener作为整数一不是创建这种类型的事件。可以使用此功能来创建更通用的监听器监听一个广泛的事件和更详细的具体的特殊的事件。

 一个综合实例:

1public class UserThread extends Thread {
2    private Socket connection;
3    private EventBus channel;
4    private BufferedReader in;
5    private PrintWriter out;
6
7    public UserThread(Socket connection, EventBus channel) {
8        this.connection = connection;
9        this.channel = channel;
10        try {
11            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
12            out = new PrintWriter(connection.getOutputStream(), true);
13        } catch (IOException e) {
14            e.printStackTrace();
15            System.exit(1);
16        }
17    }
18
19    @Subscribe
20    public void recieveMessage(String message) {
21        if (out != null) {
22            out.println(message);
23            System.out.println("recieveMessage:"+message);
24        }
25    }
26
27    @Override
28    public void run() {
29        try {
30            String input;
31            while ((input = in.readLine()) != null) {
32                channel.post(input);
33            }
34        } catch (IOException e) {
35            e.printStackTrace();
36        }
37        
38        //reached eof
39        channel.unregister(this);
40        try {
41            connection.close();
42        } catch (IOException e) {
43            e.printStackTrace();
44        }
45        in = null;
46        out = null;
47    }
48}
49
50mport java.io.IOException;
51import java.net.ServerSocket;
52import java.net.Socket;
53
54import com.google.common.eventbus.EventBus;
55
56public class EventBusChat {
57    public static void main(String[] args) {
58        EventBus channel = new EventBus();
59        ServerSocket socket;
60        try {
61            socket = new ServerSocket(4444);
62            while (true) {
63                Socket connection = socket.accept();
64                UserThread newUser = new UserThread(connection, channel);
65                channel.register(newUser);
66                newUser.start();
67            }
68        } catch (IOException e) {
69            e.printStackTrace();
70        }
71    }
72}

说明：用telnet命令登录：telnet 127.0.0.1 4444 ，如果你连接多个实例你会看到任何消息发送被传送到其他实例。