1. UDP是一个无连接协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。
2. 由于传输数据不建立连接，因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。
3. UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很小。
4. 吞吐量不受拥挤控制算法的调节，只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制。
5. UDP使用尽最大努力交付，即不保证可靠交付，因此主机不需要维持复杂的链接状态表（这里面有许多参数）。
6. UDP是面向报文的。发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付给IP层。既不拆分，也不合并，而是保留这些报文的边界，因此，应用程序需要选择合适的报文大小。

本章UDP程序例子的示意图入如下：

13.3 日志事件POJO

13.4 编写广播器

        我们要做的是广播一个DatagramPacket日志条目，如下图所示：

        上图显示我们有一个从日志条路到DatagramPacket一对一的关系。如同所有的基于Netty的应用程序一样，它由一个或多个ChannelHandler和一些实体对象绑定，用于引导该应用程序。首先让我们来看看LogEventBroadcaster的ChannelPipeline以及作为数据载体的LogEvent的流向，看下图：

        上图显示，LogEventBroadcaster使用LogEvent消息并将消息写入本地Channel，所有的信息封装在LogEvent消息中，这些消息被传到ChannelPipeline中。流进ChannelPipeline的LogEvent消息被编码成DatagramPacket消息，最后通过UDP广播到远程对等通道。

        这可以归结为有一个自定义的ChannelHandler，从LogEvent消息编程成DatagramPacket消息。回忆我们在第七章讲解的编解码器，我们定义个LogEventEncoder，代码如下：

[java] view plain copy

1. package netty.in.action.udp;
3. import io.netty.buffer.ByteBuf;
4. import io.netty.channel.ChannelHandlerContext;
5. import io.netty.channel.socket.DatagramPacket;
6. import io.netty.handler.codec.MessageToMessageEncoder;
7. import io.netty.util.CharsetUtil;
9. import java.net.InetSocketAddress;
10. import java.util.List;
12. public class LogEventEncoder extends MessageToMessageEncoder<LogEvent> {
14.     private final InetSocketAddress remoteAddress;
16.     public LogEventEncoder(InetSocketAddress remoteAddress){
17.         this.remoteAddress = remoteAddress;
18.     }
20.     @Override
21.     protected void encode(ChannelHandlerContext ctx, LogEvent msg, List<Object> out)
22.             throws Exception {
23.         ByteBuf buf = ctx.alloc().buffer();
24.         buf.writeBytes(msg.getLogfile().getBytes(CharsetUtil.UTF_8));
25.         buf.writeByte(LogEvent.SEPARATOR);
26.         buf.writeBytes(msg.getMsg().getBytes(CharsetUtil.UTF_8));
27.         out.add(new DatagramPacket(buf, remoteAddress));
28.     }
30. }

下面我们再编写一个广播器：

[java] view plain copy

1. package netty.in.action.udp;
3. import io.netty.bootstrap.Bootstrap;
4. import io.netty.channel.Channel;
5. import io.netty.channel.ChannelOption;
6. import io.netty.channel.EventLoopGroup;
7. import io.netty.channel.nio.NioEventLoopGroup;
8. import io.netty.channel.socket.nio.NioDatagramChannel;
10. import java.io.File;
11. import java.io.IOException;
12. import java.io.RandomAccessFile;
13. import java.net.InetSocketAddress;
15. public class LogEventBroadcaster {
17.     private final EventLoopGroup group;
18.     private final Bootstrap bootstrap;
19.     private final File file;
21.     public LogEventBroadcaster(InetSocketAddress address, File file) {
22.         group = new NioEventLoopGroup();
23.         bootstrap = new Bootstrap();
24.         bootstrap.group(group).channel(NioDatagramChannel.class)
25.                 .option(ChannelOption.SO_BROADCAST, true)
26.                 .handler(new LogEventEncoder(address));
27.         this.file = file;
28.     }
30.     public void run() throws IOException {
31.         Channel ch = bootstrap.bind(0).syncUninterruptibly().channel();
32.         long pointer = 0;
33.         for (;;) {
34.             long len = file.length();
35.             if (len < pointer) {
36.                 pointer = len;
37.             } else {
38.                 RandomAccessFile raf = new RandomAccessFile(file, "r");
39.                 raf.seek(pointer);
40.                 String line;
41.                 while ((line = raf.readLine()) != null) {
42.                     ch.write(new LogEvent(null, -1, file.getAbsolutePath(), line));
43.                 }
44.                 ch.flush();
45.                 pointer = raf.getFilePointer();
46.                 raf.close();
47.             }
48.             try {
49.                 Thread.sleep(1000);
50.             } catch (InterruptedException e) {
51.                 Thread.interrupted();
52.                 break;
53.             }
54.         }
55.     }
57.     public void stop() {
58.         group.shutdownGracefully();
59.     }
61.     public static void main(String[] args) throws Exception {
62.         int port = 4096;
63.         String path = System.getProperty("user.dir") + "/log.txt";
64.         LogEventBroadcaster broadcaster = new LogEventBroadcaster(new InetSocketAddress(
65.                 "255.255.255.255", port), new File(path));
66.         try {
67.             broadcaster.run();
68.         } finally {
69.             broadcaster.stop();
70.         }
71.     }
73. }

