基于Netty-Socket-io的无直接调用式的数据传输

最新推荐文章于 2024-08-08 07:26:02 发布
最新推荐文章于 2024-08-08 07:26:02 发布
阅读量1.8k 收藏
点赞数
分类专栏： web前端 Java开发 文章标签： socket web服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smile_Miracle/article/details/78131882
版权

实时消息的推送，PC端的推送技术可以使用socket建立一个长连接来实现。传统的web服务都是客户端发出请求，服务端给出响应。但是现在直观的要求是允许特定时间内在没有客户端发起请求的情况下服务端主动推送消息到客户端。

有哪些可以实现web消息推送的技术：

①不断地轮询（俗称“拉”，polling）是获取实时消息的一个手段：Ajax 隔一段时间（通常使用 JavaScript 的 setTimeout 函数）就去服务器查询是否有改变，从而进行增量式的更新。但是间隔多长时间去查询成了问题，因为性能和即时性造成了严重的反比关系。间隔太短，连续不断的请求会冲垮服务器，间隔太长，务器上的新数据就需要越多的时间才能到达客户机。

优点：服务端逻辑简单；

缺点：其中大多数请求可能是无效请求，在大量用户轮询很频繁的情况下对服务器的压力很大；

应用：并发用户量少，而且要求消息的实时性不高，一般很少采用；

②长轮询技术（long-polling）：客户端向服务器发送Ajax请求，服务器接到请求后hold住连接，直到有新消息或超时（设置）才返回响应信息并关闭连接，客户端处理完响应信息后再向服务器发送新的请求。

优点：实时性高，无消息的情况下不会进行频繁的请求；

缺点：服务器维持着连接期间会消耗资源；

③基于Iframe及htmlfile的流（streaming）方式：iframe流方式是在页面中插入一个隐藏的iframe，利用其src属性在服务器和客户端之间创建一条长链接，服务器向iframe传输数据（通常是HTML，内有负责插入信息的javascript），来实时更新页面。

优点：消息能够实时到达；

缺点：服务器维持着长连接期会消耗资源；

④插件提供socket方式：比如利用Flash XMLSocket，Java Applet套接口，Activex包装的socket。

优点：原生socket的支持，和PC端和移动端的实现方式相似；

缺点：浏览器端需要装相应的插件；

⑤WebSocket：是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。

优点：更好的节省服务器资源和带宽并达到实时通讯；

缺点：目前还未普及，浏览器支持不好；

综上，考虑到浏览器兼容性和性能问题，采用长轮询（long-polling）是一种比较好的方式。
netty-socketio是一个开源的Socket.io服务器端的一个java的实现， 它基于Netty框架。 项目地址为(https://github.com/mrniko/netty-socketio)

基于项目需要，我们系统要做一个中转的服务，类似：三方系统A调用我们的接口通过参数的形式把数据传给我们，然后我们在接收到这个参数并做检验之后马上推送给三方系统B，实现数据的高实时性。但由于三方系统B是纯前端项目，类似Echarts，无任何后台，重要的是他们无法知道什么时间三方A系统调用了我们的接口传给我们数据，所以三方B系统无法通过接口形式来获取数据，鉴于此，参考了一下实时通信的案例，发现
netty-socketio是一个很好的解决方案，然后自己改造了下完成了自己的需求，改造如下：

POM依赖

<!-- socket心跳包 -->
        <dependency> 
            <groupId>com.corundumstudio.socketio</groupId>  
            <artifactId>netty-socketio</artifactId>  
            <version>1.7.3</version>  
        </dependency>

这个包下有很多依赖包，大概七八个。

工具类封装
package com.spdb.hs.data.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

import com.corundumstudio.socketio.Configuration;
import com.corundumstudio.socketio.SocketIOServer;

public class WebSocketService implements ApplicationListener{

private static Logger log = LoggerFactory.getLogger(WebSocketService.class);

private  static Configuration config;
private  static SocketIOServer server;
private String eventName;
private String data;

public WebSocketService(){};

public WebSocketService(String eventName,String data){
    this.data=data;
    this.eventName=eventName;
}

 public void startLisener(){  
     try {  
            SocketEventListener(eventName,data);  
        } catch (Exception e) {  
            server.stop();  
            e.printStackTrace();  
        }  


}  


private void SocketEventListener(final String eventName, final String data) {
    try {
        //默认给所有连接的客户端推送数据，广播形式
        server.getBroadcastOperations().sendEvent(eventName, data);
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }


}

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    Properties p = new Properties();
    InputStream in = event.getApplicationContext().getClassLoader().getResourceAsStream("conf/socket.properties");
    try {
        p.load(in);
    } catch (IOException e) {
        log.error("Socket配置文件读取失败......", e);
    }
    String Host = p.getProperty("socket.host");
    String Port = p.getProperty("socket.port");
    log.info("Host="+Host+",Port="+Port);
    if(server==null){
        config = new Configuration();  
        config.setHostname(Host);  
        config.setPort(Integer.valueOf(Port));  
        server = new SocketIOServer(config);  
        server.start();  
        log.info("Socket Service was started");
    }
}

}

