Terry Zou
Terry Zou

androidpn(本文服务器为tomcat)

androidpn(本文服务器为tomcat)

-------------------------------------------------- (一) androidpn-server服务器端启动的理解和分析-----------------------------------------------

    在Androidpn的底层主要采用的两大框架mina和openfire两大框架，其中mina主要为底层数据传输的Socket框架。下面简单的介绍一下Socket框架
    Apache Mina Server 是一个网络通信应用框架，也就是说，它主要是对基于TCP/IP、UDP/IP协议栈的通信框架(也可以提供JAVA 对象的序列化服务、虚拟机管道通信服务等),Mina 同时提供了网络通信的Server 端、Client 端的封装，无论是哪端，Mina 在整个网通通信结构中都处于如下的位置：
                                                                    
    


可见Mina 的API 将真正的网络通信与我们的应用程序隔离开来，你只需要关心你要发送、接收的数据以及你的业务逻辑即可。同样的，无论是哪端，Mina 的执行流程如下所示：
androidpn(本文服务器为tomcat)_第1张图片
(1). IoService：这个接口在一个线程上负责套接字的建立，拥有自己的Selector，监听是否有连接被建立。
(2). IoProcessor：这个接口在另一个线程上负责检查是否有数据在通道上读写，也就是说它也拥有自己的Selector，这是与我们使用JAVA NIO 编码时的一个不同之处，通常在JAVA NIO 编码中，我们都是使用一个Selector，也就是不区分IoService与IoProcessor 两个功能接口。另外，IoProcessor 负责调用注册在IoService 上的过滤器，并在过滤器链之后调用IoHandler。
 (3). IoFilter：这个接口定义一组拦截器，这些拦截器可以包括日志输出、黑名单过滤、数据的编码（write 方向）与解码（read 方向）等功能，其中数据的encode 与decode是最为重要的、也是你在使用Mina 时最主要关注的地方。
 (4). IoHandler：这个接口负责编写业务逻辑，也就是接收、发送数据的地方。


 通过Mina的原理我们研究androidpn的运行流程不能看出，如下：


androidpn-server执行过程如下：

1.spring初始化并启动过程，调用NioSocketAcceptor。

2.NioSocketAcceptor开始执行调用IoProcessor.

3.IoProcessor开始调用FilterChain。FilterChain调用相关的IoFilter的。其中ProtocolCodecFilter的过滤器调用了org.androidpn.server.xmpp.codec.XmppCodecFactory进行编码。

4.XmppIoHandler实现自IoHanlder并调用通过openfire 的XMLLightweightParser解析相关的业务逻辑。

5.根据解析的信息调用xmpp并处理相关信息。

-------------------------------------------------- (二) androidpn-server服务器端几个类的说明-----------------------------------------------

AndroidPN(Android Push Notification) 是一个基于 XMPP 协议的 Java 开源推送通知实现，它包含了完整的客户端和服务端。

AndroidPN基于Openfire下的一些开源项目构建。

AndroidPN服务器包含两个部分，

      一个是侦听在5222端口上的XMPP服务，负责与客户端的XMPPConnection类进行通信，作用是用户注册和身份认证，并发送推送通知消息。

      另外一部分是Web服务器，采用一个轻量级的HTTP服务器，负责接收用户的Web请求。

最上层包含四个组成部分，分别是SessionManager，Auth Manager，PresenceManager以及Notification Manager。

        SessionManager负责管理客户端与服务器之间的会话。

        Auth Manager负责客户端用户认证管理。

        Presence Manager负责管理客户端用户的登录状态。

        NotificationManager负责实现服务器向客户端推送消息功能。

IQHandler消息处理器的类：

     IQHandler：消息处理器抽象类。

     IQAuthHandler：权限协议的消息处理类，消息的类型为：jabber:iq:auth

     IQRegisterHandler：用户注册的消息处理类，消息类型为： jabber:iq:register

     IQRosterHandler：用户消息交互类，消息类型为：jabber:iq:roster

     PresenceUpdateHandler：用户状态展现变化处理类。内部调用，不具有类型。

NotificationManager源代码：
Java代码  收藏代码
  1. public class NotificationManager {
  2.  
  3.     private static final String NOTIFICATION_NAMESPACE = "androidpn:iq:notification"; 
  4.  
  5.     private final Log log = LogFactory.getLog(getClass()); 
  6.  
  7.     private SessionManager sessionManager; 
  8.  
  9.     /**
  10.      * Constructor.
  11.      */ 
  12.     public NotificationManager() { 
  13.         sessionManager = SessionManager.getInstance(); 
  14.     } 
  15.  
  16.     /**
  17.      * Broadcasts a newly created notification message to all connected users.
  18.      *
  19.      * @param apiKey the API key
  20.      * @param title the title
  21.      * @param message the message details
  22.      * @param uri the uri
  23.      */ 
  24.     public void sendBroadcast(String apiKey, String title, String message, 
  25.             String uri) { 
  26.         log.debug("sendBroadcast()..."); 
  27.         IQ notificationIQ = createNotificationIQ(apiKey, title, message, uri); 
  28.         for (ClientSession session : sessionManager.getSessions()) { 
  29.             if (session.getPresence().isAvailable()) { 
  30.                 notificationIQ.setTo(session.getAddress()); 
  31.                 session.deliver(notificationIQ); 
  32.             } 
  33.         } 
  34.     } 
  35.  
  36.     /**
  37.      * Sends a newly created notification message to the specific user.
  38.      *
  39.      * @param apiKey the API key
  40.      * @param title the title
  41.      * @param message the message details
  42.      * @param uri the uri
  43.      */ 
  44.     public void sendNotifcationToUser(String apiKey, String username, 
  45.             String title, String message, String uri) { 
  46.         log.debug("sendNotifcationToUser()..."); 
  47.         IQ notificationIQ = createNotificationIQ(apiKey, title, message, uri); 
  48.         ClientSession session = sessionManager.getSession(username); 
  49.         if (session != null) { 
  50.             if (session.getPresence().isAvailable()) { 
  51.                 notificationIQ.setTo(session.getAddress()); 
  52.                 session.deliver(notificationIQ); 
  53.             } 
  54.         } 
  55.     } 
  56.  
  57.     /**
  58.      * Creates a new notification IQ and returns it.
  59.      */ 
  60.     private IQ createNotificationIQ(String apiKey, String title, 
  61.             String message, String uri) { 
  62.         Random random = new Random(); 
  63.         String id = Integer.toHexString(random.nextInt()); 
  64.         // String id = String.valueOf(System.currentTimeMillis()); 
  65.  
  66.         Element notification = DocumentHelper.createElement(QName.get( 
  67.                 "notification", NOTIFICATION_NAMESPACE)); 
  68.         notification.addElement("id").setText(id); 
  69.         notification.addElement("apiKey").setText(apiKey); 
  70.         notification.addElement("title").setText(title); 
  71.         notification.addElement("message").setText(message); 
  72.         notification.addElement("uri").setText(uri); 
  73.  
  74.         IQ iq = new IQ(); 
  75.         iq.setType(IQ.Type.set); 
  76.         iq.setChildElement(notification); 
  77.  
  78.         return iq; 
  79.     } 
  80. } 

其中：

    发布订阅式的发送消息调用方法：

    /**
     * Broadcasts a newly created notification message to all connected users.
     *
     * @param apiKey the API key
     * @param title the title
     * @param message the message details
     * @param uri the uri
     */
    public void sendBroadcast(String apiKey, String title, String message,
            String uri)；

点对点的发送消息调用方法：

    /**
     * Sends a newly created notification message to the specific user.
     *
     * @param apiKey the API key
     * @param title the title
     * @param message the message details
     * @param uri the uri
     */
    public void sendNotifcationToUser(String apiKey, String username,
            String title, String message, String uri)；

