又逢乱世
又逢乱世

Netty进阶-Netty篇

知识点前文请阅读：Netty入门

粘包、半包

  • 服务器端
	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			// 设置服务器端接收缓冲区大小为 10 字节
			serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}
  • 客户端
	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						/**
						 * 会在连接 connect 建立成功后，会触发 channelActive 事件
						 */
						@Override
						public void channelActive(ChannelHandlerContext ctx) throws Exception {
							// 向服务器端发送 5 次数据，每次 发送16个字节
							for (int i = 0; i < 5; i++) {
								ByteBuf buf = ctx.alloc().buffer(16);
								buf.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
								ctx.writeAndFlush(buf);
							}
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}
  • 服务器端打印结果
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] REGISTERED
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] ACTIVE
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ: 36B		// 可以看到这里接收到 36 字节，客户端每次发送 16 个字节，服务器端这里一次接收了36字节，36 > 16 出现了粘包现象，16:16:4 最后4这里出现了半包现象
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000010| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000020| 00 01 02 03                                     |....            |
+--------+-------------------------------------------------+----------------+
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ COMPLETE
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ: 40B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000010| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000020| 04 05 06 07 08 09 0a 0b                         |........        |
+--------+-------------------------------------------------+----------------+
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ COMPLETE
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ: 4B			// 半包
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 0c 0d 0e 0f                                     |....            |
+--------+-------------------------------------------------+----------------+
15:23:38 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x8fc90ea3, L:/127.0.0.1:8080 - R:/127.0.0.1:53151] READ COMPLETE

看 READ 类型，可以看到这里接收到 36 字节，客户端每次发送 16 个字节，服务器端这里一次接收了36字节，36 > 16 出现了粘包现象，16:16:4 最后4这里出现了半包现象

现象分析

  • 粘包

  • 现象，发送 abc def，接收 abcdef

  • 原因

    • 应用层：接收方 ByteBuf 设置太大（Netty 默认 1024）

    • 滑动窗口：假设发送方 256 bytes 表示一个完整报文，但由于接收方处理不及时且窗口大小足够大，这 256 bytes 字节就会缓冲在接收方的滑动窗口中，当滑动窗口中缓冲了多个报文就会粘包

    • Nagle 算法：会造成粘包

  •  半包

  • 现象，发送 abcdef，接收 abc def

  • 原因

    • 应用层：接收方 ByteBuf 小于实际发送数据量

    • 滑动窗口：假设接收方的窗口只剩了 128 bytes，发送方的报文大小是 256 bytes，这时放不下了，只能先发送前 128 bytes，等待 ack 后才能发送剩余部分，这就造成了半包

    • MSS 限制：当发送的数据超过 MSS 限制后，会将数据切分发送，就会造成半包

本质是因为 TCP 是流式协议，消息无边界，需要开发人员找出消息的边界

  • 滑动窗口

  • TCP 以一个段（segment）为单位，每发送一个段就需要进行一次确认应答（ack）处理，但如果这么做，缺点是包的往返时间越长性能就越差

Netty进阶-Netty篇_第1张图片

  • 为了解决此问题，引入了窗口概念，窗口大小即决定了无需等待应答而可以继续发送的数据最大值

Netty进阶-Netty篇_第2张图片

  •  窗口实际就起到一个缓冲区的作用，同时也能起到流量控制的作用
    • 图中窗口内的4段(1-1000、1001-2000、2001-3000、3001-4000)数据才允许被发送，当应答未到达前，窗口必须停止滑动
    • 如果 1-1000 这个段的数据 ack 回来了，窗口就可以向前滑动，就可以发送 4001-5000 段的数据
    • 接收方也会维护一个窗口，只有落在窗口内的数据才能允许接收
// 调整服务器端 滑动窗口大小，一般不用设置，在建立连接后系统自动设置，netty默认的是1024
serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);

// 调整客户端 滑动窗口大小，一般不用设置，在建立连接后系统自动设置，netty默认的是1024
bootstrap.option(ChannelOption.SO_SNDBUF, 10);

// 调整 netty 的接收缓冲区大小（ByteBuf） AdaptiveRecvByteBufAllocator(最小值, 初始值, 最大值)
serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(16, 16, 16));

/ 插播知识点 /

option：全局配置，给ServerSocketChannel 配置参数

childOption：单个 channel 连接的配置，给SocketChannel 配置参数

  • MSS 限制

  • 链路层对一次能够发送的最大数据有限制，这个限制称之为 MTU（maximum transmission unit），不同的链路设备的 MTU 值也有所不同，例如

  • 以太网的 MTU 是 1500

  • FDDI（光纤分布式数据接口）的 MTU 是 4352

  • 本地回环地址的 MTU 是 65535 - 本地测试不走网卡

  • MSS 是最大段长度（maximum segment size），它是 MTU 刨去 tcp 头和 ip 头后剩余能够作为数据传输的字节数

  • ipv4 tcp 头占用 20 bytes，ip 头占用 20 bytes，因此以太网 MSS 的值为 1500 - 40 = 1460

  • TCP 在传递大量数据时，会按照 MSS 大小将数据进行分割发送

  • MSS 的值在三次握手时通知对方自己 MSS 的值，然后在两者之间选择一个小值作为 MSS

  • Nagle 算法

  • 即使发送一个字节，也需要加入 tcp(20) 头和 ip(20) 头，也就是总字节数会使用 41 bytes，非常不经济。因此为了提高网络利用率，tcp 希望尽可能发送足够大的数据，这就是 Nagle 算法产生的缘由

  • 该算法是指发送端即使还有应该发送的数据，但如果这部分数据很少的话，则进行延迟发送

    • 如果 SO_SNDBUF 的数据达到 MSS，则需要发送

    • 如果 SO_SNDBUF 中含有 FIN（表示需要连接关闭）这时将剩余数据发送，再关闭

    • 如果 TCP_NODELAY = true，则需要发送

    • 已发送的数据都收到 ack 时，则需要发送

    • 上述条件不满足，但发生超时（一般为 200ms）则需要发送

    • 除上述情况，延迟发送

  • 解决方案

  1. 短链接，发一个包建立一次连接，这样连接建立到连接断开之间就是消息的边界，缺点效率太低

  2. 每一条消息采用固定长度，缺点浪费空间

  3. 每一条消息采用分隔符，例如 \n，缺点需要转义

  4. 每一条消息分为 head 和 body，head 中包含 body 的长度

- 解决方案一：短链接

服务器端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			// 设置服务器端接收缓冲区大小为 10 字节
			// serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

