netty的经典demo-具有确认ack和重连的功能

最新推荐文章于 2024-07-08 11:48:44 发布
最新推荐文章于 2024-07-08 11:48:44 发布
阅读量1.7k 收藏 3
点赞数
文章标签： netty 网络 java
原文链接：http://www.cnblogs.com/weiguangyue/p/9671608.html
版权

#################以下是客户端的代码

package com.zfsoft.nettyDemo.client;

import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSONObject;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.concurrent.Future;

public class Client {
    
    private final Random random = new Random();

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

    private final AtomicInteger requestSequence = new AtomicInteger(0);
    private final Timer timer = new Timer("NettyClient_scanneResponseTable", true);

    private Bootstrap bootstrap = new Bootstrap();
    private EventLoopGroup eventLoopGroupWorker = new NioEventLoopGroup(2, new ThreadFactory() {
        private AtomicInteger threadIndex = new AtomicInteger(-1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, String.format("NettyClient_%d", this.threadIndex.incrementAndGet()));
        }
    });
    private final int connectTimeout = 5000;
    private final String hostname;
    private final int port;
    private final String charsetName = "UTF-8";
    private Channel channel;
    private volatile boolean inited = false;
    private final int sendTimeout = 5;
    private final int waitResponseTimeout = 10;

    protected final ConcurrentMap<Integer, ReponseWrapper> responseTable = new ConcurrentHashMap<Integer, ReponseWrapper>(
            256);

    public Client(String hostname, int port) {
        super();
        this.hostname = hostname;
        this.port = port;
    }
    
    /**
     * 初始化
     */
    private void init() {
        
        log.info("初始化");
        
        final Charset charset = Charset.forName(this.charsetName);
        
        bootstrap.group(eventLoopGroupWorker)//
        .channel(NioSocketChannel.class)//
        .option(ChannelOption.TCP_NODELAY, true)//
        .option(ChannelOption.SO_KEEPALIVE, false)//
        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, this.connectTimeout)//
        .handler(new ChannelInitializer<SocketChannel>() {//
            @Override
            public void initChannel(SocketChannel ch) throws Exception {
                ChannelPipeline pipeline = ch.pipeline();
                ByteBuf delimiter = Unpooled.copiedBuffer("\n".getBytes());
                pipeline.addLast(//
                        new StringDecoder(charset), //
                        new DelimiterBasedFrameDecoder(1024, delimiter), //
                        new StringEncoder(charset), //
                        new NettyClinetHandler()//
                        );
            }
        });
    }

    /**
     * 连接服务端
     */
    public void connect() {
        
        if(!inited) {
            this.init();
        }
        
        log.info("开始连接");
        
        final ChannelFuture cf = bootstrap.connect(this.hostname, this.port);
        try {
            cf.await(this.connectTimeout, TimeUnit.SECONDS);
            if (cf.isSuccess()) {
                log.info("连接[{}]成功", cf.channel());
                this.channel = cf.channel();
                this.inited = true;
                this.timer.scheduleAtFixedRate(new TimerTask() {
                    @Override
                    public void run() {
                        try {
                            Client.this.scanResponseTable();
                        } catch (Throwable e) {
                            log.error("scanResponseTable exception", e);
                        }
                    }
                }, 1000 * 3, 1000);
            } else {
                if(!inited) {
                    //是首次连接
                    this.eventLoopGroupWorker.shutdownGracefully();                    
                }else {
                    log.info("继续重连");
                    this.eventLoopGroupWorker.schedule(new ReconnectTask(), nextReconnectDelayTime(), TimeUnit.SECONDS);
                }
            }
        } catch (InterruptedException e) {
            log.error("connect[{}] cause exception", cf.channel(), e);
        }
    }
    
    /**
     * 重连随机时间
     * @return
     */
    protected int nextReconnectDelayTime() {
        return this.random.nextInt(5);
    }
    
    /**
     * 断开连接 
     */
    public void disconnect() {
        this.timer.cancel();
        Future<?> future = this.eventLoopGroupWorker.shutdownGracefully();
        try {
            future.await(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            log.error("断开连接异常",e);
        }
        this.channel.close();
    }

    /**
     * 发送消息，true成功，false失败
     * 
     * @param msg
     * @return
     */
    public boolean send(String msg) {

        final Integer seq = requestSequence.incrementAndGet();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("seq", seq);
        jsonObject.put("msg", msg);

        final ChannelFuture channelFuture = this.channel.writeAndFlush(jsonObject.toJSONString() + "\n");

        final int timeoutMillis = (this.sendTimeout + this.waitResponseTimeout) * 1000;
        final ReponseWrapper rep = new ReponseWrapper(channelFuture, timeoutMillis);

        channelFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                responseTable.put(seq, rep);
                rep.setSendSuccess(true);
                rep.releaseSendMessage();
            }
        });
        try {
            rep.awaitSendMessage(this.sendTimeout,TimeUnit.SECONDS);
            rep.setSendSuccess(true);
        } catch (InterruptedException e) {
            log.error("awaitSendMessage[{}] cause exception", channelFuture.channel(), e);
            return false;
        }

        if (responseTable.containsKey(seq)) {
            try {
                rep.awaitResponse(this.waitResponseTimeout,TimeUnit.SECONDS);
                return rep.isResponseSuccess();
                
            } catch (InterruptedException e) {
                log.error("awaitResponse[{}] cause exception", channelFuture.channel(), e);
                return false;
            }
        } else {
            return false;
        }
    }

    /**
     * 检测请求和响应
     */
    protected void scanResponseTable() {

        Iterator<Entry<Integer, ReponseWrapper>> it = this.responseTable.entrySet().iterator();
        while (it.hasNext()) {
            Entry<Integer, ReponseWrapper> next = it.next();
            ReponseWrapper rep = next.getValue();

            long time = rep.getBeginTimestamp() + rep.getTimeoutMillis() + 1000;
            if (time <= System.currentTimeMillis()) {
                rep.releaseAll();
                it.remove();
                log.warn("remove timeout request, " + rep);
            }
        }
    }

    /**
     * 业务处理
     * @param ctx
     * @param msg
     */
    protected void processMessageReceived(ChannelHandlerContext ctx, String msg) {
        log.trace("接收消息[{}]",msg);
        JSONObject jsonObject = JSONObject.parseObject(msg);
        Integer seq = jsonObject.getInteger("seq");
        final ReponseWrapper responseChannelFutureWrapper = this.responseTable.get(seq);
        if (responseChannelFutureWrapper != null) {
            responseChannelFutureWrapper.setResponseSuccess(true);
            responseChannelFutureWrapper.releaseResponse();
        } else {
            log.warn("不存的请求号[{}]的消息[{}]",seq,msg);
        }
    }

    /**
     * 业务处理
     */
    class NettyClinetHandler extends SimpleChannelInboundHandler<String> {
        
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            processMessageReceived(ctx, msg);
        }

        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            log.info("失去连接，开始准备重连[{}]",ctx.channel());
            ctx.executor().schedule(new ReconnectTask(), nextReconnectDelayTime(), TimeUnit.SECONDS);
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            log.error("发生异常[{}]",ctx.channel(),cause);
        }
    }

    /**
     * 重连任务
     */
    class ReconnectTask implements Runnable{
        @Override
        public void run() {
            Client.this.connect();
        }
    }

    /**
     * 响应
     */
    class ReponseWrapper {

        private final long beginTimestamp = System.currentTimeMillis();
        private final long timeoutMillis;
        private final ChannelFuture channelFuture;

        private final CountDownLatch sendCountDownLatch = new CountDownLatch(1);
        private final CountDownLatch waitResponseCountDownLatch = new CountDownLatch(1);
        
        private volatile boolean sendSuccess = false;
        private volatile boolean responseSuccess = false;

        public ReponseWrapper(ChannelFuture channelFuture, long timeoutMillis) {
            super();
            this.timeoutMillis = timeoutMillis;
            this.channelFuture = channelFuture;
        }

        public void awaitSendMessage(int sendTimeout,TimeUnit unit) throws InterruptedException {
            this.sendCountDownLatch.await(sendTimeout, unit);
        }

        public void releaseSendMessage() {
            this.sendCountDownLatch.countDown();
        }

        public void awaitResponse(int waitResponseTimeout,TimeUnit unit) throws InterruptedException {
            this.waitResponseCountDownLatch.await(waitResponseTimeout, unit);
        }

        public void releaseResponse() {
            this.waitResponseCountDownLatch.countDown();
        }
        
        public void releaseAll() {
            this.sendCountDownLatch.countDown();
            this.waitResponseCountDownLatch.countDown();
        }

        public long getBeginTimestamp() {
            return beginTimestamp;
        }

        public long getTimeoutMillis() {
            return timeoutMillis;
        }

        public boolean isSendSuccess() {
            return sendSuccess;
        }

        public void setSendSuccess(boolean sendSuccess) {
            this.sendSuccess = sendSuccess;
        }

        public boolean isResponseSuccess() {
            return responseSuccess;
        }

        public void setResponseSuccess(boolean responseSuccess) {
            this.responseSuccess = responseSuccess;
        }

        @Override
        public String toString() {
            return "ReponseWrapper [beginTimestamp=" + beginTimestamp + ", timeoutMillis=" + timeoutMillis
                    + ", channelFuture=" + channelFuture + ", sendCountDownLatch=" + sendCountDownLatch
                    + ", waitResponseCountDownLatch=" + waitResponseCountDownLatch + ", sendSuccess=" + sendSuccess
                    + ", responseSuccess=" + responseSuccess + "]";
        }
    }
}

