Java之UDP编程基础

一, 基础

1，接收端代码

package net.ittimeline.java.network.socket.udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * 接收端
 * 1， 使用DatagramSocket 指定端口 创建接受端
 * 2， 准备容器 封装成DatagramPacket包裹
 * 3， 阻塞式接收包裹 receive(DatagramPacket p)
 * 4， 分析数据
 *      byte[] getData()
 *             getLength()
 * 5,  释放资源
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");
        //1， 使用DatagramSocket 指定端口 创建接受端
        DatagramSocket server = new DatagramSocket(9999);
        //2， 准备容器 封装成DatagramPacket包裹
        byte[] container = new byte[1024 * 60];
        DatagramPacket packet = new DatagramPacket(container, 0,container.length);
        //3， 阻塞式接收包裹 receive(DatagramPacket p)
        server.receive(packet);
        //4， 分析数据
        byte[] datas = packet.getData();
        System.out.println(new String(datas,0,datas.length));
        //5， 释放资源
        server.close();
    }
}

2，发送端代码

package net.ittimeline.java.network.socket.udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/**
 * 发送端
 * 1， 使用DatagramSocket 指定端口 创建发送端
 * 2， 准备数据 一定要转成字节数组
 * 3， 封装成DatagramPacket包裹，需要指定目的地
 * 4， 发送包裹 send(DatagramPacket)
 * 5,  释放资源
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("UDP 发送发启动中");
        //1， 使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client = new DatagramSocket(8888);
        //2， 准备数据 一定要转成字节数组
        String data = "Java UDP Study";
        byte[] datas = data.getBytes("UTF-8");
        //3， 封装成DatagramPacket包裹，需要指定目的地
        DatagramPacket packet = new DatagramPacket(
                datas,
                0,
                datas.length,
                new InetSocketAddress("localhost",9999)
        );
        //4， 发送包裹 send(DatagramPacket p)
        client.send(packet);
        //5,  释放资源
        client.close();
    }
}

3，结果

二，操作基础类型

1，接收端代码

package net.ittimeline.java.network.socket.udp;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * 接收端
 * 1， 使用DatagramSocket 指定端口 创建接受端
 * 2， 准备容器 封装成DatagramPacket包裹
 * 3， 阻塞式接收包裹 receive(DatagramPacket p)
 * 4， 分析数据
 *      byte[] getData()
 *             getLength()
 * 5,  释放资源
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");
        //1， 使用DatagramSocket 指定端口 创建接受端
        DatagramSocket server = new DatagramSocket(9999);
        //2， 准备容器 封装成DatagramPacket包裹
        byte[] container = new byte[1024 * 60];
        DatagramPacket packet = new DatagramPacket(container, 0,container.length);
        //3， 阻塞式接收包裹 receive(DatagramPacket p)
        server.receive(packet);
        //4， 分析数据
        byte[] datas = packet.getData();
        DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
        String msg = dis.readUTF();
        int age = dis.readInt();
        System.out.println("msg : " + msg + " age : " + age);
        //5， 释放资源
        server.close();
    }
}

2，发送端代码

package net.ittimeline.java.network.socket.udp;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * 发送端
 * 1， 使用DatagramSocket 指定端口 创建发送端
 * 2， 准备数据 一定要转成字节数组
 * 3， 封装成DatagramPacket包裹，需要指定目的地
 * 4， 发送包裹 send(DatagramPacket p)
 * 5,  释放资源
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("UDP 发送发启动中");
        //1， 使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client = new DatagramSocket(8888);
        //2， 准备数据 一定要转成字节数组
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(baos));
        //操作基本数据
        dos.writeUTF("Hello World!");
        dos.writeInt(18);
        dos.flush();
        byte[] datas = baos.toByteArray();
        //3， 封装成DatagramPacket包裹，需要指定目的地
        DatagramPacket packet = new DatagramPacket(
                datas,
                0,
                datas.length,
                new InetSocketAddress("localhost",9999)
        );
        //4， 发送包裹 send(DatagramPacket p)
        client.send(packet);
        //5,  释放资源
        client.close();
    }
}

3，结果

三， 操作引用类型

1， 接收端代码

package net.ittimeline.java.network.socket.udp;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * 接收端
 * 1， 使用DatagramSocket 指定端口 创建接受端
 * 2， 准备容器 封装成DatagramPacket包裹
 * 3， 阻塞式接收包裹 receive(DatagramPacket p)
 * 4， 分析数据
 *      byte[] getData()
 *             getLength()
 * 5,  释放资源
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");
        //1， 使用DatagramSocket 指定端口 创建接受端
        DatagramSocket server = new DatagramSocket(9999);
        //2， 准备容器 封装成DatagramPacket包裹
        byte[] container = new byte[1024 * 60];
        DatagramPacket packet = new DatagramPacket(container, 0,container.length);
        //3， 阻塞式接收包裹 receive(DatagramPacket p)
        server.receive(packet);
        //4， 分析数据
        byte[] datas = packet.getData();
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
        Object userObj = ois.readObject();
        //反序列化
        if(userObj instanceof User) {
            User user = (User) userObj;
            System.out.println("User name: " + user.getName() + " age: " + user.getAge());
        }
        //5， 释放资源
        server.close();
    }
}

2， 发送端代码

package net.ittimeline.java.network.socket.udp;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.DoubleSummaryStatistics;

/**
 * 发送端
 * 1， 使用DatagramSocket 指定端口 创建发送端
 * 2， 准备数据 一定要转成字节数组
 * 3， 封装成DatagramPacket包裹，需要指定目的地
 * 4， 发送包裹 send(DatagramPacket p)
 * 5,  释放资源
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("UDP 发送发启动中");
        //1， 使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client = new DatagramSocket(8888);
        //2， 准备数据 一定要转成字节数组
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(baos));
        /* 可以操作基本的数据类型
        oos.writeUTF("Hello World!");
        oos.writeInt(18);
        oos.writeObject("Heee");
        oos.flush();
        */
        User user = new User("123456", "Snow", (short)18);
        oos.writeObject(user);
        oos.flush();
        byte[] datas = baos.toByteArray();
        //3， 封装成DatagramPacket包裹，需要指定目的地
        DatagramPacket packet = new DatagramPacket(
                datas,
                0,
                datas.length,
                new InetSocketAddress("localhost",9999)
        );
        //4， 发送包裹 send(DatagramPacket p)
        client.send(packet);
        //5,  释放资源
        client.close();
    }
}