客户端

	public static void main(String[] args) throws InterruptedException {
		// 发送5次
		for (int i = 0; i < 5; i++) {
			send();
		}
	}

	private static void send() {
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						/**
						 * 会在连接 connect 建立成功后，会触发 channelActive 事件
						 */
						@Override
						public void channelActive(ChannelHandlerContext ctx) throws Exception {
							ByteBuf buf = ctx.alloc().buffer(16);
							buf.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
							ctx.writeAndFlush(buf);
							// 发送一次消息后，就关闭 channel 通道，关闭连接
							ctx.channel().close();
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}

服务器端打印

16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 - R:/127.0.0.1:51412] REGISTERED
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 - R:/127.0.0.1:51412] ACTIVE
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 - R:/127.0.0.1:51412] READ: 16B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
+--------+-------------------------------------------------+----------------+
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 - R:/127.0.0.1:51412] READ COMPLETE
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 - R:/127.0.0.1:51412] READ COMPLETE
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 ! R:/127.0.0.1:51412] INACTIVE
16:37:52 [DEBUG] [nioEventLoopGroup-3-8] i.n.h.l.LoggingHandler - [id: 0xffa06125, L:/127.0.0.1:8080 ! R:/127.0.0.1:51412] UNREGISTERED
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 - R:/127.0.0.1:51429] REGISTERED
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 - R:/127.0.0.1:51429] ACTIVE
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 - R:/127.0.0.1:51429] READ: 16B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
+--------+-------------------------------------------------+----------------+
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 - R:/127.0.0.1:51429] READ COMPLETE
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 - R:/127.0.0.1:51429] READ COMPLETE
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 ! R:/127.0.0.1:51429] INACTIVE
16:37:52 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x3f21d899, L:/127.0.0.1:8080 ! R:/127.0.0.1:51429] UNREGISTERED
......

可以看到可以数据没有粘在一起了，解决了粘包问题

但是短链接不能解决半包问题

测试短链接半包现象代码改造，调整服务器端netty接收缓冲区大小为16个字节，netty最小16个字节，因为取16的倍数（serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(16, 16, 16));）-------  客户端一次发送超过16个字节的数据即可。这里就不再重复贴相似的代码了

- 解决方案二：固定长度

FixedLengthFrameDecoder：netty 提供的定长解码器，构造方法参数：和客户端约定传递消息的长度

服务器端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					// FixedLengthFrameDecoder：netty 提供的定长解码器，构造方法参数：和客户端约定传递消息的长度
					ch.pipeline().addLast(new FixedLengthFrameDecoder(10));
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

客户端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						/**
						 * 会在连接 connect 建立成功后，会触发 channelActive 事件
						 */
						@Override
						public void channelActive(ChannelHandlerContext ctx) throws Exception {
							ByteBuf buf = ctx.alloc().buffer();
							char c = '0';
							for (int i = 0; i < 5; i++) {
								byte[] bytes = fill10Bytes(c, new Random().nextInt(10) + 1);
								c++;
								buf.writeBytes(bytes);
							}
							ctx.writeAndFlush(buf);
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}

	/**
	 * 发送的数据，字节长度不够时，补够字节长度
	 */
	public static byte[] fill10Bytes(char c, int len) {
		byte[] bytes = new byte[10];
		Arrays.fill(bytes, (byte) '_');
		for (int i = 0; i < len; i++) {
			bytes[i] = (byte) c;
		}
		System.out.println(new String(bytes));
		return bytes;
	}

服务器端打印

17:22:44 [DEBUG] [nioEventLoopGroup-3-3] i.n.h.l.LoggingHandler - [id: 0x565dcfb4, L:/127.0.0.1:8080 - R:/127.0.0.1:53524] REGISTERED
17:22:44 [DEBUG] [nioEventLoopGroup-3-3] i.n.h.l.LoggingHandler - [id: 0x565dcfb4, L:/127.0.0.1:8080 - R:/127.0.0.1:53524] ACTIVE
17:22:44 [DEBUG] [nioEventLoopGroup-3-3] i.n.h.l.LoggingHandler - [id: 0x565dcfb4, L:/127.0.0.1:8080 - R:/127.0.0.1:53524] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 30 30 30 30 30 30 30 5f 5f 5f                   |0000000___      |
+--------+-------------------------------------------------+----------------+
17:22:44 [DEBUG] [nioEventLoopGroup-3-3] i.n.h.l.LoggingHandler - [id: 0x565dcfb4, L:/127.0.0.1:8080 - R:/127.0.0.1:53524] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 31 31 5f 5f 5f 5f 5f 5f 5f                   |111_______      |
+--------+-------------------------------------------------+----------------+
17:22:44 [DEBUG] [nioEventLoopGroup-3-3] i.n.h.l.LoggingHandler - [id: 0x565dcfb4, L:/127.0.0.1:8080 - R:/127.0.0.1:53524] READ: 10B
......

- 解决方案三：分隔符

  • LineBasedFrameDecoder：netty 提供的支持 \n 和 \r\n 符号的解码器，构造参数传遇到换行符的最大长度，当读了指定长度的字节时，还没有遇到换行符，将抛出异常
  • DelimiterBasedFrameDecoder：netty 提供的支持 自定义符号的解码器，构造参数传符号的最大长度，和ByteBuf类型的自定义符号

服务器端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					// ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
					ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, ByteBufAllocator.DEFAULT.buffer().writeBytes("|".getBytes(StandardCharsets.UTF_8))));
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

客户端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						/**
						 * 会在连接 connect 建立成功后，会触发 channelActive 事件
						 */
						@Override
						public void channelActive(ChannelHandlerContext ctx) throws Exception {
							ByteBuf buf = ctx.alloc().buffer();
							//buf.writeBytes("hello\nworld\nhi\nzhang san\n".getBytes(StandardCharsets.UTF_8));
							buf.writeBytes("hello|world|hi|zhang san|".getBytes(StandardCharsets.UTF_8));
							ctx.writeAndFlush(buf);
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}

服务器端打印

17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] REGISTERED
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] ACTIVE
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] READ: 5B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] READ: 5B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 77 6f 72 6c 64                                  |world           |
+--------+-------------------------------------------------+----------------+
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] READ: 2B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 69                                           |hi              |
+--------+-------------------------------------------------+----------------+
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] READ: 9B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 7a 68 61 6e 67 20 73 61 6e                      |zhang san       |
+--------+-------------------------------------------------+----------------+
17:44:53 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x4cd3ff09, L:/127.0.0.1:8080 - R:/127.0.0.1:53948] READ COMPLETE

- 解决方案四：预设长度 LTC解码器

LengthFieldBasedFrameDecoder：构造参数传(最大长度，记录长度偏移量，长度占用字节数，长度调整，剥离字节数)

服务器端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();

		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					// 参数一：最大字节数，
					// 参数二：长度在buf中的偏移量，因为我在buf中先写的是长度，所以长度的偏移量是0，如果先写入2个字节的数据，再写入长度，那么长度的偏移量就是2
					// 参数三：长度占用的字节，我写的是一个int类型，占用4个字节
					// 参数四：需要调整的长度
					// 参数五：数据从头开始需要剥离的长度，现在buf中的数据是 ....hello, world 和 ....hi!，前面的4个点是长度，我们不需要长度，所以需要把长度剥离出去
					ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

