基于openfire+smack的Android、Web、PC开发(一)

时间  2019-11-10
标签 基于 openfire+smack openfire smack android web 开发 栏目 Android 繁體版
原文   原文链接

前言java

Java领域的即时通讯的解决方案能够考虑openfire+spark+smack。固然也有其余的选择。mysql

Openfire是基于Jabber协议(XMPP)实现的即时通讯服务器端版本，目前建议使用3.8.1版本，这个版本是当前最新的版本，并且网上能够找到下载的源代码。android

即时通讯客户端可以使用spark2.6.3,这个版本是目前最新的release版本，通过测试发现上一版本在视频支持,msn网关支持上可能有问题，因此选择openfire3.8.1+spark2.6.3是最合适的选择。web

Smack是即时通讯客户端编程库，目前我已测统统过jsp使用smack的API向openfire注册用户发送消息，而且能够经过监听器得到此用户的应答消息。sql

经过smack向msn用户和QQ用户,gtalk用户发送消息应该也能够实现，关于向gtalk用户发送消息的例子较多。这个留待之后研究。至少目前能够经过程序向spark发消息了。对于局域网内部应用足以解决系统与用户交互的问题，甚至能够作自动应答机器人。数据库

Spark支持聊天，语音，视频，会议，文件收发，截屏，链接msn等功能。apache

同时在Android移动端和Web端也有相应的编程库支持，在后面的章节会为你们逐步更新介绍，接下来咱们首先要对几个重点的技术环节作些必要的讲解。编程

1.什么是XMPPapi

XMPP(Extensible Messaging and Presence Protocol)，简单的来说，它就是一个发送接收处理消息的协议，可是这个协议发送的消息，既不是二进制的东东也不是字符串，而是XML。正是由于使用了XML做为消息传递的中介，Extensible 才谈的上。XMPP的前身是Jabber，一个开源形式组织产生的网络即时通讯协议。XMPP目前被IETF国际标准组织完成了标准化工做。服务器

2.IM

Instant Messenger，及时通讯软件，就是你们使用的QQ、MSN Messenger和Gtalk等等。其中Gtalk 就是基于XMPP 协议的一个实现，其余的则不是。当前IM 几乎做为每一个上网者必然使用的工具，在国外的大型企业中有一些企业级的IM应用，可是其商业价值还没彻底发挥出来。设想既然XMPP 协议是一个公开的协议，那么每一个企业均可以利用它来开发适合自己企业工做，提升自身生产效率的IM；甚至，你还能够在网络游戏中集成这种通讯软件，不但让你能够边游戏边聊天，也能够开发出适合游戏自己的IM 应用，好比说一些游戏关键场景提醒功能，团队语音交流等等均可以基于IM来实现。

3.Spark,smack和Openfire

开源界老是有许多有趣的东东，这三个合起来就是一个完整的XMPP IM 实现。包括服务器端——Openfire，客户端——Spark，XMPP 传输协议的实现——Smack（记住，XMPP是一个协议，协议是须要实现的，Smack起到的就是这样的一个做用）。三者都是基于Java 语言的实现。

Spark 提供了客户端一个基本的实现，并提出了一个很好的插件架构，这对于开发者来讲不能不说是一个福音。我强烈建议基于插件方式来实现你新增长的功能，而不是去改它的源代码，这样有利于你项目架构，把原始项目的影响降到最低。

Openfire 是基于XMPP 协议的IM 的服务器端的一个实现，虽然当两个用户链接后，能够经过点对点的方式来发送消息，可是用户仍是须要链接到服务器来获取一些链接信息和通讯信息的，因此服务器端是必需要实现的。Openfire 也提供了一些基本功能，但真的很基本的！庆幸的是，它也提供插件的扩展，像Spark 同样，一样强烈建议使用插件扩展的方式来增长新的功能，而不是修改人家的源代码。

Smack 是一个XMPP 协议的Java 实现，提供一套可扩展的API，不过有些时候，你仍是不得不使用本身定制发送的XML 文件内容的方式来实现本身的功能

下图展现了三者之间的关系：

