java socketIo 搭建 聊天服务

最新推荐文章于 2024-06-01 09:48:42 发布
最新推荐文章于 2024-06-01 09:48:42 发布
阅读量1.5k 收藏 13
点赞数 3
分类专栏： 工具类 文章标签： java socket linux spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itjavaee/article/details/108996951
版权

如果你想搭建一个聊天服务，但是又不想用第三方服务，比如：环信，融云等其他，本篇文章可作为参考。文章采用springboot2.2.x构建，因为部分代码涉及业务，已移除，标识TODO都需要配合你自身的业务实现，如果遇到问题可以在评论区提问，或者私聊我也可以

1.导入maven引入依赖

<dependency>
    <groupId>com.corundumstudio.socketio</groupId>
    <artifactId>netty-socketio</artifactId>
    <version>1.7.18</version>
</dependency>

2.配置yml

socketio:
  host: 192.168.0.120
  port: 8887
  # 设置最大每帧处理数据的长度，防止他人利用大数据来攻击服务器
  maxFramePayloadLength: 1048576
  # 设置http交互最大内容长度
  maxHttpContentLength: 1048576
  # socket连接数大小（如只监听一个端口boss线程组为1即可）
  bossCount: 1
  workCount: 100
  allowCustomRequests: true
  # 协议升级超时时间（毫秒），默认10秒。HTTP握手升级为ws协议超时时间
  upgradeTimeout: 1000000
  # Ping消息超时时间（毫秒），默认60秒，这个时间间隔内没有接收到心跳消息就会发送超时事件
  pingTimeout: 6000000
  # Ping消息间隔（毫秒），默认25秒。客户端向服务器发送一条心跳消息间隔
  pingInterval: 25000

3.创建socketIo的配置类

import com.corundumstudio.socketio.SocketConfig;
import com.corundumstudio.socketio.SocketIOClient;
import com.corundumstudio.socketio.SocketIOServer;
import com.corundumstudio.socketio.Transport;
import com.corundumstudio.socketio.listener.ExceptionListener;
import io.netty.channel.ChannelHandlerContext;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Configuration
public class SocketIOConfig {

    @Value("${socketio.host}")
    private String host;

    @Value("${socketio.port}")
    private Integer port;

    @Value("${socketio.bossCount}")
    private int bossCount;

    @Value("${socketio.workCount}")
    private int workCount;

    @Value("${socketio.allowCustomRequests}")
    private boolean allowCustomRequests;

    @Value("${socketio.upgradeTimeout}")
    private int upgradeTimeout;

    @Value("${socketio.pingTimeout}")
    private int pingTimeout;

    @Value("${socketio.pingInterval}")
    private int pingInterval;

    @Bean
    public SocketIOServer socketIOServer() {
        SocketConfig socketConfig = new SocketConfig();
        socketConfig.setTcpNoDelay(true);
        socketConfig.setSoLinger(0);
//        解决重启端口占用问题，但因为是docker部署好像没有发现这个问题
//        socketConfig.setReuseAddress(true);

        com.corundumstudio.socketio.Configuration config = new com.corundumstudio.socketio.Configuration();
        config.setSocketConfig(socketConfig);
//        config.setHostname(host);
        config.setPort(port);
        config.setBossThreads(bossCount);
        config.setWorkerThreads(workCount);
        config.setAllowCustomRequests(allowCustomRequests);
        config.setUpgradeTimeout(upgradeTimeout);
        config.setPingTimeout(pingTimeout);
        config.setPingInterval(pingInterval);
        config.setTransports(Transport.WEBSOCKET);
        config.setRandomSession(true);  //default is false
        //鉴权
        config.setAuthorizationListener(data -> {
            //socketio可以传参，可以获取到 链接后面的参数 ?username=1&pwd=2
            String username= data.getSingleUrlParam("username");
            String pwd= data.getSingleUrlParam("pwd");
            //这里可以用作链接时的权限判断，返回false就是不允许链接，
            return true;
        });

        // 异常
        config.setExceptionListener(new ExceptionListener() {
            @Override
            public void onEventException(Exception e, List<Object> args, SocketIOClient client) {
                e.printStackTrace();
            }

            @Override
            public void onDisconnectException(Exception e, SocketIOClient client) {
                e.printStackTrace();
            }

            @Override
            public void onConnectException(Exception e, SocketIOClient client) {
                e.printStackTrace();
            }

            @Override
            public void onPingException(Exception e, SocketIOClient client) {
                e.printStackTrace();
            }

            @Override
            public boolean exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                cause.printStackTrace();
                ctx.close();
                return false;
            }
        });
        return new SocketIOServer(config);
    }
}

