求openfire源码解读

   如题、欢迎各种党。满意后结贴。

据说这二十分不给漠漠的话，lz会倒霉

1. Openfire和MINA
   
2. 看了几天的openfire，网上的资料太少了，只有一个国外的网站不错，http://www.igniterealtime.org/ ，其他的只能自己摸索了。
   
3. openfire启动：
   
4. ServerStarter
   
5. 会加载 org.jivesoftware.openfire.XMPPServer
   
6. 在XMPPServer会加载一系列模块
   
7. 其中的ConnectionManagerImpl 是连接模块
   
8. // Load this module always last since we don't want to start listening for clients  
   
9.       // before the rest of the modules have been started        loadModule(ConnectionManagerImpl.class.getName());
   
10. ConnectionManagerImpl 会启动一系列的监听。
    
11. 其中的createClientListeners和startClientListeners是我比较关心的，先看看在这里面openfire都做了什么！
    
12. private void createClientListeners() {      
    
13.   // Start clients plain socket unless it's been disabled.     
    
14.     if (isClientListenerEnabled()) {           
    
15. // Create SocketAcceptor with correct number of processors         
    
16.    socketAcceptor = buildSocketAcceptor();      
    
17.       // Customize Executor that will be used by processors to process incoming stanzas        
    
18.      ExecutorThreadModel threadModel = ExecutorThreadModel.getInstance("client" );        
    
19.     int eventThreads = JiveGlobals.getIntProperty("xmpp.client.processing.threads" , 16);      
    
20.       ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor)threadModel.getExecutor();            eventExecutor.setCorePoolSize(eventThreads + 1);         
    
21.    eventExecutor.setMaximumPoolSize(eventThreads + 1);         
    
22.   eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS );           
    
23. socketAcceptor .getDefaultConfig().setThreadModel(threadModel);            // Add the XMPP codec filter             socketAcceptor .getFilterChain().addFirst("xmpp" , new ProtocolCodecFilter(new XMPPCodecFactory()));      
    
24.      // Kill sessions whose outgoing queues keep growing and fail to send traffic            
    
25. socketAcceptor .getFilterChain().addAfter("xmpp" , "outCap ", new StalledSessionsFilter());        }    }
    
26. 对了这里就是和用的mina框架去做联网处理,首先设置mina框架的线程池，然后把由XMPPCodecFactory做为 ProtocolCodecFilter的chain添加到FilterChain中！
    
27. 然后
    
28. private void startClientListeners(String localIPAddress) {   
    
29.     // Start clients plain socket unless it's been disabled.      
    
30.   if (isClientListenerEnabled()) {         
    
31.    int port = getClientListenerPort();        
    
32.     try {                // Listen on a specific network interface if it has been set.         
    
33.       String interfaceName = JiveGlobals.getXMLProperty("network.interface");           
    
34.      InetAddress bindInterface = nu``ll;              
    
35.   if (interfaceName != null) {                  
    
36. if (interfaceName.trim().length() > 0) {                  
    
37.       bindInterface = InetAddress.getByName(interfaceName);              
    
38.       }                }               
    
39. // Start accepting connections            
    
40.     socketAcceptor.bind(new InetSocketAddress(bindInterface, port), new ClientConnectionHandler(serverName));                ports.add(new ServerPort(port, serverName, localIPAddress, false, null, ServerPort.Type.client));      
    
41.          List<String> params = new ArrayList<String>();            
    
42.     params.add(Integer.toString(port));           
    
43.      Log.info(LocaleUtils.getLocalizedString("startup.plain", params));         
    
44.    } catch (Exception e) {            
    
45.     System.err.println("Error starting XMPP listener on port " + port + ": " +  e.getMessage());  
    
46. Log.error(LocaleUtils.getLocalizedString("admin.error.socket-setup"), e);   
    
47.        }        }    }
    
48.   socketAcceptor.bind(new InetSocketAddress(bindInterface, port), new ClientConnectionHandler(serverName));
    
49. 将ClientConnectionHandler作为数据处理
    
50. 服务器去监听5222端口去了，mina真方便！
    
