springboot学习(四十三) springboot使用netty-socketio实现消息推送

最新推荐文章于 2024-06-06 13:23:07 发布
最新推荐文章于 2024-06-06 13:23:07 发布
阅读量6.8k 收藏 45
点赞数 8
分类专栏： spring boot 文章标签： nettysocketio socketio websocket namespace room
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011943534/article/details/115232123
版权

本文使用netty-socketio实现类似websocket的消息推送，并通过命名空间实现用户隔离。
WebSocket是一种通信协议，它通过TCP连接在客户端和服务器之间提供双向通信，WebSocket始终保持打开状态，因此它们允许实时数据传输。当客户端向服务器触发请求时，它不会在接收到响应时关闭连接，而是会继续存在，并等待客户端或服务器终止请求。
Socket.IO 是一个库，可用于在客户端和Web服务器之间进行实时和全双工通信。它使用WebSocket协议提供接口。

1、引入依赖

如果是gradle

compile 'com.corundumstudio.socketio:netty-socketio:1.7.18'

如果是maven

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

2、定义配置类

package com.iscas.base.biz.config.socketio;

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

import java.util.Arrays;
import java.util.Optional;

/**
 * socket.io
 *
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2021/3/25 8:51
 * @since jdk1.8
 */
//@Configuration
public class SocketioConfig {
    @Value("${socket.io.port:8974}")
    private int socketIoPort;
    @Value("${socket.io.namespaces}")
    private String[] namespaces;

    @Bean
    public SocketIOServer socketIOServer() {
        com.corundumstudio.socketio.Configuration config =
                new com.corundumstudio.socketio.Configuration();
        config.setOrigin(null);   // 注意如果开放跨域设置，需要设置为null而不是"*"
        config.setPort(socketIoPort);
        config.setSocketConfig(new SocketConfig());
        config.setWorkerThreads(100);
        config.setAuthorizationListener(handshakeData -> true);
        //允许最大帧长度
        config.setMaxFramePayloadLength(1024 * 1024);
        //允许下最大内容
        config.setMaxHttpContentLength(1024 * 1024);
        final SocketIOServer server = new SocketIOServer(config);
        Optional.ofNullable(namespaces).ifPresent(nss ->
                Arrays.stream(nss).forEach(server::addNamespace));
//        server.start();
        return server;

    }

    /**
     * 注入OnConnect，OnDisconnect，OnEvent注解。 不写的话Spring无法扫描OnConnect，OnDisconnect等注解
     * */
    @Bean
    public SpringAnnotationScanner springAnnotationScanner(SocketIOServer socketIOServer){
        return new SpringAnnotationScanner(socketIOServer);
    }
}

3、配置文件内配置端口和命名空间

#########socket.io相关配置##################
socket.io.port=8974
#命名空间，多个以逗号分隔，每个空间需要对应一个Bean的名字，XXXMessageEventHandler,如chatMessageEventHandler
socket.io.namespaces=/chat,/test

4、定义事件处理接口和默认实现
连接的处理使用前端传入Authorization,可以传入token,做校验。

package com.iscas.biz.socketio;

import com.corundumstudio.socketio.SocketIOClient;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;

/**
 *
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2021/3/25 10:15
 * @since jdk1.8
 */

public interface IEventHandler {
    void onConnect(SocketIOClient client);
    void onDisConnect(SocketIOClient client);


