Chinaunix首页 | 论坛 | 博客

fhadmin的ChinaUnix博客

首页　| 　博文目录　| 　关于我

fhadmin

  • 博客访问： 648802
  • 博文数量： 298
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 3077
  • 用 户 组： 普通用户
  • 注册时间： 2019-06-17 10:57
文章分类

全部博文（298）

文章存档

2022年（96）

2021年（201）

2019年（1）

我的朋友
最近访客
推荐博文
相关博文
java WebSocket 即时通讯配置使用

分类： Java

2021-08-18 13:06:23

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

点击(此处)折叠或打开

  1. package com.fh;
  2. import java.io.IOException;
  3. import java.net.InetSocketAddress;
  4. import java.net.UnknownHostException;
  5. import java.util.Date;

  7. import net.sf.json.JSONObject;

  9. import org.java_websocket.WebSocket;
  10. import org.java_websocket.WebSocketImpl;
  11. import org.java_websocket.framing.Framedata;
  12. import org.java_websocket.handshake.ClientHandshake;
  13. import org.java_websocket.server.WebSocketServer;


  16. /**
  17.  * @author FH
  18.  * from fhadmin.cn
  19.  * 2021-5-16
  20.  */
  21. public class ChatServer extends WebSocketServer{

  23.     public ChatServer(int port) throws UnknownHostException {
  24.         super(new InetSocketAddress(port));
  25.     }

  27.     public ChatServer(InetSocketAddress address) {
  28.         super(address);
  29.     }

  31.     /**
  32.      * 触发连接事件
  33.      */
  34.     @Override
  35.     public void onOpen( WebSocket conn, ClientHandshake handshake ) {
  36.         //this.sendToAll( "new connection: " + handshake.getResourceDescriptor() );
  37.         //System.out.println( conn.getRemoteSocketAddress().getAddress().getHostAddress());
  38.     }

  40.     /**
  41.      * 触发关闭事件
  42.      */
  43.     @Override
  44.     public void onClose( WebSocket conn, int code, String reason, boolean remote ) {
  45.         userLeave(conn);
  46.     }

  48.     /**
  49.      * 客户端发送消息到服务器时触发事件
  50.      */
  51.     @Override
  52.     public void onMessage(WebSocket conn, String message){
  53.         message = message.toString();
  54.         if(null != message && message.startsWith("FHadmin313596790")){
  55.             this.userjoin(message.replaceFirst("FHadmin313596790", ""),conn);
  56.         }if(null != message && message.startsWith("LeaveFHadmin313596790")){
  57.             this.userLeave(conn);
  58.         }if(null != message && message.contains("fhadmin886")){
  59.             String toUser = message.substring(message.indexOf("fhadmin886")+10, message.indexOf("fhfhadmin888"));
  60.             message = message.substring(0, message.indexOf("fhadmin886")) +"[私信] "+ message.substring(message.indexOf("fhfhadmin888")+12, message.length());
  61.             ChatServerPool.sendMessageToUser(ChatServerPool.getWebSocketByUser(toUser),message);//向所某用户发送消息
  62.             ChatServerPool.sendMessageToUser(conn, message);//同时向本人发送消息
  63.         }else{
  64.             ChatServerPool.sendMessage(message.toString());//向所有在线用户发送消息
  65.         }
  66.     }

  68.     public void onFragment( WebSocket conn, Framedata fragment ) {
  69.     }

  71.     /**
  72.      * 触发异常事件
  73.      */
  74.     @Override
  75.     public void onError( WebSocket conn, Exception ex ) {
  76.         ex.printStackTrace();
  77.         if( conn != null ) {
  78.             //some errors like port binding failed may not be assignable to a specific websocket
  79.         }
  80.     }

  82.     
  83.     /**
  84.      * 用户加入处理
  85.      * @param user
  86.      */
  87.     public void userjoin(String user, WebSocket conn){
  88.         JSONObject result = new JSONObject();
  89.         result.element("type", "user_join");
  90.         result.element("user", "toUserMsg('"+user+"');\">"+user+"");
  91.         ChatServerPool.sendMessage(result.toString());                //把当前用户加入到所有在线用户列表中
  92.         String joinMsg = "{\"from\":\"[系统]\",\"content\":\""+user+"上线了\",\"timestamp\":"+new Date().getTime()+",\"type\":\"message\"}";
  93.         ChatServerPool.sendMessage(joinMsg);                        //向所有在线用户推送当前用户上线的消息
  94.         result = new JSONObject();
  95.         result.element("type", "get_online_user");
  96.         ChatServerPool.addUser(user,conn);                            //向连接池添加当前的连接对象
  97.         result.element("list", ChatServerPool.getOnlineUser());
  98.         ChatServerPool.sendMessageToUser(conn, result.toString());    //向当前连接发送当前在线用户的列表
  99.     }
  100.     
  101.     /**
  102.      * 用户下线处理
  103.      * @param user
  104.      */
  105.     public void userLeave(WebSocket conn){
  106.         String user = ChatServerPool.getUserByKey(conn);
  107.         boolean b = ChatServerPool.removeUser(conn);                //在连接池中移除连接
  108.         if(b){
  109.             JSONObject result = new JSONObject();
  110.             result.element("type", "user_leave");
  111.             result.element("user", "toUserMsg('"+user+"');\">"+user+"");
  112.             ChatServerPool.sendMessage(result.toString());            //把当前用户从所有在线用户列表中删除
  113.             String joinMsg = "{\"from\":\"[系统]\",\"content\":\""+user+"下线了\",\"timestamp\":"+new Date().getTime()+",\"type\":\"message\"}";
  114.             ChatServerPool.sendMessage(joinMsg);                    //向在线用户发送当前用户退出的消息
  115.         }
  116.     }
  117.     public static void main( String[] args ) throws InterruptedException , IOException {
  118.         WebSocketImpl.DEBUG = false;
  119.         int port = 8887; //端口
  120.         ChatServer s = new ChatServer(port);
  121.         s.start();
  122.         //System.out.println( "服务器的端口" + s.getPort() );
  123.     }

  125. }


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>();
  21.     
  22.     /**
  23.      * 获取用户名
  24.      * @param session
  25.      */
  26.     public static String getUserByKey(WebSocket conn){
  27.         return userconnections.get(conn);
  28.     }
  29.     
  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.     }
  46.     
  47.     /**
  48.      * 向连接池中添加连接
  49.      * @param inbound
  50.      */
  51.     public static void addUser(String user, WebSocket conn){
  52.         userconnections.put(conn,user);    //添加连接
  53.     }
  54.     
  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("toUserMsg('"+u+"');\">"+u+"");
  64.         }
  65.         return setUsers;
  66.     }
  67.     
  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.     }
  80.     
  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.     }
  91.     
  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.                     });
  48.             
  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'));
  68.                     
  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.                     });
  141.             
  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();
  163.             
  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.             '
    欢迎使用FH Admin 即时通讯系统。
    '    ,
  216.             '',
  217.             '
    ',
  218.             '
    {from} {timestamp}
    '    ,
  219.             '
    {content}
    '    , '
