一天时间用OpenFire打造自己的IM聊天工具

最新推荐文章于 2024-07-22 19:35:06 发布
转载 最新推荐文章于 2024-07-22 19:35:06 发布 · 565 阅读 · 0
文章标签：

#移动开发 #java #xhtml

介绍了基于 Java 开发的 Openfire 实时协作服务器，该服务器支持 XMPP 协议并提供用户注册、登录、添加好友及聊天等功能。支持上万并发用户，提供了核心通讯代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Openfire
采用Java开发，开源的实时协作（RTC）服务器基于XMPP（Jabber）协议。Openfire安装和使用都非常简单，并利用Web进行管理。单台服务器可支持上万并发用户。

好友界面

device-2015-01-07-130047

功能界面

device-2015-01-07-115755

聊天界面

device-2015-01-07-115905

服务端可以用本服务器测试，地址:www.ithtw.com。如果想自己搭可在本博客其它XMPP文章找到相关搭建资料。

实现了用户注册,登录,添加好友,聊天核心功能。可正常聊天！

核心通讯代码:

双击【CTRL+C】复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
package com.lee.xqq.control;
 
import java.io.ByteArrayInputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
 
import org.jivesoftware.smack.Connection;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.ConnectionCreationListener;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.PacketCollector;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.RosterGroup;
import org.jivesoftware.smack.SmackConfiguration;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.AndFilter;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.filter.PacketIDFilter;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.Presence.Type;
import org.jivesoftware.smack.packet.Registration;
import org.jivesoftware.smack.provider.PrivacyProvider;
import org.jivesoftware.smack.provider.ProviderManager;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.Form;
import org.jivesoftware.smackx.GroupChatInvitation;
import org.jivesoftware.smackx.PrivateDataManager;
import org.jivesoftware.smackx.ReportedData;
import org.jivesoftware.smackx.ReportedData.Row;
import org.jivesoftware.smackx.bytestreams.socks5.provider.BytestreamsProvider;
import org.jivesoftware.smackx.packet.ChatStateExtension;
import org.jivesoftware.smackx.packet.LastActivity;
import org.jivesoftware.smackx.packet.OfflineMessageInfo;
import org.jivesoftware.smackx.packet.OfflineMessageRequest;
import org.jivesoftware.smackx.packet.SharedGroupsInfo;
import org.jivesoftware.smackx.packet.VCard;
import org.jivesoftware.smackx.provider.AdHocCommandDataProvider;
import org.jivesoftware.smackx.provider.DataFormProvider;
import org.jivesoftware.smackx.provider.DelayInformationProvider;
import org.jivesoftware.smackx.provider.DiscoverInfoProvider;
import org.jivesoftware.smackx.provider.DiscoverItemsProvider;
import org.jivesoftware.smackx.provider.MUCAdminProvider;
import org.jivesoftware.smackx.provider.MUCOwnerProvider;
import org.jivesoftware.smackx.provider.MUCUserProvider;
import org.jivesoftware.smackx.provider.MessageEventProvider;
import org.jivesoftware.smackx.provider.MultipleAddressesProvider;
import org.jivesoftware.smackx.provider.RosterExchangeProvider;
import org.jivesoftware.smackx.provider.StreamInitiationProvider;
import org.jivesoftware.smackx.provider.VCardProvider;
import org.jivesoftware.smackx.provider.XHTMLExtensionProvider;
import org.jivesoftware.smackx.search.UserSearch;
import org.jivesoftware.smackx.search.UserSearchManager;
 
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
 
import com.lee.xqq.ChatActivity;
import com.lee.xqq.MainActivity;
import com.lee.xqq.SplashActivity;
import com.lee.xqq.base.BroadSender;
import com.lee.xqq.base.MLog;
import com.lee.xqq.item.XUserItem;
import com.lee.xqq.net.HttpResult;
import com.lee.xqq.net.HttpUtil;
import com.lee.xqq.util.CachedThreadPool;
 
/**
  * 所有的数据控制，逻辑可以在这里实现
  *
  */
