springboot编写netty-socketio实例

相关文章
java基础socket实例：https://blog.csdn.net/zhangjian8641/article/details/108615804

1、引进Maven

<dependency>
    <groupId>io.socket</groupId>
    <artifactId>socket.io-client</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
</dependency>

2、引进yml配置

# netty-socketio 配置
socketio:
  host: 127.0.0.1
  port: 9999
  # 设置最大每帧处理数据的长度，防止他人利用大数据来攻击服务器
  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、编写配置文件

package com.example.socketio;

import org.springframework.context.annotation.Configuration;
import com.corundumstudio.socketio.SocketConfig;
import com.corundumstudio.socketio.SocketIOServer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

@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);
        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);
        return new SocketIOServer(config);
    }

}

4、编写服务层

package com.example.socketio;

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

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

    /**
     * 推送信息给指定客户端
     *
     * @param userId:     客户端唯一标识
     * @param msgContent: 消息内容
     */
    void pushMessageToUser(String userId, String msgContent);
}

package com.example.socketio;

import com.corundumstudio.socketio.SocketIOClient;
import com.corundumstudio.socketio.SocketIOServer;
import org.assertj.core.util.DateUtil;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 服务层实现
 */
@Service
public class ISocketIOServiceImpl implements ISocketIOService {
    
    

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

    /**
     * 自定义事件`push_data_event`,用于服务端与客户端通信
     */
    private static final String PUSH_DATA_EVENT = "push_data_event";

    @Resource
    private SocketIOServer socketIOServer;

    /**
     * Spring IoC容器创建之后，在加载SocketIOServiceImpl Bean之后启动
     */
    @PostConstruct
    private void autoStartup() {
    
    
        start();
    }

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

    @Override
    public void start() {
    
    
        // 监听客户端连接
        socketIOServer.addConnectListener(client -> {
    
    
            System.out.println("************ 客户端： " + getIpByClient(client) + " 已连接 ************");
            // 自定义事件`connected` -> 与客户端通信  （也可以使用内置事件，如：Socket.EVENT_CONNECT）
            client.sendEvent("connected", "你成功连接上了哦...");
            String userId = getParamsByClient(client);
            if (userId != null) {
    
    
                clientMap.put(userId, client);
            }
        });

        // 监听客户端断开连接
        socketIOServer.addDisconnectListener(client -> {
    
    
            String clientIp = getIpByClient(client);
            System.out.println(clientIp + " *********************** " + "客户端已断开连接");
            String userId = getParamsByClient(client);
            if (userId != null) {
    
    
                clientMap.remove(userId);
                client.disconnect();
            }
        });

        // 自定义事件`client_info_event` -> 监听客户端消息
        socketIOServer.addEventListener(PUSH_DATA_EVENT, String.class, (client, data, ackSender) -> {
    
    
            // 客户端推送`client_info_event`事件时，onData接受数据，这里是string类型的json数据，还可以为Byte[],object其他类型
            String clientIp = getIpByClient(client);
            System.out.println(clientIp + " ************ 客户端：" + data);
        });

        // 启动服务
        socketIOServer.start();

        // broadcast: 默认是向所有的socket连接进行广播，但是不包括发送者自身，如果自己也打算接收消息的话，需要给自己单独发送。
        new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    // 每3秒发送一次广播消息
                    Thread.sleep(3000);
                    socketIOServer.getBroadcastOperations().sendEvent("myBroadcast", "广播消息 " + DateUtil.now());
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }).start();
    }

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

    @Override
    public void pushMessageToUser(String userId, String msgContent) {
    
    
        SocketIOClient client = clientMap.get(userId);
        if (client != null) {
    
    
            client.sendEvent(PUSH_DATA_EVENT, msgContent);
        }
    }

    /**
     * 获取客户端url中的userId参数（这里根据个人需求和客户端对应修改即可）
     *
     * @param client: 客户端
     * @return java.lang.String
     */
    private String getParamsByClient(SocketIOClient client) {
    
    
        // 获取客户端url参数（这里的userId是唯一标识）
        Map<String, List<String>> params = client.getHandshakeData().getUrlParams();
        List<String> userIdList = params.get("userId");
        if (!CollectionUtils.isEmpty(userIdList)) {
    
    
            return userIdList.get(0);
        }
        return null;
    }

    /**
     * 获取连接的客户端ip地址
     *
     * @param client: 客户端
     * @return java.lang.String
     */
    private String getIpByClient(SocketIOClient client) {
    
    
        String sa = client.getRemoteAddress().toString();
        return sa.substring(1, sa.indexOf(":"));
    }

}

5、模拟客户端

package com.example.socketio;

import io.socket.client.IO;
import io.socket.client.Socket;
import org.assertj.core.util.DateUtil;

/**
 * 模拟客户端
 */
public class SocketIOClientLaunch {
    
    

    public static void main(String[] args) {
    
    
        // 服务端socket.io连接通信地址
        final String url = "http://127.0.0.1:9999";
        try {
    
    
            IO.Options options = new IO.Options();
            options.transports = new String[]{
    
    "websocket"};
            options.reconnectionAttempts = 2;
            // 失败重连的时间间隔
            options.reconnectionDelay = 1000;
            // 连接超时时间(ms)
            options.timeout = 500;
            // userId: 唯一标识 传给服务端存储
            final Socket socket = IO.socket(url + "?userId=1", options);

            // 自定义事件`connected` -> 接收服务端成功连接消息
            socket.on("connected", objects -> System.out.println("服务端:" + objects[0].toString()));

            // 自定义事件`push_data_event` -> 接收服务端消息
            socket.on("push_data_event", objects -> System.out.println("服务端:" + objects[0].toString()));

            // 自定义事件`myBroadcast` -> 接收服务端广播消息
            socket.on("myBroadcast", objects -> System.out.println("服务端：" + objects[0].toString()));

            socket.connect();

            while (true) {
    
    
                Thread.sleep(3000);
                // 自定义事件`push_data_event` -> 向服务端发送消息
                socket.emit("push_data_event", "发送数据 " + DateUtil.now());
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

}

可以多客户端，只要把 userId 改掉就可以了，例：

final Socket socket = IO.socket(url + “?userId=2”, options);

package com.example.socketio;


import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 服务端主动发送消息
 */
@RestController
@RequestMapping("/api/socket.io")
public class SocketIOController {
    
    

    @Resource
    private ISocketIOService socketIOService;

    @GetMapping(value = "/pushMessageToUser")
    public String pushMessageToUser(@RequestParam String userId, @RequestParam String msgContent) {
    
    
        socketIOService.pushMessageToUser(userId, msgContent);
        return "SUCCESS";
    }

}

6、总结

socketIOServer.addConnectListener：监听客户端连接
socketIOServer.addDisconnectListener：监听客户端断开连接
socketIOServer.addEventListener：监听客户端传输的消息 client.sendEvent(“自定义事件名称”,
“消息内容”)：服务端向指定的clien客户端发送消息
socketIOServer.getBroadcastOperations().sendEvent(“自定义事件名称”,
“消息内容”)：服务端发送广播消息给所有客户端

IO.socket(url)：与指定的socket.io服务端建立连接
socket.emit：发送数据到服务端事件
socket.on：监听服务端事件

7、场景

需要实现持续获取最新信息的情况下
如：消息通知，地图当前所在位置，实时统计数据等