package com.testV3;
import java.util.List;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.SmackException.NoResponseException;
import org.jivesoftware.smack.SmackException.NotConnectedException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
import org.jivesoftware.smackx.pubsub.ItemPublishEvent;
import org.jivesoftware.smackx.pubsub.LeafNode;
import org.jivesoftware.smackx.pubsub.PayloadItem;
import org.jivesoftware.smackx.pubsub.PubSubManager;
import org.jivesoftware.smackx.pubsub.SubscribeForm;
import org.jivesoftware.smackx.pubsub.Subscription;
import org.jivesoftware.smackx.pubsub.listener.ItemEventListener;
import org.jivesoftware.smackx.xdata.packet.DataForm;
import org.jxmpp.jid.parts.Resourcepart;
public class SubscribeThread extends Thread {
private String[] nodeId;
private String userName;
private String password;
private String xmppDomain;
private String serverName;
private XMPPTCPConnection connection;
private ItemEventListener myInterface;
/**
*
* @param userName
* @param password
* @param xmppDomain
* @param serverName
* @param nodeId
* 监听节点集合
*/
public SubscribeThread(String userName, String password, String xmppDomain, String serverName, String[] nodeId) {
this.userName = userName;
this.password = password;
this.xmppDomain = xmppDomain;
this.serverName = serverName;
this.nodeId = nodeId;
try {
if (connection == null) {
getConnection(userName, password, xmppDomain, serverName);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @param userName
* @param password
* @param xmppDomain
* @param serverName
* @param nodeId
* 监听节点集合
* @param myInterface
* 监听数据处理接口
*/
public SubscribeThread(String userName, String password, String xmppDomain, String serverName, String[] nodeId,
ItemEventListener myInterface) {
this.userName = userName;
this.password = password;
this.xmppDomain = xmppDomain;
this.serverName = serverName;
this.nodeId = nodeId;
this.myInterface = myInterface;
try {
if (connection == null) {
getConnection(userName, password, xmppDomain, serverName);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取连接
*
* @param userName
* @param password
* @param xmppDomain
* @param serverName
*/
public void getConnection(String userName, String password, String xmppDomain, String serverName) {
try {
XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder();
configBuilder.setHost(xmppDomain);
configBuilder.setPort(5222);
configBuilder.setUsernameAndPassword(userName, password);
configBuilder.setXmppDomain(xmppDomain);
/*Resourcepart resource = Resourcepart.from("pc");
configBuilder.setResource(resource);*/
configBuilder.setSendPresence(true);
//configBuilder.setSendPresence(false);// 状态设为离线,目的为了取离线消息
configBuilder.setDebuggerEnabled(true);//设置Debugger模式
configBuilder.setSecurityMode(XMPPTCPConnectionConfiguration.SecurityMode.disabled);
connection = new XMPPTCPConnection(configBuilder.build());
connection.addConnectionListener(new MyConnectionListener(connection, nodeId, myInterface));
// 连接服务器
connection.connect();
// 登录服务器
connection.login();
/*Presence presence = new Presence(Presence.Type.available);
connection.sendPacket(presence); */
} catch (Exception e) {
e.printStackTrace();
}
}
public void run() {
while (true) {
}
}
}
package com.testV3;
import java.io.IOException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import org.jivesoftware.smack.AbstractXMPPConnection;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.SmackException.NotConnectedException;
import org.jivesoftware.smack.StanzaListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.StanzaFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.Stanza;
import org.jivesoftware.smack.packet.StreamError;
import org.jivesoftware.smack.packet.XMPPError;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import org.jivesoftware.smackx.ping.PingFailedListener;
import org.jivesoftware.smackx.pubsub.ConfigurationEvent;
import org.jivesoftware.smackx.pubsub.ItemPublishEvent;
import org.jivesoftware.smackx.pubsub.LeafNode;
import org.jivesoftware.smackx.pubsub.PayloadItem;
import org.jivesoftware.smackx.pubsub.PubSubManager;
import org.jivesoftware.smackx.pubsub.SubscribeForm;
import org.jivesoftware.smackx.pubsub.Subscription;
import org.jivesoftware.smackx.pubsub.listener.ItemEventListener;
import org.jivesoftware.smackx.pubsub.listener.NodeConfigListener;
import org.jivesoftware.smackx.xdata.packet.DataForm;
import org.jxmpp.jid.parts.Resourcepart;
public class MyConnectionListener implements ConnectionListener, PingFailedListener {
private String[] nodeId;
private XMPPTCPConnection connection;
private ItemEventListener myInterface;
private boolean subscribed = false; // 是否已注册监听订阅事件
private Timer tReconn;
private int logintime = 30 * 1000;
class ReconnTimetask extends TimerTask {
@Override
public void run() {
if (!connection.isConnected() || !connection.isAuthenticated()) {
System.out.println("断开重连...");
connection.disconnect();
// 连接服务器
try {
connection.connect();
// 登录服务器
connection.login();
Presence presence = new Presence(Presence.Type.available);
connection.sendPacket(presence);
} catch (Exception e) {
connectionClosed();//异常,未连接,进行重连
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class PingTimetask extends TimerTask {
@Override
public void run() {
if (connection.isConnected() && connection.isAuthenticated()) {
Presence presence = new Presence(Presence.Type.available);
try {
connection.sendPacket(presence);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public MyConnectionListener(XMPPTCPConnection connection, String[] nodeId) {
this.connection = connection;
this.nodeId = nodeId;
}
public MyConnectionListener(XMPPTCPConnection connection, String[] nodeId, ItemEventListener myInterface) {
this.connection = connection;
this.nodeId = nodeId;
this.myInterface = myInterface;
}
public void connected(XMPPConnection connection) {
// TODO Auto-generated method stub
System.out.println("connection");
}
public void authenticated(final XMPPConnection connection, boolean resumed) {
// TODO Auto-generated method stub
System.out.println("authenticated");
try {
// 已注册监听之后就避免重复注册,防止重复监听
if (!subscribed) {
subscribed = true;
// 添加订阅监听
if (myInterface == null) {
subscribeListener(nodeId, new MyItemEventListener());
} else {
subscribeListener(nodeId, myInterface);
}
MyPingManager.setDefaultPingInterval(30);// Ping every 30 seconds
MyPingManager myPingManager = MyPingManager.getInstanceFor(connection);
// Set PingListener here to catch connect status
myPingManager.registerPingFailedListener(MyConnectionListener.this);
// 添加接受数据监听
connection.addAsyncStanzaListener(new StanzaListener() {
public void processStanza(Stanza packet) throws NotConnectedException, InterruptedException {
// TODO Auto-generated method stub
System.out.println("截获的内容:" + packet.toXML());
if (packet instanceof Presence) {
Presence presence = (Presence) packet;
System.out.println("在线状态:" + presence.getType());
if (presence.getType().equals(Presence.Type.unavailable)) {// 证明已掉线
tReconn = new Timer();
tReconn.schedule(new ReconnTimetask(), logintime);
}
}
}
}, new StanzaFilter() {
public boolean accept(Stanza stanza) {
// TODO Auto-generated method stub
return true;
}
});
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void connectionClosed() {
// TODO Auto-generated method stub
System.out.println("connectionClosed");
try {
tReconn = new Timer();
tReconn.schedule(new ReconnTimetask(), logintime);
} catch (Exception e) {
e.printStackTrace();
}
}
public void connectionClosedOnError(Exception e) {
// TODO Auto-generated method stub
System.out.println("connectionClosedOnError");
try {
tReconn = new Timer();
tReconn.schedule(new ReconnTimetask(), logintime);
} catch (Exception ee) {
e.printStackTrace();
ee.printStackTrace();
}
}
public void reconnectionSuccessful() {
// TODO Auto-generated method stub
System.out.println("reconnectionSuccessful");
}
public void reconnectingIn(int seconds) {
// TODO Auto-generated method stub
System.out.println("reconnectingIn");
}
public void reconnectionFailed(Exception e) {
// TODO Auto-generated method stub
System.out.println("reconnectionFailed");
}
/**
* 订阅节点监听及数据处理
*
* @param nodeId
* @param myItemEventListener
* @throws Exception
*/
public void subscribeListener(String[] nodeId, ItemEventListener myItemEventListener)
throws Exception {
PubSubManager mgr = PubSubManager.getInstance(connection);
if (nodeId != null && nodeId.length > 0) {
for (String id : nodeId) {
// Get the node
LeafNode node = null;
node = mgr.getNode(id);
SubscribeForm subscriptionForm = new SubscribeForm(DataForm.Type.submit);
subscriptionForm.setDeliverOn(true);
subscriptionForm.setDigestFrequency(5000);
subscriptionForm.setDigestOn(true);
subscriptionForm.setIncludeBody(true);
if (myItemEventListener != null) {
node.removeItemEventListener(myItemEventListener);
node.addItemEventListener(myItemEventListener);
} else {
myItemEventListener = new ItemEventListener() {
public void handlePublishedItems(ItemPublishEvent items) {
List list = (List) items.getItems();
for (PayloadItem item : list) {
System.out.println("订阅消息内容:" + item.getPayload().toXML());
}
}
};
node.removeItemEventListener(myItemEventListener);
node.addItemEventListener(myItemEventListener);
}
List subscriptions = node.getSubscriptions();
boolean flag = true;
if (subscriptions != null && subscriptions.size() > 0) {
for (Subscription s : subscriptions) {
if (s.getJid().toLowerCase()
.equals(connection.getUser().asEntityBareJidString().toLowerCase())) {// 已订阅过
flag = false;
break;
}
}
}
if (flag) {// 未订阅,开始订阅
node.subscribe(connection.getUser().asEntityBareJidString(), subscriptionForm);
}
}
}
}
public void pingFailed() {
// TODO Auto-generated method stub
if (connection.isConnected()) {
connection.disconnect();
}
tReconn = new Timer();
tReconn.schedule(new ReconnTimetask(), logintime);
}
}
package com.testV3;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import org.jivesoftware.smackx.pubsub.ItemPublishEvent;
import org.jivesoftware.smackx.pubsub.PayloadItem;
import org.jivesoftware.smackx.pubsub.listener.ItemEventListener;
class MyItemEventListener implements ItemEventListener {
public void handlePublishedItems(ItemPublishEvent items) {
List list = (List) items.getItems();
for (PayloadItem item : list) {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//System.out.println("当前时间:" + sdf.format(d));
System.out.println(sdf.format(d)+",订阅消息内容:" + item.getPayload().toXML());
}
}
}
package com.testV3;
/**
*
* Copyright 2012-2015 Florian Schmaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jivesoftware.smack.AbstractConnectionClosedListener;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.SmackException.NoResponseException;
import org.jivesoftware.smack.SmackException.NotConnectedException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.ConnectionCreationListener;
import org.jivesoftware.smack.Manager;
import org.jivesoftware.smack.XMPPConnectionRegistry;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
import org.jivesoftware.smack.iqrequest.AbstractIqRequestHandler;
import org.jivesoftware.smack.iqrequest.IQRequestHandler.Mode;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.IQ.Type;
import org.jivesoftware.smack.util.SmackExecutorThreadFactory;
import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
import org.jivesoftware.smackx.ping.PingFailedListener;
import org.jivesoftware.smackx.ping.packet.Ping;
import org.jxmpp.jid.DomainBareJid;
import org.jxmpp.jid.Jid;
/**
* Implements the XMPP Ping as defined by XEP-0199. The XMPP Ping protocol
* allows one entity to ping any other entity by simply sending a ping to the
* appropriate JID. PingManger also periodically sends XMPP pings to the server
* to avoid NAT timeouts and to test the connection status.
*
* The default server ping interval is 30 minutes and can be modified with
* {@link #setDefaultPingInterval(int)} and {@link #setPingInterval(int)}.
*
*
* @author Florian Schmaus
* @see XEP-0199:XMPP
* Ping
*/
public class MyPingManager extends Manager {
private static final Logger LOGGER = Logger.getLogger(MyPingManager.class.getName());
private static final Map INSTANCES = new WeakHashMap();
static {
XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
public void connectionCreated(XMPPConnection connection) {
getInstanceFor(connection);
}
});
}
/**
* Retrieves a {@link MyPingManager} for the specified {@link XMPPConnection},
* creating one if it doesn't already exist.
*
* @param connection
* The connection the manager is attached to.
* @return The new or existing manager.
*/
public static MyPingManager getInstanceFor(XMPPConnection connection) {
MyPingManager MyPingManager = INSTANCES.get(connection);
if (MyPingManager == null) {
MyPingManager = new MyPingManager(connection);
INSTANCES.put(connection, MyPingManager);
}
return MyPingManager;
}
/**
* The default ping interval in seconds used by new MyPingManager instances. The
* default is 30 minutes.
*/
private static int defaultPingInterval = 60 * 30;
/**
* Set the default ping interval which will be used for new connections.
*
* @param interval
* the interval in seconds
*/
public static void setDefaultPingInterval(int interval) {
defaultPingInterval = interval;
}
private final Set pingFailedListeners = Collections
.synchronizedSet(new HashSet());
private final ScheduledExecutorService executorService;
/**
* The interval in seconds between pings are send to the users server.
*/
private int pingInterval = defaultPingInterval;
private ScheduledFuture> nextAutomaticPing;
private MyPingManager(XMPPConnection connection) {
super(connection);
executorService = Executors
.newSingleThreadScheduledExecutor(new SmackExecutorThreadFactory(connection, "Ping"));
ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
sdm.addFeature(Ping.NAMESPACE);
connection.registerIQRequestHandler(
new AbstractIqRequestHandler(Ping.ELEMENT, Ping.NAMESPACE, Type.get, Mode.async) {
@Override
public IQ handleIQRequest(IQ iqRequest) {
Ping ping = (Ping) iqRequest;
return ping.getPong();
}
});
connection.addConnectionListener(new AbstractConnectionClosedListener() {
@Override
public void authenticated(XMPPConnection connection, boolean resumed) {
maybeSchedulePingServerTask();
}
@Override
public void connectionTerminated() {
maybeStopPingServerTask();
}
});
maybeSchedulePingServerTask();
}
/**
* Pings the given jid. This method will return false if an error occurs. The
* exception to this, is a server ping, which will always return true if the
* server is reachable, event if there is an error on the ping itself (i.e. ping
* not supported).
*
* Use {@link #isPingSupported(String)} to determine if XMPP Ping is supported
* by the entity.
*
* @param jid
* The id of the entity the ping is being sent to
* @param pingTimeout
* The time to wait for a reply in milliseconds
* @return true if a reply was received from the entity, false otherwise.
* @throws NoResponseException
* if there was no response from the jid.
* @throws NotConnectedException
*/
public boolean ping(DomainBareJid jid, long pingTimeout) throws NotConnectedException, NoResponseException {
final XMPPConnection connection = connection();
// Packet collector for IQs needs an connection that was at least authenticated
// once,
// otherwise the client JID will be null causing an NPE
if (!connection.isAuthenticated()) {
throw new NotConnectedException();
}
Ping ping = new Ping(jid);
try {
connection.createStanzaCollectorAndSend(ping).nextResultOrThrow(pingTimeout);
} catch (XMPPException exc) {
return jid.equals(connection.getServiceName());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
}
/**
* Same as calling {@link #ping(String, long)} with the defaultpacket reply
* timeout.
*
* @param jid
* The id of the entity the ping is being sent to
* @return true if a reply was received from the entity, false otherwise.
* @throws NotConnectedException
* @throws NoResponseException
* if there was no response from the jid.
*/
public boolean ping(DomainBareJid jid) throws NotConnectedException, NoResponseException {
return ping(jid, connection().getPacketReplyTimeout());
}
/**
* Query the specified entity to see if it supports the Ping protocol (XEP-0199)
*
* @param jid
* The id of the entity the query is being sent to
* @return true if it supports ping, false otherwise.
* @throws XMPPErrorException
* An XMPP related error occurred during the request
* @throws NoResponseException
* if there was no response from the jid.
* @throws NotConnectedException
*/
public boolean isPingSupported(Jid jid) throws NoResponseException, XMPPErrorException, NotConnectedException,InterruptedException {
return ServiceDiscoveryManager.getInstanceFor(connection()).supportsFeature(jid, Ping.NAMESPACE);
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(String)} case, this method will return true even if
* {@link #isPingSupported(String)} is false.
*
* @return true if a reply was received from the server, false otherwise.
* @throws NotConnectedException
*/
public boolean pingMyServer() throws NotConnectedException {
return pingMyServer(true);
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(String)} case, this method will return true even if
* {@link #isPingSupported(String)} is false.
*
* @param notifyListeners
* Notify the PingFailedListener in case of error if true
* @return true if the user's server could be pinged.
* @throws NotConnectedException
*/
public boolean pingMyServer(boolean notifyListeners) throws NotConnectedException {
return pingMyServer(notifyListeners, connection().getPacketReplyTimeout());
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(String)} case, this method will return true even if
* {@link #isPingSupported(String)} is false.
*
* @param notifyListeners
* Notify the PingFailedListener in case of error if true
* @param pingTimeout
* The time to wait for a reply in milliseconds
* @return true if the user's server could be pinged.
* @throws NotConnectedException
*/
public boolean pingMyServer(boolean notifyListeners, long pingTimeout) throws NotConnectedException {
boolean res;
try {
res = ping(connection().getServiceName(), pingTimeout);
} catch (NoResponseException e) {
res = false;
}
if (!res && notifyListeners) {
for (PingFailedListener l : pingFailedListeners)
l.pingFailed();
}
return res;
}
/**
* Set the interval in seconds between a automated server ping is send. A
* negative value disables automatic server pings. All settings take effect
* immediately. If there is an active scheduled server ping it will be canceled
* and, if pingInterval
is positive, a new one will be scheduled in
* pingInterval seconds.
*
* If the ping fails after 3 attempts waiting the connections reply timeout for
* an answer, then the ping failed listeners will be invoked.
*
*
* @param pingInterval
* the interval in seconds between the automated server pings
*/
public void setPingInterval(int pingInterval) {
this.pingInterval = pingInterval;
maybeSchedulePingServerTask();
}
/**
* Get the current ping interval.
*
* @return the interval between pings in seconds
*/
public int getPingInterval() {
return pingInterval;
}
/**
* Register a new PingFailedListener
*
* @param listener
* the listener to invoke
*/
public void registerPingFailedListener(PingFailedListener listener) {
pingFailedListeners.add(listener);
}
/**
* Unregister a PingFailedListener
*
* @param listener
* the listener to remove
*/
public void unregisterPingFailedListener(PingFailedListener listener) {
pingFailedListeners.remove(listener);
}
private void maybeSchedulePingServerTask() {
maybeSchedulePingServerTask(0);
}
/**
* Cancels any existing periodic ping task if there is one and schedules a new
* ping task if pingInterval is greater then zero.
*
* @param delta
* the delta to the last received stanza in seconds
*/
private void maybeSchedulePingServerTask(int delta) {
maybeStopPingServerTask();
if (pingInterval > 0) {
int nextPingIn = pingInterval - delta;
LOGGER.fine("Scheduling ServerPingTask in " + nextPingIn + " seconds (pingInterval=" + pingInterval
+ ", delta=" + delta + ")");
nextAutomaticPing = executorService.schedule(pingServerRunnable, nextPingIn, TimeUnit.SECONDS);
}
}
private void maybeStopPingServerTask() {
if (nextAutomaticPing != null) {
nextAutomaticPing.cancel(true);
nextAutomaticPing = null;
}
}
/**
* Ping the server if deemed necessary because automatic server pings are
* enabled ({@link #setPingInterval(int)}) and the ping interval has expired.
*/
public void pingServerIfNecessary() {
final int DELTA = 1000; // 1 seconds
final int TRIES = 3; // 3 tries
final XMPPConnection connection = connection();
// final XMPPConnection connection = this.connection;
if (connection == null) {
// connection has been collected by GC
// which means we can stop the thread by breaking the loop
return;
}
if (pingInterval <= 0) {
// Ping has been disabled
return;
}
long lastStanzaReceived = connection.getLastStanzaReceived();
if (lastStanzaReceived > 0) {
long now = System.currentTimeMillis();
// Delta since the last stanza was received
int deltaInSeconds = (int) ((now - lastStanzaReceived) / 1000);
// If the delta is small then the ping interval, then we can defer the ping
if (deltaInSeconds < pingInterval) {
maybeSchedulePingServerTask(deltaInSeconds);
return;
}
}
if (connection.isAuthenticated()) {
boolean res = false;
for (int i = 0; i < TRIES; i++) {
if (i != 0) {
try {
Thread.sleep(DELTA);
} catch (InterruptedException e) {
// We received an interrupt
// This only happens if we should stop pinging
return;
}
}
try {
res = pingMyServer(false);
/* Log.i("XMPP Ping", "result:"+res); */
} catch (SmackException e) {
LOGGER.log(Level.WARNING, "SmackError while pinging server", e);
res = false;
}
// stop when we receive a pong back
if (res) {
break;
}
}
if (!res) {
for (PingFailedListener l : pingFailedListeners) {
l.pingFailed();
}
} else {
// Ping was successful, wind-up the periodic task again
maybeSchedulePingServerTask();
}
} else {
LOGGER.warning("XMPPConnection was not authenticated");
}
}
private final Runnable pingServerRunnable = new Runnable() {
public void run() {
LOGGER.fine("ServerPingTask run()");
pingServerIfNecessary();
}
};
@Override
protected void finalize() throws Throwable {
LOGGER.fine("finalizing MyPingManager: Shutting down executor service");
try {
executorService.shutdown();
} catch (Throwable t) {
LOGGER.log(Level.WARNING, "finalize() threw throwable", t);
} finally {
super.finalize();
}
}
}
package com.testV3;
public class Test3 {
final static String USERNAME = "gm";
final static String PASSWORD = "123456";
final static String XMPPDOMAIN = "172.19.12.240";
final static String SERVERNAME = "pc-20170308pkrs";
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] nodeId = {"/BAGGL/GJXX/LCGJ","/BAGGL/GJXX/TLGJ"};
SubscribeThread smark = new SubscribeThread(USERNAME,PASSWORD,XMPPDOMAIN,SERVERNAME,nodeId,new MyItemEventListener());
smark.start();
}
}
1.1 查询XMPP服务的所有服务
返回:
1.2 查询发布订阅中的某一个持久化的叶子节点
返回
http://jabber.org/protocol/pubsub#meta-data
流程告警
leaf
1
0
1
1
1
1
0
/BAGGL/GJXX/LCGJ
open
open
English
admin@pc-20170308pkrs
owner
1
1
100000
5120
1.3 订阅消息到达
-
/BAGGL/GJXX/LCGJ
1528350475613
流程告警193
A5OJTdo105AM4hNOhMeNRvKiVelT2CAMCGb9NYxC