Spark 提供了客户端一个基本的实现，并提出了一个很好的插件架构，这对于开发者来讲不能不说是一个福音。我强烈建议基于插件方式来实现你新增长的功能，而不是去改它的源代码，这样有利于你项目架构，把原始项目的影响降到最低。

Openfire 是基于XMPP 协议的IM 的服务器端的一个实现，虽然当两个用户链接后，能够经过点对点的方式来发送消息，可是用户仍是须要链接到服务器来获取一些链接信息和通讯信息的，因此服务器端是必需要实现的。Openfire 也提供了一些基本功能，但真的很基本的！庆幸的是，它也提供插件的扩展，像Spark 同样。

Smack 是一个XMPP 协议的Java 实现，提供一套可扩展的API，不过有些时候，你仍是不得不使用本身定制发送的XML 文件内容的方式来实现本身的功能。

4.安装Openfire3.8.1

使用openfire须要配置机器的域名。若是局域网内没有安装域服务器，则须要手工为机器配置域名，打开C:\WINDOWS\system32\drivers\etc\hosts文件，增长一新行： 127.0.0.1 csdn.shimiso.com （用户根据本身的须要可配置称别的名字，但最好符合带.的域名格式） 其余机器使用域名访问openfire,也须要在C:\WINDOWS\system32\drivers\etc\hosts中指定bzwang.tzsoft.com对应的ip地址，假设安装openfire的主机IP为192.168.1.10,则hosts文件中应增长一新行: 192.168.1.10 csdn.shimiso.com 经过这种方式指定主机域名，建议安装openfire的机器配置静态ip地址以避免ip发生改变。

语言选择简体中文，见下图：

后续按照提示安装，点击完成启动openfire，最后出现下面的界面：

点”Launch Admin”,出现下面的页面，页面链接为http://127.0.0.1:9090/setup/index.jsp

语种选择中文（简体），点”Continue”:（下面的页面若是出现英文，请刷新一下页面或者从新点Launch Admin）

这个页面的Domain默认为机器名，请改成一开始设置的域名，例如csdn.shimiso.com，接着点Continue(继续):

这个页面中第一个选项，即标准数据库链接，不要选择嵌入的数据库( Embedded Database,嵌入的数据库是hsqldb数据库，生产环境不要选择此选项),而后点”继续”:

这里我用的是mysql数据库，按官方要求最好是5.0以上，确保有个名字叫openfire的库存在，配好后点继续

这个页面是配置是否使用LDAP,咱们如今不配置LDAP,因此选择 Default默认便可，点继续:

这里填写邮箱和确认密码后直接点继续：

等待大约30秒左右，到此安装和配置操做所有完成。打开http://127.0.0.1:9090/login.jsp登陆管理页面

进入用户/组新增一个用户。

5.客户端配置和调试

这里我没用使用官方的spark客户端，而是用了 潘迪安 和 如意通 ，配置截图以下：

聊天演示：

从上面的聊天记录咱们发现全部的用户id全称都是：用户名@域名/资源名，这个就是咱们在XMPP协议中一般说说的JID，即jabber id，它是一个xmpp协议账号系统的通称，后面咱们在使用smack编程库调试接口时会常常用到这个参数。

6.使用Smack编程库进行代码功能调试

关于Smack编程库，前面咱们提到，它是面向Java端的api，主要在PC上使用，利用它咱们能够 向openfire服务器注册用户，发送消息，而且能够经过监听器得到此用户的应答消息，以及构建聊天室，分组，我的通信录等等。

下面咱们写几个程序小例子测试一下。

（1）登陆操做 PPConnection.DEBUG_ENABLED = true; AccountManager accountManager; final ConnectionConfiguration connectionConfig = new ConnectionConfiguration( "192.168.1.78", Integer.parseInt("5222"), "csdn.shimiso.com");

// 容许自动链接
connectionConfig.setReconnectionAllowed(true);
connectionConfig.setSendPresence(true);

Connection connection = new XMPPConnection(connectionConfig);
try {
  connection.connect();// 开启链接
  accountManager = connection.getAccountManager();// 获取帐户管理类
} catch (XMPPException e) {
  throw new IllegalStateException(e);
}

