java WebSocket 即时通讯配置使用说明

朱雀 2022-09-05 12:58 351阅读 0赞

  1. 后台 启动类，执行main方法启动

    package com.fh;
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.UnknownHostException;
    import java.util.Date;

    import net.sf.json.JSONObject;

    import org.java_websocket.WebSocket;
    import org.java_websocket.WebSocketImpl;
    import org.java_websocket.framing.Framedata;
    import org.java_websocket.handshake.ClientHandshake;
    import org.java_websocket.server.WebSocketServer;

  1. /**
  2.  * @author FH
  3.  * from fhadmin.cn
  4.  * 2021-5-16
  5.  */
  6. public class ChatServer extends WebSocketServer{
  8.     public ChatServer(int port) throws UnknownHostException {
  9.         super(new InetSocketAddress(port));
  10.     }
  12.     public ChatServer(InetSocketAddress address) {
  13.         super(address);
  14.     }
  16.     /**
  17.      * 触发连接事件
  18.      */
  19.     @Override
  20.     public void onOpen( WebSocket conn, ClientHandshake handshake ) {
  21.         //this.sendToAll( "new connection: " + handshake.getResourceDescriptor() );
  22.         //System.out.println( conn.getRemoteSocketAddress().getAddress().getHostAddress());
  23.     }
  25.     /**
  26.      * 触发关闭事件
  27.      */
  28.     @Override
  29.     public void onClose( WebSocket conn, int code, String reason, boolean remote ) {
  30.         userLeave(conn);
  31.     }
  33.     /**
  34.      * 客户端发送消息到服务器时触发事件
  35.      */
  36.     @Override
  37.     public void onMessage(WebSocket conn, String message){
  38.         message = message.toString();
  39.         if(null != message && message.startsWith("FHadmin313596790")){
  40.             this.userjoin(message.replaceFirst("FHadmin313596790", ""),conn);
  41.         }if(null != message && message.startsWith("LeaveFHadmin313596790")){
  42.             this.userLeave(conn);
  43.         }if(null != message && message.contains("fhadmin886")){
  44.             String toUser = message.substring(message.indexOf("fhadmin886")+10, message.indexOf("fhfhadmin888"));
  45.             message = message.substring(0, message.indexOf("fhadmin886")) +"[私信]  "+ message.substring(message.indexOf("fhfhadmin888")+12, message.length());
  46.             ChatServerPool.sendMessageToUser(ChatServerPool.getWebSocketByUser(toUser),message);//向所某用户发送消息
  47.             ChatServerPool.sendMessageToUser(conn, message);//同时向本人发送消息
  48.         }else{
  49.             ChatServerPool.sendMessage(message.toString());//向所有在线用户发送消息
  50.         }
  51.     }
  53.     public void onFragment( WebSocket conn, Framedata fragment ) {
  54.     }
  56.     /**
  57.      * 触发异常事件
  58.      */
  59.     @Override
  60.     public void onError( WebSocket conn, Exception ex ) {
  61.         ex.printStackTrace();
  62.         if( conn != null ) {
  63.             //some errors like port binding failed may not be assignable to a specific websocket
  64.         }
  65.     }
  68.     /**
  69.      * 用户加入处理
  70.      * @param user
  71.      */
  72.     public void userjoin(String user, WebSocket conn){
  73.         JSONObject result = new JSONObject();
  74.         result.element("type", "user_join");
  75.         result.element("user", "<a onclick=\"toUserMsg('"+user+"');\">"+user+"</a>");
  76.         ChatServerPool.sendMessage(result.toString());                //把当前用户加入到所有在线用户列表中
  77.         String joinMsg = "{\"from\":\"[系统]\",\"content\":\""+user+"上线了\",\"timestamp\":"+new Date().getTime()+",\"type\":\"message\"}";
  78.         ChatServerPool.sendMessage(joinMsg);                        //向所有在线用户推送当前用户上线的消息
  79.         result = new JSONObject();
  80.         result.element("type", "get_online_user");
  81.         ChatServerPool.addUser(user,conn);                            //向连接池添加当前的连接对象
  82.         result.element("list", ChatServerPool.getOnlineUser());
  83.         ChatServerPool.sendMessageToUser(conn, result.toString());    //向当前连接发送当前在线用户的列表
  84.     }
  86.     /**
  87.      * 用户下线处理
  88.      * @param user
  89.      */
  90.     public void userLeave(WebSocket conn){
  91.         String user = ChatServerPool.getUserByKey(conn);
  92.         boolean b = ChatServerPool.removeUser(conn);                //在连接池中移除连接
  93.         if(b){
  94.             JSONObject result = new JSONObject();
  95.             result.element("type", "user_leave");
  96.             result.element("user", "<a onclick=\"toUserMsg('"+user+"');\">"+user+"</a>");
  97.             ChatServerPool.sendMessage(result.toString());            //把当前用户从所有在线用户列表中删除
  98.             String joinMsg = "{\"from\":\"[系统]\",\"content\":\""+user+"下线了\",\"timestamp\":"+new Date().getTime()+",\"type\":\"message\"}";
  99.             ChatServerPool.sendMessage(joinMsg);                    //向在线用户发送当前用户退出的消息
  100.         }
  101.     }
  102.     public static void main( String[] args ) throws InterruptedException , IOException {
  103.         WebSocketImpl.DEBUG = false;
  104.         int port = 8887; //端口
  105.         ChatServer s = new ChatServer(port);
  106.         s.start();
  107.         //System.out.println( "服务器的端口" + s.getPort() );
  108.     }
  110. }

