java xmpp

在本文中，我们将开发用Java编写的XMPP负载测试工具。

1.简介

可扩展消息传递和状态协议 （ XMPP ）是基于XML（可扩展标记语言）的面向消息的中间件的通信协议。 它是由Internet工程任务组 （IETF） 标准化并由XMPP标准基金会 （XSF）支持和扩展的开放协议。 XMPP是在开放标准中定义的，并使用开放系统的开发和应用方法。 因此，许多服务器，客户端和库的实现都以自由和开源软件的形式分发。 XMPP扩展协议 （XEP）中还定义了许多扩展。

IgniteRealtime发行的一种免费的开源发行版提供了以下实现：

• Openfire聊天服务器
• Spark聊天客户端
• XMPP协议的Smack Java库

Spark是类似于Messenger，What's app，Viber或Google Talk（实际上后者使用XMPP协议）的聊天客户端应用程序。 一个人可以发送聊天消息，文件作为附件等。这些消息被发送到Openfire服务器，然后由其负责将它们传递到目的地，该服务器可以是直接与其连接的另一个Spark（或其他）聊天客户端，也可以是另一个Openfire。实例（联盟），直到他们到达最终目的地。

但是，服务器和客户端在负载下的性能如何，即当它们必须处理许多聊天消息或许多文件传输时？

2. XMPP负载测试工具

存在许多解决方案来对XMPP服务器（例如Openfire）进行负载/压力测试（列表并不详尽）：

• 带有XMPP协议支持插件的Apache JMeter（请参阅[1,2]）
• iksemel XMPP C库
• Tsung ，一种开源的多协议分布式负载测试工具

在本文中，我们将使用Smack XMPP库编写Java XMPP负载测试工具。

3.先决条件

您需要在系统上下载并安装Openfire 。 要尝试我们的负载测试工具，使用嵌入式数据库就足够了，即使您需要记住嵌入式数据库（HSQLDB）将在一段时间后填满。 当然，推荐使用真实的RDBMS。

您必须创建许多用户，这些用户将模拟用户消息交换负载。 在我们的示例中，我们将创建50个用户名，用户名分别为user001到user050并具有相同的密码a 。 如果您不知道该怎么做，请登录管理控制台（例如http：// localhost：9090或https：// localhost：9091 ），然后单击“ 用户/组”选项卡；然后单击“确定”。 在那里，您可以单击创建新用户来创建用户。

由于创建大量用户非常繁琐，因此有几个插件可以节省您的时间。 单击Openfire管理控制台的“ 插件”标签，然后单击“ 可用插件”并安装“ 用户创建”和/或“ 用户导入/导出”插件。 如果现在单击返回到“ 用户/组”选项卡，您将看到已创建新链接； 用户创建 （由于用户创建插件）和导入和导出 （由于用户导入/导出插件）。 剩下的练习是找出它们如何工作。

但是，这些并不是唯一需要做的更改。 在最新版本的Openfire中，安全机制已更改，因此要使我们的程序正常运行，我们需要定义两个属性。 单击服务器选项卡， 服务器管理器->系统属性，然后在页面底部输入以下属性名称/值对：

sasl.mechs.00001	PLAIN
sasl.mechs.00002	DIGEST-MD5

4. LoadXmppTest Java程序

我们将创建的工具是一个使用smack库的Java程序。 它提供了命令行界面（CLI），但是如果发现有用，则可以为其编写图形用户界面（GUI）。

$ java -Djava.util.logging.config.file=logging.properties -jar loadxmpptest.jar
Required options: s, d, p, n
usage: java -Djava.util.logging.config.file=logging.properties –jar loadxmpptest.jar
-a,--attachment  Test attachments
-b,--big         Test big attachments or messages
-d,--domain      Domain
-n,--number      Number of users
-o,--observer    Observer
-p,--password    Password
-s,--server      Server
Usage : java -Djava.util.logging.config.file=logging.properties -jar loadxmpptest.jar -s  -d  -p  -n  [-o ] [-a] [-b]jabber id : userXXX@chatroom  : roomXXX@conference.observer  : userXXX@/Spark (just to test)10 users per chatroom5 chatrooms
Use:-a to test small attachments (file transfers) or-a -b to test big attachments (file transfers)
or:-b to test long messages

此外， loadxmpptest.properties允许进一步配置测试应用程序：

SHORT_MESSAGES_DELAY_SECONDS = 100
LONG_MESSAGES_DELAY_SECONDS = 60
SMALL_ATTACHMENTS_DELAY_MINUTES = 1
BIG_ATTACHMENTS_DELAY_MINUTES = 5
DELAY_TO_SEND_MESSAGES_MILLISECONDS = 1000
BIG_FILE_NAME_PATH=blob.txt
SMALL_FILE_NAME_PATH=test.txt