创建发送消息的方法：

    /**
     * Creates a new notification IQ and returns it.
     */
    private IQ createNotificationIQ(String apiKey, String title,
            String message, String uri)；


-------------------------------------------------- (三) androidpn-client客户端几个类的说明-----------------------------------------------

在androidpn的客户端几个重要的类：

                ServiceManager：管理消息服务和加载相关的配置。

                ConnectivityReceiver：处理网络状态的广播。

                NotificationReceiver：处理服务端发送的推送消息。

                NotificationService：后台服务用户响应服务端的消息。需要在AndroidManifest.xml.注册。

                NotificationSettingsActivity：推送信息设置页面。

                PersistentConnectionListener：监控连接关闭和重连事件的监听。

                PhoneStateChangeListener：监听手机状态的事件监听类。

                ReconnectionThread：重连的线程类。

                Notifier：客户端发送通知的类。

                NotificationIQ：消息的数据包。


ServiceManager中获取属性信息的方法：
Java代码  收藏代码
  1. private Properties loadProperties() { 
  2.     //        InputStream in = null; 
  3.     //        Properties props = null; 
  4.     //        try { 
  5.     //            in = getClass().getResourceAsStream( 
  6.     //                    "/org/androidpn/client/client.properties"); 
  7.     //            if (in != null) { 
  8.     //                props = new Properties(); 
  9.     //                props.load(in); 
  10.     //            } else { 
  11.     //                Log.e(LOGTAG, "Could not find the properties file."); 
  12.     //            } 
  13.     //        } catch (IOException e) { 
  14.     //            Log.e(LOGTAG, "Could not find the properties file.", e); 
  15.     //        } finally { 
  16.     //            if (in != null) 
  17.     //                try { 
  18.     //                    in.close(); 
  19.     //                } catch (Throwable ignore) { 
  20.     //                } 
  21.     //        } 
  22.     //        return props; 
  23.  
  24.     Properties props = new Properties(); 
  25.     try { 
  26.         int id = context.getResources().getIdentifier("androidpn", "raw", 
  27.                 context.getPackageName()); 
  28.         props.load(context.getResources().openRawResource(id)); 
  29.     } catch (Exception e) { 
  30.         Log.e(LOGTAG, "Could not find the properties file.", e); 
  31.         // e.printStackTrace(); 
  32.     } 
  33.     return props; 
  34. } 

SharedPreferences的使用：

Java代码  收藏代码
  1. sharedPrefs = context.getSharedPreferences( 
  2.         Constants.SHARED_PREFERENCE_NAME, Context.MODE_PRIVATE); 
  3. Editor editor = sharedPrefs.edit(); 
  4. editor.putString(Constants.API_KEY, apiKey); 
  5. editor.putString(Constants.VERSION, version); 
  6. editor.putString(Constants.XMPP_HOST, xmppHost); 
  7. editor.putInt(Constants.XMPP_PORT, Integer.parseInt(xmppPort)); 
  8. editor.putString(Constants.CALLBACK_ACTIVITY_PACKAGE_NAME, 
  9.         callbackActivityPackageName); 
  10. editor.putString(Constants.CALLBACK_ACTIVITY_CLASS_NAME, 
  11.         callbackActivityClassName); 
  12. editor.commit(); 

获取手机的设备id：

Java代码  收藏代码
  1. TelephonyManager       telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
  2.         // wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); 
  3.         // connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 
  4.  
  5.         // Get deviceId 
  6.         deviceId = telephonyManager.getDeviceId(); 

Notifier中发送通知的方法：

Java代码  收藏代码
  1. // Notification 
  2. Notification notification = new Notification(); 
  3. notification.icon = getNotificationIcon(); 
  4. notification.defaults = Notification.DEFAULT_LIGHTS; 
  5. if (isNotificationSoundEnabled()) { 
  6.     notification.defaults |= Notification.DEFAULT_SOUND; 
  7. } 
  8. if (isNotificationVibrateEnabled()) { 
  9.     notification.defaults |= Notification.DEFAULT_VIBRATE; 
  10. } 
  11. notification.flags |= Notification.FLAG_AUTO_CANCEL; 
  12. notification.when = System.currentTimeMillis(); 
  13. notification.tickerText = message; 
  14.  
  15. //            Intent intent; 
  16. //            if (uri != null 
  17. //                    && uri.length() > 0 
  18. //                    && (uri.startsWith("http:") || uri.startsWith("https:") 
  19. //                            || uri.startsWith("tel:") || uri.startsWith("geo:"))) { 
  20. //                intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri)); 
  21. //            } else { 
  22. //                String callbackActivityPackageName = sharedPrefs.getString( 
  23. //                        Constants.CALLBACK_ACTIVITY_PACKAGE_NAME, ""); 
  24. //                String callbackActivityClassName = sharedPrefs.getString( 
  25. //                        Constants.CALLBACK_ACTIVITY_CLASS_NAME, ""); 
  26. //                intent = new Intent().setClassName(callbackActivityPackageName, 
  27. //                        callbackActivityClassName); 
  28. //                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
  29. //                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); 
  30. //            } 
  31.  
  32. Intent intent = new Intent(context, 
  33.         NotificationDetailsActivity.class); 
  34. intent.putExtra(Constants.NOTIFICATION_ID, notificationId); 
  35. intent.putExtra(Constants.NOTIFICATION_API_KEY, apiKey); 
  36. intent.putExtra(Constants.NOTIFICATION_TITLE, title); 
  37. intent.putExtra(Constants.NOTIFICATION_MESSAGE, message); 
  38. intent.putExtra(Constants.NOTIFICATION_URI, uri); 
  39. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
  40. intent.setFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); 
  41. intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY); 
  42. intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); 
  43. intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
  44.  
  45. PendingIntent contentIntent = PendingIntent.getActivity(context, 0, 
  46.         intent, PendingIntent.FLAG_UPDATE_CURRENT); 
  47.  
  48. notification.setLatestEventInfo(context, title, message, 
  49.         contentIntent); 
  50. notificationManager.notify(random.nextInt(), notification); 

androidpn用户名和密码来源：

