import java.nio.ByteBuffer;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

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.FixedLengthFrameDecoder;

import io.netty.handler.codec.string.StringDecoder;

import io.netty.handler.codec.string.StringEncoder;

public class Server {

	public static void main(String[] args) throws Exception{

		//1 创建2个线程，一个是负责接收客户端的连接。一个是负责进行数据传输的

		EventLoopGroup pGroup = new NioEventLoopGroup();

		EventLoopGroup cGroup = new NioEventLoopGroup();

		//2 创建服务器辅助类

		ServerBootstrap b = new ServerBootstrap();

		b.group(pGroup, cGroup)

		 .channel(NioServerSocketChannel.class)

		 .option(ChannelOption.SO_BACKLOG, 1024)

		 .option(ChannelOption.SO_SNDBUF, 32*1024)

		 .option(ChannelOption.SO_RCVBUF, 32*1024)

		 .childHandler(new ChannelInitializer<SocketChannel>() {

			@Override

			protected void initChannel(SocketChannel sc) throws Exception {

				//设置特殊分隔符

				ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());

				sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));

				//设置字符串形式的解码

				sc.pipeline().addLast(new StringDecoder());

				sc.pipeline().addLast(new ServerHandler());

			}

		});

		//4 绑定连接

		ChannelFuture cf = b.bind(8765).sync();

		//等待服务器监听端口关闭

		cf.channel().closeFuture().sync();

		pGroup.shutdownGracefully();

		cGroup.shutdownGracefully();

	}

}

　　

import io.netty.bootstrap.Bootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

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.FixedLengthFrameDecoder;

import io.netty.handler.codec.string.StringDecoder;

import io.netty.handler.codec.string.StringEncoder;

public class Client {

	public static void main(String[] args) throws Exception {

		EventLoopGroup group = new NioEventLoopGroup();

		Bootstrap b = new Bootstrap();

		b.group(group)

		 .channel(NioSocketChannel.class)

		 .handler(new ChannelInitializer<SocketChannel>() {

			@Override

			protected void initChannel(SocketChannel sc) throws Exception {

				//

				ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());

				sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));

				sc.pipeline().addLast(new StringDecoder());

				sc.pipeline().addLast(new ClientHandler());

			}

		});

		ChannelFuture cf = b.connect("127.0.0.1", 8765).sync();

		cf.channel().writeAndFlush(Unpooled.wrappedBuffer("bbbb$_".getBytes()));

		cf.channel().writeAndFlush(Unpooled.wrappedBuffer("cccc$_".getBytes()));

		//等待客户端端口关闭

		cf.channel().closeFuture().sync();

		group.shutdownGracefully();

	}

}

　　

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {

	@Override

	public void channelActive(ChannelHandlerContext ctx) throws Exception {

		System.out.println(" server channel active... ");

	}

	@Override

	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

		String request = (String)msg;

		System.out.println("Server :" + msg);

		String response = "服务器响应：" + msg + "$_";

		ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));

	}

	@Override

	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

	}

	@Override

	public void exceptionCaught(ChannelHandlerContext ctx, Throwable t) throws Exception {

		ctx.close();

	}

}

　　

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter{

	@Override

	public void channelActive(ChannelHandlerContext ctx) throws Exception {

		System.out.println("client channel active... ");

	}

	@Override

	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

		try {

			String response = (String)msg;

			System.out.println("Client: " + response);

		} finally {

			ReferenceCountUtil.release(msg);

		}

	}

	@Override

	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

	}

	@Override

	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

		ctx.close();

	}

}

　　

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.handler.logging.LogLevel;

import io.netty.handler.logging.LoggingHandler;

import io.netty.handler.timeout.ReadTimeoutHandler;

public class Server {

    public Server() {

    }

    public static void main(String[] args) throws Exception {

        EventLoopGroup pGroup = new NioEventLoopGroup();

        EventLoopGroup cGroup = new NioEventLoopGroup();

        ServerBootstrap b = new ServerBootstrap();

        ((ServerBootstrap)((ServerBootstrap)((ServerBootstrap)b.group(pGroup, cGroup).channel(NioServerSocketChannel.class)).option(ChannelOption.SO_BACKLOG, 1024)).handler(new LoggingHandler(LogLevel.INFO))).childHandler(new ChannelInitializer<SocketChannel>() {

            protected void initChannel(SocketChannel sc) throws Exception {

                sc.pipeline().addLast(new ChannelHandler[]{MarshallingCodeCFactory.buildMarshallingDecoder()});

                sc.pipeline().addLast(new ChannelHandler[]{MarshallingCodeCFactory.buildMarshallingEncoder()});

                sc.pipeline().addLast(new ChannelHandler[]{new ReadTimeoutHandler(5)});

                sc.pipeline().addLast(new ChannelHandler[]{new ServerHandler()});

            }

        });

        ChannelFuture cf = b.bind(8765).sync();

        cf.channel().closeFuture().sync();

        pGroup.shutdownGracefully();

        cGroup.shutdownGracefully();

    }

}

　　

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelHandler;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import io.netty.handler.logging.LogLevel;

