springboot websocket 实现用户在线聊天 及部分初始化接口

已于 2022-08-22 18:02:33 修改
阅读量1k 收藏 19
点赞数 5
文章标签： websocket spring boot java
于 2022-08-22 17:38:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44903702/article/details/126470066
版权

springboot websocket 实现用户在线聊天

1. 添加pom依赖

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

2. 配置websocket 和监听器

/**
 * WebSocket的配置信息
 */
@Configuration
public class WebSocketConfig extends ServerEndpointConfig.Configurator {

    @Override
    public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {

        //获取httpsession
        HttpSession session = (HttpSession) request.getHttpSession();
        sec.getUserProperties().put(HttpSession.class.getName(), session);
    }

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

监听器, 主要是同步httpSession, 这样就可以拿到用户信息

/**
 * 监听器类:主要任务是用ServletRequest将我们的HttpSession携带过去
 */
@Component
public class RequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre)  {

        //将所有request请求都携带上httpSession
        ((HttpServletRequest) sre.getServletRequest()).getSession();
    }
    public RequestListener() {}

    @Override
    public void requestDestroyed(ServletRequestEvent arg0)  {}
}

3. BeanUtils

因为项目启动加载websocket时, spring bean容器还没就绪, 通过@Resource等自动注入是null, 所以需要在项目启动时提前实例化bean给websocketservice使用

@Service
public class BeanUtils implements BeanFactoryAware {
    // Spring的bean工厂
    private static BeanFactory beanFactory;
    @Override
    public void setBeanFactory(BeanFactory factory) throws BeansException {
        beanFactory=factory;
    }
    public static<T> T getBean(String beanName){
        return (T) beanFactory.getBean(beanName);
    }
}

4. WebSocketServer 主要的socket服务

  • @OnOpen 创建连接时执行
  • @OnClose 关闭连接时执行
  • @OnMessage 服务端和客户端通信的主要方法
  • @OnError 异常时执行

详细的注释代码里有

@Component
@Slf4j
//todo 前端的连接地址,可以自己修改 示例为: ws://ip:端口/message/userId
@ServerEndpoint("/message/{userId}")
public class WebSocketServer {

    /**
     * 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
     */
    private static int onlineCount = 0;
    /**
     * concurrent包的线程安全Set，用来存放每个客户端对应的WebSocket对象。
     * 注意, 这种方式 只适用于单节点部署,
     * 如果是多接点部署, 各个节点之间的在线用户是不互通的, 需要改用其他方式.
     */
    private static final ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
    /**
     * 与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    private Session session;
    /**
     * 接收userId
     */
    private String userId = "";

    private final MessageService messageService = BeanUtils.getBean("messageService");
    private final ChatListService chatListService = BeanUtils.getBean("chatListService");;

    /**
     * 连接关闭
     * 调用的方法
     */
    @OnClose
    public void onClose() {
        if (webSocketMap.containsKey(userId)) {
            webSocketMap.remove(userId);
            //从set中删除
            subOnlineCount();
        }
        //todo 修改数据库, 用户的状态为下线
        log.info("用户退出:" + userId + ",当前在线人数为:" + getOnlineCount());
        //todo 测试回应,可以和前端约定返回值
        //todo 如果有订阅下线提醒的逻辑 可以加在这里
        sendMessage("用户下线");
    }