#######################客户端的测试代码

/**
 * <p>Coyright (R) 2014 正方软件股份有限公司。<p>
 */
package com.zfsoft.nettyDemo;


import com.zfsoft.nettyDemo.client.Client;

public class BootstrapClientDemo {

    public static void main(String[] args) {

        Client client = new Client("127.0.0.1", 9000);
        client.connect();
        try {
            System.out.println("开始发送:"+System.currentTimeMillis());
            client.send("hello,world");
            System.out.println("结束发送:"+System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

########################以下是服务端的代码

package com.zfsoft.nettyDemo.server;

import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class Server {
    
    private AtomicInteger requestSequence = new AtomicInteger(0);

    private final ServerBootstrap serverBootstrap;
    private final EventLoopGroup eventLoopGroupBoss = new NioEventLoopGroup();
    private final EventLoopGroup eventLoopGroupWorker = new NioEventLoopGroup();

    private String charsetName = "UTF-8";

    public Server() {
        this.serverBootstrap = new ServerBootstrap();
    }

    public void startup() {

        final Charset charset = Charset.forName(this.charsetName);

        this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupWorker)
                .channel(NioServerSocketChannel.class)//
                .option(ChannelOption.SO_BACKLOG, 1024)//
                .option(ChannelOption.SO_REUSEADDR, true)//
                .childOption(ChannelOption.TCP_NODELAY, true)//
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        ByteBuf delimiter = Unpooled.copiedBuffer("\n".getBytes());
                        pipeline.addLast(//
                                new StringDecoder(charset), //
                                new DelimiterBasedFrameDecoder(1024,delimiter),//
                                new StringEncoder(charset), //
                                new NettyServerHandler()//
                        );
                    }
                });
        try {
            ChannelFuture sync = this.serverBootstrap.bind(9000).sync();
            sync.get();
            System.out.println("绑定结果:"+sync.isSuccess());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    class NettyServerHandler extends SimpleChannelInboundHandler<String> {
        
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            processMessageReceived(ctx,msg);
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            super.channelActive(ctx);
        }
        
    }

    public void shutdown() {

    }

    protected void processMessageReceived(final ChannelHandlerContext ctx, final String msg) {
        System.out.println("接收消息:"+msg);
        ctx.executor().schedule(new Runnable() {
            @Override
            public void run() {
                //System.out.println("回显消息:"+msg);
                //ctx.channel().writeAndFlush(msg+"\n");
            }
        }, 10, TimeUnit.SECONDS);
    }
}

##########################以下是服务端的测试代码

/**
 * <p>Coyright (R) 2014 正方软件股份有限公司。<p>
 */
package com.zfsoft.nettyDemo;

import java.util.concurrent.TimeUnit;

import com.zfsoft.nettyDemo.server.Server;

public class BootstrapServerDemo {