3， 结果

4， User类代码

package net.ittimeline.java.network.socket.udp;

public class User implements java.io.Serializable{
    /**该数据不需要序列化*/
    private transient String password;
    private String name;
    private Short age;

    public User(String password, String name, Short age) {
        this.password = password;
        this.name = name;
        this.age = age;
    }

    public String getPassword() {
        return password;
    }
    public String getName() {
        return name;
    }
    public Short getAge() {
        return age;
    }
}

四， 操作文件类型

1， 接收端代码

package net.ittimeline.java.network.socket.udp;

import net.ittimeline.java.io.IOUtil;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * 接收端
 * 1， 使用DatagramSocket 指定端口 创建接受端
 * 2， 准备容器 封装成DatagramPacket包裹
 * 3， 阻塞式接收包裹 receive(DatagramPacket p)
 * 4， 分析数据
 *      byte[] getData()
 *             getLength()
 * 5,  释放资源
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");
        //1， 使用DatagramSocket 指定端口 创建接受端
        DatagramSocket server = new DatagramSocket(9999);
        //2， 准备容器 封装成DatagramPacket包裹
        byte[] container = new byte[1024 * 60];
        DatagramPacket packet = new DatagramPacket(container, 0,container.length);
        //3， 阻塞式接收包裹 receive(DatagramPacket p)
        server.receive(packet);
        //4， 分析数据
        byte[] datas = packet.getData();
        IOUtil.byteArrayToFile(datas,"network/src/main/java/net/ittimeline/java/network/socket/udp/copy.png");
        //5， 释放资源
        server.close();
    }
}

2， 发送端代码

package net.ittimeline.java.network.socket.udp;

import net.ittimeline.java.io.IOUtil;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * 发送端
 * 1， 使用DatagramSocket 指定端口 创建发送端
 * 2， 准备数据 一定要转成字节数组
 * 3， 封装成DatagramPacket包裹，需要指定目的地
 * 4， 发送包裹 send(DatagramPacket p)
 * 5,  释放资源
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("UDP 发送发启动中");
        //1， 使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client = new DatagramSocket(8888);
        //2， 准备数据 一定要转成字节数组
        byte[] datas = IOUtil.fileToByteArray("network/src/main/java/net/ittimeline/java/network/socket/udp/logo.png");
        //3， 封装成DatagramPacket包裹，需要指定目的地
        DatagramPacket packet = new DatagramPacket(
                datas,
                0,
                datas.length,
                new InetSocketAddress("localhost",9999)
        );
        //4， 发送包裹 send(DatagramPacket p)
        client.send(packet);
        //5,  释放资源
        client.close();
    }
}

3， 结果

4， IOUtil工具类代码

package net.ittimeline.java.io;

import java.io.*;

/**
 * IO操作工具
 */
public final class IOUtil {
    /**
     * 将文件读取到字节数组
     * 1, 文件到程序 FileInputStream
     * 2, 程序到字节数组 ByteArrayOutputStream
     */
    public static byte[] fileToByteArray(String filePath) {
        //1， 创建源与目的地
        File src = new File(filePath);
        byte[] dest = null;
        //选择流
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            is = new FileInputStream(src);
            baos = new ByteArrayOutputStream();
            //3, 操作分段读取
            byte[] flush = new byte[1024 * 10];
            int len = -1;//接收长度
            while((len = is.read(flush)) != -1){
                baos.write(flush,0,len);
            }
            baos.flush();
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //4,释放资源
            try {
                if(null!= baos){
                    baos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 字节数组写到文件中中
     * 1, 字节数组到程序ByteArrayInputStream
     * 2, 程序到文件 FileOutputStream
     */
    public static void byteArrayToFile(byte[] src, String filePath) {
        //1, 创建源
        File dest = new File(filePath);
        //2, 选择流
        InputStream is = null;
        OutputStream fos = null;
        try{
            is = new ByteArrayInputStream(src);
            fos = new FileOutputStream(dest);
            //3, 操作(分段读取)
            byte[] flush = new byte[5];//缓冲容器
            int len = -1;//接收长度
            while((len = is.read(flush)) != -1){
                fos.write(flush,0,len);//写出到文件
            }
            fos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(null!= fos){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}