    /**
     * 连接建立成
     * 功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId, EndpointConfig config) {

        //todo 用户体系接入后, 可以拿session里的user而不是用明文路径的形式传递userid, 安全性更高
//        HttpSession httpSession= (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
//        User user = (User) httpSession.getAttribute("user");

        this.session = session;
        this.userId = userId;
        if (webSocketMap.containsKey(userId)) {
            webSocketMap.remove(userId);
            //加入set中
            webSocketMap.put(userId, this);
        } else {
            //加入set中
            webSocketMap.put(userId, this);
            //在线数加1
            addOnlineCount();
        }
        //todo 修改数据库, 用户的状态为在线
        log.info("用户连接:" + userId + ",当前在线人数为:" + getOnlineCount());
        //todo 测试回应,可以和前端约定返回具体什么代表上线
        //todo 如果有订阅上线提醒的逻辑 可以加在这里
        sendMessage("连接成功");
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     *                目前暂定的前端带过来的结构为:  {"to":"xxx","msg":"xxx"}
     *                               todo message结构可以按具体情况自定义约定修改
     **/
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("用户消息:" + userId + ",报文:" + message);
        //todo 群发消息(群聊消息)的话, message 的结构改动判断即可
        //消息保存到数据库、redis
        if (StringUtils.isNotBlank(message)) {
            try {
                //解析发送的报文
                JSONObject jsonObject = JSON.parseObject(message);
                //追加发送人(防止篡改)
                jsonObject.put("from", this.userId);
                String toUserId = jsonObject.getString("to");
                //todo 这里可以效验目标id是否是正确的id
                if (StringUtils.isNotBlank(toUserId)) {
                    Message messageEntity;
                    //todo 判断目标用户是否是自己的好友,
                    if (true) {

                        //消息记录保存到数据库
                        messageEntity = Message.builder()
                                .fromId(jsonObject.getLong("from"))
                                .toId(jsonObject.getLong("to"))
                                .content(jsonObject.getString("msg"))
                                //单聊消息固定: 1, 后续拓展群里等消息对应定义值
                                .type(1)
                                .time(new Date())
                                .isTransport(1)
                                .build();
                        messageService.save(messageEntity);
                        // 重置好友聊天列表的内容和最后时间, 展示在最上面
                        chatListService.updateChatList(messageEntity);

                        //判断用户是否在线 在线实时推送, 不在线不推送
                        if (webSocketMap.containsKey(toUserId)) {
                            //回推数据结构: {"from":"xxx", "to":"xxx","msg":"xxx"}
                            //todo 可以按具体情况自定义约定修改
                            webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                        }

                    } else {
                        //todo 不为对方好友, 或者被拉黑等, isTransport 是否送达, 设置为0
                        //或者不需要保存这些记录的话, 这段删了也行
                        messageEntity = Message.builder()
                                .fromId(jsonObject.getLong("from"))
                                .toId(jsonObject.getLong("to"))
                                .content(jsonObject.getString("msg"))
                                //单聊消息固定: 1, 后续拓展群里等消息对应定义值
                                .type(1)
                                .time(new Date())
                                .isTransport(0)
                                .build();
                        messageService.save(messageEntity);
                        //todo 可以发送消息提醒, 请先添加对方为好友
//                        sendMessage("xxx");
                    }

                } else {
                    log.error("请求的userId为空");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * @param session Session
     * @param error   Throwable
     */
    @OnError
    public void onError(Session session, Throwable error) {
        //todo 服务器关闭或者其他不可预料情况, 会走这里,  可以在这里对用户做强制下线处理
        log.error("用户错误:" + this.userId + ",原因:" + error.getMessage());
        error.printStackTrace();
    }

    /**
     * 服务器主动推送
     * todo  需求: 新用户注册, 用户开通vip等, 用户消费,礼物赠送等 场景, 调用此函数即可 发送消息
     * todo 消息内容结构同上, 和前端约定即可
     */
    public void sendMessage(String message) {
        try {
            this.session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送自定义消息
     * 同上 "服务器主动推送" 接口
     **/
    public static void sendInfo(String userId, String message) {
        log.info("发送消息到:" + userId + "，报文:" + message);
        if (StringUtils.isNotBlank(userId) && webSocketMap.containsKey(userId)) {
            webSocketMap.get(userId).sendMessage(message);
        } else {
            log.warn("用户" + userId + ",不在线！");
        }
    }
    public static void sendInfo(Long userId, String message) {
        sendInfo(String.valueOf(userId), message);
    }

    /**
     * 获得此时的
     * 在线人数
     *
     * @return int
     */
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    /**
     * 在线人
     * 数加1
     */
    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    /**
     * 在线人
     * 数减1
     */
    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

5. 启动类开启websocket服务

@EnableWebSocket

@SpringBootApplication
@EnableWebSocket
@MapperScan("com.service.chat.dao")
public class ChatServiceApplication {

	public static void main(String[] args) {
		SpringApplication.run(ChatServiceApplication.class, args);
	}

}

6. 功能测试

以上为websocket功能, 以下为部分初始化接口及逻辑

只是需要试试websocket功能, 不需要试入库这些的, 到这里即可, 把上面wocketserver里的业务代码删除即可

6.1 测试地址:

可以用这个网站进行后端自测

http://coolaf.com/tool/chattest

6.2 测试两个用户之间的相互通信

  1. 建立两个连接

ws://localhost:8080/message/111
ws://localhost:8080/message/222
在这里插入图片描述

  1. 按定义的格式发消息

{“to”:“xxx”,“msg”:“xxx”}
在这里插入图片描述

功能ok

7. entity 实体

包含, 聊天记录 和 好友聊天列表

7.1 sql


SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for chat_list
-- ----------------------------
DROP TABLE IF EXISTS `chat_list`;
CREATE TABLE `chat_list`  (
  `id` bigint(20) NOT NULL,
  `user_id` bigint(20) NOT NULL,
  `friend_id` bigint(20) NOT NULL,
  `un_read_num` int(11) NOT NULL,
  `last_message_id` bigint(20) NULL DEFAULT NULL,
  `last_message_content` varchar(5000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `send_time` datetime(0) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `user_id`(`user_id`, `friend_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for message
-- ----------------------------
DROP TABLE IF EXISTS `message`;
CREATE TABLE `message`  (
  `id` bigint(20) NOT NULL,
  `from_id` bigint(20) NOT NULL,
  `to_id` bigint(20) NOT NULL,
  `content` varchar(5000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `type` int(11) NOT NULL,
  `time` datetime(0) NOT NULL,
  `is_transport` int(11) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `from_id`(`from_id`) USING BTREE,
  INDEX `to_id`(`to_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

7.2 java

聊天列表

@Data
@ApiModel(value = "聊天列表", description = "聊天列表")
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatList {
	@ApiModelProperty(value = "主键id")
	@TableId
	private Long id;
	//用户id
	private Long userId;
	//好友id
	private Long friendId;
	//消息未读数量
	private int unReadNum;
	//最后一条消息id
	private Long lastMessageId;
	//最后一条消息内容
	private String lastMessageContent;
	//时间(排序用)
	private Date sendTime;

}

聊天记录:

@Data
@ApiModel(value = "消息", description = "消息记录表")
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Message {
	@ApiModelProperty(value = "主键id")
	@TableId
	private Long id;
	//发送方
	private Long fromId;
	//接收方
	private Long toId;
	//内容
	private String content;
	/**
	 * 类型字段, 目前定义单聊消息 = 1
	 * todo 群聊消息, 添加好友消息, 好友请求通过, 好友请求不通过, 上线提醒, 等等等等各种类型, 可以自定义, 和前端联动即可
	 */
	private int type;
	//时间
	private Date time;
	//是否送达
	private int isTransport;
}

8. dao

持久层采用mybatis plus 实现

@Component
public interface MessageDao extends BaseMapper<Message> {

    /**
     * 倒序查询两人的所有聊天记录
     * todo 后续可以考虑分页
     * @param userIdA
     * @param userIdB
     * @return
     */
    @Select("SELECT * FROM message WHERE (from_id = '${userIdA}' AND to_id = '${userIdB}') OR (from_id = '${userIdB}' AND to_id = '${userIdA}') ORDER BY time DESC;")
    List<Message> getMessageRecordBetweenUsers(@Param("userIdA") Long userIdA, @Param("userIdB") Long userIdB);

    /**
     * 查询两人最后一条聊天记录
     * @param userIdA
     * @param userIdB
     * @return
     */
    @Select("SELECT * FROM message WHERE (from_id = '${userIdA}' AND to_id = '${userIdB}') OR (from_id = '${userIdB}' AND to_id = '${userIdA}') ORDER BY time DESC LIMIT 0, 1;")
    Message getLastMessage(@Param("userIdA") Long userIdA, @Param("userIdB") Long userIdB);
}

@Component
public interface ChatListDao extends BaseMapper<ChatList> {

}

9. service

包含部分逻辑:


@Component
public class ChatListService {

    @Resource
    private ChatListDao chatListDao;

    @Resource
    private MessageDao messageDao;


    /**
     * 新增自己的一条聊天列表
     * @param currUserId
     * @param friendId
     */
    public void add(Long currUserId, Long friendId) {
        ChatList one = getOne(currUserId, friendId);
        if (Objects.isNull(one)){
            //没有才新增, 有的话不增
            ChatList chatList = ChatList.builder()
                    .userId(currUserId)
                    .friendId(friendId)
                    .unReadNum(0)
                    .sendTime(new Date())
                    .build();
            //查询之前最后的一条聊天记录, 有的话填充内容
            Message lastMessage = messageDao.getLastMessage(currUserId, friendId);
            if (Objects.nonNull(lastMessage)){
                chatList.setLastMessageId(lastMessage.getId());
                chatList.setLastMessageContent(lastMessage.getContent());
                chatList.setSendTime(lastMessage.getTime());
            }
            chatListDao.insert(chatList);
            //todo 聊天列表变动 发送消息给前端
//            WebSocketServer.sendInfo(currUserId, "xxx");
        }

    }

    /**
     * 删除自己的一条聊天列表
     * @param currUserId
     * @param friendId
     */
    public void delete(Long currUserId, Long friendId) {
        LambdaQueryWrapper<ChatList> queryWrapper = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, currUserId)
                .eq(ChatList::getFriendId,friendId);
        chatListDao.delete(queryWrapper);
        //todo 聊天列表变动 发送消息给前端
    }

    /**
     * 查询自己的一条聊天列表
     * @param userId
     * @param friendId
     * @return
     */
    public ChatList getOne(Long userId, Long friendId) {
        LambdaQueryWrapper<ChatList> queryWrapper = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, userId)
                .eq(ChatList::getFriendId,friendId);
        List<ChatList> chatLists = chatListDao.selectList(queryWrapper);
        return CollectionUtils.isEmpty(chatLists) ? null: chatLists.get(0);
    }

    /**
     * 查询自己的所有聊天列表
     * @param userId
     * @return
     */
    public List<ChatList> getChatList(Long userId) {
        LambdaQueryWrapper<ChatList> queryWrapper = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, userId)
                .orderByDesc(ChatList::getSendTime);
        return chatListDao.selectList(queryWrapper);
    }

    /**
     * 消息已读, 未读数清0
     * @param userId
     * @return
     */
    public void read(Long userId, Long friendId) {
        LambdaQueryWrapper<ChatList> queryWrapper = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, userId)
                .eq(ChatList::getFriendId, friendId);
        ChatList chatList = chatListDao.selectOne(queryWrapper);

        if (Objects.nonNull(chatList) && chatList.getUnReadNum() != 0){
            chatList.setUnReadNum(0);
            chatListDao.updateById(chatList);
            //todo 聊天列表变动 发送消息给前端
        }
    }


    /**
     * 更新聊天列表
     * @param message 消息
     */
    public void updateChatList(Message message) {
        //发送者的聊天列表更新
        LambdaQueryWrapper<ChatList> queryWrapper = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, message.getFromId())
                .eq(ChatList::getFriendId, message.getToId());
        ChatList chatList = chatListDao.selectOne(queryWrapper);
        if (Objects.isNull(chatList)){
            //列表没有, 新增
            chatListDao.insert(ChatList.builder()
                            .userId(message.getFromId())
                            .friendId(message.getToId())
                            .lastMessageId(message.getId())
                            .lastMessageContent(message.getContent())
                            .sendTime(message.getTime())
                            //这里, 接收者是未读的, 而发送者是已读的
                            .unReadNum(0)
                            .build());
            //todo 聊天列表变动 发送消息给前端
        }else {
            //列表有, 修改
            chatList.setLastMessageId(message.getId());
            chatList.setLastMessageContent(message.getContent());
            chatList.setSendTime(message.getTime());
            chatListDao.updateById(chatList);
            //todo 聊天列表变动 发送消息给前端
        }


        //接收者的聊天列表更新
        LambdaQueryWrapper<ChatList> queryWrapper2 = new QueryWrapper<ChatList>().lambda()
                .eq(ChatList::getUserId, message.getToId())
                .eq(ChatList::getFriendId, message.getFromId());
        ChatList chatList2 = chatListDao.selectOne(queryWrapper2);
        if (Objects.isNull(chatList2)){
            //列表没有, 新增
            chatListDao.insert(ChatList.builder()
                    //注意这里发送者和接收者的顺序
                    .userId(message.getToId())
                    .friendId(message.getFromId())
                    .lastMessageId(message.getId())
                    .lastMessageContent(message.getContent())
                    .sendTime(message.getTime())
                    //这里, 接收者是未读的, 而发送者是已读的
                    .unReadNum(1)
                    .build());
            //todo 聊天列表变动 发送消息给前端 发给好友的, 要填好友的id
        }else {
            //列表有, 修改
            chatList2.setLastMessageId(message.getId());
            chatList2.setLastMessageContent(message.getContent());
            chatList2.setSendTime(message.getTime());
            //未读数量+1
            chatList2.setUnReadNum(chatList2.getUnReadNum() + 1);
            chatListDao.updateById(chatList2);
            //todo 聊天列表变动 发送消息给前端 发给好友的, 要填好友的id
        }

    }


}



@Component
public class MessageService {

    @Resource
    private MessageDao messageDao;
    @Resource
    private ChatListService chatListService;

    /**
     * 1.查询聊天记录
     * 2.未读数量清0
     * 3.如果没有聊天列表的话, 要新增一条空的聊天列表
     * @param currUserId
     * @param friendId
     * @return
     */
    public List<Message> getMessageRecordBetweenUsers(Long currUserId, Long friendId){
        List<Message> messageRecordBetweenUsers = messageDao.getMessageRecordBetweenUsers(currUserId, friendId);
        chatListService.read(currUserId,friendId);
        chatListService.add(currUserId,friendId);

        return messageRecordBetweenUsers;
    }

    public Integer save(Message message) {
        return messageDao.insert(message);
    }

}

10. controller 包含部分初始化接口

部分初始化接口:


@Controller
@RequestMapping("/chatList")
public class ChatListController {

    @Resource
    private ChatListService chatListService;

    /**
     查询我的聊天列表, 及最后一条消息记录, 及未读消息数量
     */
    @GetMapping("/detail/{currUserId}")
    public ResponseEntity detail(@PathVariable("currUserId") Long currUserId){
        return ResponseEntity.ok().body(chatListService.getChatList(currUserId));
    }

    /**
     未读数量清0,
     前端点开好友聊天框时 默认清0, 不需要额外触发,
     其他情况清0时 调用;
     */
    @GetMapping("/read/{currUserId}/{friendId}")
    public ResponseEntity read(@PathVariable("currUserId") Long currUserId,
                               @PathVariable("friendId") Long friendId){
        chatListService.read(currUserId,friendId);
        return ResponseEntity.ok().build();
    }

    /**
     * 删除自己的一条聊天列表
     * @param currUserId
     * @param friendId
     * @return
     */
    @GetMapping("/delete/{currUserId}/{friendId}")
    public ResponseEntity delete(@PathVariable("currUserId") Long currUserId,
                               @PathVariable("friendId") Long friendId){
        chatListService.delete(currUserId,friendId);
        return ResponseEntity.ok().build();
    }

}


@Controller
@RequestMapping("/messageList")
public class MessageController {

    @Resource
    private MessageService messageService;

    /**
     * 点开聊天框时触发, 查询与好友的聊天记录, 并将未读数量清0
     * @param currUserId
     * @param friendId
     * @return
     */
    @GetMapping(value="/getMessageRecordBetweenUsers/{currUserId}/{friendId}")
    public ResponseEntity getMessageRecordBetweenUsers(@PathVariable("currUserId") Long currUserId,
                                                       @PathVariable("friendId") Long friendId){
        return ResponseEntity.ok().body(messageService.getMessageRecordBetweenUsers(currUserId, friendId));
    }

}
花儿为什么那样红~
关注
  • 5
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Springboot基于websocket实现简单在线聊天功能
08-19
主要介绍了Springboot基于websocket实现简单在线聊天功能,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
WebSocket 开发
harvestUachieve的博客
08-17 903
websocketWebSocket是HTML5下一种新的协议（websocket协议本质上是一个基于tcp的协议）它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的Websocket是一个持久化的协议WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。
接口自动化处理websocket接口
最新发布
Tom_FengZe的博客
06-14 293
接口自动化处理websocket接口
SpringBoot集成WebSocket实现在线聊天
陈宝子的博客
09-29 6512
WebSocket是HTML5规范中的一个部分，它借鉴了socket这种思想，为web应用程序客户端和服务端之间提供了一种全双工通信机制。同时，它又是一种新的应用层协议，WebSocket协议是为了提供web应用程序和服务端全双工通信而专门制定的一种应用层协议，其基于TCP传输协议，并复用了HTTP的握手通道。通常它表示为：ws://echo.websocket.org/?encoding=text HTTP/1.1。
用websocket实现实时聊天功能
道阻且长，行则将至！
02-25 9586
最近想实现网页版的仿QQ聊天工具，本来想用ajax实现的，但是一想到要一直轮询，就感觉有点蠢。后来在网上找到了websocket相关的资料，就拿来跟大家分享下（不是很熟练，现在只实现了群聊，单聊的前端不会写了。但可以跟大家说说思路）。 服务器端代码： 首先要创建类WebSocketConfig实现ServerApplicationConfig接口，ServerApplicationConfig项目...
Springboot集成WebSocket实现即时通讯
m0_52348758的博客
02-22 3836
在SpringBoot的pom.xml文件里添加依赖: <!-- websocket --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 在配置中加入 WebSocket...
springboot集成websocket实现一个简易聊天室
03-28
// 连接建立后，可以执行一些初始化操作 } @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws IOException { // 接收到消息后，进行处理，例如转发给其他...
springboot实现的在线多功能聊天室
12-10
结合WebSocket技术，我们可以实现实时、双向通信，为用户提供无缝的聊天体验。 首先，让我们了解一下Spring Boot的核心特性。Spring Boot基于Spring框架，旨在简化Spring应用程序的初始设置和配置。它提供了预配置...
轻量级的基于SpringBoot + WebSocket的在线聊天室.zip
05-29
在本项目中，"轻量级的基于SpringBoot + WebSocket的在线聊天室.zip"是一个使用SpringBoot框架构建的Java应用程序，旨在实现一个实时的在线聊天功能。SpringBoot以其简化Spring应用开发的特性，使得开发者可以快速...
基于Vue+SpringBoot+WebSocket实现Web端聊天系统源码
10-16
本项目“基于Vue+SpringBoot+WebSocket实现Web端聊天系统源码”就是一个很好的示例，它整合了前端Vue.js框架、后端Spring Boot微服务框架以及WebSocket通信协议，来创建一个实时的聊天系统。 首先，Vue.js是当前...
springBoot+webSocket+uniapp实现实时聊天功能
05-22
在聊天应用中，Spring Boot将作为后端服务器，负责处理用户请求、存储和检索消息、提供API接口等。 2. **WebSocket**： WebSocket是一种在客户端和服务器之间建立长时间连接的协议，允许双向通信，即服务器和...
Java后端WebSocket的实现
lxzGood的博客
04-19 9630
WebSocket 1.什么是WebSocket? webSocket是HTML5开始提供的一种在单个TCP连接上进行全双工通讯的协议。 webSocket使得客户端和服务器之间的数据交换变得更加简单，（在线聊天基础）允许服务端主动向客户端推送数据(服务器可以主动发消息给客户端)。在webSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 其他特点： 较少的控制开销 更强的实时性 保持连接状态 更好的二进制支持 可以支持扩展 更好的压缩效果
vue和node使用websocket实现数据推送，实时聊天
请叫我欧皇！的博客
06-26 1802
需求：node做后端根据websocket，连接数据库，数据库的字段改变后，前端不用刷新页面也能更新到数据，前端也可以发送消息给后端，后端接受后把前端消息做处理再推送给前端展示。
websocket显示实时消息
qq_51076413的博客
01-17 1236
websocket实现实时消息的接收、websocket实时消息推送、websocket实现在线聊天、websocket实现一对一在线聊天
WebSocket零基础极速上手开发指南
huangtenglong的博客
01-13 609
WebSocket零基础极速上手开发指南
Web在线聊天室(6) --- login登录接口
starry1441的博客
05-22 961
目录登录接口接口设计文档编写servlet实现dopost方法编写操作数据库方法实现结果检测登录接口接口设计文档编写servlet实现doget方法实现效果 登录接口 接口设计文档 请求: POST /login { name: xxx, password: xxx } 响应: HTTP/1.1 200 OK { ok: true, reason: xxx, userId: xxx, name: xxx, nickName: xxx, signature: xxx } 编写servlet
【十五】springboot整合WebSocket实现聊天室
热门推荐
weixin_56995925的博客
10-08 2万+
springboot整合WebSocket实现聊天室
毕业设计-基于Spring Boot的在线聊天系统
lqz709698的博客
06-09 265
项目简介：在线聊天系统是一款类似于QQ聊天的通讯系统，用户注册以后可以添加好或者添加群聊进行聊天，后台则可以进行管理。
springboot开发websocket
weixin_58775072的博客
10-14 1416
springboot的websocket
springboot中websocket实现在线聊天
05-19
Spring Boot框架提供了WebSocket API，可以很方便地实现在线聊天功能。 首先，需要在pom.xml文件中添加WebSocket依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-websocket ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值