2.ChatServerPool.java

  1. package com.fh;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.HashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;
  10. import org.java_websocket.WebSocket;
  12. /**
  13.  * @author FH
  14.  * from fhadmin.cn
  15.  * 2021-5-16
  16.  */
  17. public class ChatServerPool {
  19.     /*保存连接的MAP容器*/
  20.     private static final Map<WebSocket,String> userconnections = new HashMap<WebSocket,String>();
  22.     /**
  23.      * 获取用户名
  24.      * @param session
  25.      */
  26.     public static String getUserByKey(WebSocket conn){
  27.         return userconnections.get(conn);
  28.     }
  30.     /**
  31.      * 获取WebSocket
  32.      * @param user
  33.      */
  34.     public static WebSocket getWebSocketByUser(String user){
  35.         Set<WebSocket> keySet = userconnections.keySet();
  36.         synchronized (keySet) {
  37.             for (WebSocket conn : keySet) {
  38.                 String cuser = userconnections.get(conn);
  39.                 if(cuser.equals(user)){
  40.                     return conn;
  41.                 }
  42.             }
  43.         }
  44.         return null;
  45.     }
  47.     /**
  48.      * 向连接池中添加连接
  49.      * @param inbound
  50.      */
  51.     public static void addUser(String user, WebSocket conn){
  52.         userconnections.put(conn,user);    //添加连接
  53.     }
  55.     /**
  56.      * 获取所有的在线用户
  57.      * @return
  58.      */
  59.     public static Collection<String> getOnlineUser(){
  60.         List<String> setUsers = new ArrayList<String>();
  61.         Collection<String> setUser = userconnections.values();
  62.         for(String u:setUser){
  63.             setUsers.add("<a onclick=\"toUserMsg('"+u+"');\">"+u+"</a>");
  64.         }
  65.         return setUsers;
  66.     }
  68.     /**
  69.      * 移除连接池中的连接
  70.      * @param inbound
  71.      */
  72.     public static boolean removeUser(WebSocket conn){
  73.         if(userconnections.containsKey(conn)){
  74.             userconnections.remove(conn);    //移除连接
  75.             return true;
  76.         }else{
  77.             return false;
  78.         }
  79.     }
  81.     /**
  82.      * 向特定的用户发送数据
  83.      * @param user
  84.      * @param message
  85.      */
  86.     public static void sendMessageToUser(WebSocket conn,String message){
  87.         if(null != conn && null != userconnections.get(conn)){
  88.             conn.send(message);
  89.         }
  90.     }
  92.     /**
  93.      * 向所有的用户发送消息
  94.      * @param message
  95.      */
  96.     public static void sendMessage(String message){
  97.         Set<WebSocket> keySet = userconnections.keySet();
  98.         synchronized (keySet) {
  99.             for (WebSocket conn : keySet) {
  100.                 String user = userconnections.get(conn);
  101.                 if(user != null){
  102.                     conn.send(message);
  103.                 }
  104.             }
  105.         }
  106.     }
  107. }