XmppManager的注册任务（RegisterTask）中run方法：

            if (!xmppManager.isRegistered()) {
                final String newUsername = newRandomUUID();
                final String newPassword = newRandomUUID();

                Registration registration = new Registration();

                PacketFilter packetFilter = new AndFilter(new PacketIDFilter(
                        registration.getPacketID()), new PacketTypeFilter(
                        IQ.class));

-------------------------------------------------- (四) androidpn-client常见的bug-----------------------------------------------

Androidpn用的比较广泛，但Androidpn还不成熟，存在一些BUG。
目前比较困扰大家的BUG主要有：
1.当服务端连续发送多条通知时，客户端都是显示同一条通知内容。
2.服务端重启，客户端也需要重启建立连接。

最后还有一个问题当我们服务器端重启的时候,客户端就无法在连接到服务器了,除非把android后台的服务

关掉,然后重启才行.在XmmpManager中加上如下红色代码就可:

    private void addTask(Runnable runnable) {
        Log.d(LOGTAG, "addTask(runnable)...");
        taskTracker.increase();
        synchronized (taskList) {
            if (taskList.isEmpty() && !running) {
                running = true;
                futureTask = taskSubmitter.submit(runnable);
                if (futureTask == null) {
                    taskTracker.decrease();
                }
            } else {
            //解决服务器端重启后,客户端不能成功连接androidpn服务器
            runTask();
           
                taskList.add(runnable);
            }
        }
        Log.d(LOGTAG, "addTask(runnable)... done");
    }



      由于没有经验，有BUG也只能继续GOOGLE，最终发现 http://jclick.iteye.com/blog/1289383 这个TOMCAT版本比较符合项目的需求。在此还是要感谢这位大神，真是造福广大人民群众。在这个版本中主要修复了第二个问题，相信很多朋友都已经看过了这篇BLOG ，但是大神在回复中写错了类名XMPPWriter，所有导致大家并不知道问题是怎么解决的, 其实是修改了org.androidpn.client.XmppManager,org.jivesoftware.smack.PacketWriter（smack源码）这2个类，这个将他2个版本的代码比较一下就可以看出来了，废话了那么多，在此说一下大神解决此问题的方法。代码在
http://phonepush.sinaapp.com/forum.php?mod=viewthread&tid=5&extra=page%3D1 篇帖子中已经贴出来了。在org.androidpn.client.XmppManager的LoginTask方法中加了一行代码getConnection().startKeepAliveThread(xmppManager);跟踪进去发现是开启了一个线程发送心跳，当发送失败时捕获异常，客户端每隔一段时间进行重连。
org.jivesoftware.smack.PacketWriter的run方法
Java代码
  1. catch (SocketException e) {
  2. Log.e("PacketReader", e.toString());
  3. connection.disconnect();
  4. xmppManager.startReconnectionThread();
  5. } catch (IOException e) {
  6. e.printStackTrace();
  7. }
这样就达到了当与服务端失去连接时，客户端能够进行重新连接的效果。后来群里有朋友说在LoginTask方法中加入
getConnection().startKeepAliveThread(xmppManager); 编译就报错，那是因为他用的是第一个版本 ，所有请先下载第二个版本，第二个版本带大神精简过smack源码。 其实心跳机制在官方的asmack中就已经存在，并且在建立XmppConnection的时候就已经启动，但是遗憾的是asmack的开发人员并没有进行异常之后的重连

Java代码
  1. catch (Exception e) {
  2. // Do nothing
  3. }
所有才出现这个困扰大家的问题。

       然后是第二个问题，我们刚才下载的这个版本并没有处理这个BUG，其实很简单，群里的高手经解决，就是将org.androidpn.client.Notifier中的notify方法的

  1. PendingIntent contentIntent = PendingIntent.getActivity(context, 0,intent, PendingIntent.FLAG_UPDATE_CURRENT);
复制代码
改成
  1. PendingIntent contentIntent = PendingIntent.getActivity(context, random.nextInt(),
  2.                     intent, PendingIntent.FLAG_UPDATE_CURRENT);
复制代码

       好了，这2个问题基本上就解决了，本人也只是在此将前辈们的经验写一下，方便大家集中修正BUG。其实在碰到框架BUG时，看看框架的源码还是有帮助，可能会有很多不解，但我觉得多多少少还是能看出一点东西来。以后大家碰到什么问题也可以提出来，大家一起研究讨论，集思广益，总比一个人瞎想的强，有什么好的想法也可以拿出来分享。再次谢谢各位前辈。


在网上androidpn上的BUG基本都解决了，也多亏牛人们顶力相助，灰常感谢啊。在这里要说的问题是手机锁屏后，客户端心跳包不再发送了。由于android也接触不是很久，对一些系统的机制不太了解，经过多次测试与分析，才发现了是由于锁屏后CPU处于睡眠状态，线程都被挂起，所以在服务器端设定的闲置时间内收不到心跳包，强制移除用户下线。

      OK问题已经找到了就好办多了，既然是被挂起了我们就只有让心跳一直在跑了，不啰嗦了。既而在网上有找到两种方法，第一种是让系统不睡眠，第二种则是使用AlarmManager来做我们的操作，在这里我是用的第二种方案来解决我们的问题的。但这样可能有点费电，暂时只能这样解决了了，不知道大家有木有更好点的解决办法能说出来大家一起研究研究。

1).

[java] view plain copy print ?
  1. //申请设备电源锁  
  2.     public void acquireWakeLock() 
  3.     { 
  4.         if (null == mWakeLock) 
  5.         { 
  6.             PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE); 
  7.             mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "NotificationService"); 
  8.             if (null != mWakeLock) 
  9.             { 
  10.                 mWakeLock.acquire(); 
  11.             } 
  12.         } 
  13.     } 
  14.      
  15.     //释放设备电源锁  
  16.     public void releaseWakeLock() 
  17.     { 
  18.         if (null != mWakeLock) 
  19.         { 
  20.             mWakeLock.release(); 
  21.             mWakeLock = null; 
  22.         } 
  23.     } 
Java代码  收藏代码
  1. //申请设备电源锁 
  2.     public void acquireWakeLock() 
  3.     { 
  4.         if (null == mWakeLock) 
  5.         { 
  6.             PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE); 
  7.             mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "NotificationService"); 
  8.             if (null != mWakeLock) 
  9.             { 
  10.                 mWakeLock.acquire(); 
  11.             } 
  12.         } 
  13.     } 
  14.      
  15.     //释放设备电源锁 
  16.     public void releaseWakeLock() 
  17.     { 
  18.         if (null != mWakeLock) 
  19.         { 
  20.             mWakeLock.release(); 
  21.             mWakeLock = null; 
  22.         } 
  23.     } 


2).

 

Java代码 收藏代码
  1. public void registerAlarmManager(){
  2. am = (AlarmManager)getSystemService(ALARM_SERVICE);
  3. pi = PendingIntent.getBroadcast(this, 0, new Intent(this, HeartActionBroadCast.class), Intent.FLAG_ACTIVITY_NEW_TASK);
  4. long now = System.currentTimeMillis();
  5. am.setInexactRepeating(AlarmManager.RTC_WAKEUP, now, 20000, pi);
  6. }

 


-------------------------------------------------- (五) androidpn-server编码和解码解析的过程-----------------------------------------------

在许多网络应用中可能针对传输的数据进行加密操作，接收到数据之后进行解码操作。

在mina中提供许多加密和解密的解析方式：

1.带一定前缀的字符串的解析方式。

2.序列化对象的字符串解析方式。

3.分隔符方式的字符串解析方式。

在mina中提供相关的filterchain支持相关的操作。

Mina的源代码如下：

Java代码  收藏代码
  1. package org.apache.mina.filter.codec; 
  2.  
  3. import org.apache.mina.core.session.IoSession; 
  4.  
  5. /**
  6. * Provides {@link ProtocolEncoder} and {@link ProtocolDecoder} which translates
  7. * binary or protocol specific data into message object and vice versa.
  8. * <p>
  9. * Please refer to
  10. * <a href="../../../../../xref-examples/org/apache/mina/examples/reverser/ReverseProtocolProvider.html"><code>ReverserProtocolProvider</code></a>
  11. * example.
  12. *
  13. * @author <a href="http://mina.apache.org">Apache MINA Project</a>
  14. */ 
  15. public interface ProtocolCodecFactory { 
  16.     /**
  17.      * Returns a new (or reusable) instance of {@link ProtocolEncoder} which
  18.      * encodes message objects into binary or protocol-specific data.
  19.      */ 
  20.     ProtocolEncoder getEncoder(IoSession session) throws Exception; 
  21.  
  22.     /**
  23.      * Returns a new (or reusable) instance of {@link ProtocolDecoder} which
  24.      * decodes binary or protocol-specific data into message objects.
  25.      */ 
  26.     ProtocolDecoder getDecoder(IoSession session) throws Exception; 
  27. } 

加密处理类：