// 登陆
connection.login("admin", "admin","SmackTest");
System.out.println(connection.getUser()); 
connection.getChatManager().createChat("shimiso@csdn.shimiso.com",null).sendMessage("Hello word!");

运行结果：

在login中一共有三个参数，登陆名，密码，资源名，可能有人不明白资源名究竟是什么意思，其实就是客户端的来源，客户端的名称，若是不写它默认就叫smack，若是你用相同的帐户不一样的资源名和同一我的发三条消息，那将会弹出三个窗口，而不是一个窗口。 同时smack还为咱们提供了很是好的调试工具Smack Debug，利用该工具咱们能够准确的捕获详细的往返报文信息。

（2）下面咱们继续写个聊天的例子： PPConnection.DEBUG_ENABLED = true; AccountManager accountManager; final ConnectionConfiguration connectionConfig = new ConnectionConfiguration( "192.168.1.78", Integer.parseInt("5222"), "csdn.shimiso.com");

// 容许自动链接
connectionConfig.setReconnectionAllowed(true);
connectionConfig.setSendPresence(true);

Connection connection = new XMPPConnection(connectionConfig);
try {
  connection.connect();// 开启链接
  accountManager = connection.getAccountManager();// 获取帐户管理类
} catch (XMPPException e) {
  throw new IllegalStateException(e);
}

// 登陆
connection.login("admin", "admin","SmackTest3");  
ChatManager chatmanager = connection.getChatManager();
Chat newChat = chatmanager.createChat("shimiso@csdn.shimiso.com", new MessageListener() {
  public void processMessage(Chat chat, Message message) {
    if (message.getBody() != null) {
      System.out.println("Received from 【"
          + message.getFrom() + "】 message: "
          + message.getBody());
    }

  }
});
Scanner input = new Scanner(System.in);
while (true) {
  String message = input.nextLine(); 
  newChat.sendMessage(message);
}

运行结果：

这里咱们用Scanner来捕捉用户在控制台的键盘操做，将信息发出，同时建立了一个MessageListener监听，在其中强制实现processMessage方法便可捕获发回的信息，在初次使用上仍是较为容易上手的，咱们只要细心查看API便可逐步深刻下去。

（3）除了聊天之外咱们常常还能想到就是广播，须要给全部在线的用户发送一个通知，或者给全部在线和离线的用户全发送，咱们先演示如何给在线用户发送一个广播： PPConnection.DEBUG_ENABLED = false; AccountManager accountManager; final ConnectionConfiguration connectionConfig = new ConnectionConfiguration( "192.168.1.78", Integer.parseInt("5222"), "csdn.shimiso.com");

// 容许自动链接
connectionConfig.setReconnectionAllowed(true);
connectionConfig.setSendPresence(true);

Connection connection = new XMPPConnection(connectionConfig);
try {
  connection.connect();// 开启链接
  accountManager = connection.getAccountManager();// 获取帐户管理类
} catch (XMPPException e) {
  throw new IllegalStateException(e);
}
connection.login("admin", "admin","SmackTest3"); 
Message newmsg = new Message(); 
newmsg.setTo("shimiso@csdn.shimiso.com");
newmsg.setSubject("重要通知");
newmsg.setBody("今天下午2点60分有会！");
newmsg.setType(Message.Type.headline);// normal支持离线 
connection.sendPacket(newmsg);
connection.disconnect();

运行结果：

将参数设置为Message.Type.normal便可支持离线广播，openfire系统会自动判断该用户是否在线，若是在线就直接发送出去，若是不在线则将信息存入ofoffline表，如今我将shimiso用户退出登陆，再给它发消息，咱们能够进入openfire库的ofoffline表中，很是清楚看到里面躺着一条离线消息记录是发给shimiso这个用户的

（4）那么咱们如何让shimiso这个用户一登录就取到离线消息呢？请看以下代码 PPConnection.DEBUG_ENABLED = false; AccountManager accountManager; final ConnectionConfiguration connectionConfig = new ConnectionConfiguration( "192.168.1.78", Integer.parseInt("5222"), "csdn.shimiso.com");