import io.netty.handler.logging.LoggingHandler;

import io.netty.handler.timeout.ReadTimeoutHandler;

import java.util.concurrent.TimeUnit;

public class Client {

    private EventLoopGroup group;

    private Bootstrap b;

    private ChannelFuture cf;

    public static Client getInstance() {

        return Client.SingletonHolder.instance;

    }

    private Client() {

        this.group = new NioEventLoopGroup();

        this.b = new Bootstrap();

        ((Bootstrap)((Bootstrap)((Bootstrap)this.b.group(this.group)).channel(NioSocketChannel.class)).handler(new LoggingHandler(LogLevel.INFO))).handler(new ChannelInitializer<SocketChannel>() {

            protected void initChannel(SocketChannel sc) throws Exception {

                sc.pipeline().addLast(new ChannelHandler[]{MarshallingCodeCFactory.buildMarshallingDecoder()});

                sc.pipeline().addLast(new ChannelHandler[]{MarshallingCodeCFactory.buildMarshallingEncoder()});

                sc.pipeline().addLast(new ChannelHandler[]{new ReadTimeoutHandler(5)});

                sc.pipeline().addLast(new ChannelHandler[]{new ClientHandler()});

            }

        });

    }

    public void connect() {

        try {

            this.cf = this.b.connect("127.0.0.1", 8765).sync();

            System.out.println("远程服务器已经连接, 可以进行数据交换..");

        } catch (Exception var2) {

            var2.printStackTrace();

        }

    }

    public ChannelFuture getChannelFuture() {

        if (this.cf == null) {

            this.connect();

        }

        if (!this.cf.channel().isActive()) {

            this.connect();

        }

        return this.cf;

    }

    public static void main(String[] args) throws Exception {

        final Client c = getInstance();

        ChannelFuture cf = c.getChannelFuture();

        for(int i = 1; i <= 3; ++i) {

            Request request = new Request();

            request.setId("" + i);

            request.setName("pro" + i);

            request.setRequestMessage("数据信息" + i);

            cf.channel().writeAndFlush(request);

            TimeUnit.SECONDS.sleep(4L);

        }

        cf.channel().closeFuture().sync();

        (new Thread(new Runnable() {

            public void run() {

                try {

                    System.out.println("进入子线程...");

                    ChannelFuture cf = c.getChannelFuture();

                    System.out.println(cf.channel().isActive());

                    System.out.println(cf.channel().isOpen());

                    Request request = new Request();

                    request.setId("4");

                    request.setName("pro4");

                    request.setRequestMessage("数据信息4");

                    cf.channel().writeAndFlush(request);

                    cf.channel().closeFuture().sync();

                    System.out.println("子线程结束.");

                } catch (InterruptedException var3) {

                    var3.printStackTrace();

                }

            }

        })).start();

        System.out.println("断开连接,主线程结束..");

    }

    private static class SingletonHolder {

        static final Client instance = new Client((Client)null);

        private SingletonHolder() {

        }

    }

}

