Netty4实战第十三章:使用UDP

本章主要内容:

  • 学习UDP协议
  • 学习Netty对UDP的支持
  • 启动UDP协议的Netty应用
  前面学习的例子都是基于连接的协议,如TCP。这一章我们重点学习UDP。UDP是一种无连接的协议,主要适用于高性能且丢部分包不是问题的场景。基于UDP协议的应用有一个著名的例子,就是DNS域名解析服务。
  由于Netty提供了统一的API,所以无论使用的是TCP还是UDP,大部分API都是一样的。你也可以重用你实现的ChannelHandler或者其他基于Netty的实现。
  学习完本章之后,你会对无连接协议会有一个基本的了解,特别是UDP,并且你也能知道什么样的场景适合使用UDP协议。
  本章的大部分知识比较独立,也就是说你没有学习前面的章节,也能看懂大部分本章的内容。因为本章已经涵盖了基于Netty的UDP的应用的大部分知识,而且不会对前面提到过的知识过多的深入讲解。只要知道一些基本的Netty API,学习本章就是没问题的。

一、了解UDP

  在实际开发应用之前,我们需要先花一些时间来学习UDP协议,因为在使用它之前,我们至少得了解它是什么,它能干什么以及它的优点和缺点。
  前面说过,UDP是无连接的协议,也就是说在客户端和服务端使用UDP通信的过程中是没有连接的,所以很难说这个消息属于哪个连接。
  UDP的一个限制就是没有像TCP那样的纠错能力。TCP协议中发送端发送一个包之后,接收端会返回一个消息表示我收到了这个包,当发送端没收到接收端的确认信息时发送端就会重发这个包。UDP就不是这样的,UDP发送包之后立即就不管了,继续发送下面的包,所以UDP的发送端并不知道接收端有没有收到包,也就是说UDP只管发,接收端收没收到就是不是它的事了。
  所以,UDP很适合那些数据量大但是丢包又对应用无太大影响的应用情况,例如视频类应用。当然,如果数据准确性很高,消息不能丢失类型的应用是绝对不能使用UDP的,这种情况应该使用TCP类协议,例如金钱交易类型的应用。

二、设计UDP应用

  接下来的章节我们会开发一个UDP应用,主要逻辑就是通过UDP将数据转发给其他客户端。这个应用的主要功能就是监测一个文件,通过UDP转发新增的行内容。

  如果你很数据类UNIX系统,则会很熟悉这个功能,和Syslog的功能很像。

  UDP协议很适合这种类型应用,因为你即使丢失几行数据没有转发,也不会对应用产生致命影响。最重要的是,日志量很大时,需要靠UDP这种高性能的协议来达到应用需求。

  这个应用的另一个特点是,新增一个文件监视器不需要额外的操作。只需要启动一个实例,然后指定端口就可以看到文件内容了。不过有时候这也不一定是好事,只要能启动实例就能获取到内容了,相对来说有一些不安全。所以一般UDP广播数据时都是在安全的内网环境中使用。另外一般广播数据的服务端和客户端都在同一个网络环境中,一旦夸网络经过路由,可能就会被拦截掉,防火墙会误判。这种模式一般被成为“发布-订阅”模式,服务端发布数据,一个或多个客户端订阅数据。

  写代码之前,先看看应用的基本结构。


  这个应用主要由两部分组成。其中一个用来监测文件内容,一般就是一个实例,类似服务端;另一个事件监测器用来获取服务端转发的文件内容,由一个或多个实例组成。

  为了节省时间,实际项目中的安全验证、过滤等功能就不再这里说了。

  如果你觉得这个应用还不错,某些代码很适合你,你可以适当调整满足自己的需求。得益于Netty的设计,逻辑分散,统一的API,所以修改起来还是很容易的。

  后面还会介绍一些UDP的基础知识,来看看它和基于TCP的应用的不同。

三、EventLog对象

  大家如果编写过其他类型的应用,特别是使用面向对象的语言的时候,如C++、JAVA,会定义很多对象来保存传输的消息类容。所以这个应用的EventLog也可以理解成消息对象。它会在客户端与服务端之间分享,存储数据,并生成日志文件。

package com.nan.netty.udp;

import java.net.InetSocketAddress;

public final class LogEvent {

    public static final byte SEPARATOR = (byte) ':';
    //发送方地址
    private final InetSocketAddress source;
    //文件名称
    private final String logfile;
    //实际消息内容
    private final String msg;
    //发送数据的时间戳
    private final long received;

    public LogEvent(String logfile, String msg) {
        this(null, -1, logfile, msg);
    }

    public LogEvent(InetSocketAddress source, long received,
                    String logfile, String msg) {
        this.source = source;
        this.logfile = logfile;
        this.msg = msg;
        this.received = received;
    }

    public InetSocketAddress getSource() {
        return source;
    }

    public String getLogfile() {
        return logfile;
    }