// 容许自动链接
connectionConfig.setReconnectionAllowed(true);
connectionConfig.setSendPresence(false);//不要告诉服务器本身的状态
Connection connection = new XMPPConnection(connectionConfig);
try {
  connection.connect();// 开启链接
  accountManager = connection.getAccountManager();// 获取帐户管理类
} catch (XMPPException e) {
  throw new IllegalStateException(e);
} 
connection.login("shimiso", "123","SmackTest"); 
OfflineMessageManager offlineManager = new OfflineMessageManager(
    connection);
try {
  Iterator<org.jivesoftware.smack.packet.Message> it = offlineManager
      .getMessages();

  System.out.println(offlineManager.supportsFlexibleRetrieval());
  System.out.println("离线消息数量: " + offlineManager.getMessageCount());

  Map<String, ArrayList<Message>> offlineMsgs = new HashMap<String, ArrayList<Message>>();

  while (it.hasNext()) {
    org.jivesoftware.smack.packet.Message message = it.next();
    System.out
        .println("收到离线消息, Received from 【" + message.getFrom()
            + "】 message: " + message.getBody());
    String fromUser = message.getFrom().split("/")[0];

    if (offlineMsgs.containsKey(fromUser)) {
      offlineMsgs.get(fromUser).add(message);
    } else {
      ArrayList<Message> temp = new ArrayList<Message>();
      temp.add(message);
      offlineMsgs.put(fromUser, temp);
    }
  }

  // 在这里进行处理离线消息集合......
  Set<String> keys = offlineMsgs.keySet();
  Iterator<String> offIt = keys.iterator();
  while (offIt.hasNext()) {
    String key = offIt.next();
    ArrayList<Message> ms = offlineMsgs.get(key);

    for (int i = 0; i < ms.size(); i++) {
      System.out.println("-->" + ms.get(i));
    }
  }

  offlineManager.deleteMessages();
} catch (Exception e) {
  e.printStackTrace();
}
offlineManager.deleteMessages();//删除全部离线消息
Presence presence = new Presence(Presence.Type.available);
    		nnection.sendPacket(presence);//上线了
    		nnection.disconnect();//关闭链接

运行结果：

这里咱们须要特别小心的是先不要告诉openfire服务器你上线了，不然永远也拿不到离线消息，用下面老外的话将就是在你上线以前去获取离线消息，这么设计是颇有道理的。

The OfflineMessageManager helps manage offline messages even before the user has sent an available presence. When a user asks for his offline messages before sending an available presence then the server will not send a flood with all the offline messages when the user becomes online. The server will not send a flood with all the offline messages to the session that made the offline messages request or to any other session used by the user that becomes online.

同时拿到离线消息之后删除离线消息offlineManager.deleteMessages();，同是通知服务器本身上线了。

（5）下面咱们来看看如何来发送文件 PPConnection.DEBUG_ENABLED = false; AccountManager accountManager; final ConnectionConfiguration connectionConfig = new ConnectionConfiguration( "192.168.1.78", Integer.parseInt("5222"), "csdn.shimiso.com");

// 容许自动链接
connectionConfig.setReconnectionAllowed(true);
connectionConfig.setSendPresence(true);

Connection connection = new XMPPConnection(connectionConfig);
try {
  connection.connect();// 开启链接
  accountManager = connection.getAccountManager();// 获取帐户管理类
} catch (XMPPException e) {
  throw new IllegalStateException(e);
}
  connection.login("admin", "admin","Rooyee"); 
  Presence pre = connection.getRoster().getPresence("shimiso@csdn.shimiso.com");
  System.out.println(pre);
  if (pre.getType() != Presence.Type.unavailable) {
    // 建立文件传输管理器
    FileTransferManager manager = new FileTransferManager(connection);
    // 建立输出的文件传输
    OutgoingFileTransfer transfer = manager
        .createOutgoingFileTransfer(pre.getFrom());
    // 发送文件
    transfer.sendFile(new File("E:\\Chrysanthemum.jpg"), "图片");
    while (!transfer.isDone()) {
      if (transfer.getStatus() == FileTransfer.Status.in_progress) {
        // 能够调用transfer.getProgress();得到传输的进度　
        System.out.println(transfer.getStatus());
        System.out.println(transfer.getProgress());
        System.out.println(transfer.isDone());
      }
    }
  }

运行结果：