JavaTCP粘包、拆包的更多相关文章

  1. Netty（三）TCP粘包拆包处理

    tcp是一个“流”的协议,一个完整的包可能会被TCP拆分成多个包进行发送,也可能把小的封装成一个大的数据包发送,这就是所谓的TCP粘包和拆包问题. 粘包.拆包问题说明 假设客户端分别发送数据包D1和D ...

  2. TCP粘包/拆包问题

    无论是服务端还是客户端,当我们读取或者发送消息的时候,都需要考虑TCP底层的粘包/拆包机制. TCP粘包/拆包 TCP是个"流"协议,所谓流,就是没有界限的一串数据.大家可以想想河 ...

  3. 1. Netty解决Tcp粘包拆包

    一. TCP粘包问题 实际发送的消息, 可能会被TCP拆分成很多数据包发送, 也可能把很多消息组合成一个数据包发送 粘包拆包发生的原因 (1) 应用程序一次写的字节大小超过socket发送缓冲区大小 ...

  4. TCP 粘包/拆包问题

    简介    TCP 是一个’流’协议,所谓流,就是没有界限的一串数据. 大家可以想想河里的流水,是连成一片的.期间并没有分界线, TCP 底层并不了解上层业务数据的具体含义 ,它会根据 TCP 缓冲区 ...

  5. TCP粘包/拆包问题的解决

    TCP粘包拆包问题 一个完整的包可能被TCP拆分成多个包,或多个小包封装成一个大的数据包发送. 解决策略 消息定长,如果不够,空位补空格 在包尾增加回车换行符进行分割,例如FTP协议 将消息分为消息头 ...

  6. Netty（二）——TCP粘包/拆包

    转载请注明出处:http://www.cnblogs.com/Joanna-Yan/p/7814644.html 前面讲到:Netty(一)--Netty入门程序 主要内容: TCP粘包/拆包的基础知 ...

  7. Netty2：粘包/拆包问题与使用LineBasedFrameDecoder的解决方案

    什么是粘包.拆包 粘包.拆包是Socket编程中最常遇见的一个问题,本文来研究一下Netty是如何解决粘包.拆包的,首先我们从什么是粘包.拆包开始说起: TCP是个"流"协议,所谓 ...

  8. Netty 粘包 & 拆包 & 编码 & 解码 & 序列化 介绍

    目录: 粘包 & 拆包及解决方案 ByteToMessageDecoder 基于长度编解码器 基于分割符的编解码器 google 的 Protobuf 序列化介绍 其他的 前言 Netty 作 ...

  9. 【转】Netty之解决TCP粘包拆包(自定义协议)

    1.什么是粘包/拆包 一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据.TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往往小于在应用处理的消 ...

  10. Netty之解决TCP粘包拆包(自定义协议)

    1.什么是粘包/拆包 一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据.TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往往小于在应用处理的消 ...

随机推荐

  1. tf.matmul()报错expected scalar type Float but found Double

    tf.matmul(a,b)将矩阵a乘以矩阵b,生成a * b,这里的a,b要有相同的数据类型,否则会因为数据类型不匹配而出错. 如果出错,请看是前后分别是什么类型的,然后把数据类型进行转换.

  2. 帝国CMS排行榜调用标签

    [e:loop={0,9,4,0,'newstime>UNIX_TIMESTAMP()-86400*30','onclick desc'}]<li><a href=" ...

  3. SpringCloud Feign通过FallbackFactory显示异常信息

    SpringCloud Feign可以进行服务消费,而且内置了Hystrix,能够进行熔断. Feign可以通过fallback指定熔断回调的类.代码示例及讲解可见: https://www.cnbl ...

  4. MacBook Air在macOS Mojave和macOS Seirra系统下使用Loopback在OBS Studio推流时输出系统软件声音

    转载请标注原地址:https://www.cnblogs.com/lixiaojing/p/11440533.html 运行环境: Loopback破解版获取: https://pan.baidu.c ...

  5. #C++初学记录（typedef和define）

    typedef的用法 typedef关键字可以用于给数据类型定义一个别名,即可以给long long 定义成ll,也可以给结构体定义,当你定义了一个结构体时,每次创建一个结构体都要使用struct+结 ...

  6. var let const区别

      var let const 可否同一作用域下声明同名变量 可以 不可以 不可以 声明的变量是否会挂载到window上 会 不会 不会 声明变量是否存在变量提升 存在 不存在(变量必须声明之后才能使 ...

  7. _blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} pip

    python2.6 get-pip.py 报错下面的错误_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} pip解决方案:# 1, 从官方git ...

  8. 第10组 Beta冲刺（1/5）

    链接部分 队名:女生都队 组长博客: 博客链接 作业博客:博客链接 小组内容 恩泽(组长) 过去两天完成了哪些任务 描述 tomcat的学习与实现 服务器后端部署,API接口的beta版实现 后端代码 ...

  9. jq select change下拉框选项变化判断选中值,添加（attr)或移除(removeAttr)一个或多个属性

    select change下拉框选项变化判断选中值,添加(attr)或移除(removeAttr)一个或多个属性 $("#IsRecommend").change(function ...

  10. DOM 是什么，Document Object Model，文档对像模型

    #为什么会想起来写这个 在写dynaTrace Ajax的时候,写到这个是个前端性能测试工具,这个工具能记录请求时间,前端页面渲染时间,DOM方法执行时间,以及JavaScript代码解析和执行时间. ...