日志存储在log/loadxmpptest.log ，可以通过编辑logging.properties进行配置。

这是一个执行示例，其中服务器为localhost ，域为localhost （可以是其他名称），使用相同的密码a模拟了50个用户：

java -Djava.util.logging.config.file=logging.properties -jar loadxmpptest.jar -s localhost -d localhost -p a -n 50

另一个例子，这次发送大型附件：

java -Djava.util.logging.config.file=logging.properties -jar loadxmpptest.jar -s localhost -d localhost -p a -n 50 -ba

如上所述，要在loadxmpptest.properties中配置要发送的文件。

4.1创建一个新的Maven项目

跳到您最喜欢的IDE并创建一个新的Maven项目。 将以下依赖项添加到pom.xml ：

<dependencies><dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-core</artifactId><version>4.3.4</version></dependency><dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-tcp</artifactId><version>4.3.4</version></dependency><dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-im</artifactId><version>4.3.4</version></dependency>    <dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-extensions</artifactId><version>4.3.4</version></dependency><dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-java7</artifactId><version>4.3.4</version></dependency><dependency><groupId>org.igniterealtime.smack</groupId><artifactId>smack-debug</artifactId><version>4.3.4</version></dependency><dependency><groupId>commons-cli</groupId><artifactId>commons-cli</artifactId><version>1.4</version></dependency>
</dependencies>

这些是撰写本文时的最新版本，但是您可以使用在Maven Central中可能找到的最新版本。

4.2创建主类

该程序由基于[10]的两个类组成。 XmppLoadTest包含main()方法，并委托XmppManager来完成工作（与现实相反，因为规范是经理委托而不是实际进行工作:)）。

public static void main(String[] args) throws Exception {parseCLIArguments(args);final XmppLoadTest loadXmppTest = new XmppLoadTest();loadProperties(PROPERTIES_FILE);init(loadXmppTest);performLoad(loadXmppTest);
}

我将跳过parseCLIArguments()方法的描述。 它使用Apache Commons CLI库来解析命令行参数（请参见[4]）。 您可以根据需要选择其他任何CLI库或创建GUI。

我们的测试模拟了50个用户和5个聊天室（您可以模拟自己的方案来满足您的需求）。 这些存储在：

private static final List<User> users = new ArrayList< >(numberOfUsers);
private static final List<ChatRoom> chatRooms = new ArrayList< >(numberOfRooms);

类User和ChatRoom的定义如下：