Java代码  收藏代码
  1. package org.apache.mina.filter.codec; 
  2.  
  3. import org.apache.mina.core.buffer.IoBuffer; 
  4. import org.apache.mina.core.session.IoSession; 
  5.  
  6. /**
  7. * Encodes higher-level message objects into binary or protocol-specific data.
  8. * MINA invokes {@link #encode(IoSession, Object, ProtocolEncoderOutput)}
  9. * method with message which is popped from the session write queue, and then
  10. * the encoder implementation puts encoded messages (typically {@link IoBuffer}s)
  11. * into {@link ProtocolEncoderOutput} by calling {@link ProtocolEncoderOutput#write(Object)}.
  12. * <p>
  13. * Please refer to
  14. * <a href="../../../../../xref-examples/org/apache/mina/examples/reverser/TextLineEncoder.html"><code>TextLineEncoder</code></a>
  15. * example.
  16. *
  17. * @author <a href="http://mina.apache.org">Apache MINA Project</a>
  18. *
  19. * @see ProtocolEncoderException
  20. */ 
  21. public interface ProtocolEncoder { 
  22.  
  23.     /**
  24.      * Encodes higher-level message objects into binary or protocol-specific data.
  25.      * MINA invokes {@link #encode(IoSession, Object, ProtocolEncoderOutput)}
  26.      * method with message which is popped from the session write queue, and then
  27.      * the encoder implementation puts encoded messages (typically {@link IoBuffer}s)
  28.      * into {@link ProtocolEncoderOutput}.
  29.      *
  30.      * @throws Exception if the message violated protocol specification
  31.      */ 
  32.     void encode(IoSession session, Object message, ProtocolEncoderOutput out) 
  33.             throws Exception; 
  34.  
  35.     /**
  36.      * Releases all resources related with this encoder.
  37.      *
  38.      * @throws Exception if failed to dispose all resources
  39.      */ 
  40.     void dispose(IoSession session) throws Exception; 
  41. } 

解密类如下：

Java代码  收藏代码
  1. package org.apache.mina.filter.codec; 
  2.  
  3. import org.apache.mina.core.buffer.IoBuffer; 
  4. import org.apache.mina.core.session.IoSession; 
  5.  
  6. /**
  7. * Decodes binary or protocol-specific data into higher-level message objects.
  8. * MINA invokes {@link #decode(IoSession, IoBuffer, ProtocolDecoderOutput)}
  9. * method with read data, and then the decoder implementation puts decoded
  10. * messages into {@link ProtocolDecoderOutput} by calling
  11. * {@link ProtocolDecoderOutput#write(Object)}.
  12. * <p>
  13. * Please refer to
  14. * <a href="../../../../../xref-examples/org/apache/mina/examples/reverser/TextLineDecoder.html"><code>TextLineDecoder</code></a>
  15. * example.
  16. *
  17. * @author <a href="http://mina.apache.org">Apache MINA Project</a>
  18. *
  19. * @see ProtocolDecoderException
  20. */ 
  21. public interface ProtocolDecoder { 
  22.     /**
  23.      * Decodes binary or protocol-specific content into higher-level message objects.
  24.      * MINA invokes {@link #decode(IoSession, IoBuffer, ProtocolDecoderOutput)}
  25.      * method with read data, and then the decoder implementation puts decoded
  26.      * messages into {@link ProtocolDecoderOutput}.
  27.      *
  28.      * @throws Exception if the read data violated protocol specification
  29.      */ 
  30.     void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) 
  31.             throws Exception; 
  32.  
  33.     /**
  34.      * Invoked when the specified <tt>session</tt> is closed.  This method is useful
  35.      * when you deal with the protocol which doesn't specify the length of a message
  36.      * such as HTTP response without <tt>content-length</tt> header. Implement this
  37.      * method to process the remaining data that {@link #decode(IoSession, IoBuffer, ProtocolDecoderOutput)}
  38.      * method didn't process completely.
  39.      *
  40.      * @throws Exception if the read data violated protocol specification
  41.      */ 
  42.     void finishDecode(IoSession session, ProtocolDecoderOutput out) 
  43.             throws Exception; 
  44.  
  45.     /**
  46.      * Releases all resources related with this decoder.
  47.      *
  48.      * @throws Exception if failed to dispose all resources
  49.      */ 
  50.     void dispose(IoSession session) throws Exception; 
  51. } 

在androidpn中的没有采取任何加密方式，但是提供相关的类org.androidpn.server.xmpp.codec，如果需要可以针对传输的数据进行加密和解密工作。

Java代码  收藏代码
  1. package org.androidpn.server.xmpp.codec; 
  2.  
  3. import org.apache.mina.core.session.IoSession; 
  4. import org.apache.mina.filter.codec.ProtocolCodecFactory; 
  5. import org.apache.mina.filter.codec.ProtocolDecoder; 
  6. import org.apache.mina.filter.codec.ProtocolEncoder; 
  7.  
  8. /**
  9. * Factory class that specifies the encode and decoder to use for parsing XMPP stanzas.
  10. *
  11. * @author Sehwan Noh ([email protected])
  12. */ 
  13. public class XmppCodecFactory implements ProtocolCodecFactory { 
  14.  
  15.     private final XmppEncoder encoder; 
  16.  
  17.     private final XmppDecoder decoder; 
  18.  
  19.     /**
  20.      * Constructor.
  21.      */ 
  22.     public XmppCodecFactory() { 
  23.         encoder = new XmppEncoder(); 
  24.         decoder = new XmppDecoder(); 
  25.     } 
  26.  
  27.     /**
  28.      * Returns a new (or reusable) instance of ProtocolEncoder.
  29.      */ 
  30.     public ProtocolEncoder getEncoder(IoSession session) throws Exception { 
  31.         return encoder; 
  32.     } 
  33.  
  34.     /**
  35.      * Returns a new (or reusable) instance of ProtocolDecoder.
  36.      */ 
  37.     public ProtocolDecoder getDecoder(IoSession session) throws Exception { 
  38.         return decoder; 
  39.     } 
  40.  
  41. } 

androidpn的解密类：

Java代码  收藏代码
  1. package org.androidpn.server.xmpp.codec; 
  2.  
  3. import org.androidpn.server.xmpp.net.XmppIoHandler; 
  4. import org.apache.mina.core.buffer.IoBuffer; 
  5. import org.apache.mina.core.session.IoSession; 
  6. import org.apache.mina.filter.codec.CumulativeProtocolDecoder; 
  7. import org.apache.mina.filter.codec.ProtocolDecoderOutput; 
  8. import org.jivesoftware.openfire.nio.XMLLightweightParser; 
  9.  
  10. /**
  11. * Decoder class that parses ByteBuffers and generates XML stanzas.
  12. *
  13. * @author Sehwan Noh ([email protected])
  14. */ 
  15. public class XmppDecoder extends CumulativeProtocolDecoder { 
  16.  
  17.     // private final Log log = LogFactory.getLog(XmppDecoder.class); 
  18.  
  19.     @Override 
  20.     public boolean doDecode(IoSession session, IoBuffer in, 
  21.             ProtocolDecoderOutput out) throws Exception { 
  22.         // log.debug("doDecode(...)..."); 
  23.  
  24.         XMLLightweightParser parser = (XMLLightweightParser) session 
  25.                 .getAttribute(XmppIoHandler.XML_PARSER); 
  26.         parser.read(in); 
  27.  
  28.         if (parser.areThereMsgs()) { 
  29.             for (String stanza : parser.getMsgs()) { 
  30.                 out.write(stanza); 
  31.             } 
  32.         } 
  33.         return !in.hasRemaining(); 
  34.     } 
  35.  
  36. } 

androidpn的加密类：

Java代码  收藏代码
  1. package org.androidpn.server.xmpp.codec; 
  2.  
  3. import org.apache.mina.core.session.IoSession; 
  4. import org.apache.mina.filter.codec.ProtocolEncoder; 
  5. import org.apache.mina.filter.codec.ProtocolEncoderOutput; 
  6.  
  7. /**
  8. *  Encoder class that does nothing (to the already encoded data).
  9. *
  10. * @author Sehwan Noh ([email protected])
  11. */ 
  12. public class XmppEncoder implements ProtocolEncoder { 
  13.  
  14.     // private final Log log = LogFactory.getLog(XmppEncoder.class); 
  15.  
  16.     public void encode(IoSession session, Object message, 
  17.             ProtocolEncoderOutput out) throws Exception { 
  18.         // log.debug("encode()..."); 
  19.     } 
  20.  
  21.     public void dispose(IoSession session) throws Exception { 
  22.         // log.debug("dispose()..."); 
  23.     } 
  24.  
  25. } 

   最终将编码解析器转换为过滤器使用，具体配置如下：