    default void connect(SocketIOClient client) {
//        if (!client.getNamespace().getName().equals("/chat")) {
            client.disconnect();
//            return;
//        }
        String token = client.getHandshakeData().getSingleUrlParam("Authorization");
        if (token == null) {
            System.err.println("客户端" + client.getSessionId() + "建立websocket连接失败，Authorization不能为null");
            client.disconnect();
            return;
        }

        Map header = new HashMap<>();
        header.put("Authorization", token);

        String username = null;
//        try {
//            Map<String, Claim> claimMap = JWTUtils.verifyToken(token);
//            username = claimMap.get("username").asString();
//            if (username == null) {
//                throw new RuntimeException("websocket认证失败");
//            }
//        } catch (UnsupportedEncodingException e) {
//            e.printStackTrace();
//            throw new RuntimeException("websocket认证失败", e);
//        } catch (ValidTokenException e) {
//            e.printStackTrace();
//            throw new RuntimeException("websocket认证失败", e);
//        }
        username = token;
        if (username != null) {
            System.out.println("客户端" + client.getSessionId() + "建立websocket连接成功");
            //将用户名和clientId对应 方便推送时候使用
            SocketIOStaticInfo.userClientIdMap.put(username, client.getSessionId());
        } else {
            System.err.println("客户端" + client.getSessionId() + "建立websocket连接失败");
            client.disconnect();
        }

    }

    default void disconnect(SocketIOClient client) {
        System.out.println("客户端" + client.getSessionId() + "断开websocket连接成功");
        //移除
        for (Map.Entry<String, UUID> entry : SocketIOStaticInfo.userClientIdMap.entrySet()) {
            if (Objects.equals(entry.getValue(), client.getSessionId())) {
                SocketIOStaticInfo.userClientIdMap.remove(entry.getKey());
            }
        }
    }
}

5、定义启动类
这里为每个命名空间注册一个事件处理Handler, 规则为bean的name为命名空间名称+MessageHandler。

package com.iscas.base.biz.config;

import com.corundumstudio.socketio.SocketIONamespace;
import com.corundumstudio.socketio.SocketIOServer;
import com.iscas.base.biz.service.common.SpringService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Optional;

/**
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2021/3/25 10:07
 * @since jdk1.8
 */
@Component
public class ServerRunner implements CommandLineRunner {
    @Autowired(required = false)
    private SocketIOServer socketIOServer;

    @Value("${socket.io.namespaces}")
    private String[] namespaces;

    @Override
    public void run(String... args) throws Exception {
        if (socketIOServer != null) {
            /*Optional.ofNullable(SpringService.getBean("messageEventHandler"))
                    .ifPresent(handler -> socketIOServer.getNamespace("/").addListeners(handler));*/


            Optional.ofNullable(namespaces).ifPresent(nss ->
                    Arrays.stream(nss).forEach(ns -> {
                        //获取命名空间
                        SocketIONamespace socketIONamespace = socketIOServer.getNamespace(ns);
                        //获取期待的类名
                        String className = ns.substring(1) + "MessageEventHandler";
                        try {
                            Object bean = SpringService.getBean(className);
                            Optional.ofNullable(bean).ifPresent(socketIONamespace::addListeners);
                        } catch (Exception e) {

                        }

                    }));
//            socketIOServer.getNamespace("/chat").addListeners(messageEventHandler);
            socketIOServer.start();
        }
    }
}

6、几种消息接收和发送模式
（1）点对点消息

@OnEvent(value = "aaaa")
    public void onEvent(SocketIOClient client, AckRequest request, String data) {
        log.debug("发来消息：" + data);
        UUID sessionId = client.getSessionId();
        socketIOServer.getNamespace(namespace).getClient(sessionId).sendEvent("bbbb", "点对点消息的返回" + Math.random());
    }

（2）房间消息

/**
     * 测试加入房间
     * */
    @OnEvent(value = "joinRoom")
    public void onTestJoinRoomEvent(SocketIOClient client, AckRequest request, String data) {
        client.leaveRoom(data);
        client.joinRoom(data);
    }

    /**
     * 测试房间发送信息(类似于订阅式广播消息)
     * */
    @OnEvent(value = "testRoom")
    public void onTestRoomEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getRoomOperations("room1").sendEvent("testRoom", "房间里的消息" + Math.random());
    }

(3) 广播消息

/**
     * 测试发送广播消息
     * */
    @OnEvent(value = "testBroadcast")
    public void onTestBroadcastEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getBroadcastOperations().sendEvent("testBroadcast", "广播的消息" + Math.random());
    }