实现了ApplicationListener接口，这么做的原因是让项目在spring容器加载完成后默认会去做的事，目的在于项目一启动就创建唯一的SocketService服务端。后续可以已调用方法的形式自定义的给客户端发信息（具体服务端与特定客户端通信省略）

配置文件

Socket.properties

socket.host=xxx.xxx.xxx.xxx
socket.port=9001

spring-bean.xml

<bean id="webSocketService" class="com.spdb.hs.data.utils.WebSocketService"/>

这个东西必须在bean中配置好，不然不起作用。

调用实例

package com.spdb.hs.data.controller.app;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.mchange.v2.lang.StringUtils;
import com.spdb.hs.data.parameter.EventType;
import com.spdb.hs.data.utils.ApiService;
import com.spdb.hs.data.utils.WebSocketService;
import com.spdb.hs.data.vo.RspVo;
import com.spdb.hs.oms.vo.PacketHead;

@Controller
@RequestMapping("/drill")
public class DrillController {

    private Logger log = LoggerFactory.getLogger(DrillController.class);

    /**   
    *    
    * 方法描述：   
    * 创建人：zhy 
    * 创建时间：2017年9月21日 下午2:27:44   
    * 修改时间：2017年9月21日 下午2:27:44   
    * Description： 启动
    *    
    */
    @RequestMapping("quickStart")
    @ResponseBody
    public RspVo getReady(){
        RspVo vo = new RspVo();
        String drillUrl = "xxx.xxx.xxx.xxx";
        String data = null;
        try {
            data = new ApiService().doGet(drillUrl);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        if(null==data){
            vo.setCode(PacketHead.JSON_ERR_FORMAT);
            vo.setMsg("请求参数错误，请检查数据......");
        }else{
            vo.setData(data);
        }
        return vo;
    }

    /**   
    *    
    * 方法描述：   
    * 创建人：zhy 
    * 创建时间：2017年9月21日 下午2:27:30   
    * 修改时间：2017年9月21日 下午2:27:30   
    * Description：  定时更新接口
    *    
    */
    @RequestMapping(value="timerUpd")
    @ResponseBody
    public RspVo timingUpdate(@RequestParam(required=true)String data){
                    RspVo vo = new RspVo();
                    log.info(" 定时更新接口接收到的参数为：data="+data);
                    if(StringUtils.nonEmptyString(data)){
                        try {
                            WebSocketService socketService = new WebSocketService(EventType.EventType_Timer,data);
                            socketService.startLisener();
                        } catch (Exception e) {
                            log.error(e.getMessage(), e);
                            vo.setCode(PacketHead.JSON_ERR_SYS);
                            vo.setMsg("系统繁忙请稍候再试......");
                            return vo;
                        }
                    }
                    return vo;

    }

/*  @RequestMapping(value="timerUpd2")
    @ResponseBody
    public RspVo timingUpdate2(@RequestParam(required=true)String beginTime,@RequestParam(required=true)String endTime,
                                                     @RequestParam(required=true)String processStatus,@RequestParam(required=true)String onlineUserCount,
                                                     @RequestParam(required=true)String allUserCount,@RequestParam(required=true)String facilityCount,
                                                     @RequestParam(required=true)String allTaskCount,@RequestParam(required=true)String autoTaskCount,
                                                     @RequestParam(required=true)String doneTaskCount,@RequestParam(required=true) String customFields){

                    log.info(" 定时更新接口接收到的参数为：beginTime="+beginTime+",endTime="+endTime+",processStatus="+processStatus+
                                                           ",onlineUserCount="+onlineUserCount+",allUserCount="+allUserCount+",facilityCount="+facilityCount+
                                                           ",allTaskCount="+allTaskCount+",autoTaskCount="+autoTaskCount+",doneTaskCount="+doneTaskCount+
                                                           ",customFields="+customFields);

                    RspVo vo = new RspVo();
                    return vo;
    }*/


    /**   
    *    
    * 方法描述：   
    * 创建人：zhy 
    * 创建时间：2017年9月21日 下午2:45:38   
    * 修改时间：2017年9月21日 下午2:45:38   
    * Description：  任务更新接口
    *    
    */
    @RequestMapping(value="tasksUpd")
    @ResponseBody
    public RspVo tasksUpdate(@RequestParam(required=true)String data){
         RspVo vo = new RspVo();
         log.info(" 任务更新接口接收到的参数为：data="+data);
         if(StringUtils.nonEmptyString(data)){
            try {
                    WebSocketService socketService = new WebSocketService(EventType.EventType_Tasks,data);
                    socketService.startLisener();
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                    vo.setCode(PacketHead.JSON_ERR_SYS);
                    vo.setMsg("系统繁忙请稍候再试......");
                    return vo;
                }
         }
         return vo;
    }

/*  @RequestMapping(value="tasksUpd2")
    @ResponseBody
    public RspVo tasksUpdate2(@RequestParam(required=true)String taskId,@RequestParam(required=true)String taskType,
                                                     @RequestParam(required=true)String taskStatus,@RequestParam(required=true)String beginTime,
                                                     @RequestParam(required=true)String acceptTime,@RequestParam(required=true)String endTime,
                                                     @RequestParam(required=true)String duration){
        log.info("任务更新接口接收到的参数为：taskId="+taskId+",taskType="+taskType+",taskStatus="+taskStatus+",beginTime="+beginTime+
                                                                  ",endTime="+endTime+",acceptTime="+acceptTime+",duration="+duration);
        RspVo vo = new RspVo();
        return vo;
    }*/

    /**   
    *    
    * 方法描述：   
    * 创建人：zhy 
    * 创建时间：2017年9月21日 下午2:46:13   
    * 修改时间：2017年9月21日 下午2:46:13   
    * Description：  日志更新接口
    *    
    */
    @RequestMapping(value="logsUpd")
    @ResponseBody
    public RspVo logsUpdate(@RequestParam(required=true)String data){
        RspVo vo = new RspVo();
        log.info(" 日志更新接口接收到的参数为：data="+data);
        if(StringUtils.nonEmptyString(data)){
            try {
                    WebSocketService socketService = new WebSocketService(EventType.EventType_Logs,data);
                    socketService.startLisener();
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                    vo.setCode(PacketHead.JSON_ERR_SYS);
                    vo.setMsg("系统繁忙请稍候再试......");
                    return vo;
                }
        }
        return vo;
    }

    /*@RequestMapping(value="logsUpd2")
    @ResponseBody
    public RspVo logsUpdate2(@RequestParam(required=true)String id,@RequestParam(required=true)String content) {
        log.info("日志更新接口接收到的参数为：id="+id+",content="+content);
        RspVo vo = new RspVo();
        return vo;
    }*/

    /**   
    *    
    * 方法描述：   
    * 创建人：zhy 
    * 创建时间：2017年9月21日 下午2:46:13   
    * 修改时间：2017年9月21日 下午2:46:13   
    * Description：  状态更新接口
    *    
    */
    @RequestMapping(value="statusUpd")
    @ResponseBody
    public RspVo statusUpdate(@RequestParam String data){
        RspVo vo = new RspVo();
        log.info(" 状态更新接口接收到的参数为：data="+data);
        if(StringUtils.nonEmptyString(data)){
            try {
                    WebSocketService socketService = new WebSocketService(EventType.EventType_Status,data);
                    socketService.startLisener();
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                    vo.setCode(PacketHead.JSON_ERR_SYS);
                    vo.setMsg("系统繁忙请稍候再试......");
                    return vo;
                }
        }
        return vo;
    }
    /**   
     *    
     * 方法描述：   
     * 创建人：zhy 
     * 创建时间：2017年9月21日 下午2:46:13   
     * 修改时间：2017年9月21日 下午2:46:13   
     * Description： 人员更新接口
     *    
     */
    @RequestMapping(value="usersUpd")
    @ResponseBody
    public RspVo usersUpdate(@RequestParam(required=true)String data){
        RspVo vo = new RspVo();
        log.info(" 人员更新接口接收到的参数为：data="+data);
        if(StringUtils.nonEmptyString(data)){
            try {
                    WebSocketService socketService = new WebSocketService(EventType.EventType_Users,data);
                    socketService.startLisener();
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                    vo.setCode(PacketHead.JSON_ERR_SYS);
                    vo.setMsg("系统繁忙请稍候再试......");
                    return vo;
                }
        }
        return vo;
    }


}

简单的说就是我通过HttpClient去三方A获取一个启动数据，然后三方A会不断调用我的接口给我传数据，我一接收到数据就穿给三方系统B

package com.spdb.hs.data.utils;

import java.io.IOException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class ApiService{

    /**
     * 
     * @return 响应体的内容
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public String doGet(String url) throws ClientProtocolException, IOException{

        // 创建http GET请求
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(this.getConfig());//设置请求参数
        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = this.getHttpClient().execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                String content = EntityUtils.toString(response.getEntity(), "UTF-8");
//                System.out.println("内容长度："+content.length());
                return content;
            }
        } finally {
            if (response != null) {
                response.close();
            }
            //httpClient.close();
        }
        return null;
    }

    /**
     * 带有参数的get请求
     * @param url
     * @return
     * @throws URISyntaxException 
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public String doGet(String url , Map<String, String> params) throws URISyntaxException, ClientProtocolException, IOException{
        URIBuilder uriBuilder = new URIBuilder(url);
        if(params != null){
            for(String key : params.keySet()){
                uriBuilder.setParameter(key, params.get(key));
            }
        }//http://xxx?ss=ss
        return this.doGet(uriBuilder.build().toString());
    }
    /**
     * 带有参数的post请求
     * @param url
     * @param params
     * @return
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public HttpResult doPost(String url , Map<String, String> params) throws ClientProtocolException, IOException{


        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(this.getConfig());
        if(params != null){

            // 设置2个post参数，一个是scope、一个是q
            List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);

            for(String key : params.keySet()){
                parameters.add(new BasicNameValuePair(key, params.get(key)));
            }
            // 构造一个form表单式的实体
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters);
            // 将请求实体设置到httpPost对象中
            httpPost.setEntity(formEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = this.getHttpClient().execute(httpPost);
            // 判断返回状态是否为200
            /*if (response.getStatusLine().getStatusCode() == 200) {
                String content = EntityUtils.toString(response.getEntity(), "UTF-8");
                System.out.println(content);
            }*/
            return new HttpResult(response.getStatusLine().getStatusCode(),EntityUtils.toString(response.getEntity(), "UTF-8"));
        } finally {
            if (response != null) {
                response.close();
            }
            //httpClient.close();
        }
    }

    public HttpResult doPostJson(String url , String json) throws ClientProtocolException, IOException{
         // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(this.getConfig());
        if(StringUtils.isNotBlank(json)){
            //标识出传递的参数是 application/json
            StringEntity stringEntity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(stringEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response =this.getHttpClient().execute(httpPost);
            // 判断返回状态是否为200
            /*if (response.getStatusLine().getStatusCode() == 200) {
                String content = EntityUtils.toString(response.getEntity(), "UTF-8");
                System.out.println(content);
            }*/
            return new HttpResult(response.getStatusLine().getStatusCode(),EntityUtils.toString(response.getEntity(), "UTF-8"));
        } finally {
            if (response != null) {
                response.close();
            }
            //httpClient.close();
        }
    }

    /**
     * 没有参数的post请求
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    public HttpResult doPost(String url) throws ClientProtocolException, IOException{
        return this.doPost(url, null);
    }

    private CloseableHttpClient getHttpClient(){
        return HttpClientBuilder.create().setMaxConnTotal(200)
                                                                    .setMaxConnPerRoute(100)
                                                                    .build();
    }

    private RequestConfig getConfig(){
        return  RequestConfig.custom().setConnectionRequestTimeout(500)
                                                                 .setSocketTimeout(30000)
                                                                 .setConnectTimeout(5000)
                                                                 .build();

    }

}

package com.spdb.hs.data.utils;

public class HttpResult {

    private int statusCode;
    private String result;

    public HttpResult(int statusCode, String result) {
        super();
        this.statusCode = statusCode;
        this.result = result;
    }

    public int getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }


}

调试实例

Index.html

<html>

</html>
<script src="./socket.io.js"></script>
<script>
    var socket = io.connect('http://10.112.5.60:9001');
</script>

socket.io.js这个需要自己去网上下载

在10.112.5.60这个IP的服务器上我们一起吧项目启动起来了，9001端口也开通了，那我我们现在要做的就是测试客户端连接上服务端后会有什么数据。效果如下：

这里写图片描述

图片表明测试成功。

Smile_Miracle
关注
专栏目录
使用Netty进行文件传输
07-19 2万+
在写出了Netty Hello World 和 netty对象传输之后，又觉得不够，看了官网的例子，所以有了现在的这个文件传输。顺便说下，netty官网的例子真的好，如果要学习netty，还是看官网例子的好。不过我英文不太好，刚开始走了绕了好大一圈，但是现在熟悉了之后，回过头来看
netty与socket对比_t-io和netty的差异对比
weixin_39663602的博客
12-21 1306
本篇文章主要介绍下t-io和netty的差异，t-io和netty到底有何区别，相信很多用户都会有此疑问，我这里列一些差异化的东西来进行对比，如果有不对的地方欢迎在文中底部留言。netty：拥有大量公有协议实现，用到了零拷贝来改善性能，有大量书籍可供查阅。t-io：目前提供的仅有http和websocket，并且放弃了零拷贝，t-io提供了拥有即战力的showcase工程，用户并不需要太多时间即可...
物联网netty对接socket设备-netty定义
01-20
netty定义1.netty定义2.阻塞与非阻塞3.同步与异步 1.netty定义 简单来讲，Netty是一个提供了易于使用的API的客户端/服务端框架。Netty并发非常高，一个非阻塞的IO，Netty传输速度也非常快，因为他是0拷贝，什么是零拷贝？NIO中的特性之一就是零拷贝，在Java中，内存分为堆和栈以及字符串常量值等等，如果有一些数据从IO中读取并且放到堆里面，中间会经过一些缓冲区。 具体来讲，如果要从IO中读取数据，分为两个步骤： (1）从IO流中读取出来放到缓冲区，程序从缓冲区中读取，再放到堆中，此时数据就会被拷贝两次才能到达堆或者堆内存中。如果数据量很大，那么就会造成资源的浪费
Netty-socketio：高性能的Socket.IO服务器实现
最新发布
gitblog_00281的博客
08-08 485
Netty-socketio：高性能的Socket.IO服务器实现 netty-socketioSocket.IO server implemented on Java. Realtime java framework项目地址:https://gitcode.com/gh_mirrors/ne/netty-socketio 项目介绍 Netty-socketio 是一个开源的Java实现，用于构...
Socket.IO Netty
王人冉的博客
04-30 720
https://www.cnblogs.com/ygj0930/p/6543901.html Java并发容器——ConcurrentSkipListMap和ConcurrentHashMap https://blog.csdn.net/sunxianghuang/article/details/52221913 跳表（SkipList）及ConcurrentSkipListMap源码解析 ht...
Spring Boot集成Netty-SocketIO
网络技术联盟站
01-15 1442
Netty-SocketIO是基于Netty的一个开源框架，用于构建实时、双向通信的应用。它基于SocketIO协议，为开发者提供了轻松构建实时Web应用的能力。在Spring Boot中集成Netty-SocketIO可以使得我们更方便地处理实时通信需求。在传统的Web应用中，基于HTTP的通信模式存在一定的限制，特别是在处理实时数据时。Netty-SocketIO通过提供全双工通信、实时事件处理等特性，使得开发者能够更容易地构建具有实时性要求的应用，例如在线聊天、协同编辑等。
Netty-SocketIo 完美替换 nodejs 的 socketio
mxs1226的博客
10-16 1273
Java Netty- socketio 替换 nodejs的socketio
基于netty-socketio 进行全平台消息推送1
08-08
Netty-SocketIO 是一个基于Netty框架的Socket.IO服务器实现，由mrniko维护。Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于构建高效的网络服务。通过集成Netty-SocketIO，开发者可以利用Netty的强大...
springboot websocket(netty-socket.io)和http，http设置cookie，websocket获取cookie。websocket使用多连接共享的cookie
绝圣弃智-零的博客
10-14 3130
名词解释： http，一次请求，一次连接。基于请求响应模型。 websocket，多次请求，只需一次连接。服务端可以主动给客户端发送消息。 netty-socket.io，基于netty的java版socket.io socket.io，将Websocket和轮询（Polling）机制以及其它的实时通信方式封装成了通用的接口，并且在服务端实现了这些实时机制的相应代码。 目的： 我...
java 原生连接netty_基于Netty实现的netty-socketio实现WebSocket
weixin_42396588的博客
02-24 592
介绍netty-socketio是socket.io使用Java语言基于Netty网络库编写的WebSocket库.功能非常强大，简单易用，稳定可靠.com.corundumstudio.socketionetty-socketio1.7.14后端使用Demo1.配置SocketIOServer@Value("${my.server.host}")private String host;@Valu...
Netty-SocketIO技术实时推送技术
05-25
主要简介是Netty-SocketIO技术的使用和介绍，实时推送技术的介绍
基于netty的socket.io集成
～
09-07 1010
基于netty的socket.io集成非常容易、并且功能强大，协议可自定义长连接、websocket等，非常适用与前后端互相推送消息、以及聊天等功能。
websocket之netty-socketio高性能实时消息推送框架
qq_49949568的博客
02-21 2315
websocket协议的出现，打破http那种只能由客户端发起请求，服务器响应的单项数据传输局面，采用websocket之后，可以由客户端推送数据到服务端，也可以由服务器主动推送数据到客户端，从而同时进行双向通信，便于数据实时更新推送netty-socketio便是为了方便我们进行websocket开发的框架，底层采用netty，提供了可靠高效的性能直接继承抽象类ApplicationEvent，然后自定义属性，自定义的属性用于在事件传播过程中记录自己需要的数据。
Netty网络通信之Socket
qq_33816292的博客
09-12 4732
网络通信之Socket
netty-socketio概述
天涯芳草
04-20 4763
netty-socketio 概述 netty-socketio是一个开源的Socket.io服务器端的一个java的实现，它基于Netty框架，可用于服务端推送消息给客户端。 说到服务端推送技术，一般会涉及WebSocket，WebSocket是HTML5最新提出的规范，虽然主流浏览器都已经支持，但仍然可能有不兼容的情况，为了兼容所有浏览器，给程序员提供一致的编程体验， SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一的...
使用Netty实现Socket网络编程
m0_68856746的博客
01-09 2522
Netty可以实现高并发的非阻塞的NIO操作,实现socket的实时并发双工通信!
Netty-Socketio的简单使用
weixin_43501359的博客
02-03 1788
springboot中netty-socketio的简单使用 文章目录springboot中netty-socketio的简单使用1.导入依赖2.配置类3.事件处理类4.消息体5.前端页面 客户端： 服务器端： 1.导入依赖 <dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-socketio</artifactId> <vers
日常记录-SpringBoot整合netty-socketio
会走的鱼
07-27 9676
SpringBoot整合netty-socketio一、准备工作1、maven依赖2、socketIO的yml配置3、socketIO的config代码4、SocketIOServer启动或关闭5、项目目录结构二、客户端和服务端建立连接1、服务端1.1 用户缓存信息ClientCache1.2 SocketIOServerHandler2、客户端3、简单的演示三、广播1、SocketIO基础概念图2、定义namespace3、创建namespace所属的Handler3.1 自定义Handler3.2 监听
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值