Xml代码  收藏代码
  1. <bean class="org.apache.mina.filter.codec.ProtocolCodecFilter"> 
  2.     <constructor-arg> 
  3.         <bean class="org.androidpn.server.xmpp.codec.XmppCodecFactory" /> 
  4.     </constructor-arg> 
  5. </bean> 


-----------------(六)Androidpn-server的添加其他xmpp相关的协议（如查看好友列表等）--------------------------------

曾经有一个同学，在网上问我，如果想androidpn添加额外的xmpp协议的方法在怎么加呢？我当时很迷惑，后来经过一翻仔细研究androidpn发现，其实每一种处理xmpp协议方法，必须有一个Handler实现。具体可以参考org.androidpn.server.xmpp.handler中。

针对每一个Handler对应的xml拥有不同的命名空间，每一个命名空间在xmpp中都有定义，因为传输的xml的格式是一定的。

例如：

               IQAuthHandler：命名空间 String NAMESPACE = "jabber:iq:auth";

               IQRegisterHandler：命名空间 String NAMESPACE = "jabber:iq:register";

               IQRosterHandler：命名空间 String NAMESPACE = "jabber:iq:roster";

        同时我们从Handler的实现可以看到每一个handler最好实现对应IQHandler类，但是为辅助类型的Handler那么可以不用，例如androidpn的状态更新处理器类PresenceUpdateHandler，不必要发送相关的消息到客户端。

       所以如果要实现xmpp中如查看好友，用户分组等通信协议，那么你可能要实现相关的Handler并使用xmpp协议规定的相关的命名空间。

       在androidpn中主要的业务处理类XmppIoHandler可以看出最终消息解析之后分发到IQRouter中。IQRouter用于处理消息的响应的消息。

IQRouter的源代码如下：

Java代码  收藏代码
  1. package org.androidpn.server.xmpp.router; 
  2.  
  3. import java.util.ArrayList; 
  4. import java.util.List; 
  5. import java.util.Map; 
  6. import java.util.concurrent.ConcurrentHashMap; 
  7.  
  8. import org.androidpn.server.xmpp.handler.IQAuthHandler; 
  9. import org.androidpn.server.xmpp.handler.IQHandler; 
  10. import org.androidpn.server.xmpp.handler.IQRegisterHandler; 
  11. import org.androidpn.server.xmpp.handler.IQRosterHandler; 
  12. import org.androidpn.server.xmpp.session.ClientSession; 
  13. import org.androidpn.server.xmpp.session.Session; 
  14. import org.androidpn.server.xmpp.session.SessionManager; 
  15. import org.apache.commons.logging.Log; 
  16. import org.apache.commons.logging.LogFactory; 
  17. import org.dom4j.Element; 
  18. import org.xmpp.packet.IQ; 
  19. import org.xmpp.packet.JID; 
  20. import org.xmpp.packet.PacketError; 
  21.  
  22. /**
  23. * This class is to route IQ packets to their corresponding handler.
  24. *
  25. * @author Sehwan Noh ([email protected])
  26. */ 
  27. public class IQRouter { 
  28.  
  29.     private final Log log = LogFactory.getLog(getClass()); 
  30.  
  31.     private SessionManager sessionManager; 
  32.  
  33.     private List<IQHandler> iqHandlers = new ArrayList<IQHandler>(); 
  34.  
  35.     private Map<String, IQHandler> namespace2Handlers = new ConcurrentHashMap<String, IQHandler>(); 
  36.  
  37.     /**
  38.      * Constucts a packet router registering new IQ handlers.
  39.      */ 
  40.     public IQRouter() { 
  41.         sessionManager = SessionManager.getInstance(); 
  42.         iqHandlers.add(new IQAuthHandler()); 
  43.         iqHandlers.add(new IQRegisterHandler()); 
  44.         iqHandlers.add(new IQRosterHandler()); 
  45.     } 
  46.  
  47.     /**
  48.      * Routes the IQ packet based on its namespace.
  49.      *
  50.      * @param packet the packet to route
  51.      */ 
  52.     public void route(IQ packet) { 
  53.         if (packet == null) { 
  54.             throw new NullPointerException(); 
  55.         } 
  56.         JID sender = packet.getFrom(); 
  57.         ClientSession session = sessionManager.getSession(sender); 
  58.  
  59.         if (session == null 
  60.                 || session.getStatus() == Session.STATUS_AUTHENTICATED 
  61.                 || ("jabber:iq:auth".equals(packet.getChildElement() 
  62.                         .getNamespaceURI()) 
  63.                         || "jabber:iq:register".equals(packet.getChildElement() 
  64.                                 .getNamespaceURI()) || "urn:ietf:params:xml:ns:xmpp-bind" 
  65.                         .equals(packet.getChildElement().getNamespaceURI()))) { 
  66.             handle(packet); 
  67.         } else { 
  68.             IQ reply = IQ.createResultIQ(packet); 
  69.             reply.setChildElement(packet.getChildElement().createCopy()); 
  70.             reply.setError(PacketError.Condition.not_authorized); 
  71.             session.process(reply); 
  72.         } 
  73.     } 
  74.  
  75.     private void handle(IQ packet) { 
  76.         try { 
  77.             Element childElement = packet.getChildElement(); 
  78.             String namespace = null; 
  79.             if (childElement != null) { 
  80.                 namespace = childElement.getNamespaceURI(); 
  81.             } 
  82.             if (namespace == null) { 
  83.                 if (packet.getType() != IQ.Type.result 
  84.                         && packet.getType() != IQ.Type.error) { 
  85.                     log.warn("Unknown packet " + packet); 
  86.                 } 
  87.             } else { 
  88.                 IQHandler handler = getHandler(namespace); 
  89.                 if (handler == null) { 
  90.                     sendErrorPacket(packet, 
  91.                             PacketError.Condition.service_unavailable); 
  92.                 } else { 
  93.                     handler.process(packet); 
  94.                 } 
  95.             } 
  96.  
  97.         } catch (Exception e) { 
  98.             log.error("Could not route packet", e); 
  99.             Session session = sessionManager.getSession(packet.getFrom()); 
  100.             if (session != null) { 
  101.                 IQ reply = IQ.createResultIQ(packet); 
  102.                 reply.setError(PacketError.Condition.internal_server_error); 
  103.                 session.process(reply); 
  104.             } 
  105.         } 
  106.     } 
  107.  
  108.     /**
  109.      * Senda the error packet to the original sender
  110.      */ 
  111.     private void sendErrorPacket(IQ originalPacket, 
  112.             PacketError.Condition condition) { 
  113.         if (IQ.Type.error == originalPacket.getType()) { 
  114.             log.error("Cannot reply an IQ error to another IQ error: " 
  115.                     + originalPacket); 
  116.             return; 
  117.         } 
  118.         IQ reply = IQ.createResultIQ(originalPacket); 
  119.         reply.setChildElement(originalPacket.getChildElement().createCopy()); 
  120.         reply.setError(condition); 
  121.         try { 
  122.             PacketDeliverer.deliver(reply); 
  123.         } catch (Exception e) { 
  124.             // Ignore 
  125.         } 
  126.     } 
  127.  
  128.     /**
  129.      * Adds a new IQHandler to the list of registered handler.
  130.      *
  131.      * @param handler the IQHandler
  132.      */ 
  133.     public void addHandler(IQHandler handler) { 
  134.         if (iqHandlers.contains(handler)) { 
  135.             throw new IllegalArgumentException( 
  136.                     "IQHandler already provided by the server"); 
  137.         } 
  138.         namespace2Handlers.put(handler.getNamespace(), handler); 
  139.     } 
  140.  
  141.     /**
  142.      * Removes an IQHandler from the list of registered handler.
  143.      *
  144.      * @param handler the IQHandler
  145.      */ 
  146.     public void removeHandler(IQHandler handler) { 
  147.         if (iqHandlers.contains(handler)) { 
  148.             throw new IllegalArgumentException( 
  149.                     "Cannot remove an IQHandler provided by the server"); 
  150.         } 
  151.         namespace2Handlers.remove(handler.getNamespace()); 
  152.     } 
  153.  
  154.     /**
  155.      * Returns an IQHandler with the given namespace.
  156.      */ 
  157.     private IQHandler getHandler(String namespace) { 
  158.         IQHandler handler = namespace2Handlers.get(namespace); 
  159.         if (handler == null) { 
  160.             for (IQHandler handlerCandidate : iqHandlers) { 
  161.                 if (namespace.equalsIgnoreCase(handlerCandidate.getNamespace())) { 
  162.                     handler = handlerCandidate; 
  163.                     namespace2Handlers.put(namespace, handler); 
  164.                     break; 
  165.                 } 
  166.             } 
  167.         } 
  168.         return handler; 
  169.     } 
  170.  
  171. } 

       由以上的源代码可以看出，IQRouter在加载时候将各种处理器添加到回话管理器中，当消息分发到IQRouter中时候，根据命名空间的不同使用不同的处理处置即可。