7、完整消息处理器
chat 和test

package com.iscas.biz.socketio;

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.iscas.common.tools.core.random.RandomStringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2018/7/22 18:32
 * @since jdk1.8
 */
@Component(value= "chatMessageEventHandler")
@ConditionalOnClass(SocketIOServer.class)
@Slf4j
public class ChatMessageEventHandler implements IEventHandler {
    private final SocketIOServer socketIOServer;
    private static int testPushCount = 0;
    private String namespace = "/chat";

    public ChatMessageEventHandler(SocketIOServer socketIOServer) {
        this.socketIOServer = socketIOServer;
    }

    @Override
    @OnConnect
    public void onConnect(SocketIOClient client) {
        connect(client);
    }


    @Override
    @OnDisconnect
    public void onDisConnect(SocketIOClient client) {
        disconnect(client);
    }

    @OnEvent(value = "aaaa")
    public void onEvent(SocketIOClient client, AckRequest request, String data) {
        log.debug("发来消息：" + data);
        UUID sessionId = client.getSessionId();
        socketIOServer.getNamespace(namespace).getClient(sessionId).sendEvent("bbbb", "点对点消息的返回" + Math.random());
    }

    /**
     * 测试无限推送
     * */
    @OnEvent(value = "testPush")
    public void onTestPushEvent(SocketIOClient client, AckRequest request, String data) {
        UUID sessionId = client.getSessionId();
        Runnable runnable = () -> {
            testPushCount++;
            int thisTestPushCount = testPushCount;
            for (; ; ) {
                if (thisTestPushCount < testPushCount) {
                    break;
                }
                socketIOServer.getNamespace(namespace).getClient(sessionId).sendEvent("testPush", RandomStringUtils.randomStr(1024 * 200));
                try {
                    TimeUnit.MILLISECONDS.sleep(900);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        new Thread(runnable).start();
    }

    /**
     * 测试加入房间
     * */
    @OnEvent(value = "joinRoom")
    public void onTestJoinRoomEvent(SocketIOClient client, AckRequest request, String data) {
        client.leaveRoom(data);
        client.joinRoom(data);
    }

    /**
     * 测试房间发送信息(类似于订阅式广播消息)
     * */
    @OnEvent(value = "testRoom")
    public void onTestRoomEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getRoomOperations("room1").sendEvent("testRoom", "房间里的消息" + Math.random());
    }

    /**
     * 测试发送广播消息
     * */
    @OnEvent(value = "testBroadcast")
    public void onTestBroadcastEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getBroadcastOperations().sendEvent("testBroadcast", "广播的消息" + Math.random());
    }

}


package com.iscas.biz.socketio;

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.iscas.common.tools.core.random.RandomStringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2018/7/22 18:32
 * @since jdk1.8
 */
@Component(value= "testMessageEventHandler")
@ConditionalOnClass(SocketIOServer.class)
@Slf4j
public class TestMessageEventHandler implements IEventHandler {
    private final SocketIOServer socketIOServer;
    private static int testPushCount = 0;

    private String namespace = "/test";

    public TestMessageEventHandler(SocketIOServer socketIOServer) {
        this.socketIOServer = socketIOServer;
    }

    @Override
    @OnConnect
    public void onConnect(SocketIOClient client) {
        connect(client);
    }


    @Override
    @OnDisconnect
    public void onDisConnect(SocketIOClient client) {
       disconnect(client);
    }

    @OnEvent(value = "aaaa")
    public void onEvent(SocketIOClient client, AckRequest request, String data) {
        log.debug("发来消息：" + data);
        UUID sessionId = client.getSessionId();
        socketIOServer.getNamespace(namespace).getClient(sessionId).sendEvent("bbbb", "点对点消息的返回" + Math.random());
    }