13.5 编写监听者

        这一节我们编写一个监听者：EventLogMonitor，也就是用来接收数据的程序。EventLogMonitor做下面事情：

• 接收LogEventBroadcaster广播的DatagramPacket
• 解码LogEvent消息
• 输出LogEvent

EventLogMonitor的示意图如下：

解码器代码如下：

[java] view plain copy

1. package netty.in.action.udp;
3. import io.netty.buffer.ByteBuf;
4. import io.netty.channel.ChannelHandlerContext;
5. import io.netty.channel.socket.DatagramPacket;
6. import io.netty.handler.codec.MessageToMessageDecoder;
7. import io.netty.util.CharsetUtil;
9. import java.util.List;
11. public class LogEventDecoder extends MessageToMessageDecoder<DatagramPacket> {
13.     @Override
14.     protected void decode(ChannelHandlerContext ctx, DatagramPacket msg, List<Object> out)
15.             throws Exception {
16.         ByteBuf buf = msg.content();
17.         int i = buf.indexOf(0, buf.readableBytes(), LogEvent.SEPARATOR);
18.         String filename = buf.slice(0, i).toString(CharsetUtil.UTF_8);
19.         String logMsg = buf.slice(i + 1, buf.readableBytes()).toString(CharsetUtil.UTF_8);
20.         LogEvent event = new LogEvent(msg.sender(),
21.                 System.currentTimeMillis(), filename, logMsg);
22.         out.add(event);
23.     }
25. }

处理消息的Handler代码如下：

[java] view plain copy

1. package netty.in.action.udp;
3. import io.netty.channel.ChannelHandlerContext;
4. import io.netty.channel.SimpleChannelInboundHandler;
6. public class LogEventHandler extends SimpleChannelInboundHandler<LogEvent> {
8.     @Override
9.     protected void channelRead0(ChannelHandlerContext ctx, LogEvent msg) throws Exception {
10.         StringBuilder builder = new StringBuilder();
11.         builder.append(msg.getReceived());
12.         builder.append(" [");
13.         builder.append(msg.getSource().toString());
14.         builder.append("] [");
15.         builder.append(msg.getLogfile());
16.         builder.append("] : ");
17.         builder.append(msg.getMsg());
18.         System.out.println(builder.toString());
19.     }
20. }

EventLogMonitor代码如下：

[java] view plain copy

1. package netty.in.action.udp;
3. import io.netty.bootstrap.Bootstrap;
4. import io.netty.channel.Channel;
5. import io.netty.channel.ChannelInitializer;
6. import io.netty.channel.ChannelOption;
7. import io.netty.channel.ChannelPipeline;
8. import io.netty.channel.EventLoopGroup;
9. import io.netty.channel.nio.NioEventLoopGroup;
10. import io.netty.channel.socket.nio.NioDatagramChannel;
12. import java.net.InetSocketAddress;
14. public class LogEventMonitor {
16.     private final EventLoopGroup group;
17.     private final Bootstrap bootstrap;
19.     public LogEventMonitor(InetSocketAddress address) {
20.         group = new NioEventLoopGroup();
21.         bootstrap = new Bootstrap();
22.         bootstrap.group(group).channel(NioDatagramChannel.class)
23.                 .option(ChannelOption.SO_BROADCAST, true)
24.                 .handler(new ChannelInitializer<Channel>() {
25.                     @Override
26.                     protected void initChannel(Channel channel) throws Exception {
27.                         ChannelPipeline pipeline = channel.pipeline();
28.                         pipeline.addLast(new LogEventDecoder());
29.                         pipeline.addLast(new LogEventHandler());
30.                     }
31.                 }).localAddress(address);
32.     }
34.     public Channel bind() {
35.         return bootstrap.bind().syncUninterruptibly().channel();
36.     }
38.     public void stop() {
39.         group.shutdownGracefully();
40.     }
42.     public static void main(String[] args) throws InterruptedException {
44.         LogEventMonitor monitor = new LogEventMonitor(new InetSocketAddress(4096));
45.         try {
46.             Channel channel = monitor.bind();
47.             System.out.println("LogEventMonitor running");
48.             channel.closeFuture().sync();
49.         } finally {
50.             monitor.stop();
51.         }
52.     }
53. }

13.6 使用LogEventBroadcaster和LogEventMonitor

        为避免LogEventMonitor接收不到数据，我们必须先启动LogEventMonitor后，再启动LogEventBroadcaster，输出内容这么就不贴图了，读者可以自己运营本例子测试。

13.7 Summary

        本章依然没按照原书中的来翻译，主要是以一个例子来说明UDP在Netty中的使用。概念性的东西都是从网上复制的，读者只需要了解UDP的概念再了解清楚例子代码的含义，并试着运行一些例子。