    public static void main(String[] args) {
        Server s = new Server();
        s.startup();
        try {
            TimeUnit.SECONDS.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

#########################maven依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.zfsoft</groupId>
    <artifactId>NettyDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>NettyDemo</name>
    <url>http://maven.apache.org</url>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.test.skip>false</maven.test.skip>
        <maven.javadoc.skip>true</maven.javadoc.skip>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.29.Final</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

 

#################log4j配置文件

log4j.rootCategory=DEBUG,stdout
 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%p %t %d{yyyy-MM-dd HH:mm:ss}  %C %m%n

package com.zfsoft.nettyDemo.server;
 
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
 
public class Server {
    
    private AtomicInteger requestSequence = new AtomicInteger(0);
 
    private final ServerBootstrap serverBootstrap;
    private final EventLoopGroup eventLoopGroupBoss = new NioEventLoopGroup();
    private final EventLoopGroup eventLoopGroupWorker = new NioEventLoopGroup();
 
    private String charsetName = "UTF-8";
 
    public Server() {
        this.serverBootstrap = new ServerBootstrap();
    }
 
    public void startup() {
 
        final Charset charset = Charset.forName(this.charsetName);
 
        this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupWorker)
                .channel(NioServerSocketChannel.class)//
                .option(ChannelOption.SO_BACKLOG, 1024)//
                .option(ChannelOption.SO_REUSEADDR, true)//
                .childOption(ChannelOption.TCP_NODELAY, true)//
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        ByteBuf delimiter = Unpooled.copiedBuffer("\n".getBytes());
                        pipeline.addLast(//
                                new StringDecoder(charset), //
                                new DelimiterBasedFrameDecoder(1024,delimiter),//
                                new StringEncoder(charset), //
                                new NettyServerHandler()//
                        );
                    }
                });
        try {
            ChannelFuture sync = this.serverBootstrap.bind(9000).sync();
            sync.get();
            System.out.println("绑定结果:"+sync.isSuccess());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    class NettyServerHandler extends SimpleChannelInboundHandler<String> {
        
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            processMessageReceived(ctx,msg);
        }
 
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            super.channelActive(ctx);
        }
         
    }
 