客户端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						@Override
						public void channelActive(ChannelHandlerContext ctx) throws Exception {
							ByteBuf buf = ctx.alloc().buffer();

							msg(buf, "hello, world");
							msg(buf, "hi!");
							ctx.writeAndFlush(buf);
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}

	/**
	 * // 4 个字节的长度，然后是实际内容
	 */
	private static void msg(ByteBuf buf, String content) {
		byte[] bytes = content.getBytes(StandardCharsets.UTF_8); // 实际内容
		int length = bytes.length;    // 实际内容长度

		buf.writeInt(length);    // int的长度是4个字节，把长度写入
		buf.writeBytes(bytes);
	}

服务器端打印

18:36:43 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x21c2c017, L:/127.0.0.1:8080 - R:/127.0.0.1:59190] REGISTERED
18:36:43 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x21c2c017, L:/127.0.0.1:8080 - R:/127.0.0.1:59190] ACTIVE
18:36:43 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x21c2c017, L:/127.0.0.1:8080 - R:/127.0.0.1:59190] READ: 12B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64             |hello, world    |
+--------+-------------------------------------------------+----------------+
18:36:43 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x21c2c017, L:/127.0.0.1:8080 - R:/127.0.0.1:59190] READ: 3B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 69 21                                        |hi!             |
+--------+-------------------------------------------------+----------------+
18:36:43 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x21c2c017, L:/127.0.0.1:8080 - R:/127.0.0.1:59190] READ COMPLETE

加深 LengthFieldBasedFrameDecoder 解码器的理解，使用 EmbeddedChannel 工具类调试

	public static void main(String[] args) {
		EmbeddedChannel embeddedChannel = new EmbeddedChannel(
				// 参数一：最大字节数，
				// 参数二：长度在buf中的偏移量，因为我在buf中先写的是长度，所以长度的偏移量是0，如果先写入2个字节的数据，再写入长度，那么长度的偏移量就是2
				// 参数三：长度占用的字节，我写的是一个int类型，占用4个字节
				// 参数四：需要调整的长度，现在除了内容以外，在buf中又加了1个字节长度的版本号，所以需要调整的长度是1
				// 参数五：数据从头开始需要剥离的长度，现在buf中的数据是 .....hello, world 和 .....hi!，前面的4个点是长度，第5个点是版本号，我们不需要长度，所以需要把长度剥离出去，最后的数据是 .hello, world 和 .hi!
				new LengthFieldBasedFrameDecoder(1024, 0, 4, 1, 4)
				, new LoggingHandler(LogLevel.DEBUG)
		);
		// 4 个字节的长度，然后是实际内容
		ByteBuf buf = ByteBufAllocator.DEFAULT.buffer();

		msg(buf, "hello, world");
		msg(buf, "hi!");
		embeddedChannel.writeInbound(buf);
	}

	private static void msg(ByteBuf buf, String content) {
		byte[] bytes = content.getBytes(StandardCharsets.UTF_8); // 实际内容
		int length = bytes.length;    // 实际内容长度
		// buf.writeBytes(new byte[]{1,2}); // 加入在长度之前多写入了两个字节的数据，那么LengthFieldBasedFrameDecoder的第二个参数就是2
		buf.writeInt(length);    // int的长度是4个字节，把长度写入
		buf.writeByte(1);        // 传入其他数据，例如版本号
		buf.writeBytes(bytes);
	}

打印

18:50:42 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] REGISTERED
18:50:42 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] ACTIVE
18:50:42 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ: 13B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64          |.hello, world   |
+--------+-------------------------------------------------+----------------+
18:50:42 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ: 4B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 68 69 21                                     |.hi!            |
+--------+-------------------------------------------------+----------------+
18:50:42 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ COMPLETE

协议设计与解析

  • 为什么需要协议？

TCP/IP 中消息传输基于流的方式，没有边界。

协议的目的就是划定消息的边界，制定通信双方要共同遵守的通信规则

例如：在网络上传输

下雨天留客天留我不留

是中文一句著名的无标点符号句子，在没有标点符号情况下，这句话有数种拆解方式，而意思却是完全不同，所以常被用作讲述标点符号的重要性。

  • 一种解读

下雨天留客，天留，我不留

  • 另一种解读

下雨天，留客天，留我不？留

如何设计协议呢？其实就是给网络传输的信息加上“标点符号”。但通过分隔符来断句不是很好，因为分隔符本身如果用于传输，那么必须加以区分。因此，下面一种协议较为常用

定长字节表示内容长度 + 实际内容

以 redis 为例 学习协议

比如我们要向redis中存入一个键值对

命令：set key value

示例：set name zhangsan

redis 协议以*号开头，要使用的一条命令比喻成一个以空格分隔的数组，set命令的数组长度是3，那么要告诉redis我要发送的数组长度是3个(*3)，然后写入内容，数组第一个元素set的长度是3 ($3)，第一个元素的实际内容是set (set)，数组第二个元素的长度是4 ($4)，第二个元素的实际内容是name (name)，数组第三个元素的长度是8 ($8)，数组第三个元素的实际内容是zhangsan (zhangsan)，内容之间要以回车换行进行分隔，组合起来就是以下内容

*3

$3

set

$4

name

$8

zhangsan

redis 示例

启动一个redis服务

Netty进阶-Netty篇_第3张图片

编写客户端，并向redis中set一个键值对

	public static void main(String[] args) throws InterruptedException {
		final byte[] LINE = {13, 10};    // 回车换行
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker)
					.channel(NioSocketChannel.class)
					.handler(new ChannelInitializer() {
						@Override
						protected void initChannel(SocketChannel ch) throws Exception {
							ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
							ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
								/**
								 * 连接成功后，执行此事件
								 */
								@Override
								public void channelActive(ChannelHandlerContext ctx) throws Exception {
									// redis 写
									ByteBuf buf = ctx.alloc().buffer();
									buf.writeBytes("*3".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("$3".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("set".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("$4".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("name".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("$8".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("zhangsan".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									ctx.writeAndFlush(buf);

									// redis 读
									/*buf.writeBytes("*2".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("$3".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("get".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("$4".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									buf.writeBytes("name".getBytes(StandardCharsets.UTF_8));
									buf.writeBytes(LINE);
									ctx.writeAndFlush(buf);*/
								}

								/**
								 * channel 中有消息过来时，此事件读
								 */
								@Override
								public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
									ByteBuf buf = (ByteBuf) msg;
									String s = buf.toString(CharsetUtil.UTF_8);
									System.err.println("返回消息：" + s);
								}
							});
						}
					});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 6379)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}

打印

11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831] REGISTERED
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831] CONNECT: localhost/127.0.0.1:6379
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831, L:/127.0.0.1:62599 - R:localhost/127.0.0.1:6379] ACTIVE
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831, L:/127.0.0.1:62599 - R:localhost/127.0.0.1:6379] WRITE: 37B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 2a 33 0d 0a 24 33 0d 0a 73 65 74 0d 0a 24 34 0d |*3..$3..set..$4.|
|00000010| 0a 6e 61 6d 65 0d 0a 24 38 0d 0a 7a 68 61 6e 67 |.name..$8..zhang|
|00000020| 73 61 6e 0d 0a                                  |san..           |
+--------+-------------------------------------------------+----------------+
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831, L:/127.0.0.1:62599 - R:localhost/127.0.0.1:6379] FLUSH
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831, L:/127.0.0.1:62599 - R:localhost/127.0.0.1:6379] READ: 5B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 2b 4f 4b 0d 0a                                  |+OK..           |
+--------+-------------------------------------------------+----------------+
11:48:28 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0xfc444831, L:/127.0.0.1:62599 - R:localhost/127.0.0.1:6379] READ COMPLETE
返回消息：+OK