    /**
     * 测试无限推送
     * */
    @OnEvent(value = "testPush")
    public void onTestPushEvent(SocketIOClient client, AckRequest request, String data) {
        UUID sessionId = client.getSessionId();
        Runnable runnable = () -> {
            testPushCount++;
            int thisTestPushCount = testPushCount;
            for (; ; ) {
                if (thisTestPushCount < testPushCount) {
                    break;
                }
                socketIOServer.getNamespace(namespace).getClient(sessionId).sendEvent("testPush", RandomStringUtils.randomStr(1024 * 200));
                try {
                    TimeUnit.MILLISECONDS.sleep(900);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        new Thread(runnable).start();
    }

    /**
     * 测试加入房间
     * */
    @OnEvent(value = "joinRoom")
    public void onTestJoinRoomEvent(SocketIOClient client, AckRequest request, String data) {
        client.leaveRoom(data);
        client.joinRoom(data);
    }

    /**
     * 测试房间发送信息(类似于订阅式广播消息)
     * */
    @OnEvent(value = "testRoom")
    public void onTestRoomEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getRoomOperations("room1").sendEvent("testRoom", "房间里的消息" + Math.random());
    }

    /**
     * 测试发送广播消息
     * */
    @OnEvent(value = "testBroadcast")
    public void onTestBroadcastEvent(SocketIOClient client, AckRequest request, String data) {
        socketIOServer.getNamespace(namespace).getBroadcastOperations().sendEvent("testBroadcast", "广播的消息" + Math.random());
    }
    
}

8、前端代码

chat:

<html>
<head>
    <meta charset="utf-8"/>
    <!--<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/2.1.0/socket.io.js"></script>-->
    <script src="socket.io-2.1.0.js"></script>
    <script>

        var socket = null;
        var i = 0;
        window.onload = function(){
            initSocket();
        }
        function getCookie(c_name)
        {
            if (document.cookie.length>0)
            {
                c_start=document.cookie.indexOf(c_name + "=")
                if (c_start!=-1)
                {
                    c_start=c_start + c_name.length+1
                    c_end=document.cookie.indexOf(";",c_start)
                    if (c_end==-1) c_end=document.cookie.length
                    return unescape(document.cookie.substring(c_start,c_end))
                }
            }
            return ""
        }
        function initSocket(){
            socket = io('http://localhost:8974/chat?Authorization=' + new Date()); //正式发布环境
            // socket = io('http://localhost:8974/test'); //正式发布环境
            socket.on('connect', function () {
                console.log('socket连接成功');

            });

            socket.on('disconnect', function () {
                console.log('socket断开连接');
            });


            //==============以下使用命名空间chat========================

            //监听广播消息
            socket.on('testNamespace', function (data) {
                console.log("接收到消息:" + data);
            });

            //监听点对点消息
            socket.on('bbbb', function (data) {
                //....收到消息后具体操作
                //  console.log(data);
                console.log(data);
            });

            //监听后端无限推送的点对点消息
            socket.on('testPush', function (data) {
                console.log("接收到消息的次数:" + ++i);
            });

            //监听加入房间的反馈
            socket.on('testJoinRoom', function (data) {
                console.log("接收到消息:" + data);
            });

            //监听房间消息
            socket.on('testRoom', function (data) {
                console.log("接收到消息:" + data);
            });

            //监听广播消息
            socket.on('testBroadcast', function (data) {
                console.log("接收到消息:" + data);
            });


        }

        //发送点对点消息
        function send(){
            socket.emit('aaaa', "aaaaaa");
        }
        //触发无限推送
        function send2(){
            socket.emit('testPush', "begin");
        }
        //发送加入房间消息
        function send3(){
            socket.emit('joinRoom', "room1");
        }
        //发送房间消息
        function send4(){
            socket.emit('testRoom', "testRoomData");
        }
        //发送广播消息
        function send5(){
            socket.emit('testBroadcast', "testBroadCastData");
        }


    </script>
    <input type="button" value="发送点对点消息" onclick="send();">
    <br/><br/>
    <input type="button" value="开启无限推送测试" onclick="send2();">
    <br/><br/>
    <input type="button" value="测试加入房间" onclick="send3();">
    <br/><br/>
    <input type="button" value="测试房间内发消息" onclick="send4();">
    <br/><br/>
    <input type="button" value="测试发送广播消息" onclick="send5();">
    <br/><br/>

</head>
</html>

test:

<html>
<head>
    <meta charset="utf-8"/>
    <!--<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/2.1.0/socket.io.js"></script>-->
    <script src="socket.io-2.1.0.js"></script>
    <script>

        var socket = null;
        var i = 0;
        window.onload = function(){
            initSocket();
        }
        function getCookie(c_name)
        {
            if (document.cookie.length>0)
            {
                c_start=document.cookie.indexOf(c_name + "=")
                if (c_start!=-1)
                {
                    c_start=c_start + c_name.length+1
                    c_end=document.cookie.indexOf(";",c_start)
                    if (c_end==-1) c_end=document.cookie.length
                    return unescape(document.cookie.substring(c_start,c_end))
                }
            }
            return ""
        }
        function initSocket(){
            socket = io('http://localhost:8974/test?Authorization=' + new Date()); //正式发布环境
            // socket = io('http://localhost:8974/test'); //正式发布环境
            socket.on('connect', function () {
                console.log('socket连接成功');

            });

            socket.on('disconnect', function () {
                console.log('socket断开连接');
            });


            //==============以下使用命名空间test========================

            //监听广播消息
            socket.on('testNamespace', function (data) {
                console.log("接收到消息:" + data);
            });

            //监听点对点消息
            socket.on('bbbb', function (data) {
                //....收到消息后具体操作
                //  console.log(data);
                console.log(data);
            });

            //监听后端无限推送的点对点消息
            socket.on('testPush', function (data) {
                console.log("接收到消息的次数:" + ++i);
            });

            //监听加入房间的反馈
            socket.on('testJoinRoom', function (data) {
                console.log("接收到消息:" + data);
            });

            //监听房间消息
            socket.on('testRoom', function (data) {
                console.log("接收到消息:" + data);
            });
            //监听广播消息
            socket.on('testBroadcast', function (data) {
                console.log("接收到消息:" + data);
            });

        }

        //发送点对点消息
        function send(){
            socket.emit('aaaa', "aaaaaa");
        }
        //触发无限推送
        function send2(){
            socket.emit('testPush', "begin");
        }
        //发送加入房间消息
        function send3(){
            socket.emit('joinRoom', "room1");
        }
        //发送房间消息
        function send4(){
            socket.emit('testRoom', "testRoomData");
        }
        //发送广播消息
        function send5(){
            socket.emit('testBroadcast', "testBroadCastData");
        }


    </script>

    <input type="button" value="发送点对点消息" onclick="send();">
    <br/><br/>
    <input type="button" value="开启无限推送测试" onclick="send2();">
    <br/><br/>
    <input type="button" value="测试加入房间" onclick="send3();">
    <br/><br/>
    <input type="button" value="测试房间内发消息" onclick="send4();">
    <br/><br/>
    <input type="button" value="测试发送广播消息" onclick="send5();">
    <br/><br/>

</head>
</html>

9、SocketIOStaticInfo

package com.iscas.biz.socketio;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 一些静态变量
 *
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2018/7/22 21:26
 * @since jdk1.8
 */
public class SocketIOStaticInfo {
    private SocketIOStaticInfo(){}
    /**用户名和websocket clientId 对应关系*/
    public static Map<String, UUID> userClientIdMap = new ConcurrentHashMap<>();
}

10、定义一个启用开关

package com.iscas.base.biz.aop.enable;

import com.iscas.base.biz.config.socketio.SocketioConfig;
import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

/**
 * <p>socketIo服务器开关</>
 *
 * @author zhuquanwen
 * @vesion 1.0
 * @date 2021/3/26 10:14
 * @since jdk1.8
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(SocketioConfig.class)
public @interface EnableSocketio {
}

在启动类上加上@EnableSocketio注解

码农-文若书生
关注
  • 8
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot 整合Netty-SocketIO实现信息推送
蒯厅博客
10-27 1282
SpringBoot 整合Netty-SocketIO实现信息推送
Spring Boot与Netty-SocketIO：构建现代化实时Web应用的强大组合
chenmuchen_的博客
01-23 767
Netty-SocketIO，一个基于Netty的开源框架，以及Spring Boot，一个强大的Java开发框架，为开发者们提供了一个理想的组合，以构建具有实时通信需求的Web应用。通过将Netty-SocketIO集成到Spring Boot中，我们能够充分利用Spring Boot的便利性和Netty-SocketIO的实时通信能力，从而更高效地构建现代化的Web应用。这个组合的优势在于，Spring Boot提供了丰富的特性和便利的配置，而Netty-SocketIO则提供了强大的实时通信能力。
Springboot项目Netty-WebSocket前后端消息交互
最新发布
m0_72397750的博客
06-06 716
最近在用消息队列处理可能会时间较长的任务，用户在提交后可以先做别的，处理的过程会异步完成，完成后及时通知用户。如何实现？ 首先分析一下我们的需求：（1）即时通信，我不知道什么时候需要发送消息，所以希望双方能提前建立连接或者保持长时间的连接（2）需要服务器端主动向客户端发送消息。Netty作为一个成熟的开源项目，经过了广泛的实战检验，拥有活跃的社区支持和持续的更新维护。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序，是目前最流行的 NIO 框架。
SpringBoot集成SocketIO
qq_43334498的博客
09-18 4908
这个配置写在服务端，客户端不用写，主要是一些socket.io的配置信息。
Spring-Boot快速集成netty-socketio(socket服务实现，支持认证)
qq_42271561的博客
08-09 5212
Spring-Boot快速集成netty-socketio(socket服务实现，支持认证) netty-socketio是一个开源的Socket.io服务器端的一个java的实现，它基于Netty框架，可用于服务端推送消息给客户端。 说到服务端推送技术，一般会涉及WebSocket，WebSocket是HTML5最新提出的规范，虽然主流浏览器都已经支持，但仍然可能有不兼容的情况，为了兼容所有浏览器，给程序员提供一致的编程体验，SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一
springboot集成socketIo，实现webSocket
weixin_43241706的博客
12-18 3168
之前都是使用http接口请求，最近有用到WebSocket的场景，客户端之间长连接通讯，记录一下spring boot整合socketIO的过程。 国际惯例，引入依赖 application.yml（或者是application.properties）配置文件添加socketIo配置 添加socketIoConfig配置类 @Configuration public class SocketConfig { private static final Logger logger = Logge
netty-socketio 集群测试
liuhm的博客
06-17 2397
socket.io 官网地址 服务端 Java: https://github.com/mrniko/netty-socketio Java: https://github.com/trinopoty/socket.io-server-java netty-socketio demo Class - Web client page com.corundumstudio.socketio.demo.ChatLauncher - /client/index.html com.corundumstudio.s
springboot集成socketio
angeltangc的博客
12-07 906
不说废话，直接上干货，代码只贴关键代码。后端使用netty-socketio。前端 使用html+js。socketio启动类。socketio配置类。
SpringBoot + Netty-SocketIO在项目中实战详解
Jason Blog
12-10 3016
序言：因工作项目需要使用到推送功能，且与前端Socket.IO框架对接，因此使用了Netty-SocketIO。Netty-SocketIO顾名思义是基于Netty的SocketIO，底层是基于Netty。有关SocketIO的相关API与官网提供的NodeJS版本API相似，相关配置与Netty相关配置相似。以下代码在SpringBoot项目中书写，解...
netty-socketio+spring boot 长链接 实时通信 消息推送
Misster华
06-30 1359
Springboot 集成 netty-socketio, 基于 Netty 实现， 进行 Sockcet 长连接，进行实时通讯，消息推送。
SpringBoot 集成 Netty 使用Socket功能
七濑武的博客
07-07 1141
SpringBoot 集成 Netty 使用Socket功能
2.C#利用SocketIoClientDotNet做Socket客户端跟Java netty-socketio服务端通信
qq_27860623的博客
06-20 716
注意SocketIoClientDotNet的版本，刚开始使用的版本是0.9.0版本（第一个版本），不稳定，有时候能连接成功有时候连接不成功。后来升级到了最新的版本这个问题得与解决，但是出现了一个新的问题，就是每次连接的时候，会与服务端随机建立2~4个连接。接到一个任务，是C#端做Socket的客户端，服务端在用Java，Java那边用的Socket组件是 netty-socketio，在网上找了很多，最后发现用SocketIoClientDotNet可以连通。没有java服务端的代码（请谅解）。
springboot集成netty-socketio集群实现
zsj777的专栏
04-11 1355
1、实现思路 IM每个节点定义唯一标识A，A = 机器码加im端口号。 当客户端连接到IM节点后，把客户端的用户唯一标识ID和连接的IM服务端的唯一标识A进行绑定。 当两个用户相互发送消息时，判断接收用户是否在线，在线，则获取接收消息用户的socketclient，若获取不到，则根据接收用户ID获取接收用户所在节点的唯一标识。 然后通过redis的订阅发布，发送消息到接收用户所在的节点。每个节点只订阅和该节点唯一标识相同的topic。 2、代码 pom <dependencies&g
基于netty-socket.io给指定客户端发送消息
haishui2的专栏
06-20 5429
前言： 1、使用netty-socketio搭建socketIo服务； 2、client连接socketIo服务时，保存下该client对象； 3、使用TestController，向指定client推送消息； 一、netty-socket.io版本； <dependency> <groupId>com.corundumstudio.so...
SpringBoot实现Socket客户端，Netty服务端实现Java通讯（附源码及注释详解）
热门推荐
beishanyingluo的博客
09-26 1万+
SpringBoot实现Socket通讯： 使用Netty实现一个Socket通讯，包括客户端和服务端，通过服务端进行监听，客户端发送信息，服务端可进行接收，并进行返回数据，完成一个完整的通讯 客户端用的Socket编程，而服务端用到Netty框架实现。源码地址： 源码地址！！！！！！！！ 而且启动初始化及调用的日志、注释写的很清楚，如下： package com.xu.server; impo...
实用水文篇--SpringBoot整合Netty实现消息推送服务器
`or 1 or 不正经の泡泡
10-16 3449
由于今天是要练车的，所以的话只能写一点简单的东西了，做一个整合吧，刚好先前随便说了一下Netty是吧，那么我们就直接实战吧，我们来整合一下Netty。我的设想是使用Netty来实现客户端消息的实时推送，就是这个破玩意：当然还有咱们的聊天，用户聊天，反正都做推送了，再加一个用户聊天有何不可。都TM是一个玩意。那么既然咱们是使用SpringBoot或者是Spring的话，那么我们就刚好直接使用IOC来实例化咱们的Netty。
SpringBoot集成Netty实现消息推送、接收、自动重连
whl 博客专栏
07-17 6838
SpringBoot集成Netty实现消息消息推送、消息接收、自动重连、身份认证
SpringBoot整合Netty搭建高性能Websocket服务器（实现聊天功能）
冯冬冬的博客
12-27 5479
之前使用Springboot整合了websocket，实现了一个后端向前端推送信息的基本小案例，这篇文章主要是增加了一个新的框架就是Netty，实现一个高性能的websocket服务器，并结合前端代码，实现一个基本的聊天功能。你可以根据自己的业务需求进行更改。 这里假设你已经了解了Netty和websocket的相关知识，仅仅是想通过Springboot来整合他们。根据之前大家的需求，代码已经上...
spring boot netty socket服务端_Java-彻底弄懂netty-程序员先从简单例子开启netty编程-知识铺...
weixin_39737947的博客
12-05 147
知识铺： 致力于打造轻知识点，持续更新每次的知识点较少，阅读不累。不占太多时间，不停的来唤醒你记忆深处的知识点。一、回顾Nio编程 1.1 创建ServerSocketChannel。 1.2 设置非阻塞模式。 1.3 绑定端口，开始监听TCP连接。 1.4 创建处理I/O线程。 1.5 创建Selector，把ssc注册到Selector。 1.6 开始接等待客户端连接 ssc.accept。...
springboot整合netty-socketio
05-17
Spring Boot是一个非常流行的Java开发框架，而Netty-socketio是一个基于Netty框架的WebSocket实现，提供了方便的实时通信解决方案。将它们结合起来，可以实现高效的WebSocket通信服务。 下面是整合的步骤： 1. 添加依赖 在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-socketio</artifactId> <version>1.7.16</version> </dependency> ``` 2. 编写Netty-socketio服务 创建一个类，继承自SpringBoot的ApplicationListener接口，用于启动Netty-socketio服务。 ``` import com.corundumstudio.socketio.Configuration; import com.corundumstudio.socketio.SocketIOServer; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.event.ApplicationReadyEvent; import org.springframework.context.ApplicationListener; import org.springframework.stereotype.Component; @Component public class NettySocketIoServer implements ApplicationListener<ApplicationReadyEvent> { @Value("${socketio.host}") private String host; @Value("${socketio.port}") private Integer port; private SocketIOServer server; @Override public void onApplicationEvent(ApplicationReadyEvent event) { Configuration config = new Configuration(); config.setHostname(host); config.setPort(port); server = new SocketIOServer(config); server.start(); } } ``` 其中，@Value注解用于从配置文件中读取host和port的值，SocketIOServer是Netty-socketio提供的服务类，用于启动和管理WebSocket服务。 3. 配置WebSocket处理器 创建一个类，继承自Spring Boot的WebSocketHandler接口，用于处理WebSocket连接和消息。 ``` import com.corundumstudio.socketio.SocketIOClient; import com.corundumstudio.socketio.SocketIOServer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.web.socket.WebSocketSession; import org.springframework.web.socket.handler.TextWebSocketHandler; @Component public class SocketIoHandler extends TextWebSocketHandler { @Autowired private SocketIOServer server; @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { super.afterConnectionEstablished(session); SocketIOClient client = server.getClient(session.getId()); if (client == null) { client = server.addClient(session); } } @Override public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { super.handleTextMessage(session, message); SocketIOClient client = server.getClient(session.getId()); if (client != null) { client.sendEvent("message", message.getPayload()); } } } ``` 其中，@Autowired注解用于从Spring容器中获取SocketIOServer实例，afterConnectionEstablished方法用于处理WebSocket连接建立时的逻辑，handleTextMessage方法用于处理WebSocket消息。 4. 配置WebSocket处理器映射 创建一个WebSocketHandlerRegistry类，用于配置WebSocket处理器的映射关系。 ``` import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.web.socket.config.annotation.EnableWebSocket; import org.springframework.web.socket.config.annotation.WebSocketConfigurer; import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry; @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Autowired private SocketIoHandler socketIoHandler; @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(socketIoHandler, "/ws").setAllowedOrigins("*"); } } ``` 其中，@EnableWebSocket注解用于开启WebSocket支持，registerWebSocketHandlers方法用于配置WebSocket处理器映射关系。 5. 配置application.yml 在application.yml文件中添加以下配置： ``` socketio: host: localhost port: 8080 ``` 其中，host和port的值应与Netty-socketio服务的配置一致。 6. 运行程序 现在，可以运行程序，并访问http://localhost:8080/ws，即可建立WebSocket连接。发送消息时，可以使用socket.emit()方法，接收消息时，可以使用socket.on()方法。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值