public class DataUtils implements ConnectionListener,
         ConnectionCreationListener, PacketListener {
 
     private static DataUtils instance;
     private Connection connection;
     private static String host;
     private static int port;
     private String user;
 
     private DataUtils() {
     }
 
     public void setHost(String host, int port) {
         DataUtils.host = host;
         DataUtils.port = port;
     }
 
     public static DataUtils getInstance() {
         if (instance == null )
             instance = new DataUtils();
         return instance;
     }
 
     public Connection getConnection() {
         return connection;
     }
 
     public String getUser() {
         return user;
     }
 
     public void requestBaidu() {
         CachedThreadPool.execute( new Runnable() {
 
             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 HttpUtil httpUtil = HttpUtil.requestText(
                         "http://www.baidu.com" , "GET" );
                 HttpResult result = httpUtil.getResponse();
                 if (result.getCode() == 200 ) {
                     // 向界面发送接收广播
                 }
             }
         });
     }
 
     public void initXMPP() {
         CachedThreadPool.execute( new Runnable() {
 
             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 connectXmppServer();
             }
         });
     }
 
     private void connectXmppServer() {
         ConnectionConfiguration config = new ConnectionConfiguration(host, port);
         /** 是否启用安全验证 */
         config.setSASLAuthenticationEnabled( false );
         config.setReconnectionAllowed( true ); // 断线重连
         /** 是否启用调试 */
         // config.setDebuggerEnabled(true);
         /** 创建connection链接 */
         try {
             Connection.addConnectionCreationListener( this );
             configure(ProviderManager.getInstance());
             connection = new XMPPConnection(config);
             /** 建立连接 */
             connection.connect();
             connection.addConnectionListener( this );
             PacketTypeFilter filter = new PacketTypeFilter(Packet. class );
             connection.addPacketListener( this , filter);
         } catch (XMPPException e) {
             e.printStackTrace();
             MLog.makeText( "服务器连接失败" );
         }
     }
 
     /**
      * Android读不到/META-INF下的配置文件，需要手工配置。
      *
      * @param pm
      */
     private void configure(ProviderManager pm) {
         // Private Data Storage
         pm.addIQProvider( "query" , "jabber:iq:private" ,
                 new PrivateDataManager.PrivateDataIQProvider());
         // Time
         try {
             pm.addIQProvider( "query" , "jabber:iq:time" ,
                     Class.forName( "org.jivesoftware.smackx.packet.Time" ));
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         // Roster Exchange
         pm.addExtensionProvider( "x" , "jabber:x:roster" ,
                 new RosterExchangeProvider());
         // Message Events
         pm.addExtensionProvider( "x" , "jabber:x:event" ,
                 new MessageEventProvider());
         // Chat State
         pm.addExtensionProvider( "active" ,
                 "http://jabber.org/protocol/chatstates" ,
                 new ChatStateExtension.Provider());
         pm.addExtensionProvider( "composing" ,
                 "http://jabber.org/protocol/chatstates" ,
                 new ChatStateExtension.Provider());
         pm.addExtensionProvider( "paused" ,
                 "http://jabber.org/protocol/chatstates" ,
                 new ChatStateExtension.Provider());
         pm.addExtensionProvider( "inactive" ,
                 "http://jabber.org/protocol/chatstates" ,
                 new ChatStateExtension.Provider());
         pm.addExtensionProvider( "gone" ,
                 "http://jabber.org/protocol/chatstates" ,
                 new ChatStateExtension.Provider());
         // XHTML
         pm.addExtensionProvider( "html" , "http://jabber.org/protocol/xhtml-im" ,
                 new XHTMLExtensionProvider());
         // Group Chat Invitations
         pm.addExtensionProvider( "x" , "jabber:x:conference" ,
                 new GroupChatInvitation.Provider());
         // Service Discovery # Items
         pm.addIQProvider( "query" , "http://jabber.org/protocol/disco#items" ,
                 new DiscoverItemsProvider());
         // Service Discovery # Info
         pm.addIQProvider( "query" , "http://jabber.org/protocol/disco#info" ,
                 new DiscoverInfoProvider());
         // Data Forms
         pm.addExtensionProvider( "x" , "jabber:x:data" , new DataFormProvider());
         // MUC User
         pm.addExtensionProvider( "x" , "http://jabber.org/protocol/muc#user" ,
                 new MUCUserProvider());
         // MUC Admin
         pm.addIQProvider( "query" , "http://jabber.org/protocol/muc#admin" ,
                 new MUCAdminProvider());
         // MUC Owner
         pm.addIQProvider( "query" , "http://jabber.org/protocol/muc#owner" ,
                 new MUCOwnerProvider());
         // Delayed Delivery
         pm.addExtensionProvider( "x" , "jabber:x:delay" ,
                 new DelayInformationProvider());
         // Version
         try {
             pm.addIQProvider( "query" , "jabber:iq:version" ,
                     Class.forName( "org.jivesoftware.smackx.packet.Version" ));
         } catch (ClassNotFoundException e) {
             // Not sure what's happening here.
             e.printStackTrace();
         }
         // VCard
         pm.addIQProvider( "vCard" , "vcard-temp" , new VCardProvider());
         // Offline Message Requests
         pm.addIQProvider( "offline" , "http://jabber.org/protocol/offline" ,
                 new OfflineMessageRequest.Provider());
         // Offline Message Indicator
         pm.addExtensionProvider( "offline" ,
                 "http://jabber.org/protocol/offline" ,
                 new OfflineMessageInfo.Provider());
         // Last Activity
         pm.addIQProvider( "query" , "jabber:iq:last" , new LastActivity.Provider());
         // User Search
         pm.addIQProvider( "query" , "jabber:iq:search" , new UserSearch.Provider());
         // SharedGroupsInfo
         pm.addIQProvider( "sharedgroup" ,
                 "http://www.jivesoftware.org/protocol/sharedgroup" ,
                 new SharedGroupsInfo.Provider());
         // JEP-33: Extended Stanza Addressing
         pm.addExtensionProvider( "addresses" ,
                 "http://jabber.org/protocol/address" ,
                 new MultipleAddressesProvider());
         // FileTransfer
         pm.addIQProvider( "si" , "http://jabber.org/protocol/si" ,
                 new StreamInitiationProvider());
         pm.addIQProvider( "query" , "http://jabber.org/protocol/bytestreams" ,
                 new BytestreamsProvider());
         // Privacy
         pm.addIQProvider( "query" , "jabber:iq:privacy" , new PrivacyProvider());
         pm.addIQProvider( "command" , "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider());
         pm.addExtensionProvider( "malformed-action" ,
                 "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider.MalformedActionError());
         pm.addExtensionProvider( "bad-locale" ,
                 "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider.BadLocaleError());
         pm.addExtensionProvider( "bad-payload" ,
                 "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider.BadPayloadError());
         pm.addExtensionProvider( "bad-sessionid" ,
                 "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider.BadSessionIDError());
         pm.addExtensionProvider( "session-expired" ,
                 "http://jabber.org/protocol/commands" ,
                 new AdHocCommandDataProvider.SessionExpiredError());
     }
 
     public boolean register(String account, String password) {
         Registration reg = new Registration();
         reg.setType(IQ.Type.SET);
         reg.setTo(connection.getServiceName());
         reg.setUsername(account); // 注意这里createAccount注册时，参数是username，不是jid，是“@”前面的部分。
         reg.setPassword(password);
         reg.addAttribute( "android" , "geolo_createUser_android" ); // 这边addAttribute不能为空，否则出错。所以做个标志是android手机创建的吧！！！！！
         PacketFilter filter = new AndFilter( new PacketIDFilter(
                 reg.getPacketID()), new PacketTypeFilter(IQ. class ));
         PacketCollector collector = connection.createPacketCollector(filter);
         connection.sendPacket(reg);
         IQ result = (IQ) collector.nextResult(SmackConfiguration
                 .getPacketReplyTimeout());
         if (result == null ) {
             MLog.makeText( "连接超时" );
         } else if (result.getType() == IQ.Type.RESULT) {
             MLog.makeText( "注册成功" );
             return true ;
         } else {
             MLog.makeText(result.getError().toString());
         }
         return false ;
     }
 
     public boolean login(String userName, String userPwd) {
         try {
             connection.login(userName, userPwd);
             user = userName + "@" + connection.getServiceName();
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
         }
         MLog.makeText( "登录失败" );
         return false ;
     }
 
     public void changePassword(String pwd) {
         try {
             connection.getAccountManager().changePassword(pwd);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 更改用户状态
      */
     public void setPresence( int code) {
         Presence presence = null ;
         switch (code) {
         case 0 :
             presence = new Presence(Presence.Type.available);
             connection.sendPacket(presence);
             MLog.makeText( "设置在线" );
             break ;
         case 1 :
             presence = new Presence(Presence.Type.available);
             presence.setMode(Presence.Mode.chat);
             connection.sendPacket(presence);
             MLog.makeText( "设置Q我吧" );
             break ;
         case 2 :
             presence = new Presence(Presence.Type.available);
             presence.setMode(Presence.Mode.dnd);
             connection.sendPacket(presence);
             MLog.makeText( "设置忙碌" );
             break ;
         case 3 :
             presence = new Presence(Presence.Type.available);
             presence.setMode(Presence.Mode.away);
             connection.sendPacket(presence);
             MLog.makeText( "设置离开" );
             break ;
         case 4 :
             Roster roster = connection.getRoster();
             Collection<RosterEntry> entries = roster.getEntries();
             for (RosterEntry entry : entries) {
                 presence = new Presence(Presence.Type.unavailable);
                 presence.setPacketID(Packet.ID_NOT_AVAILABLE);
                 presence.setFrom(connection.getUser());
                 presence.setTo(entry.getUser());
                 connection.sendPacket(presence);
             }
             // 向同一用户的其他客户端发送隐身状态
             presence = new Presence(Presence.Type.unavailable);
             presence.setPacketID(Packet.ID_NOT_AVAILABLE);
             presence.setFrom(connection.getUser());
             presence.setTo(StringUtils.parseBareAddress(connection.getUser()));
             connection.sendPacket(presence);
             MLog.makeText( "设置隐身" );
             break ;
         case 5 :
             presence = new Presence(Presence.Type.unavailable);
             connection.sendPacket(presence);
             MLog.makeText( "设置离线" );
             break ;
         default :
             break ;
         }
     }
 
     public void logoutAccount() {
         try {
             connection.getAccountManager().deleteAccount();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     public Collection<RosterGroup> getGroups() {
         return connection.getRoster().getGroups();
     }
 
     public List<RosterEntry> getEntriesByGroup(String groupName) {
         List<RosterEntry> Entrieslist = new ArrayList<RosterEntry>();
         RosterGroup rosterGroup = connection.getRoster().getGroup(groupName);
         Collection<RosterEntry> rosterEntry = rosterGroup.getEntries();
         Iterator<RosterEntry> i = rosterEntry.iterator();
         while (i.hasNext()) {
             Entrieslist.add(i.next());
         }
         return Entrieslist;
     }
 
     public Drawable getUserImage(String user) {
         ByteArrayInputStream bais = null ;
         try {
             VCard vcard = new VCard();
             // 加入这句代码，解决No VCard for
             ProviderManager.getInstance().addIQProvider( "vCard" , "vcard-temp" ,
                     new org.jivesoftware.smackx.provider.VCardProvider());
             if (user == "" || user == null || user.trim().length() <= 0 ) {
                 return null ;
             }
             vcard.load(connection, user + "@" + connection.getServiceName());
             if (vcard == null || vcard.getAvatar() == null )
                 return null ;
             bais = new ByteArrayInputStream(vcard.getAvatar());
             BitmapDrawable drawable = new BitmapDrawable(bais);
             bais.close();
             return drawable;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null ;
     }
 
     public List<RosterEntry> getAllEntries() {
         List<RosterEntry> Entrieslist = new ArrayList<RosterEntry>();
         Collection<RosterEntry> rosterEntry = connection.getRoster()
                 .getEntries();
         Iterator<RosterEntry> i = rosterEntry.iterator();
         while (i.hasNext()) {
             Entrieslist.add(i.next());
         }
         return Entrieslist;
     }
 
     public boolean addGroup(String groupName) {
         try {
             connection.getRoster().createGroup(groupName);
             MLog.makeText( "创建成功" );
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false ;
     }
 
     /**
      * 添加好友 无分组
      *
      * @param userName
      * @param name
      * @return
      */
     public boolean addUser(String userName, String name) {
         try {
             String account = userName + "@" + connection.getServiceName();
             connection.getRoster().createEntry(account, name, null );
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false ;
     }
 
     public boolean addUserWithName(String userName, String name,
             Presence.Type type) {
         return addUserWithName(userName, name, XMsgConst.X_DEFAULT_GROUP, type);
     }
 
     /**
      * 添加好友 有分组
      *
      * @param userName
      * @param name
      * @param groupName
      * @return
      */
     public boolean addUserWithName(String userName, String name,
             String groupName, Presence.Type type) {
         try {
             Presence subscription = new Presence(type);
             subscription.setTo(userName);
             userName += "@" + connection.getServiceName();
             connection.sendPacket(subscription);
             if (type == Type.subscribed)
                 connection.getRoster().createEntry(userName, name,
                         new String[] { groupName });
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
             return false ;
         }
     }
 
     public boolean removeUser(String userName) {
         try {
             RosterEntry entry = null ;
             if (userName.contains( "@" ))
                 entry = connection.getRoster().getEntry(userName);
             else
                 entry = connection.getRoster().getEntry(
                         userName + "@" + connection.getServiceName());
             if (entry == null )
                 entry = connection.getRoster().getEntry(userName);
             connection.getRoster().removeEntry(entry);
             return true ;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false ;
     }
 
     public List<XUserItem> searchUsers(String userName) {
         List<XUserItem> results = new ArrayList<XUserItem>();
         try {
             UserSearchManager usm = new UserSearchManager(connection);
             String serverDomain = "search." + connection.getServiceName();
             Form searchForm = usm.getSearchForm(serverDomain);
             Form answerForm = searchForm.createAnswerForm();
             answerForm.setAnswer( "Username" , true );
             answerForm.setAnswer( "search" , userName);
             ReportedData data = usm.getSearchResults(answerForm, serverDomain);
             Iterator<Row> it = data.getRows();
             Row row = null ;
             XUserItem user = null ;
             while (it.hasNext()) {
                 row = it.next();
                 String uName = row.getValues( "Username" ).next().toString();
                 String Name = row.getValues( "Name" ).next().toString();
                 String Email = row.getValues( "Email" ).next().toString();
                 user = new XUserItem(uName, Name, Email);
                 results.add(user);
             }
             return results;
         } catch (XMPPException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return results;
     }
 
     public void sendMessage(String toJID, String message) {
         // TODO Auto-generated method stub
         final Message newMessage = new Message(toJID, Message.Type.chat);
         newMessage.setBody(message);
         connection.sendPacket(newMessage);
     }
 
     @Override
     public void connectionClosed() {
         // TODO Auto-generated method stub
         MLog.makeText( "连接已关闭" );
     }
 
     @Override
     public void connectionClosedOnError(Exception arg0) {
         // TODO Auto-generated method stub
         MLog.makeText( "连接关闭异常" );
         arg0.printStackTrace();
     }
 
     @Override
     public void reconnectingIn( int arg0) {
         // TODO Auto-generated method stub
         MLog.makeText( "reconnectingIn:" + arg0);
     }
 
     @Override
     public void reconnectionFailed(Exception arg0) {
         // TODO Auto-generated method stub
         MLog.makeText( "连接失败" );
         arg0.printStackTrace();
     }
 
     @Override
     public void reconnectionSuccessful() {
         // TODO Auto-generated method stub
         MLog.makeText( "重连成功" );
     }
 
     @Override
     public void connectionCreated(Connection arg0) {
         // TODO Auto-generated method stub
         BroadSender.sendBroadcast(SplashActivity. class );
     }
 
     @Override
     public void processPacket(Packet packet) {
         // TODO Auto-generated method stub
         if (packet instanceof Message) {
             Message msg = (Message) packet;
             CacheUtils.getInstance().addMessage(msg);
             BroadSender.sendBroadcast(ChatActivity. class , "action" ,
                     XMsgConst.X_PACKET_TYPE_MESSAGE);
         } else if (packet instanceof Presence) {
             Presence presence = (Presence) packet;
             String from = presence.getFrom(); // 发送方
             String to = presence.getTo(); // 接收方
             Type type = presence.getType();
             int typeValue = 0 ;
             if (type.equals(Presence.Type.subscribe)) {
                 // 好友申请
                 typeValue = XMsgConst.X_PRESENCE_SUBSCRIBE;
             } else if (type.equals(Presence.Type.subscribed)) {
                 // 同意添加好友
                 typeValue = XMsgConst.X_PRESENCE_SUBSCRIBED;
             } else if (type.equals(Presence.Type.unsubscribe)) {
                 // 拒绝添加好友
                 typeValue = XMsgConst.X_PRESENCE_UNSUBSCRIBE;
             } else if (type.equals(Presence.Type.unsubscribed)) {
                 // 删除好友
                 typeValue = XMsgConst.X_PRESENCE_UNSUBSCRIBED;
             } else if (type.equals(Presence.Type.unavailable)) {
                 // 好友下线
                 typeValue = XMsgConst.X_PRESENCE_UNAVAILABLE;
                 from = processFrom(from);
                 CacheUtils.getInstance().putPresence(from, presence);
             } else {
                 // 好友上线
                 typeValue = XMsgConst.X_PRESENCE_ONLINE;
                 from = processFrom(from);
                 CacheUtils.getInstance().putPresence(from, presence);
             }
             String[] params = new String[] { "action" ,
                     XMsgConst.X_PACKET_TYPE_PRESENCE, "type" ,
                     String.valueOf(typeValue), "from" , from, "to" , to };
             BroadSender.sendBroadcast(MainActivity. class , params);
         }
     }
 
     /**
      * 去掉多余的服务器字符串
      *
      * @param from
      * @return
      */
     private String processFrom(String from) {
         int endPos = from.lastIndexOf( "/" );
         if (endPos != - 1 )
             from = from.substring( 0 , endPos);
         return from;
     }
 
}

点击下载

使用openfire搭建IM聊天系统(一)
Huang兄
09-15 5442
一 准备操作系统:ubuntu15.04; 数据库:mysql5.6; jdk:java8 openfire是4.0.3 没有安装java环境的可以使用ppa安装sudo apt-get install python-software-properties sudo add-apt-repository ppa:webupd8team/java sudo apt-get update如果
利用OpenFire/Spark构建企业内部IM平台
bisword的专栏
01-21 5990
 利用OpenFire构建企业内部IM平台企业IM的意义作为现代企业，部门间的沟通亦将显得尤为重要，经常使用的交流工具主要有电话，邮件，即时通信软件。而即时通信软件具有成本低廉，流通方便，并有部分人性化设计，并且具有沟通过程中相应的归档功能，因此构建内部IM交流平台就显得尤为重要。也许有人会说，有那么多商业公司开发的优秀的即时通信软件，并且大部分是免费的，为什么还需要重新造车，岂不
openfire+smack开发webim笔记
12-15
这个事个人使用openfire+smack开发webim的一些资料，收集起来，方便大家使用！
openfire系列----简单的js im聊天实现
xyy511的专栏
05-25 7834
备注：实现这个功能折腾了一天，调出了一个简单的雏形，在这里总结下 这里我大概的讲下openfire相关的各个部分的功能， 一：openfire 简单来说，OpenFire是一个采用纯Java语言编写（核心架构使用Mina构建）的开源RTC（Real-Time Communications，实时协作）服务器。它采用XMPP协议进行分布式通信，该协议的前身其实就是基于Jabber协议，只不过X
自己搞个聊天工具，爽！
纯洁的微笑
11-23 910
哈喽，大家好，我是开源君，一个资深的互联网玩家，致力于为大家分享各领域优质开源项目。微信或 QQ 是我们大家很常用的聊天工具，其实还有很多即时通讯的地方，比如某宝的客服啥的。说起这个开源君...
基于openfire的IM即时通讯软件开发
weixin_30615767的博客
04-28 126
openfire：http://www.igniterealtime.org/ Xmpp：http://xmpp.org/ IOS（xmppframework）：https://github.com/robbiehanson/XMPPFramework Android（asmack）：https://github.com/flowdalic/asmack 转载于:https://www...
XMPP_OPenfire即时通讯IM-android版
11-15
3. **单聊文本**: 实现一对一的文字聊天，使用XMPP的`Message`对象发送文本消息，并监听`Message`事件来接收对方的消息。 4. **语音消息**: 语音消息通常需要先录制，然后转换为音频文件，如MP3或AAC格式。通过上传...
基于Openfire和Spark打造安卓IM聊天应用教程
在使用Openfire和Smack库开发聊天应用时，需要考虑通信过程中的安全性，例如使用TLS/SSL加密数据传输，以及在服务器端进行合适的权限控制。同时，针对高并发的场景，要对系统进行优化，确保良好的用户体验。 #### 9...
Android IM之基于Openfire+Smack的聊天服务器的搭建与测试
09-25
在Android平台上构建即时通讯（IM）系统是一项技术挑战，但借助开源工具，我们可以简化这个过程。本教程将探讨如何利用Openfire服务器和Smack库来搭建一个基础的Android聊天应用。Openfire是一款开源的XMPP服务器，...
openfire 即时聊天
01-18
虽然QQ有自己的IM服务器和协议，但Openfire作为一个开放平台，理论上可以通过一些手段实现与QQ的互联互通，比如使用第三方插件或者自定义协议适配器。 总结起来，Openfire即时聊天系统基于XMPP协议，利用Asmack.jar...
web-im.rar_React_im_im服务器_react openfire
09-23
标题“web-im.rar_React_im_im服务器_react_openfire”暗示了一个基于React的Web即时通讯（IM）项目，其中使用了Openfire作为后端服务器。这个项目可能包含了实现单聊和群聊功能的所有必要组件和配置。让我们深入...
自建聊天系统
10-10
自建聊天系统，企业自用，摒弃qq和微信，均可以，哈哈哈
基于openfire 的android IM 即时通讯smack的android IM
03-01
基于openfire 的android IM 即时通讯smack的android IM 开源 仅用于学习研究、请勿他用
`DuckChat` 是一款即时通讯解决方案，用以搭建安全的私有聊天软件服务，可以帮你拥有一套自己的微信、钉钉等类似的移动社交产品。
10-23
# [DuckChat](http://duck.chat) > `私有部署，保证信息安全` - `长链接、大集群，支持500+服务器` > > `也支持单机部署，非常灵活` - `iOS、Android、Web全端支持` ## 当前版本(1.0-beta-6) > **向我们提问、反馈问题** > 安装与使用教程：https://duckchat.akaxin.com/wiki/ ## 简介 `DuckChat` 是一款即时通讯解决方案，用以搭建安全的私有聊天软件服务，可以帮你拥有一套自己的微信、钉钉等类似的移动社交产品。 因服务器掌握在自己手里，在获取便利的同时，还同时拥有对自己数据、业务的`100%`可控权，防止企业商业机密泄漏等。 **适用场景** - 1️⃣ `企业内部办公聊天` - 2️⃣ `精英用户私有聊天` - 3⃣️ `内网社交软件，如校园漂流瓶等` - 4⃣️ `将已有站点快速移动化，如Discuz、Wordpress等` ## 功能特性 **
聊天应用搭建
最新发布
u013543671的博客
07-22 682
新手程序员，在gitee上搜索了一个开源项目，基于uni-app+socket.io的聊天应用，记录下本地搭建应用的全过程，感谢原作者，项目地址见文章最下方
我的XMPP协议IM架构
weixin_34294649的博客
03-15 221
2019独角兽企业重金招聘Python工程师标准>>> ...
IM消息推送之Openfire
赵士杰的博客
04-13 254
关键字：IM消息推送之Openfire Openfire 采用Java开发，开源的实时协作（RTC）服务器基于XMPP（Jabber）协议。Openfire安装和使用都非常简单，并利用Web进行管理。单台服务器可支持上万并发用户。 什么是OpenFire 您可以使用它轻易的构建高效率的即时通信服务器. Openfire安装和使用都非常简单，并利用Web进行管理。单台服务器可支持上万并发用户...
IM学习-认识Openfire（三）
牛八少爷的专栏
05-18 2288
目录 3.Openfire 3.1 Openfire简介 3.2 Openfire官网 3.3 下载和安装 3.4 Openfire配置 3.4.1 进入配置页面 3.4.2配置语言 3.4.3配置服务器 3.4.4数据库配置 3.4.5 配置管理账号 3.4.6配置结果 3.Openfire 3.1 Openfire简介 Openfire是免费、开源的，基于XMP...
IM开发【2】 - Openfire 服务器编译以及部署
kerlubasola
06-08 173
由于工作需要，这几天在研究openfire的插件开发，整的头都大了，配置环境、部署源码...由于网上的资料五花八门，几乎每种都试过，好多是走不通的，所以在这里记录一下我部署openfire源码的流程，分享给大家，也方便以后时间长了如果忘记可以参考，这可是我的血泪史啊... 首先，介绍几个概念： XMPP:就是一个发送接收处理消息的协议，通过XML机制实现 IM：即时通信软件，如QQ、MSN等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值