在这里咱们须要特别注意的是，跨资源是没法发送文件的，看connection.login("admin", "admin","Rooyee");这个代码就明白了，必须是“域名和资源名”彻底相同的两个用户才能够互发文件，不然永远都没反应，若是不清楚本身所用的客户端的资源名，能够借助前面提到的SmackDebug工具查看往返信息完整报文，在to和from中必定能够看到。

若是咱们本身要写文件接收例子的话，参考代码以下： FileTransferManager transfer = new FileTransferManager(connection); transfer.addFileTransferListener(new RecFileTransferListener()); public class RecFileTransferListener implements FileTransferListener {

public String getFileType(String fileFullName) { if (fileFullName.contains(".")) { return "." + fileFullName.split("//.")[1]; } else { return fileFullName; }

}

@Override public void fileTransferRequest(FileTransferRequest request) { System.out.println("接收文件开始....."); final IncomingFileTransfer inTransfer = request.accept(); final String fileName = request.getFileName(); long length = request.getFileSize(); final String fromUser = request.getRequestor().split("/")[0]; System.out.println("文件大小:" + length + " " + request.getRequestor()); System.out.println("" + request.getMimeType()); try {

JFileChooser chooser = new JFileChooser();
  chooser.setCurrentDirectory(new File("."));

  int result = chooser.showOpenDialog(null);

  if (result == JFileChooser.APPROVE_OPTION) {
    final File file = chooser.getSelectedFile();
    System.out.println(file.getAbsolutePath());
    new Thread() {
      public void run() {
        try {

          System.out.println("接受文件: " + fileName);
          inTransfer
              .recieveFile(new File(file
                  .getAbsolutePath()
                  + getFileType(fileName)));

          Message message = new Message();
          message.setFrom(fromUser);
          message.setProperty("REC_SIGN", "SUCCESS");
          message.setBody("[" + fromUser + "]发送文件: "
              + fileName + "/r/n" + "存储位置: "
              + file.getAbsolutePath()
              + getFileType(fileName));
          if (Client.isChatExist(fromUser)) {
            Client.getChatRoom(fromUser)
                .messageReceiveHandler(message);
          } else {
            ChatFrameThread cft = new ChatFrameThread(
                fromUser, message);
            cft.start();

          }
        } catch (Exception e2) {
          e2.printStackTrace();
        }
      }
    }.start();
  } else {

    System.out.println("拒绝接受文件: " + fileName);

    request.reject();
    Message message = new Message();
    message.setFrom(fromUser);
    message.setBody("拒绝" + fromUser + "发送文件: " + fileName);
    message.setProperty("REC_SIGN", "REJECT");
    if (Client.isChatExist(fromUser)) {
      Client.getChatRoom(fromUser).messageReceiveHandler(message);
    } else {
      ChatFrameThread cft = new ChatFrameThread(fromUser, message);
      cft.start();
    }
  }

  /*
   * InputStream in = inTransfer.recieveFile();
   * 
   * String fileName = "r"+inTransfer.getFileName();
   * 
   * OutputStream out = new FileOutputStream(new
   * File("d:/receive/"+fileName)); byte[] b = new byte[512];
   * while(in.read(b) != -1) { out.write(b); out.flush(); }
   * 
   * in.close(); out.close();
   */
} catch (Exception e) {
  e.printStackTrace();
}

System.out.println("接收文件结束.....");

}

} （6）用户列表 **

  • 返回全部组信息 <RosterGroup>
  • @return List(RosterGroup) */ public static List<RosterGroup> getGroups(Roster roster) { List<RosterGroup> groupsList = new ArrayList<RosterGroup>(); Collection<RosterGroup> rosterGroup = roster.getGroups(); Iterator<RosterGroup> i = rosterGroup.iterator(); while (i.hasNext()) groupsList.add(i.next()); return groupsList; }

/**

  • 返回相应(groupName)组里的全部用户<RosterEntry>
  • @return List(RosterEntry) */ public static List<RosterEntry> getEntriesByGroup(Roster roster, String groupName) { List<RosterEntry> EntriesList = new ArrayList<RosterEntry>(); RosterGroup rosterGroup = roster.getGroup(groupName); Collection<RosterEntry> rosterEntry = rosterGroup.getEntries(); Iterator<RosterEntry> i = rosterEntry.iterator(); while (i.hasNext()) EntriesList.add(i.next()); return EntriesList; }

