UDP协议不面向连接,提供不可靠传输,使用UDP协议传输文件时发送方和接收方不需要建立连接,发送方直接将数据报包扔进网络,包就会自行寻找目标IP及端口,如果目标端口没开不会报错但会发生丢包

    1. import java.io.*;
    2. import java.net.DatagramPacket;
    3. import java.net.DatagramSocket;
    4. import java.net.InetSocketAddress;
    5. /**
    6. * 利用网络传输数据
    7. */
    8. public class Client {
    9. public static void clientSend(byte[] data, int len, InetSocketAddress server) throws IOException {
    10. //1、使用DatagramSocket创建发送端
    11. DatagramSocket client = new DatagramSocket(6666);
    12. //2、准备数据,数据必须是字符数组
    13. //3、数据打包
    14. DatagramPacket packet = new DatagramPacket(data,0, len, server);
    15. //4、发送数据
    16. client.send(packet);
    17. //5、释放资源
    18. client.close();
    19. }
    20. }
    1. import java.io.File;
    2. import java.io.IOException;
    3. import java.io.RandomAccessFile;
    4. import java.net.InetSocketAddress;
    5. import java.nio.charset.StandardCharsets;
    6. /**
    7. * 将文件分块后每块单独发送
    8. */
    9. public class Subsection{
    10. private final File src;
    11. private final int blockSize;
    12. private int blockNum;
    13. private long len;
    14. InetSocketAddress server = new InetSocketAddress("localhost", 8888);//"192.168.1.26";
    15. public Subsection(String filePath, int blockSize) {
    16. this.src = new File(filePath);
    17. //每块多大
    18. this.blockSize = blockSize;
    19. init();
    20. }
    21. //初始化
    22. private void init(){
    23. //一共读多少字节:这里读整个文件
    24. len = src.length();
    25. //一共分多少块:文件大小除每块大小并向上取整
    26. blockNum = (int)Math.ceil(len*1.0/blockSize);
    27. }
    28. //将文件分割成块
    29. public void split() throws IOException, InterruptedException {
    30. //定义开始位置
    31. int beginPos;
    32. //定义实际上要读多长,因为不一定每一次都会读满一块的内容
    33. int actualSize;
    34. for(int i = 0; i<blockNum; i++){
    35. //设置开始位置,当i=0即第一块时,从0即第一个字节开始,当i=1即第二块时,从第1024个字节即第一块的最后一个字节的下一个字节开始
    36. beginPos = i * blockSize;
    37. if( i == blockNum-1 ){
    38. //若是最后一块,就读取剩余长度个大小
    39. actualSize = (int)len;
    40. }else{
    41. //若不是最后一块,就将一块读满,然后用文件的大小减去一块的长度,算出剩余长度
    42. actualSize = blockSize;
    43. len -= blockSize;
    44. }
    45. toBlock(i, beginPos, actualSize);
    46. }
    47. String flag = "false";
    48. Client.clientSend(flag.getBytes(StandardCharsets.UTF_8), flag.getBytes(StandardCharsets.UTF_8).length, server);
    49. }
    50. //将分割为块的数据装入容器并输出到文件
    51. private void toBlock(int i, int beginPos, int actualSize) throws IOException, InterruptedException {
    52. byte[] flush = new byte[blockSize];
    53. int cut, j;
    54. j = i+1;
    55. //输入源
    56. RandomAccessFile raf = new RandomAccessFile(src, "r");
    57. System.out.println("第"+j+"个包:从第"+beginPos+"字节开始,发送"+actualSize+"个字节");
    58. raf.seek(beginPos);
    59. cut = raf.read(flush);
    60. Client.clientSend(flush, Math.min(actualSize, cut), server);
    61. raf.close();
    62. Thread.sleep(10);
    63. }
    64. }
    1. import org.apache.commons.io.FileUtils;
    2. import java.io.File;
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. /**
    7. * 分块接收数据
    8. */
    9. public class Server {
    10. public static void serverReceive(String filepath) throws IOException {
    11. //1、使用DatagramSocket创建接收端
    12. DatagramSocket server = new DatagramSocket(8888);
    13. //2、准备容器,封装为DatagramPacket包
    14. byte[] container = new byte[1024*10];
    15. String str;
    16. int i = 1;
    17. DatagramPacket packet = new DatagramPacket(container, 0, container.length);
    18. File destfile = new File(filepath);
    19. while(true) {
    20. //3、接收数据
    21. server.receive(packet);
    22. //4、分析数据
    23. byte[] data = packet.getData();
    24. int len = packet.getLength();
    25. str = new String(data, 0, len);
    26. if (!str.equals("false")) {
    27. System.out.println("收到第"+i+"个包,大小"+len+"字节");
    28. FileUtils.writeByteArrayToFile(destfile, data, true);
    29. i++;
    30. }
    31. else {
    32. System.out.println("STOP");
    33. //5、释放资源
    34. server.close();
    35. return;
    36. }
    37. }
    38. }
    39. }