    public String getMsg() {
        return msg;
    }

    public long getReceivedTimestamp() {
        return received;
    }
}

  定义好了这个消息实体,下一步该实现具体的逻辑了。下一小节我们就开始编写Broadcaster,并了解这个Broadcaster是如何工作的。

四、编写Broadcaster

  这个应用的核心就是广播消息,所以我们的重点就是广播。而广播的消息就是通过DatagramPacket包装。


  从上图可以看出,每一条消息都对应一个DatagramPacket。基本上所有基于Netty的应用都会包含一个或多个ChannelHandler通过启动器配置到Channel中。我们来看看这个应用的ChannelPipeline的基本结构。


  LogEventBroadcaster将数据放到LogEvent中并通过Channel发送出去。也就是说消息都封装在了LogEvent中,然后通过Channel发送给客户端。

  在ChannelPipeline中,LogEvent消息会被编码成DatagramPacket消息,最终通过UDP发送出去的就是这个DatagramPacket。

  所以这里我们需要自定义一个ChannelHandler,用来将LogEvent编码成DatagramPacket,通过前面的知识,这个编码还是很容易编写的。因为这里其实是两个对象转换,所以使用MessageToMessageEncoder比较适合。

package com.nan.netty.udp;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.socket.DatagramPacket;
import io.netty.handler.codec.MessageToMessageEncoder;
import io.netty.util.CharsetUtil;

import java.net.InetSocketAddress;
import java.util.List;

public class LogEventEncoder extends MessageToMessageEncoder<LogEvent> {

    private final InetSocketAddress remoteAddress;

    public LogEventEncoder(InetSocketAddress remoteAddress) {
        this.remoteAddress = remoteAddress;
    }

    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, LogEvent logEvent, List<Object> out)
            throws Exception {
        ByteBuf buf = channelHandlerContext.alloc().buffer();
        //文件名称写到ByteBuf中
        buf.writeBytes(logEvent.getLogfile().getBytes(CharsetUtil.UTF_8));
        //分割字符
        buf.writeByte(LogEvent.SEPARATOR);
        //实际文件内容
        buf.writeBytes(logEvent.getMsg().getBytes(CharsetUtil.UTF_8));
        //创建DatagramPacket实例并添加到结果列表
        out.add(new DatagramPacket(buf, remoteAddress));
    }
}

  接下来就可以编写启动器,包括Channel的配置,连接的配置等。

package com.nan.netty.udp;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.InetSocketAddress;

public class LogEventBroadcaster {
    private final EventLoopGroup group;
    private final Bootstrap bootstrap;
    private final File file;

    public LogEventBroadcaster(InetSocketAddress address, File file) {
        group = new NioEventLoopGroup();
        bootstrap = new Bootstrap();
        //这里使用NioDatagramChannel,因为是广播地址所以下面的SO_BROADCAST属性要设置为true
        bootstrap.group(group)
                .channel(NioDatagramChannel.class)
                .option(ChannelOption.SO_BROADCAST, true)
                .handler(new LogEventEncoder(address));
        this.file = file;
    }

    public void run() throws IOException {
        Channel ch = bootstrap.bind(0).syncUninterruptibly().channel();
        long pointer = 0;
        while (true) {
            long len = file.length();
            if (len < pointer) {
                pointer = len;
            } else if (len > pointer) {
                //长度大于上一次读取的位置,则说明文件增加了内容
                RandomAccessFile raf = new RandomAccessFile(file, "r");
                raf.seek(pointer);
                String line;
                while ((line = raf.readLine()) != null) {
                    ch.writeAndFlush(new LogEvent(null, -1, file.getName(), line));
                }
                pointer = raf.getFilePointer();
                raf.close();
            }
            try {
                //每个1秒检查一次文件内容

                Thread.sleep(1000);
            } catch (Exception e) {
                Thread.interrupted();
                break;
            }
        }
    }

    public void stop() {
        group.shutdownGracefully();
    }

    public static void main(String[] args) throws Exception {
        int port = 9090;
        LogEventBroadcaster broadcaster = new LogEventBroadcaster(new InetSocketAddress("255.255.255.255", port),
                new File("C:/Users/wangj/Desktop/udp.txt"));
        try {
            broadcaster.run();
        } finally {
            broadcaster.stop();
        }
    }
}

  这里我们完成了我们应用的第一部分。虽然没完成全部应用,但是我们还是有办法看看我们第一部分的结果是否正确。这里我们需要用到一个工具Netcat。一般的类UNIX系统都自带有此工具,没有的话也可以很容易安装。因为我这里用的是Windows系统,所以我这里使用的是Windows版的Netcat。需要此工具的可以访问这个地址下载,解压就可以直接使用了。

  解压Netcat工具后,在命令行窗口使用如下命令。

