精华内容
下载资源
问答
  • 基于tomcat的websocket,实现一对一通讯,支持https协议。
  • 基于WebSocket实现网页版聊天,支持一对一聊天,功能包含登录页面、对话界面、好友列表、上下线提醒等。 运行步骤: 1、获取GoEasy Appkey 先到GoEasy官网(https://www.goeasy.io)注册一个账号,登录后,创建一...
  • 利用websocket实现一对一聊天

    千次阅读 2020-08-07 21:22:47
    一对一聊天websocket1. 效果展示2. 业务分析(逻辑展示...)3. 技术点 功能 即时发送消息||随时发送消息 历史消息显示 已读未读状态 1. 效果展示 由于没做登录,就以jack和rose两人聊天 两人可相互发消息 ...

    • 功能
      1. 即时发送消息||随时发送消息
      2. 历史消息显示
      3. 已读未读状态

    1. 效果展示

    • 由于没做登录,就以jack和rose两人聊天

    • 两人可相互发消息

    • 持续输出. .

    • 当只有jack在线时

    • 嘤嘤嘤怪上线

    • jack发出的消息未读改为已读

    • 当jack离线,rose想jack了

    • jack上线了(jack已读)

    2. 业务分析(逻辑展示…)

    发送的消息默认未读
    1. 加载页面查询jack和rose之间的历史消息
    2. 修改发给jack的历史消息状态为已读
    3. jack发送通知到服务器,发给jack的消息已经收到,
    服务器再用websocket发送消息到rose,把未读消息不做展示
    
    上面分析了rose不在线的情况下,当两人同时在线的情况
    4. jack发送消息到服务器,服务器保存消息,在把消息转发到rose
    5. rose收到消息,修改jack发给rose的消息为已读(js websocket)
    6. 然后rose通过ajax发送消息到服务器,服务器通知jack 把未读消息不做展示
    

    3. 技术点

    后台
    	1. java websocket 传输部分业务数据
    	2. servlet, 数据库技术, json 作为数据传输 
    	3. oracle 作为持久化存储
    页面
    	1. html+css+js
    	2. js有jQuery, ajax, js websocket, js dom操作
    

    具体的websocket代码实现

    gitHub项目下载地址

    嘤嘤嘤. .

    展开全文
  • SpringBoot+Mybatis-Plus使用webSocket实现一对一聊天 一、WebSocket WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。 WebSocket 使得客户端和服务器之间的数据交换变得更加简单,...

    SpringBoot+Mybatis-Plus使用webSocket实现一对一聊天

    进一步修改完善连接:https://blog.csdn.net/w75545521/article/details/108642973

    一、WebSocket

    WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。

    WebSocket 使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据。在 WebSocket API 中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。

    在 WebSocket API 中,浏览器和服务器只需要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。

    二、代码实现

    1、 websocket依赖

    <!--websocket依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
            </dependency>
    

    2、WebSocketConfig配置类

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    /**
     * 
     * @description:WebSocketConfig配置类,
     *              注入对象ServerEndpointExporter,这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint
     *
     * @author 火烛
     * @since 2020-9-11
     */
    
    @Configuration
    public class WebSocketConfig {
        @Bean
        public ServerEndpointExporter serverEndpointExporter(){
            return new ServerEndpointExporter();
        }
    }
    

    接下来就是重点了

    3、一对一聊天

    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.medical.health.MyUtils.MapUnite;
    import com.medical.health.MyUtils.MyUtils;
    import com.medical.health.entity.Message;
    import com.medical.health.entity.Users;
    import com.medical.health.service.impl.MessageServiceImpl;
    import com.medical.health.service.impl.UsersServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RestController;
    import redis.clients.jedis.Jedis;
    
    import javax.websocket.*;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.io.IOException;
    import java.time.LocalDateTime;
    import java.time.ZoneOffset;
    import java.time.format.DateTimeFormatter;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     *  描述:
     *  一对一聊天
     *
     * @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端,
     *                 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
     */
    @RestController
    @ServerEndpoint(value = "/webSocketOneToOne/{param}")
    public class WebSocketOneToOne {
    
    	//这里是之前想用Redis存放聊天记录,以实现离线消息的推送
    //    private static Jedis jedis = new Jedis("localhost");
    
        // 这里使用静态,让 service 属于类
        private static UsersServiceImpl userService;
        
        // 注入的时候,给类的 service 注入
        @Autowired
        public void setUserService(UsersServiceImpl userService) {
            WebSocketOneToOne.userService = userService;
        }
        private static MessageServiceImpl messageService;
        @Autowired
        public void setChatMsgService(MessageServiceImpl messageService) {
            WebSocketOneToOne.messageService = messageService;
        }
    
        // 静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
        private static int onlineCount;
        //实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key为用户标识
        private static final Map<String,WebSocketOneToOne> connections = new ConcurrentHashMap<>();
        // 与某个客户端的连接会话,需要通过它来给客户端发送数据
        private Session session;
        private String sendId;
        private String roomId;
    
        /**
         * 连接建立成功调用的方法
         *
         * @param session
         * 可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
         */
        @OnOpen
        public void onOpen(@PathParam("param") String param, Session session) {
            this.session = session;
            String[] arr = param.split(",");
            this.sendId = arr[0];             //用户标识
            this.roomId = arr[1];         //会话标识
            connections.put(sendId,this);     //添加到map中
            addOnlineCount();               // 在线数加
            System.out.println(param);
            System.out.println(this.session);
            System.out.println("有新连接加入!新用户:"+sendId+",当前在线人数为" + getOnlineCount());
            Users userByid = userService.getById(sendId);
            //用户上次下线时间
            String downTime = userByid.getDownTime();
            System.out.println("downTime------------" + downTime);
            //最后一条消息时间
    //        String createTime = jedis.hget(roomId, "createTime");
            String createTime = messageService.getLastCreateTime();
            System.out.println("createTime------------" + createTime);
            //当前时间戳
            long timeMillis = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8));
            System.out.println("timeMillis-------------" + timeMillis);
            if (downTime != null && createTime != null){
                if (Integer.valueOf(downTime) < Integer.valueOf(createTime)){
                    //用户下线以后再有新消息
    //                send(jedis.hget(roomId, "content"), jedis.hget(roomId, "sendId"), sendId, roomId, "1");
                    List<Message> messages = messageService.queryDownTime(downTime);
                    for (Message message : messages){
                        downSend(message.getContent(), message.getSendId(), message.getReceiveId(), message.getRoomId(), message.getType());
                    }
                }
            }
        }
    
    
        /**
         * 连接关闭调用的方法
         * 
         * 这里本来是想离线清空数据库中存放在线时间之前的聊天记录
         * 目前还未实现
         */
        @OnClose
        public void onClose() {
            Users users = new Users();
            users.setId(sendId);
            users.setDownTime(String.valueOf(LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8))));
            userService.updateById(users);
            connections.remove(sendId);  // 从map中移除
            subOnlineCount();          // 在线数减
            System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
    
        }
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param message
         *            客户端发送过来的消息
         * @param session
         *            可选的参数
         */
        @OnMessage
        public void onMessage(String message, Session session) {
            System.out.println("来自客户端的消息:" + message);
            JSONObject json= JSON.parseObject(message);
            String msg = (String) json.get("message");  //需要发送的信息
            String receiveId = (String) json.get("receiveId");      //发送对象的用户标识(接收者)
            String type = (String) json.get("type");      //发送对象的用户标识(接收者)
            send(msg,sendId,receiveId,roomId,type);
        }
    
        /**
         * 发生错误时调用
         *
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            System.out.println("发生错误");
            error.printStackTrace();
        }
    
    
        //发送给指定角色
        public void send(String msg,String sendId,String receiveId,String roomId,String type){
            Message message = new Message();
            message.setId(MyUtils.getRandomString(10));
            message.setContent(msg);
            message.setCreateTime(LocalDateTime.now());
            //时间格式化
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            message.setCreateTimeM(String.valueOf(dateTimeFormatter.format(LocalDateTime.now())));
            message.setReceiveId(receiveId);
            message.setRoomId(roomId);
            message.setSendId(sendId);
            message.setType(type);
            try {
                Users u = userService.getById(sendId);
                System.out.println(u);
                //to指定用户
                WebSocketOneToOne con = connections.get(receiveId);
                if(con!=null){
                    if(roomId.equals(con.roomId)){
                        Map map = MapUnite.getMap(message);
                        //用户头像
                        map.put("avatar",u.getIcon());
    					//webSocket向前端推送消息的重点                    
                        con.session.getBasicRemote().sendText(JSON.toJSONString(map));
                    }
                }
                //from具体用户
                WebSocketOneToOne confrom = connections.get(sendId);
                if(confrom!=null){
                    if(roomId.equals(confrom.roomId)){
                        Map map = MapUnite.getMap(message);
    					//Redis hash 是一个 string 类型的 field(字段) 和 value(值)
    					//的映射表,hash 特别适合用于存储对象。
    					//发现只有最后一条记录,之前的因为key和filed相同全部被覆盖
    //                    jedis.hset(roomId, "sendId", message.getSendId());
    //                    jedis.hset(roomId, "receiveId", message.getReceiveId());
    //                    jedis.hset(roomId, "content", message.getContent());
    //                    jedis.hset(roomId, "roomId", message.getRoomId());
    //                    jedis.hset(roomId, "createTime", String.valueOf(message.getCreateTime().toEpochSecond(ZoneOffset.ofHours(8))));
    					//最终妥协直接存入数据库,目前还没有想到更好我方法
    					messageService.save(message);
                        map.put("avatar",u.getIcon());
                        confrom.session.getBasicRemote().sendText(JSON.toJSONString(map));
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    
        //发送离线消息给指定角色
        public void downSend(String msg,String sendId,String receiveId,String roomId,String type){
            Message message = new Message();
            message.setId(MyUtils.getRandomString(10));
            message.setContent(msg);
            message.setCreateTime(LocalDateTime.now());
            //时间格式化
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            message.setCreateTimeM(String.valueOf(dateTimeFormatter.format(LocalDateTime.now())));
            message.setReceiveId(receiveId);
            message.setRoomId(roomId);
            message.setSendId(sendId);
            message.setType(type);
            try {
                Users u = userService.getById(sendId);
                System.out.println(u);
                //to指定用户
                WebSocketOneToOne con = connections.get(receiveId);
                if(con!=null){
                    if(roomId.equals(con.roomId)){
                        Map map = MapUnite.getMap(message);
                        map.put("avatar",u.getIcon());
                        con.session.getBasicRemote().sendText(JSON.toJSONString(map));
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public static synchronized int getOnlineCount() {
            return onlineCount;
        }
    
        public static synchronized void addOnlineCount() {
            WebSocketOneToOne.onlineCount++;
        }
    
        public static synchronized void subOnlineCount() {
            WebSocketOneToOne.onlineCount--;
        }
    
    }
    
    

    记一次修改:

    原因:

       如果某用户A已经离线接收到用户B、用户C发来的消息
       
       1、用户A上线只查看了B发来的消息,没有看用户C发送的消息就下线
       2、用户A上线没有查看任何消息就下线
       
       这个时候用户A再次上线,这时用户A的最后一次离线到上线期间没有接收到
       任何消息,之前的离线消息推送就会失效。
    

    解决:

    给聊天记录一个已读/未读的标识,用户查看消息标记为已读
    

    代码修改:

    WebSocketOneToOne

    //        Users userByid = userService.getById(sendId);
    //        //用户上次下线时间
    //        String downTime = userByid.getDownTime();
    //        System.out.println("downTime------------" + downTime);
    //        //最后一条消息时间
            String createTime = jedis.hget(roomId, "createTime");
    //        String createTime = messageService.getLastCreateTime();
    //        System.out.println("createTime------------" + createTime);
    //        //当前时间戳
    //        long timeMillis = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8));
    //        System.out.println("timeMillis-------------" + timeMillis);
    //        if (downTime != null && createTime != null){
    //            if (Integer.valueOf(downTime) < Integer.valueOf(createTime)){
    //                //用户下线以后再有新消息
                    send(jedis.hget(roomId, "content"), jedis.hget(roomId, "sendId"), sendId, roomId, "1");
    //                List<Message> messages = messageService.queryDownTime(downTime);
    //                for (Message message : messages){
    //                    downSend(message.getContent(), message.getSendId(), message.getReceiveId(), message.getRoomId(), message.getType());
    //                }
                    System.out.println("用户下线以后再有新消息");
    //            }
    //        }
            List<Message> messageList = messageService.queryByType(sendId);
            for (Message message : messageList){
                downSend(message.getContent(), message.getSendId(), message.getReceiveId(), message.getRoomId(), message.getType());
            }
    

    MessageController

    
    import com.medical.health.MyUtils.responseVo;
    import com.medical.health.service.IMessageService;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    
    /**
     * <p>
     * 消息列表 前端控制器
     * </p>
     *
     * @author 火烛
     * @since 2020-09-11
     */
    @RestController
    @RequestMapping("/health/message")
    public class MessageController {
    
        @Resource
        private IMessageService messageService;
    
        /**
         * 聊天记录标记为已读
         *
         * @param userId
         * @param roomId
         * @return
         */
        @RequestMapping(value = "updateType", method = RequestMethod.PUT)
        @ApiOperation(value = "聊天记录标记为已读")
        public responseVo updateType(String userId, String roomId){
            responseVo result = messageService.updateType(userId, roomId);
            return result;
        }
    }
    

    MessageServiceImpl

    package com.medical.health.service.impl;
    
    import com.medical.health.MyUtils.responseVo;
    import com.medical.health.entity.Message;
    import com.medical.health.mapper.MessageMapper;
    import com.medical.health.service.IMessageService;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.transaction.interceptor.TransactionAspectSupport;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    /**
     * <p>
     * 消息列表 服务实现类
     * </p>
     *
     * @author 火烛
     * @since 2020-09-11
     */
    @Transactional
    @Service
    public class MessageServiceImpl extends ServiceImpl<MessageMapper, Message> implements IMessageService {
    
        @Resource
        private MessageMapper messageMapper;
    
        @Override
        public responseVo updateType(String userId, String roomId) {
            try {
                messageMapper.updateType(userId, roomId);
            }catch (Exception e){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                e.printStackTrace();
                return new responseVo(500, "修改失败", null);
            }
            return new responseVo(200, "修改成功", null);
        }
    
        @Override
        public List<Message> queryByType(String sendId) {
            return messageMapper.queryByType(sendId);
        }
    }
    
    

    最后放上一点SQL(type = 0为未读,1为已读):
    SELECT * FROM message WHERE type = '0' AND receive_id = #{userId}


    如有违规请联系wx:qy773787875

    特别感谢:Mr_Song_799
    参考链接:https://blog.csdn.net/songxinyong1995/article/details/104635981

    展开全文
  • websocket 即时通讯案例 ,一对一聊天,多人聊天 java 版本
  • 主要为大家详细介绍了微信小程序websocket实现聊天功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 这是个简单使用websocket实现多人聊天室,单人聊天室的demo,里面使用的是最原始的websocket的方法,附有客户端界面可以直接跑起来发送消息看效果。 该项目对应刚刚接触websocket技术是比较有用的。 2019-10-11的...
  • WebSocket实现一个简单的聊天室以及单聊功能,其中包括注解,比较容易
  • 主要介绍了Springboot基于websocket实现简单在线聊天功能,文中通过示例代码介绍的非常详细,大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 代码请清晰简洁适合新手,利用html 5 websocket做个山寨版web聊天室(手写C#服务器),C# 实现WebSocket服务端
  • 令人欣慰的是,我用google找到了关于websocket的点聊天,更好的是可以和大多数系统很好的配合起来看下效果图 因为是模拟的,这里给出的是两个JSP页面A和B,里面分别向session里放了两个名字小明和小化,注意,...
  • springboot集成websocket实现即时通信,你发的消息将直接显示在另台pc机的浏览器上
  • Spring Boot整合websocket实现群聊,点聊天,图片发送,音频发送
  • springboot+websocket 实现IM聊天功能,支持一对一、一对多聊天 gitbub地址: https://github.com/jason1210/chat

    springboot+websocket 实现IM聊天功能,支持一对一、一对多聊天

    gitbub地址: https://github.com/jason1210/chat

    若有什么疑问,欢迎留言探讨!

    展开全文
  • C#版 websocket 在线聊天实例代码运行即可使用,已经调试好了的。可以支持在线聊天室,单人消息发送这些基础功能
  • 正在做毕业设计,需要做个在线客服的功能,由于在网上关于websocket的demo太入门了,只好自己琢磨,可能资质问题,花了两天时间织写了个简单的聊天页面,只能发文字。 服务端是用java写的,服务器用的是tomcat8...
  • springboot集成websocket实现聊天室功能(可多人聊天和单独聊天
  • WebSocket实现微信小程序一对一聊天

    千次阅读 2019-09-11 15:56:54
    引入jar包 这是在springboot框架下需要引入的 <!-- spring socket --> <dependency> <groupId>org.springframework.boot<...spring-boot-starter-websocket</artifac...
    1. 引入jar包
      这是在springboot框架下需要引入的
    	<!-- spring socket -->
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-websocket</artifactId>
    	</dependency>
    
    1. webSocket服务
    import java.io.IOException;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    import javax.websocket.OnClose;
    import javax.websocket.OnError;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import io.nuite.modules.online_sales_app.entity.OnlineUserEntity;
    import io.nuite.modules.online_sales_app.service.ChatMessageService;
    
    //该注解用来指定一个URI,客户端可以通过这个URI来连接到WebSocket。类似Servlet的注解mapping。无需在web.xml中配置。
    @ServerEndpoint("/websocket/{id}/{to}")
    @Component
    public class WebSocketServer {
    
       //调用另外的服务层方法,如:将聊天信息插入数据库等,需要定义静态对象,再之后重写构造方法
       private static ChatMessageService chatMessageService;
       
       //静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
       private static int onlineCount = 0;
    
       //concurrent包的线程安全Set,用来存放每个客户端对应的WebSocketServer对象。若要实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key可以为用户标识
       //private static CopyOnWriteArraySet<WebSocketServer >  onlineUserSet = new CopyOnWriteArraySet<WebSocketServer >();
       private static Map<String, OnlineUserEntity> onlineUserMap = new ConcurrentHashMap<String, OnlineUserEntity>(); 
       
       //重写构造,并加入自动注入的标签,实现自动注入对象
       @Autowired
       public WebSocketServer(ChatMessageService chatMessageService){
    	   this.chatMessageService = chatMessageService;
       }
       
       //原来的构造方法要保留
       public WebSocketServer(){
    	   
       }
       
       /**
        * 连接建立成功调用的方法
        * @param session  可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
        */
    	@OnOpen
    	public void onOpen(Session session, @PathParam("id") String id, @PathParam("to") String to) {
            // 将当前用户存到在线用户列表中
            OnlineUserEntity onlineUser = new OnlineUserEntity();
            onlineUser.setUserid(id);
            onlineUser.setSession(session);
            onlineUserMap.put(id,onlineUser);
    		addOnlineCount(); // 在线数加1
    		// System.out.println("有新连接加入!当前在线人数为" + getOnlineCount());
    	}
    
        
    
       /**
        * 连接关闭调用的方法
        */
       @OnClose
       public void onClose(Session session, @PathParam("id") String id, @PathParam("to") String to){
           // 移除的用户信息
    	   OnlineUserEntity removeUser = onlineUserMap.remove(id);
           onlineUserMap.remove(id);
           
           subOnlineCount();           //在线数减1    
           //System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
       }
    
        
    
       /**
        * 收到客户端消息后调用的方法
        * @param message 客户端发送过来的消息
        * @param session 可选的参数
        */
    	@OnMessage
    	public void onMessage(Session session, @PathParam("id") String id, @PathParam("to") String to, String message) {
    		if (!to.equals(id)) {
    			if (onlineUserMap.get(to) != null) {
    				singleSend(message, onlineUserMap.get(to)); // 分别发送给指定的用户
    			}
    		}
    		// 将信息插入数据库
    		chatMessageService.insertMessage(id, to, message);
    		// 返回用户
    		singleSend(message, onlineUserMap.get(id));
       }
       
       
       /**
        * 发生错误时调用
        * @param session
        * @param error
        */
       @OnError
       public void onError(Session session, Throwable error){
           //System.out.println("发生错误");
           error.printStackTrace();
       }
        
       /**
        * 这个方法与上面几个方法不一样。没有用注解,是根据自己需要添加的方法。对特定用户发送消息
        * @param message
        * @throws IOException
        */
       public static void singleSend(String message, OnlineUserEntity onlineUser){
           try {
               onlineUser.getSession().getAsyncRemote().sendText(message);
               //onlineUser.getSession().getBasicRemote().sendText(message);
               //getAsyncRemote()和getBasicRemote()是异步与同步的区别,大部分情况下,推荐使用getAsyncRemote()异步
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
    
       public static synchronized int getOnlineCount() {
           return onlineCount;
       }
    
    
       public static synchronized void addOnlineCount() {
    	   WebSocketServer.onlineCount++;
       }
    
    
       public static synchronized void subOnlineCount() {
    	   WebSocketServer.onlineCount--;
       }
    
    }
    
    
    1. 注意点
      核心是@ServerEndpoint这个注解。这个注解是Javaee标准里的注解,tomcat7以上已经对其进行了实现  
      首先要注入ServerEndpointExporter,这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint。
      项目整合了shiro,需要在shiro配置文件中放行。
      要注意,如果使用springboot内置的spring-boot-starter-tomcat跑,那么以下代码加上,如果是打war包放到服务器的tomcat上跑,就得把这段注释
    @Configuration
    public class WebSocketConfig {
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    
    }
    
    1. 连接
      访问ws://IP:端口/项目名/websocket/id/to就可以连接了
      有在线websocket模拟工具可以模拟的,地址 http://www.bejson.com/httputil/websocket/
    展开全文
  • springboot+mybatis+websocket实现聊天功能
  • 最近项目中要实现客服系统,其实网上有很多的服务商提供这种接口,但最终决定使用SpringBoot+WebSocket的方式实现。 下面我的项目的结构是使用SpringBoot+Nginx实现的前后端分离的,但是这个不重要,这里只是提出来...
  • 基于Springboot、WebSocket、STOMP协议、SockJS协议的一对一聊天室 作者:SGCoder,转载需注明。 因为最近学校一个项目,需要实现与商家沟通的这么一个需求,所以经过一段时间的网上收集资料,了解到了要主动让...
  • WebSocket(3)---实现一对一聊天功能

    千次阅读 2019-04-03 00:59:56
    实现一对一聊天功能 功能介绍:实现A和B单独聊天功能,即A发消息给B只能B接收,同样B向A发消息只能A接收。 本篇博客是在上一遍基础上搭建,上一篇博客地址:【WebSocket】---实现游戏公告功能。底部有源码。 先看...
  • 近年来,随着HTML5的诞生,WebSocket协议被提出,它实现了浏览器与服务器的全双工通信,扩展了浏览器与服务端的通信功能,使服务端也能主动向客户端发送数据。 环境: tomcat7.0.70(tomcat需要在7.0.27以上才能支持)...
  • php+前端实现websocket时时聊天实现聊天室私聊。大神绕过 实例http://mess.qaq6.cn/
  • gin websocket 一对一聊天

    千次阅读 2020-08-11 16:06:57
    依赖包 ...github.com/gorilla/websocket 代码 创建ws/ws.go package ws import ( "encoding/json" ... "github.com/gorilla/websocket" ...// ClientManager is a websocket manager type ClientManager stru
  • 主要为大家详细介绍了WebSocket实现简单客服聊天系统,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Spring Boot整合websocket实现群聊,音频发送,点聊天,图片发送。 Spring Boot整合websocket实现群聊,点聊天,图片发送,音频发送。 Spring Boot整合websocket实现群聊,点聊天,图片发送,音频发送 ...
  • java 基于websocket实现的视频聊天,解压项目到对应位置部署到tomcat8即可使用
  • 主要为大家详细介绍了微信小程序WebSocket实现聊天对话功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了PHP用swoole+websocket和redis实现web一对一聊天,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,732
精华内容 4,292
关键字:

websocket实现一对一聊天