51. 关于MINA框架可以去网上找找资料，这里就不说了。
    
52.   这里要说下MINA中的IoHandler这个接口，IoHandler是最终面对用户的接口，看下这个接口中的方法：
    
53. 
    
54. public interface IoHandler {   
    
55. /**     * Invoked from an I/O processor thread when a new connection has been created.   
    
56. * Because this method is supposed to be called from the same thread that   
    
57. * handles I/O of multiple sessions, please implement this method to perform   
    
58. * tasks that consumes minimal amount of time such as socket parameter   
    
59. * and user-defined session attribute initialization.   
    
60. */   
    
61. void sessionCreated(IoSession session) throws Exception;   
    
62. /**
    
63. * Invoked when a connection has been opened.  This method is invoked after     
    
64. * {@link #sessionCreated(IoSession)}.  The biggest difference from     
    
65. * {@link #sessionCreated(IoSession)} is that it's invoked from other thread     
    
66. * than an I/O processor thread once thread model is configured properly.     
    
67. */     
    
68. void sessionOpened(IoSession session) throws Exception;   
    
69. /**
    
70. * Invoked when a connection is closed.     
    
71. */     void sessionClosed(IoSession session) throws Exception;   
    
72. /**
    
73. * Invoked with the related {@link IdleStatus} when a connection becomes idle.     
    
74. * This method is not invoked if the transport type is UDP; it's a known bug,     
    
75. * and will be fixed in 2.0.     
    
76. */
    
77. void sessionIdle(IoSession session, IdleStatus status) throws Exception;   
    
78. /**
    
79. * Invoked when any exception is thrown by user {@link IoHandler}     
    
80. * implementation or by MINA.  If <code>cause</code> is an instance of     
    
81. * {@link IOException}, MINA will close the connection automatically.     
    
82. */   
    
83. void exceptionCaught(IoSession session, Throwable cause) throws Exception;   
    
84. /**
    
85. * Invoked when a message is received.     
    
86. */     
    
87. void messageReceived(IoSession session, Object message) throws Exception;   
    
88. /**
    
89. * Invoked when a message written by {@link IoSession#write(Object)} is     
    
90. * sent out.     
    
91. */     
    
92. void messageSent(IoSession session, Object message) throws Exception;}
    
93. 
    
94. 在mina中实现这个接口的类是IoHandlerAdapter 这个类
    
95. /**
    
96. * An abstract adapter class for {@link IoHandler}.  You can extend this
    
97. * class and selectively override required event handler methods only.  All
    
98. * methods do nothing by default.
    
99. *
    
100. * @author The Apache MINA Project (dev@mina.apache.org)
     
101. * @version $Rev: 671827 $, $Date: 2008-06-26 10:49:48 +0200 (jeu, 26 jun 2008) $
     
102. */
     
103. public class IoHandlerAdapter implements IoHandler {   
     
104. private final Logger logger = LoggerFactory.getLogger(getClass());
     
105.     public void sessionCreated(IoSession session) throws Exception {
     
106.         }   
     
107.         public void sessionOpened(IoSession session) throws Exception {
     
108.         }   
     
109.         public void sessionClosed(IoSession session) throws Exception {
     
110.     }   
     
111.         public void sessionIdle(IoSession session, IdleStatus status)throws Exception {
     
112.         }   
     
113.         public void exceptionCaught(IoSession session, Throwable cause)throws Exception {
     
114.         if (logger.isWarnEnabled()) {   
     
115.         logger.warn("EXCEPTION, please implement "+ getClass().getName()+ ".exceptionCaught() for proper handling:", cause);        
     
116.         }   
     
117.         }   
     
118.         public void messageReceived(IoSession session, Object message)throws Exception {  
     
119.         }   
     
120.         public void messageSent(IoSession session, Object message) throws Exception {   
     
121.         }
     
122. }
     
123. 
     
124. 接下来转到openfire，在openfire中ConnectionHandler类继承自IoHandlerAdapter，也就充当着最后要面对用户的角色。
     
125. public abstract class ConnectionHandler extends IoHandlerAdapter

复制代码

Openfire的socket网络连接包括：