效果

Netty进阶-Netty篇_第4张图片

  • http 协议

HttpServerCodec：netty 提供的 http 协议，像上面redis协议一样，如果是我们自己写一套http协议的话，工作量复杂度都还是挺高的。所以netty提供了http协议的编解码handler。此handler是一个组合的即包含入站HttpRequestDecoder，也包含出站HttpResponseEncoder的handler。

服务器端

	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(SocketChannel ch) throws Exception {
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
					// netty 提供的 http 协议的处理器
					ch.pipeline().addLast(new HttpServerCodec());
					/*
					 * 消息经过 http 协议处理器解码后，轮到我们来使用消息，处理相应的业务
					 * SimpleChannelInboundHandler：如果只对特定类型的消息感兴趣，可以使用此handler，泛型传感兴趣的类型，只有符合类型的消息，才会被此handler处理
					 * ChannelInboundHandlerAdapter：处理所有类型的消息
					 */
					ch.pipeline().addLast(new SimpleChannelInboundHandler() {
						@Override
						protected void channelRead0(ChannelHandlerContext ctx, HttpRequest msg) throws Exception {
							log.debug("获取请求头：{}", msg.uri());
							/*
							 * 返回响应
							 * 第一个参数：协议版本
							 * 第二个参数：http响应状态码
							 */
							DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
							byte[] bytes = "Hello, world!".getBytes();

							// 响应内容
							response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, bytes.length);
							response.content().writeBytes(bytes);
							// 写回响应
							ctx.writeAndFlush(response);
						}
					});
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

/ 插播知识点 /

SimpleChannelInboundHandler：如果只对特定类型的消息感兴趣，可以使用此handler，泛型传感兴趣的类型，只有符合类型的消息，才会被此handler处理

客户端

使用浏览器访问：http://localhost:8080

  • 自定义协议

自定义协议要素

  1. 魔数，用来在第一时间判定是否是无效数据包

  2. 版本号，可以支持协议的升级

  3. 序列化算法，消息正文到底采用哪种序列化反序列化方式，可以由此扩展，例如：json、protobuf、hessian、jdk

  4. 指令类型，是登录、注册、单聊、群聊... 跟业务相关

  5. 请求序号，为了双工通信，提供异步能力

  6. 正文长度

  7. 消息正文

示例：

比如我们要定义一个聊天的系统，消息的类型是 抽象的message，不同的消息类型有不同的实现，例如 登录、注册

Message.java  消息体

@Data
public abstract class Message implements Serializable {
	
	/**
	 * 请求序号
	 */
	private int sequenceId;

	/**
	 * 消息类型
	 */
	private int messageType;

	public abstract int getMessageType();

	public static final int LoginRequestMessage = 0;    // 登录的请求消息
	public static final int LoginResponseMessage = 1;    // 登录的响应消息
}

LoginRequestMessage.java  消息体的具体实现

@Data
@ToString(callSuper = true)
public class LoginRequestMessage extends Message {
	/**
	 * 登录账号
	 */
	private String username;
	/**
	 * 登录密码
	 */
	private String password;

	public LoginRequestMessage() {
	}

	public LoginRequestMessage(String username, String password) {
		this.username = username;
		this.password = password;
	}

	@Override
	public int getMessageType() {
		return LoginRequestMessage;
	}
}

MessageCodec.java  自定义消息协议---重点

@Slf4j
public class MessageCodec extends ByteToMessageCodec {

	/**
	 * 自定义消息协议 编码
	 * 消息出站时会调用
	 */
	@Override
	protected void encode(ChannelHandlerContext ctx, Message msg, ByteBuf out) throws Exception {
		// 1. 4个字节的魔数，这里随便定义
		out.writeBytes(new byte[]{1, 2, 3, 4});
		// 2. 1个字节的版本
		out.writeByte(1);
		// 3. 1个字节的序列化方式，0：jdk，1：json
		out.writeByte(0);
		// 4. 1个字节的指令类型
		out.writeByte(msg.getMessageType());
		// 5. 4个字节的请求序号
		out.writeInt(msg.getSequenceId());
		// 对齐 2的n次方倍，填充
		out.writeByte(0xff);
		// 6.0 获取内容的字节数组
		ByteArrayOutputStream bos = new ByteArrayOutputStream();    // 拿到最终的结果
		ObjectOutputStream oos = new ObjectOutputStream(bos);    // 可以把对象转成字节数组
		oos.writeObject(msg);    // 将 msg 消息对象，写入 oos, oos 又写入 bos
		byte[] bytes = bos.toByteArray();
		// 6.1 4个字节的内容长度
		out.writeInt(bytes.length);
		// 7. 写入内容
		out.writeBytes(bytes);
	}

	/**
	 * 自定义消息协议 解码
	 * 消息入站时，会调用
	 */
	@Override
	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception {
		// 1. 获取 4 个字节的魔数
		int magicNum = in.readInt();
		// 2. 获取 1 个字节的版本
		byte version = in.readByte();
		// 3. 获取 1 个字节的序列化方式
		byte serializerType = in.readByte();
		// 4. 获取 1 个字节的 指令类型
		byte messageType = in.readByte();
		// 5. 获取 4 个字节的请求序号
		int sequenceId = in.readInt();
		// 跳过填充的 字节
		in.readByte();
		// 6. 获取 4个字节的内容长度
		int length = in.readInt();
		// 7. 获取实际内容
		byte[] bytes = new byte[length];
		in.readBytes(bytes, 0, length);

		// 把字节流中 转成消息对象
		ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
		Message message = (Message) ois.readObject();
		
		log.debug(" === {}, {}, {},{},{},{}", magicNum, version, serializerType, messageType, sequenceId, length);
		log.debug(" === {}", message);

		out.add(message);    // 解析出来的数据要加入到集合中，不然后续的 handler获取不到消息
	}
}