/**

  • 返回全部用户信息 <RosterEntry>
  • @return List(RosterEntry) */ public static List<RosterEntry> getAllEntries(Roster roster) { List<RosterEntry> EntriesList = new ArrayList<RosterEntry>(); Collection<RosterEntry> rosterEntry = roster.getEntries(); Iterator<RosterEntry> i = rosterEntry.iterator(); while (i.hasNext()) EntriesList.add(i.next()); return EntriesList; } （7）用户头像的获取， 使用VCard，很强大，具体本身看API吧，能够看看VCard传回来XML的组成，含有不少信息的 **
  • 获取用户的vcard信息
  • @param connection
  • @param user
  • @return
  • @throws XMPPException */ public static VCard getUserVCard(XMPPConnection connection, String user) throws XMPPException { VCard vcard = new VCard(); vcard.load(connection, user);
return vcard;

}

/**

  • 获取用户头像信息 */ public static ImageIcon getUserImage(XMPPConnection connection, String user) { ImageIcon ic = null; try { System.out.println("获取用户头像信息: "+user); VCard vcard = new VCard(); vcard.load(connection, user);

    if(vcard == null || vcard.getAvatar() == null) { return null; } ByteArrayInputStream bais = new ByteArrayInputStream( vcard.getAvatar()); Image image = ImageIO.read(bais);

    ic = new ImageIcon(image); System.out.println("图片大小:"+ic.getIconHeight()+" "+ic.getIconWidth());

} catch (Exception e) {
  e.printStackTrace();
}
return ic;

} （8）组操做和用户分组操做 **

  • 添加一个组 */ public static boolean addGroup(Roster roster,String groupName) { try { roster.createGroup(groupName); return true; } catch (Exception e) { e.printStackTrace(); return false; } }

/**

  • 删除一个组 */ public static boolean removeGroup(Roster roster,String groupName) { return false; }

/**

  • 添加一个好友 无分组 / public static boolean addUser(Roster roster,String userName,String name) { try { roster.createEntry(userName, name, null); return true; } catch (Exception e) { e.printStackTrace(); return false; } } /*
  • 添加一个好友到分组
  • @param roster
  • @param userName
  • @param name
  • @return */ public static boolean addUser(Roster roster,String userName,String name,String groupName) { try { roster.createEntry(userName, name,new String[]{ groupName}); return true; } catch (Exception e) { e.printStackTrace(); return false; } }