<!--[if !supportLists]-->1.       <!--[endif]-->服务器和服务器之间的连接（监听在端口5269）

<!--[if !supportLists]-->2.       <!--[endif]-->外部组件和服务器之间的连接（监听在端口5275）

<!--[if !supportLists]-->3.       <!--[endif]-->多元(complex)连接（监听在端口5269）

<!--[if !supportLists]-->4.       <!--[endif]-->客户端和服务器的连接（监听在端口5222）

<!--[if !supportLists]-->5.       <!--[endif]-->和客户端通过TLS/SSL3.0和服务器的连接。（监听在端口5223）

这些连接都是通过ConnectionManager接口实现管理的，程序中对ConnectionManager接口的实现类是ConnectionManagerImpl，它是作为一个模块（Module）类加载到服务器中的。

下面分析的是客户端和服务器的连接。



在ConnectionManagerImpl中是通过调用startClientListeners方法来初始化和开始端口监听的。

<!--[endif]-->在startClientListeners方法使用的是Apache的Mina框架来实现网络连接的，Mina框架的模式如下：

IoFilter：

       IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理。它与Servlet中的filter机制十分相似。多个IoFilter存放在IoFilterChain中

       IoFilter能够实现以下功能：

              数据转换

              事件日志

              性能检测

       在Openfire中主要用filter这种机制来进行数据转换。

Protocol Codec Factory：

       Protocol Codec Factory提供了方便的Protocol支持，通过它的Encoder和Decoder，可以方便的扩展并支持各种基于Socket的网络协议，比如HTTP服务器、FTP服务器、Telnet服务器等等。

       要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可，在Openfire中实现ProtocolCodecFactory的类为XMPPCodecFactory。

IoHandler:

    MINA中，所有的业务逻辑都有实现了IoHandler的class完成    ，当事件发生时，将触发IoHandler中的方法:

           sessionCreated

sessionOpened

sessionClosed

sessionIdle

exceptionCaught

messageReceived

messageSent

       在Openfire中客户端和服务器连接的IoHandler实现类是ClientConnectionHandler，它是从ConnectionHandler中继承来的。

startClientListeners方法首先为Mian框架设置线程池，再将一个由XMPPCodecFactory作为Protocol Codec Factory的Filter放入到FilterChain中，然后绑定到端口5222，并将ClientConnectionHandler作为IoHandler对数据进行处理。完成这些步骤后Openfire就在5222等待客户端的连接。

客户端连接的处理过程：



当有客户端进行连接时根据Mina框架的模式首先调用的是sessionOpened方法。

       sessionOpened首先为此新连接构造了一个parser（XMLLightWeightParser），这个parser是专门给XMPPDecoder（是XMPPCodecFactory的解码器类）使用的，再创建一个Openfire的Connection类实例connection和一个StanzaHandler的实例。最后将以上的parser, connection和StanzaHandler的实例存放在Mina的session中，以便以后使用。

       当有数据发送过来时，Mina框架会调用messageReceived方法

       messageReceived首先从Mina的session中得到在sessionOpened方法中创建的StanzaHandler实例handler，然后从parsers中得到一个parser（如果parsers中没有可以创建一个新的实例）（注意这个parser和在sessionOpened方法中创建的parser不同，这个parser是用来处理Stanza的，而在sessionOpened方法中创建的parser是在filter中用来解码的，一句话说就是在sessionOpened方法中创建的parser是更低一层的parser）。最后将xml数据包交给StanzaHander的实例hander进行处理。

       StanzaHander的实例hander处理xml数据包的过程

       StanzaHander首先判断xml数据包的类型，.如果数据包以“<stream:stream”打头那么说明客户端刚刚连接，需要初始化通信（符合XMPP协议）Openfire首先为此客户端建立一个与客户端JID相关的ClientSession，而后与客户端交互协商例如是否使用SSL，是否使用压缩等问题。当协商完成之后进入正常通信阶段，则可以将xml数据包交给这个用户的ClientSession进行派送（deliever），经过派送数据包可以发送给PacketRouteImpl模块进行处理。

把分给我好了

给我更好