4.创建 ISocketIoService 用作socketio的接口服务

public interface ISocketIoService {
    /**
     * 启动服务
     */
    void start();

    /**
     * 停止服务
     */
    void stop();
}

5. 实现SocketIoServiceImpl

package com.yianjia.im.socketio;

import com.alibaba.fastjson.JSON;
import com.corundumstudio.socketio.AckRequest;
import com.corundumstudio.socketio.SocketIOClient;
import com.corundumstudio.socketio.SocketIOServer;
import com.corundumstudio.socketio.annotation.OnConnect;
import com.corundumstudio.socketio.annotation.OnDisconnect;
import com.corundumstudio.socketio.annotation.OnEvent;
import com.yianjia.im.project.utils.JsonUtils;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PreDestroy;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

@Service
public class SocketIoServiceImpl implements ISocketIoService {

    private final static Logger logger = LoggerFactory.getLogger(SocketIoServiceImpl.class);

    /**
     * 存放已连接的客户端
     */
    private static final Map<String, SocketIOClient> accountClientMap = new ConcurrentHashMap<>();
    private static final Map<String, ImAccount> clientAccountMap = new ConcurrentHashMap<>();

    /**
     * 发送消息
     */
    private static final String SEND_MSG_EVENT = "send_msg_event";

    /**
     * 客户端接收消息
     */
    private static final String ON_RECEIVE_MSG = "on_receive_msg";

    /**
     * 未签收
     */
    private static final String UNSIGN_MSG_EVENT = "unsign_msg_event";

    @Autowired
    private SocketIOServer socketIOServer;

    /**
     * Spring IoC容器在销毁SocketIOServiceImpl Bean之前关闭,避免重启项目服务端口占用问题
     */
    @PreDestroy
    private void autoStop() {
        stop();
    }

    @Override
    public void start() {
        socketIOServer.start();
    }

    @Override
    public void stop() {
        if (socketIOServer != null) {
            socketIOServer.stop();
            socketIOServer = null;
        }
    }

    /**
     * 推送信息给指定客户端
     *
     * @param accountCode
     * @param msgContent
     * @param imMsg
     */
    public void pushMessageToAccount(String accountCode, String msgContent, 发送消息体 imMsg) {
        SocketIOClient client = accountClientMap.get(accountCode);
        if (client != null && client.isChannelOpen()) {
            client.sendEvent(ON_RECEIVE_MSG, msgContent);
            logger.info("发送消息：" + accountCode);
        }
    }

    /**
     * 获取客户端url中的鉴权参数
     *
     * @param client: 客户端
     */
    private Object getParamsByClient(SocketIOClient client) {
        // 获取客户端url参数
        String username = client.getHandshakeData().getSingleUrlParam("username");
        String pwd = client.getHandshakeData().getSingleUrlParam("pwd");
        //这里主要是返回用户信息 TODO
        return null;
    }

    /**
     * 获取连接的客户端ip地址
     *
     * @param client: 客户端
     * @return: java.lang.String
     */
    private String getIpByClient(SocketIOClient client) {
        String sa = client.getRemoteAddress().toString();
        if (client.getHandshakeData().getHttpHeaders().get("x-forwarded-for") != null) {
            return client.getHandshakeData().getHttpHeaders().get("x-forwarded-for");
        }
        return sa.substring(1, sa.indexOf(":"));
    }