/*** User (e.g. {@code user001}). Functionality delegated to @{see* XmppManager}.*/
final class User {private final String username;private final String password;private final String domain;private final XmppManager xmppManager; // delegate to itprivate MultiUserChat joinedChatRoom;public User(String username, String password, String domain, XmppManager xmppManager) {this.username = username;this.password = password;this.domain = domain;this.xmppManager = xmppManager;}public String getUsername() { return username; }public String getPassword() { return password; }public String getJabberID() { return username + "@" + domain; }public void connect() {xmppManager.connect();}public void disconnect() {xmppManager.destroy();LOG.info("User " + username + " disconnected.");}public void login() {xmppManager.login(username, password);}public void setStatus(boolean available, String status) {xmppManager.setStatus(available, status);}public void sendMessage(String toJID, String message) {xmppManager.sendMessage(toJID, message);}public void receiveMessage() {xmppManager.receiveMessage();}public void sendAttachment(String toJID, String path) {xmppManager.sendAttachment(toJID, "Smack", path);}public void receiveAttachment() {xmppManager.receiveAttachment(username);}public void joinChatRoom(String roomName, String nickname) {joinedChatRoom = xmppManager.joinChatRoom(roomName, nickname);}public void leaveChatRoom() {try {joinedChatRoom.leave();} catch (SmackException.NotConnectedException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}}public void sendMessageToChatRoom(String message) {xmppManager.sendMessageToChatRoom(joinedChatRoom, message);}public String getJoinedChatRoom() {return joinedChatRoom.getRoom().toString();}public void addRosterListener() {xmppManager.rosterChanged();}}/*** Chat room, e.g. {@code room001}*/final class ChatRoom {private final String name;private final String domain;public ChatRoom(String name, String domain) {this.name = name;this.domain = domain;}public String getName() {return name + "@conference." + domain;}}

ChatRoom类很简单。 聊天室被标识为例如room001@conference.localhost ，其中conference是您在单击Group Chat- > Group Chat Settings时在Openfire管理员控制台中定义的子域，而localhost是我们通过命令行参数-d传递的域。 getName()返回的String是房间的裸JID ，我们将在后面看到。

User类更为复杂。 它需要一个username ，一个password和一个domain并委托给XmppManager ，我们将很快看到。

XMPP客户端的地址格式为user@server.com ，其中user是用户名 ， server.com是域 。 XMPP中的节点地址称为Jabber ID，缩写为JID 。 JID也可以具有资源 （ user@server.com/resource ），这意味着用户可以从多个设备连接。 格式为user@server.com JID称为裸JID ，而格式为user@server.com/resource的JID称为完整JID 。

用户可以setStatus() connect()到Openfire服务器，然后再login() ，然后用户可以setStatus() ， sendMessage()/receiveMesage(), sendAttachment()/receiveAttachment(), joinChatRoom()/leaveChatRoom()和sendMessageToChatRoom() 。

init()方法初始化XmppManager()并创建50个用户，每个用户连接，登录并将其状态设置为available 。 如果要测试文件传输，则每个用户都开始收听文件传输。 也创建了五个聊天室。 50个用户中的每个用户都分配到一个聊天室，因此最后，每个聊天室都包含10个用户。

private static void init(XmppLoadTest loadXmppTest) {XmppManager xmppManager = new XmppManager(server, domain, port);for (int i = 1; i <= numberOfUsers; i++) {User user = loadXmppTest.new User("user" + String.format("%03d", i), password, domain, xmppManager);user.connect();user.login();user.setStatus(true, "Hello from " + user.getUsername());users.add(user);if (testAttachments || testBigAttachments) {user.receiveAttachment();}}for (int i = 0; i < numberOfRooms; i++) {chatRooms.add(loadXmppTest.new ChatRoom("room" + String.format("%03d", i + 1), domain));}if (!testAttachments && !testBigAttachments) {// join chatroomsfor (int i = 1; i <= numberOfUsers; i++) {ChatRoom chatRoom = chatRooms.get((i - 1) % numberOfRooms);User user = users.get(i - 1);user.joinChatRoom(chatRoom.getName(), user.getJabberID());}}
}

一种方案是让每个user连接到五个聊天室之一并发送消息。 任务被创建（ chatRoomMessageTask ）在performLoad()和每执行every取决于消息的类型秒（ 长或短 ）作为配置loadxmpptest.properties 。

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
....} else { // send messages to chat roomsfinal Runnable task = () -> {while (true) {if (Thread.currentThread().isInterrupted()) {return;}loadXmppTest.chatRoomMessageTask();}};int every = testLongMessages ? longMessagesDelayInSeconds : shortMessagesDelayInSeconds;scheduler.scheduleWithFixedDelay(task, 0, every, SECONDS); // every x seconds
}

另一种情况是将附件发送给另一个用户，而不是将消息发送到聊天室：

if (testAttachments || testBigAttachments) {  // send attachmentsString filePath  = testBigAttachments ? bigFileNamePath : smallFileNamePath;int delay = testBigAttachments ? bigAttachmentsDelayInMinutes : smallAttachmentsDelayInMinutes;final Runnable task = () -> {while (true) {if (Thread.currentThread().isInterrupted()) {return;}loadXmppTest.fileTransferTask(filePath);}};scheduler.scheduleWithFixedDelay(task, 0, delay, MINUTES);

当然，您可以将两种情况结合起来，但是您需要确保不会溢出Openfire的缓存。

/** Each user sends a message to a chat room. */
private synchronized void chatRoomMessageTask() {for (int i = 1; i <= numberOfUsers; i++) {String message = testLongMessages ? LONG_MESSAGE : MESSAGE;User user = users.get(i - 1);try {Thread.currentThread().sleep(delayToSendMessagesInMillis); // sleep 1"user.sendMessageToChatRoom(message);LOG.info(user.getJabberID() + " sent " + (testLongMessages ? "long" : "short") + " message to " + user.getJoinedChatRoom());} catch (InterruptedException ie) {Thread.currentThread().interrupt(); // reset the flag}}
}

在上述方法（称为第一种情况）中，每个用户向该用户加入的聊天室发送一条消息（短消息或长消息）。

在fileTransferTask() ，每个用户将附件发送给另一个用户（避免将附件发送给自己）。 请注意此方法和先前方法中的synchronized关键字，以避免代码中出现死锁。

/*** Exchange file attachments between users.** @param path path of the file to send* @see #transferFile(int, java.lang.String)*/
private void fileTransferTask(String path) {for (int i = 1; i <= numberOfUsers; i++) {transferFile(i, path);}
}
/*** Transfer the file to all other users.** @param i i-th user* @param path path of the file to be sent*/
private synchronized void transferFile(int i, String path) {int j;for (j = 1; j <= numberOfUsers; j++) {if (i != j) {try {int delay = testBigAttachments ? bigAttachmentsDelayInMinutes : smallAttachmentsDelayInMinutes;Thread.currentThread().sleep(delay); if (users.get(i - 1).sendAttachment(users.get(j - 1).getJabberID(), path)) {LOG.info("Attachment " + path + " sent from " + users.get(i - 1).getJabberID() + " to " + users.get(j - 1).getJabberID());} else {LOG.severe("Attachment " + path + " from " + users.get(i - 1).getJabberID() + " to " + users.get(j - 1).getJabberID() + "  was not sent!");}} catch (InterruptedException ie) {Thread.currentThread().interrupt(); // reset the flag}}}
}

这样就完成了XmppLoadTest类的描述。

4.3 XmppManager类

XmppManager类使用smack库[6，7]与Openfire服务器进行通信。 Smack是用于与XMPP服务器通信以执行实时通信（包括即时消息传递和群聊）的库。

XmppManager与[10]中的类似，但是直到那时事情已经发生了发展，API也发生了变化。 如前所述， User委托给XmppManager 。

4.3.1连接到Openfire

要连接到Openfire服务器，您需要托管Openfire 的服务器名称 ， 域和端口 （已固定： 5222 ）。 XMPPTCPConnection类用于创建与XMPP服务器的连接。 可以使用XMPPTCPConnectionConfiguration.Builder配置其他连接参数：

private String resource = "Smack";
...
XMPPTCPConnectionConfiguration.Builder builder =  XMPPTCPConnectionConfiguration.builder();
try {builder.setXmppDomain(JidCreate.domainBareFrom(domain)).setHost(server).setPort(port).setResource(resource).setSecurityMode(SecurityMode.disabled).setHostnameVerifier((String hostname, SSLSession session) -> true);
} catch (XmppStringprepException ex) {LOG.severe(ex.getLocalizedMessage());
}
try {builder = TLSUtils.acceptAllCertificates(builder);
} catch (KeyManagementException | NoSuchAlgorithmException ex) {LOG.log(Level.SEVERE, null, ex);
}
XMPPTCPConnection.setUseStreamManagementDefault(true);
XMPPTCPConnectionConfiguration config = builder.build();

resource String对于文件传输很重要。 如果您使用的是smack，则可以是"Smack"或"Resource" 。 如果使用其他客户端，例如Spark，则可以将其设置为"Spark ”。它可以确定将文件发送到的资源。

//SASLMechanism mechanism = new SASLDigestMD5Mechanism();
SASLMechanism mechanism = new SASLPlainMechanism();
SASLAuthentication.registerSASLMechanism(mechanism);
SASLAuthentication.unBlacklistSASLMechanism("PLAIN");
SASLAuthentication.blacklistSASLMechanism("SCRAM-SHA-1");
SASLAuthentication.unBlacklistSASLMechanism("DIGEST-MD5");        try {builder = TLSUtils.acceptAllCertificates(builder);
} catch (KeyManagementException | NoSuchAlgorithmException ex) {LOG.severe(ex.getLocalizedMessage());
}
XMPPTCPConnection.setUseStreamManagementDefault(true);
XMPPTCPConnectionConfiguration config = builder.build();

TLSUtils.acceptAllCertificates(builder); 这一点很重要，因为最新版本的Openfire中的安全模型已更改。 因此，我们在Openfire的管理控制台中添加了sasl.mechs.00001和sasl.mechs.00002 。 如果他仍然遇到连接/身份验证问题，则此链接可能有帮助。

4.3.2登录

配置与Openfire的连接后，就可以连接到它了：

private AbstractXMPPConnection connection;
...
connection = new XMPPTCPConnection(config);
connection.setReplyTimeout(1000L);
try {connection.connect();
} catch (SmackException | IOException | XMPPException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());
}

默认情况下，如果突然断开连接，Smack将尝试重新连接。 重新连接管理器将尝试立即重新连接到服务器，并增加尝试之间的延迟，因为连续的重新连接始终会失败。 创建连接后，用户应使用其凭据使用XMPPConnection.login()方法登录：

public void login(String username, String password) {if (connection != null && connection.isConnected()) {try {connection.login(username, password);} catch (XMPPException | SmackException | IOException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}}LOG.info(username + " authenticated? " + connection.isAuthenticated());
}

4.3.3在场和名册

用户登录后，可以通过创建新的Chat或MultiUserChat对象开始与其他用户Chat 。 用户还可以将其状态设置为可用 ：

public void setStatus(boolean available, String status) {Presence.Type type = available ? Type.available : Type.unavailable;Presence presence = new Presence(type);presence.setStatus(status);try {connection.sendStanza(presence);} catch (SmackException.NotConnectedException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}
}

从客户端到XMPP服务器的每条消息称为数据包或节，并以XML的形式发送。 节是客户端可以在一个程序包中发送给服务器的最小XML数据段，反之亦然。 org.jivesoftware.smack.packet Java软件包包含一些类，这些类封装了XMPP允许的三种不同的基本数据包类型（ message ， 状态和IQ ）。 这些节中的每个节由XMPP服务器和客户端以不同的方式处理。 节具有类型属性 ，这些可用于进一步区分节[3]。

消息 节旨在用于在XMPP实体之间发送数据。 实在是忘了，也就是说，接收方不承认节。 通常，当您从客户端发送消息节并且未生成任何类型的错误时，可以假定消息已成功发送。 消息节的类型可以为“聊天”，“ groupchar”，“错误”等。

状态节会通告其他实体的在线状态（网络可用性）。 在线状态类似于XMPP中的订阅。 当您对某些JID的存在感兴趣时，您就订阅它们的存在，即，您告诉XMPP服务器“每次该JID向您发送状态更新时，我都希望收到通知”。 当然，服务器会询问JID持有者是否接受向您透露其在线信息。 当他们接受后，服务器会记住他们的决定，并在更改在线状态时更新订阅该状态的任何人。 术语“ 存在”还表示用户是否在线。

最后， IQ （信息/查询）节用于从服务器获取一些信息（例如，有关服务器或其注册客户端的信息）或将某些设置应用于服务器。

在XMPP中，术语名册用于指联系人列表。 用户的联系人列表通常存储在服务器上。 该名册使您可以跟踪其他用户的可用性（状态）。 可以将用户分为“朋友”和“同事”之类的组，然后您会发现每个用户是联机还是脱机。 Roster类允许您查找所有名单条目，它们所属的组以及每个条目的当前状态。

名册中的每个用户都由RosterEntry表示，该成员包括：

• XMPP地址（例如john@example.com ）。
• 您分配给用户的名称（例如"John" ）。
• 条目所属的名册中的组的列表。 如果名册条目不属于任何组，则称为“未归档条目”。

在名单中的每个条目都有一个与之关联的存在 。 Roster.getPresence(String user)方法将返回一个具有用户状态的Presence对象；如果用户不在线或您尚未订阅该用户的状态，则返回null 。 用户要么在线要么离线 。 当用户在线时，他们的存在可能包含扩展信息，例如他们当前正在做什么，是否希望受到打扰等。

public Roster createRosterFor(String user, String name) throws Exception {LOG.info(String.format("Creating roster for buddy '%1$s' with name %2$s", user, name));Roster roster = Roster.getInstanceFor(connection);roster.createEntry(JidCreate.bareFrom(user), name, null);return roster;
}
public void printRosters() throws Exception {Roster roster = Roster.getInstanceFor(connection);Collection entries = roster.getEntries();for (RosterEntry entry : entries) {LOG.info(String.format("Buddy: %s", entry.getName()));}
}
public void rosterChanged() {Roster roster = Roster.getInstanceFor(connection);roster.addRosterListener(new RosterListener() {@Overridepublic void presenceChanged(Presence presence) {LOG.info("Presence changed: " + presence.getFrom() + " " + presence);resource = presence.getFrom().getResourceOrEmpty().toString();}@Overridepublic void entriesAdded(Collection clctn) {  }@Overridepublic void entriesUpdated(Collection clctn) {  }@Overridepublic void entriesDeleted(Collection clctn) {  }});
}

状态信息可能会经常更改，并且名册条目也可能会更改或删除。 要侦听更改的花名册和状态数据，请使用RosterListener 。 为了通知有关名册的所有更改，应在登录XMPP服务器之前注册RosterListener 。 文件传输知道，如果收件人的资源发生了变化，所描述的是很重要的位置 。

4.3.4聊天和多聊

您可以在ChatManager的帮助下发送和接收聊天消息。 尽管可以将单个消息作为数据包发送和接收，但是使用org.jivesoftware.smack.chat2.Chat类将消息字符串视为聊天通常会更容易。 聊天会在两个用户之间创建新的消息线程。 Chat.send(String)方法是一种便捷方法，它创建一个Message对象，使用String参数设置正文，然后发送消息。

/*** Send message to another user.** @param buddyJID recipient* @param message to send*/
public void sendMessage(String buddyJID, String message) {LOG.info(String.format("Sending message '%1$s' to user %2$s", message, buddyJID));try {Chat chat = ChatManager.getInstanceFor(connection).chatWith(JidCreate.entityBareFrom(buddyJID));chat.send(message);} catch (XmppStringprepException | SmackException.NotConnectedException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}
}
public void receiveMessage() {ChatManager.getInstanceFor(connection).addIncomingListener((EntityBareJid from, Message message, Chat chat) -> {LOG.info("New message from " + from + ": " + message.getBody());});
}

要加入聊天室（ MultiUserChat ）并向其中发送消息：

public MultiUserChat joinChatRoom(String roomName, String nick) {try {MultiUserChatManager manager = MultiUserChatManager.getInstanceFor(connection);MultiUserChat muc = manager.getMultiUserChat(JidCreate.entityBareFrom(roomName));Resourcepart nickname = Resourcepart.from(nick);muc.join(nickname);LOG.info(muc.getNickname() + "joined chat room " + muc.getRoom());return muc;} catch (XmppStringprepException | SmackException.NotConnectedException | InterruptedException | SmackException.NoResponseException | XMPPException.XMPPErrorException | MultiUserChatException.NotAMucServiceException ex) {LOG.severe(ex.getLocalizedMessage());}return null;
}public void sendMessageToChatRoom(MultiUserChat muc, String message) {try {muc.sendMessage(message);LOG.fine("Message '" + message + "' was sent to room '" + muc.getRoom() + "' by '" + muc.getNickname() + "'");} catch (InterruptedException | SmackException.NotConnectedException ex) {LOG.severe(ex.getLocalizedMessage());}
}

您可以在加入聊天室时定义昵称。

4.3.5文件传输

要发送/接收附件，它比较复杂（请参见此处 ）：

/*** File transfer.** @param buddyJID recipient* @param res e.g. "Spark-2.8.3", default "Smack" (cannot be empty or null)* @param path path of the file attachment to send* @return {@code true} if file transfer was successful*/
public boolean sendAttachment(String buddyJID, String res, String path) {LOG.info(String.format("Sending attachment '%1$s' to user %2$s", path, buddyJID));FileTransferManager fileTransferManager = FileTransferManager.getInstanceFor(connection);FileTransferNegotiator.IBB_ONLY = true;OutgoingFileTransfer fileTransfer = null;try {fileTransfer = fileTransferManager.createOutgoingFileTransfer(JidCreate.entityFullFrom(buddyJID + "/Spark-2.8.3"));} catch (XmppStringprepException ex) {LOG.log(Level.SEVERE, null, ex);return false;}if (fileTransfer != null) {OutgoingFileTransfer.setResponseTimeout(15 * 60 * 1000);LOG.info("status is:" + fileTransfer.getStatus());File file = Paths.get(path).toFile();if (file.exists()) {try {fileTransfer.sendFile(file, "sending attachment...");} catch (SmackException ex) {LOG.severe(ex.getLocalizedMessage());return false;}LOG.info("status is:" + fileTransfer.getStatus());if (hasError(fileTransfer)) {LOG.severe(getErrorMessage(fileTransfer));return false;} else {return monitorFileTransfer(fileTransfer, buddyJID);}} else                 try {throw new FileNotFoundException("File " + path + " not found!");} catch (FileNotFoundException ex) {LOG.severe(ex.getLocalizedMessage());return false;}}}return true;
}/*** Monitor file transfer.** @param fileTransfer* @param buddyJID* @return {@code false} if file transfer failed.*/
private boolean monitorFileTransfer(FileTransfer fileTransfer, String buddyJID) {while (!fileTransfer.isDone()) {if (isRejected(fileTransfer) || isCancelled(fileTransfer)|| negotiationFailed(fileTransfer) || hasError(fileTransfer)) {LOG.severe("Could not send/receive the file to/from " + buddyJID + "." + fileTransfer.getError());LOG.severe(getErrorMessage(fileTransfer));return false;} else if (inProgress(fileTransfer)) {LOG.info("File transfer status: " + fileTransfer.getStatus() + ", progress: " + fileTransfer.getProgress());}try {Thread.sleep(1000);} catch (InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}}if (isComplete(fileTransfer)) {LOG.info(fileTransfer.getFileName() + " has been successfully transferred.");LOG.info("The file transfer is " + (fileTransfer.isDone() ? "done." : "not done."));return true;}return true;
}public void receiveAttachment(String username) {final FileTransferManager manager = FileTransferManager.getInstanceFor(connection);manager.addFileTransferListener((FileTransferRequest request) -> {// Check to see if the request should be acceptedif (request.getFileName() != null) {StringBuilder sb = new StringBuilder(BUFFER_SIZE);try {// Accept itIncomingFileTransfer transfer = request.accept();String filename = transfer.getFileName() + "_" + username;transfer.receiveFile(new File(filename));while (!transfer.isDone()) {try {Thread.sleep(1000);LOG.info("STATUS: " + transfer.getStatus()+ " SIZE: " + sb.toString().length()+ " Stream ID : " + transfer.getStreamID());} catch (Exception e) {LOG.severe(e.getMessage());}if (transfer.getStatus().equals(FileTransfer.Status.error)) {LOG.severe(transfer.getStatus().name());}if (transfer.getException() != null) {LOG.severe(transfer.getException().getLocalizedMessage());}}LOG.info("File received " + request.getFileName());} catch (SmackException | IOException ex) {LOG.severe(ex.getLocalizedMessage());}} else {try {// Reject itrequest.reject();LOG.warning("File rejected " + request.getFileName());} catch (SmackException.NotConnectedException | InterruptedException ex) {LOG.severe(ex.getLocalizedMessage());}}});
}

Openfire中定义了3种类型的文件传输 ：

• 带内 （ FileTransferNegotiator.IBB_ONLY ），其中消息被分解为多个块并作为编码消息发送。 它速度较慢，但​​始终有效。 此外，由于交换的消息存储在Openfire数据库中，因此备份起来更容易。
• 当两个用户都在同一网络上时， 对等 （p2p）效果很好，但是当一个用户在防火墙后面或使用NAT时， 对等 （p2p）失败。 它速度更快，除了上述问题之外，您还无法控制要交换的内容。
• 代理服务器 （SOCKS5，请参阅XEP-0096或更新的XEP-0234 ）使用文件传输代理，但需要打开端口7777。它比p2p慢，但比带内快。

在我们的测试工具中，正在使用带内文件传输。

一旦成功发送文件，就需要监视其状态（ monitorFileTransfer() ）。 可能存在网络错误，或者收件人可能只是拒绝文件传输。 实际上，其他用户可以选择接受，拒绝或忽略文件传输请求。

发送附件是OutgoingFileTransfer ，而接收是IncomingFileTransfer 。 这是通过将侦听器添加到FileTransferManager来实现的。 如前所述，接收者需要在发送者发送文件之前开始侦听。 此外，在我们的负载测试中，正在发送和接收相同的文件。 为了避免覆盖同一文件，源文件以不同的名称存储，在文件名中添加"_"和收件人的名称。 当然，这些文件名在负载测试工具运行时会一次又一次地写入。

建立

为了能够执行负载测试工具，您需要创建一个可执行文件XmppLoadTest-1.0.jar 。 一种方法是将以下内容添加到pom.xml中：

<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-jar-plugin</artifactId><version>3.2.0</version><configuration><archive><manifest><addClasspath>true</addClasspath><mainClass>test.xmpp.xmpploadtest.XmppLoadTest</mainClass></manifest></archive></configuration></plugin></plugins>
</build>

并且还需要将依赖项包括到classpath中 。 或者，您可以使用依赖项插件来创建一个单个jar ，该jar可以创建此处所述的所有内容。

<plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-assembly-plugin</artifactId><version>3.2.0</version><configuration><archive><manifest><mainClass>test.xmpp.xmpploadtest.XmppLoadTest</mainClass></manifest></archive><descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs></configuration><executions><execution><id>make-assembly</id> <!-- this is used for inheritance merges --><phase>package</phase> <!-- bind to the packaging phase --><goals><goal>single</goal></goals></execution></executions>
</plugin>

您也可以使用maven命令代替执行它：

mvn exec:java -Dexec.mainClass=test.xmpp.xmpploadtest.XmppLoadTest "-Dexec.args=-s localhost -d localhost -p a -n 50"

4.5负载测试

一旦执行了负载测试工具，您将看到许多发送到Openfire服务器的消息。 根据您选择的方案（群聊或文件传输），如果您使用第50个用户（例如Spark）之类的聊天客户端进行连接并加入聊天室，您将看到他们被重复发送的相同消息所填充其他49个模拟用户。

Apr 25, 2020 11:55:16 PM test.xmpp.xmpploadtest.XmppManager connect
INFO: Initializing connection to server localhost port 5222
Apr 25, 2020 11:55:18 PM test.xmpp.xmpploadtest.XmppManager connect
INFO: Connected: true
Apr 25, 2020 11:55:18 PM test.xmpp.xmpploadtest.XmppManager login
INFO: user001 authenticated? True
...
Apr 25, 2020 11:55:21 PM test.xmpp.xmpploadtest.XmppManager joinChatRoom
INFO: user001@localhost joined chat room room001@conference.localhost
Apr 25, 2020 11:55:21 PM test.xmpp.xmpploadtest.XmppManager joinChatRoom
INFO: user002@localhost joined chat room room002@conference.localhost
...
Apr 25, 2020 11:55:24 PM test.xmpp.xmpploadtest.XmppLoadTest chatRoomMessageTask
INFO: user001@localhost sent short message to room001@conference.localhost
Apr 25, 2020 11:55:25 PM test.xmpp.xmpploadtest.XmppLoadTest chatRoomMessageTask
INFO: user002@localhost sent short message to room002@conference.localhost
...

在user050情况下运行该工具时，您不会在Spark或以user050连接到的聊天客户端中看到任何附件。

INFO: Sending attachment 'test.txt' to user user003@localhost [Sun May 10 17:55:15 CEST 2020]
INFO: status is:Initial [Sun May 10 17:55:15 CEST 2020]
INFO: status is:Initial [Sun May 10 17:55:15 CEST 2020]
INFO: STATUS: Complete SIZE: 0 Stream ID : jsi_2604404248040129956 [Sun May 10 17:55:15 CEST 2020]
INFO: File received test.txt [Sun May 10 17:55:15 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_4005559316676416776 [Sun May 10 17:55:16 CEST 2020]
WARNING: Closing input stream [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_6098909703710301467 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_2348439600749627884 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_8708250841661514027 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_2119745768373873364 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_6583436044582265363 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_3738252107587424431 [Sun May 10 17:55:16 CEST 2020]
INFO: STATUS: In Progress SIZE: 0 Stream ID : jsi_4941117510857455094 [Sun May 10 17:55:16 CEST 2020]
INFO: test.txt has been successfully transferred. [Sun May 10 17:55:16 CEST 2020]
INFO: The file transfer is done. [Sun May 10 17:55:16 CEST 2020]

一旦运行了加载/压力工具，就可以搜索XMPP服务器或客户端的内存泄漏或CPU使用率过高。 您可以使用VisualVM之类的工具来监视内存和CPU，或者甚至可以根据需要使用YourKit或Java Flight Recorder之类的工具进行概要分析。

5.总结

在本教程中，我们学习了如何编写自己的负载测试工具来对XMPP服务器（如Openfire）进行负载/压力测试。 负载/压力工具还可以用于测试XMPP客户端（例如Spark）。 如果您编写了自己的XMPP客户端或服务器，那么它也可以用于测试它们。 该工具使用Smack XMPP库以Java编写。 它可以在两种模式或场景下运行，既可以将消息发送到聊天室，也可以在用户之间发送文件传输。 XMPP服务器需要使用模拟用户和聊天室进行预配置。

您可以根据需要进行自定义，进一步扩展源代码，例如用户数量，消息或文件附件的大小，消息之间的延迟，发送消息和文件传输的组合或测试XMPP的其他方面协议。

6.参考

1. Aladev R.（2017a），“ XMPP负载测试–最终指南 ”。
2. Aladev R.（2017b），“ XMPP负载测试–高级方案 ”。
3. Gakwaya D.（2016），“ XMPP的友好介绍 ”。
4. Marx D.（2017），“ Java命令行界面（第1部分）：Apache Commons CLI ”，JavaCodeGeeks。
5. Saint-Andre P.，Smith K.，Troncon R.（2009年）， XMPP：权威指南 ，O'Reilly。
6. Smack API
7. 打击文件
8. Tsagklis I.（2010a），“ Openfire服务器安装-即时消息基础结构 ”，JavaCodeGeeks。
9. Tsagklis I.（2010b），“ Openfire服务器配置-即时消息基础结构 ”，JavaCodeGeeks。
10. Tsagklis I.（2010c），“ 带有适用于Java应用程序的Smack的XMPP IM –即时消息基础结构 ”，JavaCodeGeeks。

7.下载Maven项目

那是一篇有关Java XMPP负载测试工具的文章。

翻译自: https://www.javacodegeeks.com/java-xmpp-load-test-tool.html

java xmpp