    public void shutdown() {
 
    }
 
    protected void processMessageReceived(final ChannelHandlerContext ctx, final String msg) {
        System.out.println("接收消息:"+msg);
        ctx.executor().schedule(new Runnable() {
            @Override
            public void run() {
                //System.out.println("回显消息:"+msg);
                //ctx.channel().writeAndFlush(msg+"\n");
            }
        }, 10, TimeUnit.SECONDS);
    }
}

转载于:https://www.cnblogs.com/weiguangyue/p/9671608.html

weixin_30430169
关注
Netty进阶-Netty篇
又逢乱世
01-21 3149
Netty处理粘包、半包、 粘包、半包现象分析、 什么是滑动窗口、 什么是MSS限制、 什么是Nagle算法、 协议设计与解析、 http 协议、 自定义协议、 @Sharable 注解、 空闲检测-连接假死、 Netty常用参数配置
计算机网络与Netty - F2F
OxYGC
07-21 770
一、OSI，TCP/IP，五层协议的体系结构，以及各层协议 OSI分层 （7层）：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。 TCP/IP分层（4层）：网络接口层、 网际层、运输层、 应用层。 五层协议 （5层）：物理层、数据链路层、网络层、运输层、 应用层。 每一层的协议如下： 物理层：RJ45、CLOCK、IEEE802.3 （中继器，集线器，网关） 数据链路：PPP、FR、HDLC、VLAN、MAC （网桥，交换机） 网络层：IP、ICMP、ARP、RARP、OSPF、IPX、RIP
netty-socketio之ack消息
zsj777的专栏
05-19 1462
1、客户端给服务端发送带有ack请求的消息，服务端收到消息后发送ack响应消息给客户端 var userName = 'user' + Math.floor((Math.random()*1000)+1); function sendMessage() { var message = $('#msg').val(); $('#msg').val(''); var jsonObject = {userName:
NIO与Socket笔记 ：TCP报文到达确认（ACK）机制
张伯毅的专栏
04-04 4344
SYN表示建立连接， FIN表示关闭连接， ACK表示响应 TCP数据包中的序列号（Sequence Number）不是以报文段来进行编号的，而是将连接生存周期内传输的所有数据当作一个字节流，序列号就是整个字节流中每个字节的编号。 一个TCP数据包中包含多个字节流的数据（即数据段），而且每个TCP数据包中的数据大小不一定相同。 在建立TCP连接...
netty demo
最新发布
liwang2016384的博客
07-08 235
如下所示，我们写一个简单的Netty Demo，实现客户端与服务端进行通讯。由此，一个Netty的简单Demo即搭建完成。2、Netty 服务端处理类Handler。1、Netty 服务端启动类。4、客户端处理类Handler。3、Netty 客户端启动类。
Netty入门学习
ack_Finding的博客
05-15 319
1、传统IO模型是服务器通过死循环来接收客户端的请求，为接收到的客户端请求创建新的线程进行处理。（面向流）2、了解Java NIO（面向缓存区）Java NIO浅析3、一个连接完整的网络处理过程如下：4、了解：Reactor模型Java进阶（五）Java I/O模型从BIO到NIO和Reactor模式5、Netty系列之Netty线程模型6、Netty实现原理浅析7、Netty那点事（1）概述Ne...
netty原理详解
七月流星
09-22 4810
 NIO客户端序列图步骤一：打开SocketChannel，绑定客户端本地地址（可选，默认系统会随机分配一个可用的本地地址），示例代码如下：1SocketChannel clientChannel = SocketChannel.open();步骤二：设置SocketChannel为非阻塞模式，同时设置客户端连接的TCP参数，示例代码如下：1clientChannel.configureBlock...
netty-socket.io之ack超时设置
zsj777的专栏
05-26 1089
1、socket.io服务端和客户端的版本对应 Client Installation | Socket.IO 2、java版本的netty-socketio只支持socket.io的客户端2.X版本 <dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-s
Netty-SocketIO实现服务器消息推送
热门推荐
奔跑的蜗牛
08-27 1万+
在有些场景下，如股票价格实时显示、直播、在线聊天等场景，则需要服务器主动向客户端推送消息，显然Http协议并不太适合完全这项工作，而Netty-SocketIO是基于Netty框架下用Java实现Socket通信的组件，可用于服务器主动推送消息到客户端的情形。
基于Netty实现UDP双向通信
猴子哥哥的博客
02-09 6572
1、Channel继承关系 关于ChannelPipeline原理可参考：https://blog.csdn.net/qq_21033663/article/details/105674261 2、NIO Channel分类 1）NioDatagramChannel：发送和接收数据包，支持TCP和UDP，对DatagramSocket和selector进行封装 2）NioServerSocketChannel：服务端使用，对JDK的ServerSocketChannel进行了封装 3）NioSocketC
Netty快速学习1-基础知识回顾
gzt19881123的专栏
03-28 3417
Netty作为软件高级编程必学技术框架 传统BIO框架 Java里面的线程池 网络IO模型
netty的入门经典例子的使用
03-31
NULL 博文链接：https://jilongliang.iteye.com/blog/1354265
Netty核心原理详解第三篇 编解码和数据传输
fegus的博客
07-15 1402
本节课我们详细讨论了TCP中的拆包/粘包问题，以及如何通过应用层的通信协议来解决拆包/粘包问题。其中基于消息长度+消息内容的变长协议是项目开发中最常用的一种方法，需要我们重点掌握，例如开源中间件Dubbo、RocketMQ等都基于该方法自定义了自己的通信协议，下节课我们将一起学习如何设计高效、可扩展、易维护的自定义网络通信协议。既然是网络编程，自然离不开通信协议，应用层之间通信需要实现各种各样的网络协议。在项目开发的过程中，我们就需要去构建满足自己业务场景的应用层协议。一次解码器和二次解码器。...
netty（异步非阻塞、实时、高效率）
qq_33730348的博客
12-18 7070
1.为什么使用netty 简单，再也不用编写复杂的代码逻辑去实现通信，再也不用考虑性能问题，不需要考虑编解码问题，半包读写问题。 netty运用于Hadoop的RPC框架Avro，JMS框架RocketMQ，主流的分布式通信框架Dubbox等。 在业务场景中比如导航，建立长连接实时返回数据结果，以及滴滴打车，实时返回车程等。 2.netty特性 Design：各种传输类型，阻塞和非阻塞套...
计算机网络体系结构
孙应路的博客
05-04 612
计算机网络体系结构 开放系统互连参考模型 (Open System Interconnect 简称OSI）是国际标准化组织(ISO)和国际电报电话咨询委员会(CCITT)联合制定的开放系统互连参考模型，为开放式互连信息系统提供了一种功能结构的框架。其目的是为异种计算机互连提供一个共同的基础和标准框架，并为保持相关标准的一致性和兼容性提供共同的参考。这里所说的开放系统，实质上指的是遵循OSI参考模...
Netty中的那些坑
weixin_34242331的博客
02-24 1292
Netty中的那些坑（上篇） 最近开发了一个纯异步的redis客户端，算是比较深入的使用了一把netty。在使用过程中一边优化，一边解决各种坑。儿这些坑大部分基本上是Netty4对Netty3的改进部分引起的。 注：这里说的坑不是说netty不好，只是如果这些地方不注意，或者不去看netty的代码，就有可能掉进去了。 坑1: Netty 4的线程模型转变 在Netty 3的时候，upstr...
Netty系列之Netty百万级推送服务设计要点
dandan2zhuzhu的专栏
01-04 1904
1. 背景 1.1. 话题来源 最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我，咨询推送服务相关的问题。问题五花八门，在帮助大家答疑解惑的过程中，我也对问题进行了总结，大概可以归纳为如下几类： Netty是否可以做推送服务器？ 如果使用Netty开发推送服务，一个服务器最多可以支撑多少个客户端？ 使用Netty开发推送服务遇到的各种技术问题。 由于
netty和netty-socketio
05-05
Netty是一个基于NIO的客户端/服务器框架，可以快速轻松地开发可维护和高性能的网络应用程序。它提供了许多高级的抽象，如事件驱动的异步网络编程、高性能的传输协议、可扩展的缓冲区和内存管理等。Netty被广泛应用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值