/**

  • 删除一个好友

  • @param roster

  • @param userName

  • @return */ public static boolean removeUser(Roster roster,String userName) { try {

    if(userName.contains("@")) { userName = userName.split("@")[0]; } RosterEntry entry = roster.getEntry(userName); System.out.println("删除好友:"+userName); System.out.println("User: "+(roster.getEntry(userName) == null)); roster.removeEntry(entry);

    return true; } catch (Exception e) { e.printStackTrace(); return false; }

} （9）用户查询 public static List<UserBean> searchUsers(XMPPConnection connection,String serverDomain,String userName) throws XMPPException { List<UserBean> results = new ArrayList<UserBean>(); System.out.println("查询开始..............."+connection.getHost()+connection.getServiceName());

UserSearchManager usm = new UserSearchManager(connection);


    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;
 UserBean user = null;
 while(it.hasNext())
 {
   user = new UserBean();
   row = it.next();
   user.setUserName(row.getValues("Username").next().toString());
   user.setName(row.getValues("Name").next().toString());
   user.setEmail(row.getValues("Email").next().toString());
   System.out.println(row.getValues("Username").next());
   System.out.println(row.getValues("Name").next());
   System.out.println(row.getValues("Email").next());
   results.add(user);
   //若存在，则有返回,UserName必定非空，其余两个如果有设，必定非空
 }
 
 return results;

} （10）修改自身状态， 包括上线，隐身，对某人隐身，对某人上线 ublic static void updateStateToAvailable(XMPPConnection connection) { Presence presence = new Presence(Presence.Type.available); nnection.sendPacket(presence);

public static void updateStateToUnAvailable(XMPPConnection connection) { Presence presence = new Presence(Presence.Type.unavailable); nnection.sendPacket(presence); }

public static void updateStateToUnAvailableToSomeone(XMPPConnection connection,String userName) { Presence presence = new Presence(Presence.Type.unavailable); presence.setTo(userName); nnection.sendPacket(presence); } public static void updateStateToAvailableToSomeone(XMPPConnection connection,String userName) { Presence presence = new Presence(Presence.Type.available); presence.setTo(userName); nnection.sendPacket(presence);

} （11）心情修改 **

  • 修改心情
  • @param connection
  • @param status */ public static void changeStateMessage(XMPPConnection connection,String status) { Presence presence = new Presence(Presence.Type.available); presence.setStatus(status); connection.sendPacket(presence);

} （12）修改用户头像， 有点麻烦，主要是读入图片文件，编码，传输之 public static void changeImage(XMPPConnection connection,File f) throws XMPPException, IOException{

VCard vcard = new VCard();
vcard.load(connection);

      byte[] bytes;
    
          bytes = getFileBytes(f);
          String encodedImage = StringUtils.encodeBase64(bytes);
          vcard.setAvatar(bytes, encodedImage);
          vcard.setEncodedImage(encodedImage);
          vcard.setField("PHOTO", "<TYPE>image/jpg</TYPE><BINVAL>"
                  + encodedImage + "</BINVAL>", true);
          
          
          ByteArrayInputStream bais = new ByteArrayInputStream(
        vcard.getAvatar());
    Image image = ImageIO.read(bais);
    ImageIcon ic = new ImageIcon(image);
     
     
    
      vcard.save(connection);

}

private static byte[] getFileBytes(File file) throws IOException {
    		BufferedInputStream bis = null;
    	try {
        bis = new BufferedInputStream(new FileInputStream(file));
        int bytes = (int) file.length();
        byte[] buffer = new byte[bytes];
        int readBytes = bis.read(buffer);
        if (readBytes != buffer.length) {
            throw new IOException("Entire file not read");
        }
        return buffer;
    } finally {
        if (bis != null) {
            bis.close();
        }
    }

} （13）用户状态的监听， 即对方改变头像，状态，心情时，更新本身用户列表，其实这里已经有smack实现的监听器 nal Roster roster = Client.getRoster();

roster.addRosterListener(
  new RosterListener() {

      @Override
      public void entriesAdded(Collection<String> arg0) {
        // TODO Auto-generated method stub
        System.out.println("--------EE:"+"entriesAdded");
      }

      @Override
      public void entriesDeleted(Collection<String> arg0) {
        // TODO Auto-generated method stub
        System.out.println("--------EE:"+"entriesDeleted");
      }

      @Override
      public void entriesUpdated(Collection<String> arg0) {
        // TODO Auto-generated method stub
        System.out.println("--------EE:"+"entriesUpdated");
      }

      @Override
      public void presenceChanged(Presence arg0) {
        // TODO Auto-generated method stub
        System.out.println("--------EE:"+"presenceChanged");
      }   
      
});

至此，有关openfire和smack的安装部署使用基本代码调试讲解完毕，本集源码容我稍做整理后再更新出来，请你们保持关注，同时下面会咱们进入课程的重点环节，包括

如何在Openfire服务器上开发一款Android端的聊天软件。。。

如何在openfire上二次开发，如何在在web和android上接入IM模块。。。

如何在Spark基础二次开发基于java swing的PC客户端。。。

结合我以前讲的Android端服务器推送技术原理分析及XMPP简单的使用由浅入深的对apache MINA，XMPP协议，以及socket底层等一些难点进行讨论剖析。。。

Openfire做为一款优秀的XMPP开源服务器，整合及时通信，视频，语音，会议室等多种服务，如何更好的让它集成到现有的系统中去才是咱们研究的最终价值，不然一切都是空谈，本教程结合实战和理论，为你们提供提供一个共同研究和学习的平台，欢迎有识之士加入咱们的技术交流群:173711587， 共同探讨Java开发那些事儿

放些图以飨读者。。。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程