测试：


	public static void main(String[] args) throws Exception {
		EmbeddedChannel channel = new EmbeddedChannel(
				// 自定义协议也会出现 粘包、半包问题，所以需要使用 LengthFieldBasedFrameDecoder 处理粘包半包
				/*
				 * 参数说明
				 * * * * 第一个参数：消息的最大字节数
				 * * * * 第二个参数：长度在buf中的偏移量，我们看MessageCodec中的消息体中长度之前有多少个字节，长度之前有 4个字节的魔数 1个字节的版本号等 一共12个字节，所以偏移量是12
				 * * * * 第三个参数：长度占用的字节，我写的是一个int类型，占用4个字节
				 * * * * 第四个参数：需要调整的长度，因为我们的数据是要走自己的编解码的，这里的数据都是有用的，所以不需要调整
				 * * * * 第五个参数：数据从开头需要剥离的长度，这里也不需要剥离
				 */
				new LengthFieldBasedFrameDecoder(1024, 12, 4, 0, 0)
				, new LoggingHandler(LogLevel.DEBUG)
				, new MessageCodec());

		// 编码 encode
		LoginRequestMessage message = new LoginRequestMessage("zhangsan", "123");
		channel.writeOutbound(message);    // out 出站，出站时要把消息编码

		// 解码 decode
		ByteBuf buf = ByteBufAllocator.DEFAULT.buffer();
		new MessageCodec().encode(null, message, buf);
		channel.writeInbound(buf);    // in 入站，入站时要把网络消息进行解码
	}


打印：


18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] REGISTERED
18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] ACTIVE
18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] WRITE: 220B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 01 00 00 00 00 00 00 ff 00 00 00 cc |................|
|00000010| ac ed 00 05 73 72 00 2c 63 6f 6d 2e 6c 69 78 78 |....sr.,com.lixx|
|00000020| 2e 64 65 6d 6f 2e 69 6d 2e 6d 65 73 73 61 67 65 |.demo.im.message|
|00000030| 2e 4c 6f 67 69 6e 52 65 71 75 65 73 74 4d 65 73 |.LoginRequestMes|
|00000040| 73 61 67 65 b7 2b d2 02 a3 cf 85 f0 02 00 02 4c |sage.+.........L|
|00000050| 00 08 70 61 73 73 77 6f 72 64 74 00 12 4c 6a 61 |..passwordt..Lja|
|00000060| 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 4c |va/lang/String;L|
|00000070| 00 08 75 73 65 72 6e 61 6d 65 71 00 7e 00 01 78 |..usernameq.~..x|
|00000080| 72 00 18 63 6f 6d 2e 6c 69 78 78 2e 64 65 6d 6f |r..com.lixx.demo|
|00000090| 2e 69 6d 2e 4d 65 73 73 61 67 65 d0 81 67 8f 04 |.im.Message..g..|
|000000a0| 8f b0 3b 02 00 02 49 00 0b 6d 65 73 73 61 67 65 |..;...I..message|
|000000b0| 54 79 70 65 49 00 0a 73 65 71 75 65 6e 63 65 49 |TypeI..sequenceI|
|000000c0| 64 78 70 00 00 00 00 00 00 00 00 74 00 03 31 32 |dxp........t..12|
|000000d0| 33 74 00 08 7a 68 61 6e 67 73 61 6e             |3t..zhangsan    |
+--------+-------------------------------------------------+----------------+
18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] FLUSH
18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ: 220B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 01 00 00 00 00 00 00 ff 00 00 00 cc |................|
|00000010| ac ed 00 05 73 72 00 2c 63 6f 6d 2e 6c 69 78 78 |....sr.,com.lixx|
|00000020| 2e 64 65 6d 6f 2e 69 6d 2e 6d 65 73 73 61 67 65 |.demo.im.message|
|00000030| 2e 4c 6f 67 69 6e 52 65 71 75 65 73 74 4d 65 73 |.LoginRequestMes|
|00000040| 73 61 67 65 b7 2b d2 02 a3 cf 85 f0 02 00 02 4c |sage.+.........L|
|00000050| 00 08 70 61 73 73 77 6f 72 64 74 00 12 4c 6a 61 |..passwordt..Lja|
|00000060| 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 4c |va/lang/String;L|
|00000070| 00 08 75 73 65 72 6e 61 6d 65 71 00 7e 00 01 78 |..usernameq.~..x|
|00000080| 72 00 18 63 6f 6d 2e 6c 69 78 78 2e 64 65 6d 6f |r..com.lixx.demo|
|00000090| 2e 69 6d 2e 4d 65 73 73 61 67 65 d0 81 67 8f 04 |.im.Message..g..|
|000000a0| 8f b0 3b 02 00 02 49 00 0b 6d 65 73 73 61 67 65 |..;...I..message|
|000000b0| 54 79 70 65 49 00 0a 73 65 71 75 65 6e 63 65 49 |TypeI..sequenceI|
|000000c0| 64 78 70 00 00 00 00 00 00 00 00 74 00 03 31 32 |dxp........t..12|
|000000d0| 33 74 00 08 7a 68 61 6e 67 73 61 6e             |3t..zhangsan    |
+--------+-------------------------------------------------+----------------+
18:32:02 [DEBUG] [main] c.l.d.i.MessageCodec -  === 16909060, 1, 0,0,0,204
18:32:02 [DEBUG] [main] c.l.d.i.MessageCodec -  === LoginRequestMessage(super=Message(sequenceId=0, messageType=0), username=zhangsan, password=123)
18:32:02 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ COMPLETE




@Sharable 注解


问：在 netty 的 pipeline 链中有很多 netty 提供的 handler，这些 handler 是否只需要只创建一个对象供其它 channel 共享，如下：


LoggingHandler LOGGING_HANDLER = new LoggingHandler(LogLevel.DEBUG);
......
ch.pipeline().addLast(LOGGING_HANDLER);


答：取决于 netty 提供的 handler 类中是否有注解 @Sharable，有注解的就可以只定义一个对象，没有注解的不可以共享，防止 handler 中 channel 的数据和其它 eventLoop 中的 channel 数据混乱出现多线程情况下结果不是正确值的线程安全问题。


我们自定义的 handler 是否可以被共享，要分析自定义 handler 是否有上一次未解读完的消息被下一次事件 channel 使用的操作，如果没有，就可以被共享。




ChannelInboundHandlerAdapter、SimpleChannelInboundHandler






handlerAdded
handler 添加时触发此事件




channelRegistered
channel 注册时触发此事件




channelActive
channel 连接成功时 活跃




channelRead
channel 可读消息




channelReadComplete
channel 消息读取完成后触发




channelInactive
channel 断开连接时 不活跃