------------------------------(七)Androidpn中业务类xmppIoHandler实现分析--------------------------------------
在androidpn中主要采用Mina进行网络通讯，其中Mina中IoHandler用来处理主要的业务逻辑。

Mina 中源代码如下：

Java代码  收藏代码
  1. package org.apache.mina.core.service; 
  2.  
  3. import java.io.IOException; 
  4.  
  5. import org.apache.mina.core.session.IdleStatus; 
  6. import org.apache.mina.core.session.IoSession; 
  7.  
  8. /**
  9. * Handles all I/O events fired by MINA.
  10. *
  11. * @author <a href="http://mina.apache.org">Apache MINA Project</a>
  12. *
  13. * @see IoHandlerAdapter
  14. */ 
  15. public interface IoHandler { 
  16.     /**
  17.      * Invoked from an I/O processor thread when a new connection has been created.
  18.      * Because this method is supposed to be called from the same thread that
  19.      * handles I/O of multiple sessions, please implement this method to perform
  20.      * tasks that consumes minimal amount of time such as socket parameter
  21.      * and user-defined session attribute initialization.
  22.      */ 
  23.     void sessionCreated(IoSession session) throws Exception; 
  24.  
  25.     /**
  26.      * Invoked when a connection has been opened.  This method is invoked after
  27.      * {@link #sessionCreated(IoSession)}.  The biggest difference from
  28.      * {@link #sessionCreated(IoSession)} is that it's invoked from other thread
  29.      * than an I/O processor thread once thread model is configured properly.
  30.      */ 
  31.     void sessionOpened(IoSession session) throws Exception; 
  32.  
  33.     /**
  34.      * Invoked when a connection is closed.
  35.      */ 
  36.     void sessionClosed(IoSession session) throws Exception; 
  37.  
  38.     /**
  39.      * Invoked with the related {@link IdleStatus} when a connection becomes idle.
  40.      * This method is not invoked if the transport type is UDP; it's a known bug,
  41.      * and will be fixed in 2.0.
  42.      */ 
  43.     void sessionIdle(IoSession session, IdleStatus status) throws Exception; 
  44.  
  45.     /**
  46.      * Invoked when any exception is thrown by user {@link IoHandler}
  47.      * implementation or by MINA.  If <code>cause</code> is an instance of
  48.      * {@link IOException}, MINA will close the connection automatically.
  49.      */ 
  50.     void exceptionCaught(IoSession session, Throwable cause) throws Exception; 
  51.  
  52.     /**
  53.      * Invoked when a message is received.
  54.      */ 
  55.     void messageReceived(IoSession session, Object message) throws Exception; 
  56.  
  57.     /**
  58.      * Invoked when a message written by {@link IoSession#write(Object)} is
  59.      * sent out.
  60.      */ 
  61.     void messageSent(IoSession session, Object message) throws Exception; 
  62. } 

Mina中IoHandler可供处理的事件回调

sessionCreate(IoSession)

  IoSession对象被创建时的回调，一般用于进行会话初始化操作。注意：与sessionOpened(IoSession)不同，IoSession对象的创建并不意味着对应底层TCP连接的建立，而仅仅代表字面意思：一个IoSession对象被创建出来了。

sessionOpened(IoSession)

  IoSession对象被打开时回调。在TCP中，该事件是在TCP连接建立时触发，一般可用于发起连接建立的握手、认证等操作。

sessionIdle(IoSession,IdleStatus)

  IoSession对象超时时回调。当一个IoSession对象在指定的超时时常内没有读写事件发生，就会触发该事件，一般可用于通知服务器断开长时间闲置的连接等处理。具体的超时设置可由 IoService.setWriteIdleTime(int) ,IoService.setReadIdleTime(int) ,IoService.setBothIdleTime(int)设置。

messageReceived(IoSession,Object)

  当接收到IoSession对Client发送的数据时回调。

messageSent(IoSession,Object)

  当发送给IoSession对Client的数据发送成功时回调。

exceptionCaught(IoSession,Throwable)

  当会话过程中出现异常时回调，通常用于错误处理。

session.write(Object)方法是一个异步方法，对该方法的调用并不会阻塞，而是向Mina投递一个异步的写操作，并返回一个可用于对已投递异步写操作进行控制的WriteFuture对象。例如：调用WriteFuture的await()或awaitUninterruptibly()，可由同步等待该异步操作的完成。

在I/O处理器中实现业务逻辑的时候，对于简单的情况，一般只需要在messageReceived中对传入的消息进行处理。如果需要写回数据到对等体，用IoSession.write()即可。

另外的情况，client和server的通信协议比较复杂，client是有状态变迁的，这时可用Mina提供的状态机实现，可使用IO处理器的实现更加简单。

androidpn中XmppIoHandler源代码：