nc -l -u -p 9090

  意思是使用UDP协议监听9090端口,然后启动我们的LogEventBroadcaster,在监测文件里面输入内容并保存,就可以在命令行窗口看到转发的内容,例如我的实验结果如下图。


五、开发监视器程序

  上面我们完成了我们应用的第一部分,并且使用Netcat工具验证了结果。接下来我们开始开发监视器端程序EventLogMonitor,也可以理解成客户端。

  EventLogMonitor主要干以下几件事情:

  • LogEventBroadcaster那里收到DatagramPacket数据包
  • DatagramPacket解码成LogEvent消息
  • 打印LogEvent里面的内容
  很明显,我们需要实现自定义的ChannelHandler。我们先来设计下LogEventMonitor里面的ChannelPipeline的结构。


  从上图可以看出,我们需要实现两个ChannelHandler。第一个需要实现的是LogEventDecoder,它的作用是将收到的DatagramPacket包转成LogEvent对象。大部分Netty应用收到数据收都会有这个转化ChannelHandler。

package com.nan.netty.udp;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.socket.DatagramPacket;
import io.netty.handler.codec.MessageToMessageDecoder;
import io.netty.util.CharsetUtil;

import java.util.List;

public class LogEventDecoder extends MessageToMessageDecoder<DatagramPacket> {
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, DatagramPacket datagramPacket, List<Object> out)
            throws Exception {
        //得到DatagramPacket数据内容
        ByteBuf data = datagramPacket.content();
        //获取分隔符位置
        int i = data.indexOf(0, data.readableBytes() - 1, LogEvent.SEPARATOR);
        if (i < 0) {
            //没找到分隔符,脏数据或者空行
            return;
        }
        //分隔符前面是文件内容
        String filename = data.slice(0, i).toString(CharsetUtil.UTF_8);
        //分隔符后面是实际消息数据
        String logMsg = data.slice(i + 1, data.readableBytes() - i - 1).toString(CharsetUtil.UTF_8);
        //创建LogEvent实例
        LogEvent event = new LogEvent(datagramPacket.sender(), System.currentTimeMillis(), filename, logMsg);
        out.add(event);
    }
}

  将收到的数据解码成LogEvent后,我们还需要一个ChannelHandler去处理LogEvent。这个例子中我们只是简单的将数据打印到标准输出中。在实际项目中,一般会将数据存储到数据库,保存到文件中,或者其他方式处理。

package com.nan.netty.udp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class LogEventHandler extends SimpleChannelInboundHandler<LogEvent> {

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, LogEvent event) throws Exception {
        StringBuilder builder = new StringBuilder();
        builder.append(event.getReceivedTimestamp());
        builder.append(" [");
        builder.append(event.getSource().toString());
        builder.append("] [");
        builder.append(event.getLogfile());
        builder.append("] : ");
        builder.append(event.getMsg());
        //打印收到的消息内容
        System.err.println(builder.toString());
    }
}
  这里主要打印了消息接收时间、发送端地址、文件名称以及实际内容。

  ChannelHandler都已经开发完成了,现在就可以写启动器来配置ChannelPipeline。

package com.nan.netty.udp;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;

import java.net.InetSocketAddress;

public class LogEventMonitor {

    private final EventLoopGroup group;
    private final Bootstrap bootstrap;

    public LogEventMonitor(InetSocketAddress address) {
        group = new NioEventLoopGroup();
        bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioDatagramChannel.class)
                .option(ChannelOption.SO_BROADCAST, true)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel channel) throws Exception {
                        ChannelPipeline pipeline = channel.pipeline();
                        pipeline.addLast(new LogEventDecoder());
                        pipeline.addLast(new LogEventHandler());
                    }
                }).localAddress(address);
    }

    public Channel bind() {
        return bootstrap.bind().syncUninterruptibly().channel();
    }

    public void stop() {
        group.shutdownGracefully();
    }

    public static void main(String[] main) throws Exception {
        LogEventMonitor monitor = new LogEventMonitor(new InetSocketAddress(9090));
        try {
            Channel channel = monitor.bind();
            System.out.println("LogEventMonitor running");
            channel.closeFuture().await();
        } finally {
            monitor.stop();
        }
    }
}
  现在不使用Netcat工具,直接使用我们编写的LogEventBroadcaster和LogEventMonitor配合验证,也可以得到想要的结果。


六、总结

  本章我们主要学习了如何编写基于Netty的UDP协议程序,使用起来和TCP的程序没多大区别,因为它们使用了统一的API。本章还进一步学习了如何实现自己的ChannelHandler,并添加到ChannelPipeline。并且我们划分了逻辑,将传送对象转成我们应用对象分成一部分,处理应用对象又是一部分。

  这一章我们也了解了什么是无连接协议,例如UDP协议,知道了它的优缺点,我们就知道在实际工作中改如何选择了。

  后面的章节我们会学习Netty一些高级知识和特性,算是深入到Netty内部,所以大家不要错过哦。

  


评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值