channelUnregistered
channel 注销时触发此事件




handlerRemoved
handler 移除时触发此事件




exceptionCaught
发生异常时触发




channelRead0
channel 关注的可读类型消息




userEventTriggered
触发特殊事件，配合 IdleStateHandler 一起使用








空闲检测-连接假死




原因


    

  •  
    网络设备出现故障，例如网卡，机房等，底层的 TCP 连接已经断开了，但应用程序没有感知到，仍然占用着资源。
     
    • 

  •  
    公网网络不稳定，出现丢包。如果连续出现丢包，这时现象就是客户端数据发不出去，服务端也一直收不到数据，就这么一直耗着
     
    • 

  •  
    应用程序线程阻塞，无法进行数据读写
     
    • 



问题


    

  •  
    假死的连接占用的资源不能自动释放
     
    • 

  •  
    向假死的连接发送数据，得到的反馈是发送超时
     
    • 





服务器端




怎么判断客户端连接是否假死呢？如果能收到客户端数据，说明没有假死。因此策略就可以定为，每隔一段时间就检查这段时间内是否接收到客户端数据，没有就可以判定为连接假死




	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup boss = new NioEventLoopGroup();
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(boss, worker);
			serverBootstrap.channel(NioServerSocketChannel.class);
			serverBootstrap.childHandler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
					/*
					 * 用来判断 读空闲时间和写空闲时间过长
					 * 第一个参数：读空闲时间是否超过指定的秒，超过时间没有收到 channel 的数据，会触发 IdleState#READER_IDLE 事件
					 * 第二个参数：写空闲时间是否超过指定的秒
					 * 第三个参数：读和写空闲时间是否超过指定的秒
					 * 读写时间，写时间一般是 读 时间的 2分之一左右
					 */
					ch.pipeline().addLast(new IdleStateHandler(5, 0, 0));
					// ChannelDuplexHandler：可以同时作为入站和出站处理器
					ch.pipeline().addLast(new ChannelDuplexHandler() {
						// 用来触发特殊事件，配合 IdleStateHandler 一起使用
						@Override
						public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
							IdleStateEvent event = (IdleStateEvent) evt;
							if (event.state() == IdleState.READER_IDLE) {    // 触发了读空闲事件
								log.debug("已经 5s 没有读到数据了");
							}
						}
					});
				}
			});
			ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}


客户端




客户端可以定时向服务器端发送数据，只要这个时间间隔小于服务器定义的空闲检测的时间间隔




	public static void main(String[] args) throws InterruptedException {
		NioEventLoopGroup worker = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(worker);
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.handler(new ChannelInitializer() {
				@Override
				protected void initChannel(NioSocketChannel ch) throws Exception {
					/*
					 * 用来判断 读空闲时间和写空闲时间过长
					 * 第一个参数：读空闲时间是否超过指定的秒
					 * 第二个参数：写空闲时间是否超过指定的秒，超过时间没有向 channel 写数据，会触发 IdleState#WRITER_IDLE 事件
					 * 第三个参数：读和写空闲时间是否超过指定的秒
					 * 读写时间，写时间一般是 读 时间的 2分之一左右
					 */
					ch.pipeline().addLast(new IdleStateHandler(0, 3, 0));
					// ChannelDuplexHandler：可以同时作为入站和出站处理器
					ch.pipeline().addLast(new ChannelDuplexHandler() {
						// 用来触发特殊事件，配合 IdleStateHandler 一起使用
						@Override
						public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
							IdleStateEvent event = (IdleStateEvent) evt;
							if (event.state() == IdleState.WRITER_IDLE) {    // 触发了写空闲事件
								log.debug("已经 3s 没有写数据了, 发送心跳检测包");
								// 发送心跳包
								ByteBuf buf = ctx.alloc().buffer();
								buf.writeByte(1);
								ctx.writeAndFlush(buf);
							}
						}
					});
				}
			});
			ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync();
			channelFuture.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			worker.shutdownGracefully();
		}
	}




参数配置




new ServerBootstrap().option();      // 是给 ServerSocketChannel (服务器端的通道)配置参数
 new ServerBootstrap().childOption(); // 是给 SocketChannel (客户端的通道)配置参数






CONNECT_TIMEOUT_MILLIS：指定的时间未连接上服务器抛异常，单位毫秒


/*
 * 指定的时间未连接上服务器抛异常，默认值30秒，单位毫秒
 * 1：里面是一个定时任务，定时时间到了后会抛出ConnectTimeOutException异常，使用 promise 通知主线程连接超时了（netty 中线程之间的通信使用的是 promise）
 */
Bootstrap bootstrap = new Bootstrap();
bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000);
ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("localhost", 8080)).sync(); // 2. 主线程的 promise 在这里阻塞着等待 连接结果
channelFuture.channel().closeFuture().sync();






SO_TIMEOUT：主要用在阻塞 IO，阻塞 IO 中 accept、read 等都是无限等待的，如果不希望永远阻塞，使用它调整超时时间。在 NIO 中用不到 






SO_BACKLOG：学习这个参数之前要先回顾一下著名的TCP三次握手


    

  1.  
    第一次握手，client 发送 SYN 到 server，状态修改为 SYN_SEND，server 收到，状态改变为 SYN_REVD，并将该请求放入 sync queue 半连接队列
     
    2. 

  2.  
    第二次握手，server 回复 SYN + ACK 给 client，client 收到，状态改变为 ESTABLISHED，并发送 ACK 给 server
     
    3. 

  3.  
    第三次握手，server 收到 ACK，状态改变为 ESTABLISHED，将该请求从 sync queue 放入 accept queue 全连接队列
     
    4. 



其中


    

  •  
    在 linux 2.2 之前，backlog 大小包括了两个队列的大小，在 2.2 之后，分别用下面两个参数来控制
     
    • 

  •  
    sync queue - 半连接队列
    

      

    •  
      大小通过 /proc/sys/net/ipv4/tcp_max_syn_backlog 指定，在 syncookies 启用的情况下，逻辑上没有最大值限制，这个设置便被忽略
       
      • 

    • 

  •  
    accept queue - 全连接队列
    

      

    •  
      其大小通过 /proc/sys/net/core/somaxconn 指定，在使用 listen 函数时，内核会根据传入的 backlog 参数与系统参数，取二者的较小值
       
      • 

    •  
      如果 accpet queue 队列满了，server 将发送一个拒绝连接的错误信息到 client
       
      • 

    • 



我们一般要在机器硬件能力强的情况下把机器的队列调的足够大，代码中通过SO_BACKLOG参数，来实际控制全连接队列的值。需要注意的是队列是在accept有堆积的情况下才会放在队列中。


new ServerBootstrap()
		.group(new NioEventLoopGroup())
		.channel(NioServerSocketChannel.class)
		// Windows 平台默认值200，其他平台默认值128
		.option(ChannelOption.SO_BACKLOG, 1024)
		.bind(8080).sync().channel().closeFuture().sync();