3.前端

  1. var websocket;
  2. var isCreatw = false;
  3. var title="";
  4. var win;
  5. var input;
  6. var isQj = true;
  7. var toUser="";
  8. function toUserMsg(toU){
  9.     if((!isQj && toUser == toU) || toU == user){
  10.         win.setTitle(title + "  (已连接)   【现在全局对话】");
  11.         isQj = true;
  12.         toUser = "";
  13.     }else{
  14.         win.setTitle(title + "  (已连接)   【现在单独与"+toU+"对话】");
  15.         isQj = false;
  16.         toUser = toU;
  17.     }
  18. }
  19.  function creatw() {
  20.              if(isCreatw){
  21.                  alert("已经启动");
  22.                  return;
  23.              }else{
  24.                  isCreatw = true;
  25.              }
  26.             //创建用户输入框
  27.             input = Ext.create('Ext.form.field.HtmlEditor', {
  28.                         region : 'south',
  29.                         height : 120,
  30.                         enableFont : false,
  31.                         enableSourceEdit : false,
  32.                         enableAlignments : false,
  33.                         listeners : {
  34.                             initialize : function() {
  35.                                 Ext.EventManager.on(me.input.getDoc(), {
  36.                                             keyup : function(e) {
  37.                                                 if (e.ctrlKey === true
  38.                                                         && e.keyCode == 13) {
  39.                                                     e.preventDefault();
  40.                                                     e.stopPropagation();
  41.                                                     send();
  42.                                                 }
  43.                                             }
  44.                                         });
  45.                             }
  46.                         }
  47.                     });
  49.             //创建消息展示容器
  50.             var output = Ext.create('MessageContainer', {
  51.                         region : 'center'
  52.                     });
  54.             var dialog = Ext.create('Ext.panel.Panel', {
  55.                         region : 'center',
  56.                         layout : 'border',
  57.                         items : [input, output],
  58.                         buttons : [{
  59.                                     text : '发送',
  60.                                     handler : send
  61.                                 }]
  62.                     });
  64.             //初始话WebSocket
  65.             function initWebSocket() {
  66.                 if (window.WebSocket) {
  67.                     websocket = new WebSocket(encodeURI('ws://127.0.0.1:8887'));
  69.                     websocket.onopen = function() {
  70.                         //连接成功
  71.                         win.setTitle(title + '  (已连接)   【现在全局对话】');
  72.                         websocket.send('FHadmin313596790'+user);
  73.                     }
  74.                     websocket.onerror = function() {
  75.                         //连接失败
  76.                         win.setTitle(title + '  (连接发生错误)');
  77.                     }
  78.                     websocket.onclose = function() {
  79.                         //连接断开
  80.                         win.setTitle(title + '  (已经断开连接)');
  81.                     }
  82.                     //消息接收
  83.                     websocket.onmessage = function(message) {
  84.                         var message = JSON.parse(message.data);
  85.                         //接收用户发送的消息
  86.                         if (message.type == 'message') {
  87.                             output.receive(message);
  88.                         } else if (message.type == 'get_online_user') {
  89.                             //获取在线用户列表
  90.                             var root = onlineUser.getRootNode();
  91.                             Ext.each(message.list,function(user){
  92.                                 var node = root.createNode({
  93.                                     id : user,
  94.                                     text : user,
  95.                                     iconCls : 'user',
  96.                                     leaf : true
  97.                                 });
  98.                                 root.appendChild(node);
  99.                             });
  100.                         } else if (message.type == 'user_join') {
  101.                             //用户上线
  102.                                 var root = onlineUser.getRootNode();
  103.                                 var user = message.user;
  104.                                 var node = root.createNode({
  105.                                     id : user,
  106.                                     text : user,
  107.                                     iconCls : 'user',
  108.                                     leaf : true
  109.                                 });
  110.                                 root.appendChild(node);
  111.                         } else if (message.type == 'user_leave') {
  112.                                 //用户下线
  113.                                 var root = onlineUser.getRootNode();
  114.                                 var user = message.user;
  115.                                 var node = root.findChild('id',user);
  116.                                 root.removeChild(node);
  117.                         }
  118.                     }
  119.                 }
  120.             };
  122.             //在线用户树
  123.             var onlineUser = Ext.create('Ext.tree.Panel', {
  124.                         title : '在线用户',
  125.                         rootVisible : false,
  126.                         region : 'east',
  127.                         width : 150,
  128.                         lines : false,
  129.                         useArrows : true,
  130.                         autoScroll : true,
  131.                         split : true,
  132.                         iconCls : 'user-online',
  133.                         store : Ext.create('Ext.data.TreeStore', {
  134.                                     root : {
  135.                                         text : '在线用户',
  136.                                         expanded : true,
  137.                                         children : []
  138.                                     }
  139.                                 })
  140.                     });
  142.             title = '欢迎您：' + user;
  143.             //展示窗口
  144.             win = Ext.create('Ext.window.Window', {
  145.                         title : title + '  (未连接)',
  146.                         layout : 'border',
  147.                         iconCls : 'user-win',
  148.                         minWidth : 650,
  149.                         minHeight : 460,
  150.                         width : 650,
  151.                         animateTarget : 'websocket_button',
  152.                         height : 460,
  153.                         items : [dialog,onlineUser],
  154.                         border : false,
  155.                         listeners : {
  156.                             render : function() {
  157.                                 initWebSocket();
  158.                             }
  159.                         }
  160.                     });
  162.             win.show();
  164.             win.on("close",function(){
  165.                 websocket.send('LeaveFHadmin313596790');
  166.                 isCreatw = false;
  167.              });
  169.             //发送消息
  170.             function send() {
  171.                 var content = input.getValue();
  172.                 if(toUser != ""){content = "fhadmin886"+toUser+"fhfhadmin888" + content;}
  173.                 var message = {};
  174.                 if (websocket != null) {
  175.                     if (input.getValue()) {
  176.                         Ext.apply(message, {
  177.                                     from : user,
  178.                                     content : content,
  179.                                     timestamp : new Date().getTime(),
  180.                                     type : 'message'
  181.                                 });
  182.                         websocket.send(JSON.stringify(message));
  183.                         //output.receive(message);
  184.                         input.setValue('');
  185.                     }
  186.                 } else {
  187.                     Ext.Msg.alert('提示', '您已经掉线，无法发送消息!');
  188.                 }
  189.             }
  190. };
  192. //用于展示用户的聊天信息
  193. Ext.define('MessageContainer', {
  195.     extend : 'Ext.view.View',
  197.     trackOver : true,
  199.     multiSelect : false,
  201.     itemCls : 'l-im-message',
  203.     itemSelector : 'div.l-im-message',
  205.     overItemCls : 'l-im-message-over',
  207.     selectedItemCls : 'l-im-message-selected',
  209.     style : {
  210.         overflow : 'auto',
  211.         backgroundColor : '#fff'
  212.     },
  214.     tpl : [
  215.             '<div class="l-im-message-warn">​欢迎使用FH Admin 即时通讯系统。</div>',
  216.             '<tpl for=".">',
  217.             '<div class="l-im-message">',
  218.             '<div class="l-im-message-header l-im-message-header-{source}">{from}  {timestamp}</div>',
  219.             '<div class="l-im-message-body">{content}</div>', '</div>',
  220.             '</tpl>'],
  222.     messages : [],
  224.     initComponent : function() {
  225.         var me = this;
  226.         me.messageModel = Ext.define('Leetop.im.MessageModel', {
  227.                     extend : 'Ext.data.Model',
  228.                     fields : ['from', 'timestamp', 'content', 'source']
  229.                 });
  230.         me.store = Ext.create('Ext.data.Store', {
  231.                     model : 'Leetop.im.MessageModel',
  232.                     data : me.messages
  233.                 });
  234.         me.callParent();
  235.     },
  237.     //将服务器推送的信息展示到页面中
  238.     receive : function(message) {
  239.         var me = this;
  240.         message['timestamp'] = Ext.Date.format(new Date(message['timestamp']),
  241.                 'H:i:s');
  242.         if(message.from == user){
  243.             message.source = 'self';
  244.         }else{
  245.             message.source = 'remote';
  246.         }
  247.         me.store.add(message);
  248.         if (me.el.dom) {
  249.             me.el.dom.scrollTop = me.el.dom.scrollHeight;
  250.         }
  251.     }
  252. });

发表评论

表情：
评论列表 （有 0 条评论，351人围观）

还没有评论，来说两句吧...

相关阅读