Java代码  收藏代码
  1. package org.androidpn.server.xmpp.net; 
  2.  
  3. import java.util.Map; 
  4. import java.util.concurrent.ConcurrentHashMap; 
  5.  
  6. import org.androidpn.server.xmpp.XmppServer; 
  7. import org.apache.commons.logging.Log; 
  8. import org.apache.commons.logging.LogFactory; 
  9. import org.apache.mina.core.service.IoHandler; 
  10. import org.apache.mina.core.session.IdleStatus; 
  11. import org.apache.mina.core.session.IoSession; 
  12. import org.dom4j.io.XMPPPacketReader; 
  13. import org.jivesoftware.openfire.net.MXParser; 
  14. import org.jivesoftware.openfire.nio.XMLLightweightParser; 
  15. import org.xmlpull.v1.XmlPullParserException; 
  16. import org.xmlpull.v1.XmlPullParserFactory; 
  17.  
  18. /**
  19. * This class is to create new sessions, destroy sessions and deliver
  20. * received XML stanzas to the StanzaHandler.
  21. *
  22. * @author Sehwan Noh ([email protected])
  23. */ 
  24. public class XmppIoHandler implements IoHandler { 
  25.  
  26.     private static final Log log = LogFactory.getLog(XmppIoHandler.class); 
  27.  
  28.     public static final String XML_PARSER = "XML_PARSER"; 
  29.  
  30.     private static final String CONNECTION = "CONNECTION"; 
  31.  
  32.     private static final String STANZA_HANDLER = "STANZA_HANDLER"; 
  33.  
  34.     private String serverName; 
  35.  
  36.     private static Map<Integer, XMPPPacketReader> parsers = new ConcurrentHashMap<Integer, XMPPPacketReader>(); 
  37.  
  38.     private static XmlPullParserFactory factory = null; 
  39.  
  40.     static { 
  41.         try { 
  42.             factory = XmlPullParserFactory.newInstance( 
  43.                     MXParser.class.getName(), null); 
  44.             factory.setNamespaceAware(true); 
  45.         } catch (XmlPullParserException e) { 
  46.             log.error("Error creating a parser factory", e); 
  47.         } 
  48.     } 
  49.  
  50.     /**
  51.      * Constructor. Set the server name from server instance.
  52.      */ 
  53.     protected XmppIoHandler() { 
  54.         serverName = XmppServer.getInstance().getServerName(); 
  55.     } 
  56.  
  57.     /**
  58.      * Invoked from an I/O processor thread when a new connection has been created.
  59.      */ 
  60.     public void sessionCreated(IoSession session) throws Exception { 
  61.         log.debug("sessionCreated()..."); 
  62.     } 
  63.  
  64.     /**
  65.      * Invoked when a connection has been opened.
  66.      */ 
  67.     public void sessionOpened(IoSession session) throws Exception { 
  68.         log.debug("sessionOpened()..."); 
  69.         log.debug("remoteAddress=" + session.getRemoteAddress()); 
  70.         // Create a new XML parser 
  71.         XMLLightweightParser parser = new XMLLightweightParser("UTF-8"); 
  72.         session.setAttribute(XML_PARSER, parser); 
  73.         // Create a new connection 
  74.         Connection connection = new Connection(session); 
  75.         session.setAttribute(CONNECTION, connection); 
  76.         session.setAttribute(STANZA_HANDLER, new StanzaHandler(serverName, 
  77.                 connection)); 
  78.     } 
  79.  
  80.     /**
  81.      * Invoked when a connection is closed.
  82.      */ 
  83.     public void sessionClosed(IoSession session) throws Exception { 
  84.         log.debug("sessionClosed()..."); 
  85.         Connection connection = (Connection) session.getAttribute(CONNECTION); 
  86.         connection.close(); 
  87.     } 
  88.  
  89.     /**
  90.      * Invoked with the related IdleStatus when a connection becomes idle.
  91.      */ 
  92.     public void sessionIdle(IoSession session, IdleStatus status) 
  93.             throws Exception { 
  94.         log.debug("sessionIdle()..."); 
  95.         Connection connection = (Connection) session.getAttribute(CONNECTION); 
  96.         if (log.isDebugEnabled()) { 
  97.             log.debug("Closing connection that has been idle: " + connection); 
  98.         } 
  99.         connection.close(); 
  100.     } 
  101.  
  102.     /**
  103.      * Invoked when any exception is thrown.
  104.      */ 
  105.     public void exceptionCaught(IoSession session, Throwable cause) 
  106.             throws Exception { 
  107.         log.debug("exceptionCaught()..."); 
  108.         log.error(cause); 
  109.     } 
  110.  
  111.     /**
  112.      * Invoked when a message is received.
  113.      */ 
  114.     public void messageReceived(IoSession session, Object message) 
  115.             throws Exception { 
  116.         log.debug("messageReceived()..."); 
  117.         log.debug("RCVD: " + message); 
  118.  
  119.         // Get the stanza handler 
  120.         StanzaHandler handler = (StanzaHandler) session 
  121.                 .getAttribute(STANZA_HANDLER); 
  122.  
  123.         // Get the XMPP packet parser 
  124.         int hashCode = Thread.currentThread().hashCode(); 
  125.         XMPPPacketReader parser = parsers.get(hashCode); 
  126.         if (parser == null) { 
  127.             parser = new XMPPPacketReader(); 
  128.             parser.setXPPFactory(factory); 
  129.             parsers.put(hashCode, parser); 
  130.         } 
  131.  
  132.         // The stanza handler processes the message 
  133.         try { 
  134.             handler.process((String) message, parser); 
  135.         } catch (Exception e) { 
  136.             log.error( 
  137.                     "Closing connection due to error while processing message: " 
  138.                             + message, e); 
  139.             Connection connection = (Connection) session 
  140.                     .getAttribute(CONNECTION); 
  141.             connection.close(); 
  142.         } 
  143.     } 
  144.  
  145.     /**
  146.      * Invoked when a message written by IoSession.write(Object) is sent out.
  147.      */ 
  148.     public void messageSent(IoSession session, Object message) throws Exception { 
  149.         log.debug("messageSent()..."); 
  150.     } 
  151.  
  152. } 

XmppIoHandler在加载的时候创建相关的xml解析工厂。

        sessionOpened：在连接打开时候创建相关的xml的解析器和Handler处理器。

        sessionClosed：关闭相关的连接。

        sessionIdle：关闭相关的连接。

        messageReceived：获取相关的xml解析器和handler处理器处理相关的消息。



最近正在做一个项目，要用到Android的Push技术。目前对于Android的推送技术，用的比较多的还是AndroidPn。由于要对Push的服务器端，进行压力测试。当然，不可能真找几千台手机来测试。所以只能通过PC端模拟AndroidPN的用户端，每个线程代表一个AndroidPN的客户端。

闲话少说，要想在PC端模拟AndroidPN的客户端，不了解 源码是不行的。
Google一下，大致可以找到相关源码的解析。本文是在相关基础上，添加些自己的见解。
Androidpn包含有server和client两个包，server部分可以作为服务器单独运行，也可以嵌入到web项目的servlet中，在tomcat环境中与web项目的其他部分交互。
Server部分的主要包结构如下：
其中org.androidpn.server.dao，org.androidpn.server.model和org.androidpn.server.service为使用hibernate链接 数据库并实现简单的用户登录认证，开发中可以用我们自己的认证模块替换。剩下的包就是推送的主体实现。
接下来逐个包来看：
1.util包中的类用来加载resources中的配置文件，在配置文件中可指定监听端口和ssl证书目录等属性。
2.org.androidpn.server.xmpp包里面定义了一些异常类型，主要是包含有入口类XmppServer，这个类用来启动和停止server程序。
3.org.androidpn.server.xmpp.auth包里面是认证的一些类，我们自己的认证模块可以在这里与androidpn进行结合。
4.org.androidpn.server.xmpp.codec是XMPP协议的XML文件解析包，server收到和发送的消息都要通过这个包来进行xmpp协议编码和解码。
5.org.androidpn.server.xmpp.handler包主要是对消息的处理，我们可以针对不同的消息类型定义自己的handler，
6.org.androidpn.server.xmpp.net包负责维护与client之间的持久连接，并实现了一些传输方式供发送xmpp消息时使用。
7.org.androidpn.server.xmpp.presence里面只包含PresenceManager类，用来维护client的在线状态。
8.org.androidpn.server.xmpp.push包里面的NotificationManager类包含有向client发送消息的接口。
9.org.androidpn.server.xmpp.router包负责将收到的信息包发送到相应的handler进行处理，是一个路由包。
10.org.androidpn.server.xmpp.session包定义了用来表示持久链接的session，每个session包含一条连接的状态信息。
11.org.androidpn.server.xmpp.ssl是对连接进行ssl认证的工具包。(目前服务器使用的是NonSASLAuthentication认证)
跟XMPP协议有关的类：
IQ Presence Message 分别表示XMPP中的<iq>节，<presence>节，<message>节
Packet表示XMPP节的抽象类，IQ Presence Message均是Packet的子类
Element表示XML节中的元素
如果对XMPP协议不太了解，可以先大致了解下XMPP协议中各种xml节的含义。
server发送消息的整个流程主要是：
1. NotificationManager的push接口被调用。
2.使用SessionManager在当前session集合中查找相应的client链接。
3.定义自己的XMPP消息格式并组装。
4.通过相应session，向client发送消息。
在这个流程中我们需要修改的是步骤3，也就是需要定义和组装自己的xmpp消息，以便于将适当的信息传到客户端并便于客户端解析。一个简单的消息组装例子如下：
   1: private IQ createCustomizeIQ(String apiKey, String title,
   2:            String message, String uri) {
   3:        Random random = new Random();
   4:        String id = Integer.toHexString(random.nextInt());
   5:        // String id = String.valueOf(System.currentTimeMillis());
   6: 
   7:        Element notification = DocumentHelper.createElement(QName.get(
   8:                "notification", NOTIFICATION_NAMESPACE));
   9:        notification.addElement("id").setText(id);
  10:        notification.addElement("title").setText(title);
  11:        notification.addElement("message").setText(message);
  12:        notification.addElement("uri").setText(uri);
  13:        //自定义IQ的属性
  14:        notification.addElement("属性名").setText(属性);
  15:        IQ iq = new IQ();
  16:        iq.setType(IQ.Type.set);
  17:        iq.setChildElement(notification);
  18: 
  19:        return iq;
  20:    }
