smack 源码分析- PacketReader (android上实现长连接)【3】

比眉伴天荒 2022-08-08 05:30 163阅读 0赞

***smack 源码分析- PacketWriter (android上实现长连接)***  介绍完PacketWriter 之后, 接下来分析PacketReader.  PacketReader的作用主要用来接收云端推送的消息并解析然后调用相应的监听器完成相关的操作.

什么都别说, 先看代码:

**\[java\]** [view plain][] [copy][view plain]

1.  //构造函数
2.  **protected** PacketReader(**final** XMPPConnection connection) \{ 
3.  **this**.connection = connection; 
4.  **this**.init(); 
5.  \} 
6.  
7.  
8.  /\*\*
9.   \* Initializes the reader in order to be used. The reader is initialized
10.  \* during the first connection and when reconnecting due to an abruptly
11.  \* disconnection.
12.  \*/
13. **protected****void** init() \{ 
14.  done = **false**; 
15.  connectionID = **null**; 
16. 
17. //开辟一个线程, 解析收到的数据包
18.  readerThread = **new** Thread() \{ 
19. **public****void** run() \{ 
20.  parsePackets(**this**); 
21.  \} 
22.  \}; 
23.  readerThread.setName("Smack Packet Reader (" \+ connection.connectionCounterValue + ")"); 
24.  readerThread.setDaemon(**true**); 
25. 
26. // Create an executor to deliver incoming packets to listeners. We'll
27. // use a single
28. // thread with an unbounded queue.
29.  listenerExecutor = Executors.newSingleThreadExecutor(**new** ThreadFactory() \{ 
30. 
31. **public** Thread newThread(Runnable runnable) \{ 
32.  Thread thread = **new** Thread(runnable, "Smack Listener Processor ("
33.  \+ connection.connectionCounterValue + ")"); 
34.  thread.setDaemon(**true**); 
35. **return** thread; 
36.  \} 
37.  \}); 
38. 
39.  resetParser(); 
40.  \} 
41. 
42. 
43. 
44. 
45. /\*\*
46.  \* Parse top-level packets in order to process them further.
47.  \* 
48.  \* @param thread the thread that is being used by the reader to parse
49.  \* incoming packets.
50.  \*/
51. **private****void** parsePackets(Thread thread) \{ 
52. **try** \{ 
53. **int** eventType = parser.getEventType(); 
54. **do** \{ 
55. 
56. **if** (eventType == XmlPullParser.START\_TAG) \{ 
57. **if** (parser.getName().equals("message")) \{ 
58.  processPacket(PacketParserUtils.parseMessage(parser)); 
59.  \} **else****if** (parser.getName().equals("iq")) \{ 
60.  processPacket(PacketParserUtils.parseIQ(parser, connection)); 
61.  \} **else****if** (parser.getName().equals("presence")) \{ 
62.  processPacket(PacketParserUtils.parsePresence(parser)); 
63.  \}

构造函数和init()方法PacketWriter一样, 不多说了. 直接看parsePackets(). 在parsePackets()是直接调用processPacket()方法解析, 我们再来看processPacket()方法:

**\[java\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* Processes a packet after it's been fully parsed by looping through the
3.   \* installed packet collectors and listeners and letting them examine the
4.   \* packet to see if they are a match with the filter.
5.   \* 
6.   \* @param packet the packet to process.
7.   \*/
8.  **private****void** processPacket(Packet packet) \{ 
9.  **if** (packet == **null**) \{ 
10. **return**; 
11.  \} 
12. 
13. // Loop through all collectors and notify the appropriate ones.
14. **for** (PacketCollector collector : connection.getPacketCollectors()) \{ 
15.  collector.processPacket(packet); 
16.  \} 
17. 
18. // Deliver the incoming packet to listeners.
19.  listenerExecutor.submit(**new** ListenerNotification(packet)); 
20.  \}

在processPacket()的最后一行是通过ExecutorService类型的一个listenerExecutor实例执行一个线程ListenerNotification完成的. 接下来:

**\[java\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* A runnable to notify all listeners of a packet.
3.   \*/
4.  **private****class** ListenerNotification **implements** Runnable \{ 
5.  
6.  **private** Packet packet; 
7.  
8.  **public** ListenerNotification(Packet packet) \{ 
9.  **this**.packet = packet; 
10.  \} 
11. 
12. **public****void** run() \{ 
13. //循环读取注册了的监听器并通知处理packet
14. **for** (ListenerWrapper listenerWrapper : connection.recvListeners.values()) \{ 
15. 
16.  listenerWrapper.notifyListener(packet); 
17.  \} 
18.  \} 
19.  \}

在ListenerNotification的run方法中, 是循环读取connection.recvListeners.values()获取ListenerWrapper  
.

那么ListenerWrapper 是什么呢? 我们首先来看这里connection.recvListeners.values(), 这connection实际上

是一个XMPPConnection的一个实例, 而XMPPConnection继承了Connection, recvListeners实际上是Connection

的一个成员变量. 然后再来看ListenerWrapper类:

**\[java\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* A wrapper class to associate a packet filter with a listener.
3.   \*
4.   \*/
5.  **protected****static****class** ListenerWrapper \{ 
6.  
7.  **private** PacketListener packetListener; 
8.  
9.  **private** PacketFilter packetFilter; 
10. 
11. /\*\*
12.  \* Create a class which associates a packet filter with a listener.
13.  \* 
14.  \* @param packetListener the packet listener.
15.  \* @param packetFilter the associated filter or null if it listen for
16.  \* all packets.
17.  \*/
18. **public** ListenerWrapper(PacketListener packetListener, PacketFilter packetFilter) \{ 
19. **this**.packetListener = packetListener; 
20. **this**.packetFilter = packetFilter; 
21.  \} 
22. 
23. /\*\*
24.  \* Notify and process the packet listener if the filter matches the
25.  \* packet. 
26.  \* @param packet the packet which was sent or received.
27.  \*/
28. **public****void** notifyListener(Packet packet) \{ 
29. **if** (packetFilter == **null** || packetFilter.accept(packet)) \{ 
30.  packetListener.processPacket(packet); 
31.  \} 
32.  \} 
33.  \}

ListenerWrapper类实际上是一个包装类, 该类的作用是将packetListener  
和packetFilter关联在一起. 那么

packetListener 和packetFilter分别是什么嗯, 查看smack帮助文档可知:

Smack提供灵活的框架来通过两种构造处理收到的 packet：

*  org.jivesoftware.smack.PacketCollector —— 一个让您同步等待新packet的类。
 *  org.jivesoftware.smack.PacketListener —— 一个异步通知您引入的packet的接口。

packet监听器用于事件样式的编程，而packet收集器有一个可以做轮询和阻塞操作的packet的结果队列。 所以，当您想对一个有可能随时到来的packet采取一些操作时，使用packet监听器；而当您想等待一个特别的packet到来时，使用packet收集器。您可以使用XMPPConnection实例创建packet收集器和监听器。

PacketFilter 接口决定哪个特别的将会被传递到PacketCollector或PacketListener。filter package包中有许多预定义的过滤器。

packetListener 是一个能够处理随时可能到了的packet监听器,packetFilter能够判断packet是否由该packetListener处理

是的话则调用processPacket()方法处理packet. 至此整个过程处理完成

[view plain]: http://blog.csdn.net/wqhjfree/article/details/7194428#