ulimit -n 数量 ：允许同一个进程可以允许同时打开的文件描述符的数量，操作系统的参数






TCP_NODELAY：是否开启 Nagle 算法，false 默认值启用，true 禁用。推荐禁用


new ServerBootstrap()
		.group(new NioEventLoopGroup())
		.channel(NioServerSocketChannel.class)
		// 是否开启 Nagle 算法，false 默认值启用，true 禁用。推荐禁用
		.childOption(ChannelOption.TCP_NODELAY, true)
		.bind(8080).sync().channel().closeFuture().sync();






 SO_SNDBUF & SO_RCVBUF 这两个值建议使用系统默认


    

  •  
    SO_SNDBUF：调整客户端 滑动窗口大小，在建立连接后系统自动设置，netty默认的是1024，属于 SocketChannal 参数
     
    • 

  •  
    SO_RCVBUF：服务器端接收缓冲区大小，单位字节。既可用于 SocketChannal 参数，也可以用于 ServerSocketChannal 参数（建议设置到 ServerSocketChannal 上）
     
    • 







RCVBUF_ALLOCATOR：控制 netty 接收缓冲区大小，负责入站数据的分配，决定入站缓冲区的大小（并可动态调整），统一采用 direct 直接内存，具体池化还是非池化由 allocator 决定






SO_REUSEADDR：快速复用端口，客户端断开连接后，端口会被linux内核占据一段时间，不能马上再次分配该端口，设置此配置为 true 内核会快速释放此端口



























你可能感兴趣的:(netty,netty)






    

  • netty-简易聊天
2401_84046645
程序员java开发语言

    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    

    • 

  • Netty权威指南：Netty总结-高性能与可靠性
Ty_1106
Nettyjava网络rpc

    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    

    • 

  • netty4源码阅读与分析---netty线程模型
红尘之一骑
javaNIOnetty源码阅读与分析

    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    

    • 

  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
快乐非自愿
javaspring

    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    

    • 

  • Java网络编程：IO，NIO与Netty
坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty

    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
    

    • 

  • java reactor模式例子_Netty Reactor模式实现原理详解
weixin_39923623
javareactor模式例子

    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    

    • 

  • Netty实战二-实现UDP的单播和广播(1)
2401_84048671
程序员udp网络协议网络

    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    

    • 

  • netty源码解读三（NioEventLoop）
orcharddd_real
nettyjavanetty

    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    

    • 

  • Netty源码分析:NioEventLoopGroup
HelloWorld_EE
netty源码分析源代码nettyEventLoop

    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    

    • 

  • netty-NioServerSocketChannel和boss NioEventLoopGroup 如何建立关系的
一个人的想法
javanetty

    一、EventLoopGroupbossGroup=newNioEventLoopGroup();EventLoopGroupworkerGroup=newNioEventLoopGroup();1、boss或者workerNioEventLoopGroup初始化完成了一个NioEventLoop数组（默认机器核数的2倍）所有NioEventLoop持有了同一个Executor调用execute时
    

    • 

  • 经验笔记：RPC与高性能NIO框架
漆黑的莫莫
计算机网络笔记rpcnio

    RPC与高性能NIO框架的经验笔记引言随着互联网技术的发展，分布式系统逐渐成为了现代软件架构的标准之一。在这种架构中，服务之间的通信变得尤为关键，而RPC（远程过程调用）作为一种服务间通信的方式，因其简便的使用方式和高效的性能表现而受到了广泛的关注。在实现RPC的过程中，选择合适的网络通信框架至关重要，尤其是那些基于NIO（非阻塞I/O）的高性能框架，如Netty。本文将首先介绍RPC的概念及其在
    

    • 

  • 基础学习之——Netty
北欧人写代码
学习网络服务器

    Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
    

    • 

  • Springboot-websocket实现及底层原理
