java中模拟UDP发包

原始数据是从Linux服务器上特定端口抓取的采集卡发送给服务器的UDP包，在Linux上以pcap文件进行存储，我们使用java模拟采集卡发包的方式把这些文件里的数据等于是再发送一遍。
看代码：
先导包：

<dependency>
  <groupId>io.pkts</groupId>
  <artifactId>pkts-core</artifactId>
  <version>3.0.7</version>
</dependency>

public static void main(String[] args) throws IOException, InterruptedException {
    	String path = "D:\\360MoveData\\Users\\Administrator\\Desktop\\abis";
    	String hostName = "127.0.0.1";
    	int port = 40000;
        File files = new File(path);
        File[] fs = files.listFiles();
            for (File f : fs) {
                System.out.println("pcap文件" + f + "发往" + hostName + ":" + port);
                Thread.sleep(1000);
                System.out.println("开始发送UDP");
                PcapParser.parser(f, hostName, port);
            }
            System.out.println("----------------------发送完毕-----------------------");
    }

public class PcapParser {
    private static Logger logger = LoggerFactory.getLogger(PcapParser.class);

    public static void parser(File file, final String hostName, final int port) throws IOException {
        final Pcap pcap = Pcap.openStream(file);

        pcap.loop(new PacketHandler() {
            @Override
            public boolean nextPacket(final Packet packet) throws IOException {
                if (packet.hasProtocol(Protocol.IPv4)) {
                    IPPacket ipv4 = (IPPacket) packet.getPacket(Protocol.IPv4);
                    if (ipv4.hasProtocol(Protocol.UDP)) {
                        TransportPacket udpPacket = (TransportPacket) ipv4.getPacket((Protocol.UDP));
                            if (udpPacket.getPayload() != null) {
                                try {
                                    Thread.sleep(10);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                UdpSend.send(hostName, port, udpPacket.getPayload().getArray());
                            }
                    }
                }

                return true;
            }
        });
    }

    public static String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
            stringBuilder.append(" ");
        }
        return stringBuilder.toString();
    }
}

public class UdpSend {
    private static Logger logger = LoggerFactory.getLogger(UdpSend.class);

    public static void send(String hostName, int port, byte[] data) throws IOException {
        UdpSend.logger.info(Arrays.toString(data));
        /*
         * 实现UDP协议的发送端：
         *     实现封装数据的类 java.net.DatagramPacket 将你的数据包装
         *     实现数据传输类    java.net.DatagramSocket 将数据包发出去
         *
         *    实现步骤：
         *        1.创建DatagramPacket对象，封装数据，接收的地址和端口
         *        2.创建DatagramSocket对象，
         *        3.调用DatagramSocket类的方法send，发送数据包
         *        4.关闭资源
         *
         *    DatagramPacket构造方法：
         *        DatagramPacket(byte[] buf,int length,InetAddress address,int port)
         *
         *    DatagramSocket构造方法：
         *        DatagramSocket()空参数
         *        方法：send(DatagramPacket d)
         *
         *
         */

        //创建数据包对象，封装要发送的数据，接受端IP,端口
        //创建InetAddress对象，封装自己的IP地址
        InetSocketAddress net = new InetSocketAddress(hostName, port);
        DatagramPacket packet = new DatagramPacket(data, data.length, net);
        //创建DatagramSocket对象，数据包的发送和接受对象
        DatagramSocket socket = new DatagramSocket();
        //调用ds对象的方法send，发送数据包
        socket.send(packet);
        socket.close();
    }
}