    /**
     * 客户端链接
     *
     * @param client 客户端
     */
    @OnConnect
    private void connectListener(SocketIOClient client) {
        Object user = getParamsByClient(client);
        if (null == user) {
            client.disconnect();
            return;
        }
        logger.info("************ 客户端： " + getIpByClient(client) + " 已连接： " + user + " ************");

        // TODO 获取用户的唯一标识，从上面user里面拿user.getImCode();
        String userImCode = "";

        SocketIOClient socketIOClient = accountClientMap.get(userImCode);
        if (null != socketIOClient) {
            if (clientAccountMap.containsKey(socketIOClient.getSessionId().toString())) {
                clientAccountMap.remove(socketIOClient.getSessionId().toString());
            }
            if (socketIOClient.isChannelOpen()) {
                socketIOClient.sendEvent("disconnect", "断开连接");
                socketIOClient.disconnect();
            }
        }
        accountClientMap.put(userImCode, client);

        ImAccount imAccount = new ImAccount();
        imAccount.setImCode(userImCode);
        clientAccountMap.put(client.getSessionId().toString(), imAccount);
        logger.info("当前在线人数：" + accountClientMap.keySet().size());
        client.sendEvent("connected", "成功连接");
    }

    /**
     * 链接断开
     *
     * @param client 客户端
     */
    @OnDisconnect
    private void disconnectListener(SocketIOClient client) {
        logger.info("************ 客户端： " + getIpByClient(client) + " 已断开 ************");
        client.disconnect();
        clientAccountMap.remove(client.getSessionId().toString());
        // 这里没有删除 account，是因为存在账户后登陆，然后上一个链接才断线的情况
        logger.info("当前在线人数：" + clientAccountMap.keySet().size());
    }

    /**
     * 未签收消息监听
     *
     * @param client     客户端
     * @param data       数据
     * @param ackRequest 回调函数
     */
    @OnEvent(value = UNSIGN_MSG_EVENT)
    private void unreadConversationEventListener(SocketIOClient client, String data, AckRequest ackRequest) {
        ImAccount imAccount = clientAccountMap.get(client.getSessionId().toString());
        String imCode = imAccount.getImCode();
        if (StringUtils.isBlank(imCode)) {
            client.disconnect();
            return;
        }
        String clientIp = getIpByClient(client);
        logger.info(clientIp + " 客户端 未签收消息");

        /**
         * TODO 根据imCode去数据库里面查询这个账户没有签收的消息
         */
        List<消息db类> msgList = new ArrayList<>();

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<消息db类> updateMsgList = msgList.stream().map(imMsg -> {
            发送消息体 sendChatMsg = new 发送消息体();
            // TODO 构建发送消息体，然后判断连接是否打开，打开的话，发过去

            if (client.isChannelOpen()) {
                client.sendEvent(ON_RECEIVE_MSG, JsonUtils.objectToJson(sendChatMsg));
                消息db类.setSign("已签收");
                return imMsg;
            }
            return null;
        }).filter(Objects::nonNull).collect(Collectors.toList());
        if (1 <= updateMsgList.size()) {
            // TODO 更新数据库的消息状态
            update(updateMsgList);
        }
        ackRequest.sendAckData("ok");
    }

    /**
     * 消息发送监听
     *
     * @param client     客户端
     * @param data       数据
     * @param ackRequest 回调函数
     */
    @OnEvent(value = SEND_MSG_EVENT)
    private void sendMsgEventListener(SocketIOClient client, String data, AckRequest ackRequest) {
        ImAccount imAccount = clientAccountMap.get(client.getSessionId().toString());
        String imCode = imAccount.getImCode();
        if (StringUtils.isBlank(imCode)) {
            client.disconnect();
            return;
        }
        String clientIp = getIpByClient(client);
        logger.info(clientIp + " 客户端消息：" + data);

        // TODO 将接受的消息字符串转成自己的对象
        发送消息体 chatMsg = JSON.parseObject(data, 发送消息体.class);

        // TODO 构建消息db类，并进行保存
        消息db类 imMsg = new 消息db类();
        save(imMsg);

        // TODO 构建发送消息体，然后判断连接是否打开，打开的话，发过去
        发送消息体 sendChatMsg = new 发送消息体();

        pushMessageToAccount(acceptAccountCode, JsonUtils.objectToJson(sendChatMsg), imMsg);

        ackRequest.sendAckData(data);
    }