',
  •             ''],

  •     messages : [],

  •     initComponent : function() {
  •         var me = this;
  •         me.messageModel = Ext.define('Leetop.im.MessageModel', {
  •                     extend : 'Ext.data.Model',
  •                     fields : ['from', 'timestamp', 'content', 'source']
  •                 });
  •         me.store = Ext.create('Ext.data.Store', {
  •                     model : 'Leetop.im.MessageModel',
  •                     data : me.messages
  •                 });
  •         me.callParent();
  •     },

  •     //将服务器推送的信息展示到页面中
  •     receive : function(message) {
  •         var me = this;
  •         message['timestamp'] = Ext.Date.format(new Date(message['timestamp']),
  •                 'H:i:s');
  •         if(message.from == user){
  •             message.source = 'self';
  •         }else{
  •             message.source = 'remote';
  •         }
  •         me.store.add(message);
  •         if (me.el.dom) {
  •             me.el.dom.scrollTop = me.el.dom.scrollHeight;
  •         }
  •     }
  • })


    • 阅读(1043) | 评论(0) | 转发(0) |
    0

    上一篇：java WebSocket 即时通讯配置使用

    下一篇：java 监听 redis 过期事件

    给主人留下些什么吧！~~
    关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

    Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

    感谢所有关心和支持过ChinaUnix的朋友们

    16024965号-6