要注意的是在创建element的时候，传入的namespace要和client解析使用的namespace相匹配。
server端接收和处理消息的流程是：
1.connection收到packet，使用tsc.push.server.xmpp.codec解码。
2.router根据packet的namespace等信息，将packet路由到相应的handler。
3.handler进行处理。
相应的router和handler类在androidpn中都有例子可以参考，这里就不贴代码了。开发中只要根据client发送消息的格式，定义自己的router和handler类，然后在PacketRouter中注册router，在IQHandler中注册handler即可。
补充：
PacketRouter注册router的具体步骤
      1.即在PacketRouter中添加成员变量，类型为自己定义的XXXRouter(自定义消息 路由器)
androidpn(本文服务器为tomcat)_第2张图片
     2.在PackRouter的构造函数里初始化XXXRouter
Image(1)
     3.根据不同的消息类型调用相应的路由器
Image(2)
     4.在PacketRouter中添加XXXRouter的路由方法route(XXX xxx)
androidpn(本文服务器为tomcat)_第3张图片
注：XXX(自定义XMPP节)是Packet的子类
IQHandler注册handler的具体步骤
IQHandler处理信息<iq>节的抽象类，注册IQHandler就是继承IQHandler，重写其中的handleIQ(IQ)方法返回
     应答的<iq>节.
IQHandler的process(IQ)即是处理各种IQ，在实际过程中是IQHandler handler = new IQXXXHandler()。在调用
     handler.process()就会调用子类的handleIQ(IQ)方法
Client部分的主要包结构如下：
Client这边包含有消息的收发，解析以及持久连接的发起，重连等功能呢，十分强大，我们开发时完全不用管底层的连接，也不用担心断线，可以专注于业务部分的开发。
同时，代码结构也很简单。去除android的Service和BroadCast类以及一些工具类和常量类不谈：
1.NotificationIQ,NotificationIQProvider,NotificationPacketListener三个类负责对收到的Notification格式的消息进行解析和处理，
2.XmppManager是主控制器，NotificationService通过这个类，在后台维护androidpn连接。
3.PersistentConnectionListener，PhoneStateChangeListener，ReconnectionThread.java三个类则负责监听手机的状态并进行断线重连。
我们自定义消息时需要定义3个类：在***IQ中定义消息的实体，在***IQProvider中将消息转化为***IQ实体，在***PacketListener中对实体进行处理，具体的实现可参考NotificationIQ,NotificationIQProvider,NotificationPacketListener三个类。在定义这些类之后，还需要在XmppManager中将这3个类中注册到connection中，代码如下：
  //ConnectTask类在XmppManager类里
   1: Log.i(LOGTAG, "XMPP connected successfully");
   2: // packet provider
   3: ProviderManager.getInstance().addIQProvider("notification",
   4:     "androidpn:iq:notification",new NotificationIQProvider());
  //LoginTask类在XmppManager类里
   1: // packet filter
   2: PacketFilter packetFilter = new PacketTypeFilter(NotificationIQ.class);
   3: // packet listener
   4: PacketListener packetListener = xmppManager.getNotificationPacketListener();
   5: connection.addPacketListener(packetListener, packetFilter);
需要注意的是，注册***IQProvider时，传入的namespace需要和服务端组装消息时使用的namespace一致，才能正确的收到。
以上红色部分，是自己在看这篇文章时，所添加上去的，算是对这篇文章的一点补充…如果不对的地方，请大家指正。


--

-----------------(六)Androidpn-server的添加其他xmpp相关的协议（如查看好友列表等）--------------------------------

你可能感兴趣的:(androidpn(本文服务器为tomcat))

  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动 李蕾1229
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • 直抒《紫罗兰永恒花园外传》 雷姆的黑色童话
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术 步子哥 人工智能
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 下载github patch到本地 小米人er 我的博客gitpatch
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 项目中 枚举与注解的结合使用 飞翔的马甲 javaenumannotation
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
  • 【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义   1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
  • web缓存基础：术语、http报头和缓存策略 dalan_123 Web
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
  • crontab 问题 周凡杨 linuxcrontabunix
      一： 0481-079   Reached   a   symbol   that   is   not   expected.   背景： */5   *   *   *   *  /usr/IBMIHS/rsync.sh 
  • 让tomcat支持2级域名共享session g21121 session
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 打开tomcat下conf下context.xml文件 找到Context标签,修改为如下内容 如果你的域名是www.test.com <Context sessionCookiePath="/path&q
  • web报表工具FineReport常用函数的用法总结（数学和三角函数） 老A不折腾 Webfinereport总结
      ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。 示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。   ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
  • linux 启动java进程 sh文件 墙头上一根草 linuxshelljar
    #!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
    如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
  • Linux 内存使用方法详细解析 annan211 linux内存Linux内存解析
    来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
  • 数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle函数单表查询
        创建数据库;       --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2));       创建bloguser表,里面有三个字段     &nbs
  • 多线程基础知识 bijian1013 java多线程threadjava多线程
    一．进程和线程 进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 线程：是进程内部单一的一个顺序控制流。 线程和进程 a.       每个进程都有独立的
  • fastjson简单使用实例 bijian1013 fastjson
    一.简介         阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
  • 【RPC框架Burlap】Spring集成Burlap bit1129 spring
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成  
  • 【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
    1. mahout seqdirectory   $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
  • linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 例如： <? //  test .php
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
    public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
  • linux 系统相关命令 candiio linux
    系统参数 cat /proc/cpuinfo  cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况 性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则 回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
         一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造       如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中           那么软件开发者原有的设计思想和开发路线
  • 在CentOS5.5上编译OpenJDK6 Cwind linuxOpenJDK
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
  • java乱码问题 dashuaifu java乱码问题js中文乱码
    swfupload上传文件参数值为中文传递到后台接收中文乱码     在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
  • cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
    cygwin很多命令显示command not found的解决办法   修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
  • [介绍]从 Yii 1.1 升级 dcj3sjt126com PHPyii2
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
  • Linux SSH免登录配置总结 eksliang ssh-keygenLinux SSH免登录认证Linux SSH互信
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理      我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。      生成公钥与私钥有两种加密方式，第一种是
  • 手势滑动销毁Activity gundumw100 android
    老是效仿ios，做android的真悲催！ 有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？ 不用~，网上先问一下百度。 结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
  • JavaScript变换表格边框颜色 ini JavaScripthtmlWebhtml5css
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
  • Kafka Rest : Confluent kane_xie kafkaRESTconfluent
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 环境声明：Ubu
  • Calender不是单例 men4661273 单例Calender
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 测试： Calendar c1 =
  • 线程内存和主内存之间联系 qifeifei java thread
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    lock:将主内存中的变量锁定，为一个线程所独占。   unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。   read:将主内存中的变量值读到工作内存当中。   load:将read读取的值保存到工作内存中的变量副本中。  
  • schedule和scheduleAtFixedRate tangqi609567707 javatimerschedule
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {  
  • erlang 部署 wudixiaotie erlang
    1.如果在启动节点的时候报这个错 ： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]},     2.当generate时，遇到： ERROR
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他