No.Ada
深入项目底层原理springbootwebsocket后端

    引入依赖SpringBoot中的WebSocket依赖于SpringWebFlux模块，使用了ReactorNetty库来实现底层的WebSocket通信。org.springframework.bootspring-boot-starter-websocket服务端配置/***WebSocket配置类*/@ConfigurationpublicclassWebSocketConfig{/***注
    

    • 

  • 【Netty】实战：基于WebSocket的聊天室
马丁的代码日记
netty聊天室网络websockethttp

    本文将使用Netty快速实现一个聊天室应用，该应用基于WebSocket协议，用户可以在浏览器内聊天。实现过程很简单，就几步。一、处理Http请求packagecn.md.netty.websocket.groupchat;importio.netty.channel.*;importio.netty.handler.codec.http.*;importio.netty.handler.ssl.
    

    • 

  • 精通 Spring Cloud Feign：从理论到实战的通信优化之路
TopicOnline
springcloud

    一、服务间调用的几种方式使用SpringCloud开发微服务时，在服务消费者调用服务提供者时，底层通过HTTPClient的方式访问。但实际上在服务调用时，有主要以下来实现：使用JDK原生的URLConnection；Apache提供的HTTPClient；Netty提供的异步HTTPClient；Spring提供的RestTemplate。SpringCloud的SpringCloudOpenF
    

    • 

  • Dubbo与Netty
蹩脚的小三

    CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
    

    • 

  • netty开发模拟qq斗地主
平平无奇的Coding Peasant
nettyqq斗地主

    为什么要搞这样一个项目满足自己的java网络多线程编程的欲望！因为之前一直都是搞web开发，服务器和客户端数据交流人家web服务器早就给你搞好了，比如tomcat,jetty...等等，其实之前脑子里就有想过--是否可以自己开发一个简单的类似tomcat的web服务器，这样做了的话，至少知道其实web开发是建立在网络多线程web服务器之上否则web开发无从谈起！市面上的书籍和互联网上的电子教材以及
    

    • 

  • Netty 知识目录
王小工
javajava

    Netty知识结构NettyBootstrap/ServerBootstrapNettyEventLoopGroup/EventLoopNettyChannelNettyChannelPipeline/ChannelHandlerNettyByteBufNettyTCPNettyUDPNettyHTTPNettyWebsocketNettySSL/TLS
    

    • 

  • elasticsearch简单介绍
甜美河边的钓鱼人
elasticsearch

    1、elasticsearch简单介绍elasticsearch是基于操作文档的搜索引擎，里面使用了netty，luncen相关技术。它可以用作站内搜索，也可以结合Logstash，kibana等技术进行日志收集分析，使用聚合技术可以进行各种数据的聚合，并且和kibana一起展示条形图，饼图，map地理分布等功能。1.1、elasticsearch的安装因为是练习用的，所以我直接使用windows
    

    • 

  • Netty UDP
王小工
javaudp网络协议网络javanio

    Netty在UDP（用户数据报协议，UserDatagramProtocol）通信中的应用非常广泛，特别是在对实时性要求较高、对数据准确性要求相对较低的场景中，如视频传输、语音通信等。以下是对Netty在UDP通信中的详细解析：一、UDP协议简介UDP是一种无连接的协议，它并不在通信双方之间建立连接，而是直接将数据包从发送端发送到接收端。UDP不保证数据包的可靠传输，也不保证数据包的顺序，因此其传
    

    • 

  • 【四、使用Netty编写UDP应用】
ThinkLess404
Netty网络编程udp网络协议网络

    编写UDP应用目标创建UDPServer创建ServerHandler创建UDP客户端创建客户端的Handler目标之前的章节我们学习了编码服务端，使用TCP通信，本章我们学习如何使用Netty构建一个UDP应用。创建UDPServerpackagecom.coman404.base;importcom.coman404.base.handler.UDPServerHandler;importio
    

    • 

  • linux部署jar项目报错_linux jar 服务
国家级做梦冠军
linux部署jar项目报错

    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    

    • 

  • Spring Cloud全解析：网关之GateWay简介
拾光师
springcloudjava

    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    

    • 

  • Netty+WebSocket实现高并发网络编程
Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议

    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    

    • 

  • Spring Boot 一个极简且完整的后台框架
搬砖养女人
数据库架构javaspringsqltomcat

    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    

    • 

  • netty编程
chenjunxu

    需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
    

    • 

  • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
小小工匠
【SimpleRPC】rpc网络协议网络

    文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
    

    • 

  • 使用Netty实现 WebSocket至Socket的消息转发服务
Leon-aHandler
websocket服务器网络协议nettyspringboot

    业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
    

    • 

  • Netty Websocket
王小工
javawebsocketjavanio

    一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
    

    • 

  • Netty 实现 WebSocket 协议
最业余的程序猿
nettywebsocket网络协议网络

    要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
    

    • 

  • apache ftpserver-CentOS config
gengzg
apache

    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://mina.apache.o
    

    • 

  • 优化MySQL数据库性能的八种方法
AILIKES
sqlmysql

    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    

    • 

  • JeeSite 企业信息化快速开发平台
Kai_Ge
JeeSite

    JeeSite 企业信息化快速开发平台
平台简介
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    

    • 

  • 通过Spring Mail Api发送邮件
120153216
邮件main

    原文地址：http://www.open-open.com/lib/view/open1346857871615.html
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】
Spring Mail API都在org.spri
    

    • 

  • Pysvn 程序员使用指南
2002wmj
SVN

    源文件:http://ju.outofmemory.cn/entry/35762
这是一篇关于pysvn模块的指南.
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html.
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个.
该
    

    • 

  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
357029540
SQL Server

    SELECT  R.session_id AS BlockedSessionID , 
        S.session_id AS BlockingSessionID , 
        Q1.text AS Block
    

    • 

  • Intent 常用的用法备忘
7454103
.netandroidGoogleBlogF#

    Intent
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。
下面列出几种Intent 的用法
显示网页:

    

    • 

  • Spring定时器时间配置
adminjun
spring时间配置定时器

    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />
测试的时候，由于是每天定时执行，所以后面三个数
    

    • 

  • POJ 2421 Constructing Roads 最小生成树
aijuans
最小生成树

    来源：http://poj.org/problem?id=2421
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。
代码：
#include <iostream>
#include <cstdio>
    

    • 

  • 重构笔记——提取方法（Extract Method）
ayaoxinchao
java重构提炼函数局部变量提取方法

    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。
 
下面是我学习这个重构手法的笔记：
 
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    

    • 

  • 为UILabel添加点击事件
bewithme
UILabel

        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。
 
UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    

    • 

  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
bijian1013
redis数据库NoSQL

    一.redis.php
<?php
//实例化
$redis = new Redis();
//连接服务器
$redis->connect("localhost");
//授权
$redis->auth("lamplijie");
//相关操
    

    • 

  • SecureCRT使用备注
bingyingao
secureCRT每页行数

    SecureCRT日志和卷屏行数设置
一、使用securecrt时，设置自动日志记录功能。
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs；
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    

    • 

  • 【Scala九】Scala核心三：泛型
bit1129
scala

    泛型类
package spark.examples.scala.generics
class GenericClass[K, V](val k: K, val v: V) {
def print() {
println(k + "," + v)
}
}
object GenericClass {
def main(args: Arr
    

    • 

  • 素数与音乐
bookjovi
素数数学haskell

        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    

    • 

  • Java-Collections Framework学习与总结-IdentityHashMap
BrokenDreams
Collections

            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。
        简单的说，IdentityHashMap和HashM
    

    • 

  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    

    • 

  • PS人像润饰&调色教程集锦
cherishLC
PS

      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓
http://www.howzhi.com/course/retouching/
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    

    • 

  • 更新多个字段的UPDATE语句
crabdave
update

    更新多个字段的UPDATE语句
 
                
update tableA a
set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围

    

    • 

  • hive实例讲解实现in和not in子句
daizj
hivenot inin

    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    

    • 

  • 一道24点的10+种非人类解法（2,3,10,10）
dsjt
算法

    这是人类算24点的方法？！！！
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。
然后么。。。我就在深夜很得瑟的问室友求室友算
刚出完题，文哥的暴走之旅开始了
5秒后
    

    • 

  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
dcj3sjt126com
yiiframework

    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    

    • 

  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
come_for_dream
对象

    概述
 
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。
 
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    

    • 

  • 学习编程那点事
gcq511120594
编程互联网

    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    

    • 

  • Reverse Linked List II
hcx2013
list

    Reverse a linked list from position m to n. Do it in-place and in one-pass.
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4,
return 
    

    • 

  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
jinnianshilongnian
spring 4.1

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • Hadoop集群工具distcp
liyonghui160com

     
 
1. 环境描述
两个集群：rock 和 stone
rock无kerberos权限认证，stone有要求认证。
1. 从rock复制到stone，采用hdfs
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    

    • 

  • 一个备份MySQL数据库的简单Shell脚本
pda158
mysql脚本

    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　
1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
    

    • 

  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
shoothao
IT资源图标库图片库色彩板字体

    
A. 免费的设计资源
Freebbble:来自于Dribbble的免费的高质量作品。
Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。
Graphic Burger:每个像素点都做得很细的绝佳的设计资源。
Pixel Buddha:免费和优质资源的专业社区。
Premium Pixels:为那些有创意的人提供免费的素材。

    

    • 

  • thrift总结 - 跨语言服务开发
uule
thrift

    官网
官网JAVA例子
thrift入门介绍
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架
Thrift入门及Java实例演示
thrift的使用介绍
 
RPC 
 
POM：
<dependency>
<groupId>org.apache.thrift</groupId>

    

    •