    @Data
    class ImAccount {
        /**
         * imCode，标识用户的唯一码
         */
        private String imCode;
    }
}

6.启动socketIo服务

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class SocketIoServer implements ApplicationRunner {

    @Autowired
    private ISocketIoService socketIOService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        socketIOService.start();
    }
}

7. 在Application里面注册配置

@Bean
public SpringAnnotationScanner springAnnotationScanner(SocketIOServer socketServer) {
    return new SpringAnnotationScanner(socketServer);
}

8.Nginx配置参考

 

 

 

 

 

 

97牛肉面
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
socket.io服务端是java_基于netty-socketio的web推送服务
weixin_39564807的博客
02-12 742
实时消息的推送，PC端的推送技术可以使用socket建立一个长连接来实现。传统的web服务都是客户端发出请求，服务端给出响应。但是现在直观的要求是允许特定时间内在没有客户端发起请求的情况下服务端主动推送消息到客户端。有哪些可以实现web消息推送的技术：不断地轮询(俗称“拉”，polling)是获取实时消息的一个手段：Ajax 隔一段时间(通常使用 JavaScript 的 setTimeout 函...
Java Socket编程——单线程聊天室
qq_39663771的博客
03-08 295
单线程聊天室 项目设计流程： 1.创建项目 两个模板：服务器模块，客户端模块 2.服务器 1.创建ServerSocket，绑定端口 2.接收客户端连接，Socket 3.通过Socket发送和接收数据 4.关闭ServerSocket/Socket 3.客户端 1.创建Socket，指定服务器的地址和服务端口(连接指定服务) 2.通过Socket发送和接收数据 3.关闭Socket 服务器...
netty-socketio实现web实时推送
sinaihalo的博客
08-13 2093
0准备 netty-socketio的jar包,maven坐标如下，前台需要socket.io.js，jquery-1.7.2.min.js &amp;amp;amp;amp;amp;lt;groupId&amp;amp;amp;amp;amp;gt;com.corundumstudio.socketio&amp;amp;amp;amp;amp;lt;/groupId&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;l
springboot编写netty-socketio实例
zhangjian8641的博客
09-16 838
socket基础：https://blog.csdn.net/zhangjian8641/article/details/108615804 上一篇记录了基础的Socket，本篇将结合springboot一起使用socket 1、引进Maven <dependency> <groupId>io.socket</groupId> <artifactId>socket.io-client</artifactId> <ver
推荐项目：轻量级Socket.IO Java服务器——实现高效实时通信的利器
最新发布
gitblog_00012的博客
06-01 304
推荐项目：轻量级Socket.IO Java服务器——实现高效实时通信的利器 项目地址:https://gitcode.com/scalecube/socketio 在构建高性能、低延迟的实时应用时，选择合适的通讯框架至关重要。今天，我们要推荐一个开源宝藏 —— ScaleCube Socket.IO Java Server，这是一款基于强大的Netty框架的Socket.IO服务器实现，旨在满足...
SocketIO实现Java聊天服务端
文艺的码农青年的博客
11-27 2357
本文使用到netty-socketio开源库，以及mysql，所以首先在pom.xml中添加相应的依赖库 <dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-socketio</artifactId> ...
实现Java Socket 客户端服务端交互实例
qq_42946963的博客
11-19 7056
package socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class SocketService { //搭建服务器端 public static voi
java socketio 入门教程（自制聊天系统）
浮世与人心的博客
11-01 2704
java socketio 入门Demo WebSocket ：一种通信协议 ，其作用建立一个连接通道，使数据交互从传统的请求响应的方式 改为了实时的双向推送 ，解决了 http 协议的部分不足 这里就直接整合了spring boot，spring boot 太香了 聊天demo代码（服务器版） 依赖(没贴spring boot的) <dependency> <gr...
java-socketio推送demo
06-06
总结，"java-socketio推送demo"涵盖了Java后端使用Netty-SocketIO搭建实时通信服务器，以及前端JavaScript客户端的配置和交互。通过这个示例，开发者可以学习如何实现网页间的实时通信，包括消息推送、故障处理和...
安卓使用socketio实现聊天室功能
02-17
服务器端需要运行Socket.IO服务，例如用Node.js搭建。连接代码如下： ```java Socket socket = IO.socket("http://your-server-url:port"); socket.connect(); ``` 接着，我们需要监听`connect`、`disconnect`、`...
安卓android SocketIo使用方式socketIo
02-17
本文将深入探讨如何在Android平台上利用SocketIO与服务器进行通信，实现一个基本的聊天室功能。 首先，我们需要理解SocketIO的核心概念。SocketIO不仅仅是一个简单的TCP套接字，它还提供了一种高级的API，可以方便...
SocketIO所需jar库及Java服务端和JS客户端例程
07-05
SocketIO所需要的Java库及相关例程，可以直接使用，免除在没有Maven的环境下手动下载的烦恼
socketio-nodejs-to-java:使用“ socket.io”库将事件从HTTP服务器（Node.js）发送到Java
05-26
在IT行业中，实时通信是许多应用程序的核心需求，例如在线聊天、协作工具或实时数据分析系统。在这种背景下，"socketio-nodejs-to...通过理解并实践这些知识点，开发者能够轻松地搭建Node.js和Java之间的实时通信桥梁。
webRTC+socketio+SpringBoot视频及文字聊天demo.zip
05-18
demo使用SpringBoot+socket.io框架，基于webRTC开发的浏览器web视频与文字聊天 coturn服务搭建地址：https://blog.csdn.net/qq_37231681/article/details/92834298（在main.js中配置coturn地址及账号密码）
java-io流--（八）--socket-io
qq_43470725的博客
11-16 298
通过流来实现socket中数据的处理： 代码案例： package com.example.socket; import lombok.extern.slf4j.Slf4j; import java.io.IOException; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; @Slf4j public class SocketClient00 { public static
用Java原生Socket（BIO）做一个聊天室 实现单聊和群聊（附完整源码）
小楼夜听雨的博客
04-19 1037
目录 思路 源码分析 目录结构 消息体 服务端 客户端 分析 源码地址 思路 要实现单聊和群聊需要考虑哪些方面？ 1、需要有客户端和服务端，客户端给用户提供发送消息、接收消息的途径。服务端用于接受客户端的连接，并进行消息接收、消息处理和消息转发。 2、需要统一消息的格式，我这里仅仅是定义一个Message对象，通过type字段区分消息的类型。 如果做的精细点，可以考虑自己设计一个基于tcp的通讯协议，具体思路可以看我上一篇博客的方案二。 3、单聊：服务器把收到的消息转发给目.
java socket与io流_【Java__Socket 】服务端和客户端通信案例（IO流）
weixin_35063099的博客
02-13 212
0、前言Java IO 流分为输入流InputStream和输出流OutputStream输入流输出流InputStreamOutputStream读进来写出去读到程序内存写出到流里面1、客户端public static void main(String[] args) throws IOException {new Thread(() -> {Socket socket = null;tr...
java socket套接字通信服务端和客户端详解
OceanSky的专栏
09-28 1054
1.socket服务端代码示例 package com.yaomy.control.zeromq.socket.server; import com.yaomy.control.logback.utils.LoggerUtil; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import jav...
socket.io服务端是java_SpringBoot(23) 集成socket.io服务端和客户端实现通信
weixin_39572764的博客
02-12 582
@Slf4j@Service(value = "socketIOService")public class SocketIOServiceImpl implements ISocketIOService {/*** 存放已连接的客户端*/private static Map clientMap = new ConcurrentHashMap<>();/*** 自定义事件`push_da...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值