大文件断点上传服务开发--Java服务端Python客户端

最新推荐文章于 2024-08-20 14:14:19 发布
最新推荐文章于 2024-08-20 14:14:19 发布
阅读量775 收藏 2
点赞数
分类专栏： Java 文章标签： java python docker kubernetes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingyuzhe/article/details/80970253
版权

目标：文件断点上传，Java编写服务端，Python编写客户端，以容器方式部署

环境：IntelliJ IDEA / Linux (python)

步骤：概述->文件断点上传服务端设计与实现->文件断点上传客户端设计与实现->kubernetes部署服务->运行测试

1.概述

文件断点上传服务的主要功能为实现应用的文件中转，并在大文件传输中断后可以进行断点上传。

文件服务端以容器方式部署，通过NodePort方式对外开放socket服务。

2.文件断点上传服务端设计与实现

文件断点上传服务端设计：

(1)数据通信方式

socket

(2)断点上传方式

设置断点游标，从游标处开始接收数据


服务端使用Java编写，新建maven项目fileuploadserver

修改pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.boe.cloud</groupId>
    <artifactId>fileupload-server</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <dependencies>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>                 
                    <archive>
                        <manifest>
                            <mainClass>com.boe.cloud.fileupload.FileUploadServer</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>                      
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
编写文件信息包，为将信息包转换成json格式提供便利

FileInfoPackage.java


public class FileInfoPackage {
 
    // JSON数据包信息
    int status = 0;
    String name = "";
    Long length = 0l;
 
    // Getter 与 Setter方法
    public int getStatus() {
        return status;
    }
 
    public void setStatus(int status) {
        this.status = status;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Long getLength() {
        return length;
    }
 
    public void setLength(Long length) {
        this.length = length;
    }
}
服务端主函数：FileUploadServer.java 
import net.sf.json.JSONObject;
 
import java.io.*;
import java.math.RoundingMode;
import java.net.*;
import java.text.DecimalFormat;
import java.util.*;
 
public class FileUploadServer extends ServerSocket {
    // 退出标识符
    private boolean quit = false;
 
    // 文件大小计算
    private static DecimalFormat df = null;
 
    // 设置数字格式，保留一位有效小数
    static {
        df = new DecimalFormat("#0.0");
        df.setRoundingMode(RoundingMode.HALF_UP);
        df.setMinimumFractionDigits(1);
        df.setMaximumFractionDigits(1);
    }
 
    /**
     * 服务端启动端口参数传入
     *
     */
    public FileUploadServer(int port) throws IOException {
        super(port);
    }
 
    /**
     * 启动阻塞式服务端，接收socket并开启线程
     *
     */
    public void load() throws Exception {
        System.out.println("文件断点上传服务器正在运行......");
        while (!quit) {
            Socket socket = this.accept();
            System.out.println("与客户端的连接已建立！");
 
            // 每接收到一个Socket就建立一个新的线程来处理
            new Thread(new Task(socket)).start();
        }
    }
 
    /**
     * 线程处理任务：文件断点上传
     *
     */
    class Task implements Runnable{
 
        // 当前连接
        private Socket sk;
 
        // 初始化
        public Task(Socket socket) {
            this.sk = socket;
        }
 
        // 核心方法
        public void run(){
 
            Socket socket = sk;
 
            //输出与发送流定义
            InputStreamReader isr = null;
            DataInputStream dis = null;
            BufferedReader br = null;
            OutputStreamWriter osm = null;
            BufferedWriter bw = null;
            FileOutputStream fos = null;
            RandomAccessFile raf = null;
 
            //文件信息
            int fileExist = 0;
            String fileName = "";
            Long fileLength = 0l;
            Long clientFilelength = 0l;
            String filePath = "/data";
            String filePathName = "";
            String fileCopydest = "/mnt";
            String fileCopyPathName = "";
            char pathChar = File.separatorChar;
 
            try {
                // 输入对象初始化
                isr = new InputStreamReader(socket.getInputStream());
                br = new BufferedReader(isr);
 
                // 获取客户端第一次传入的信息：文件名称、大小、存在标识符
                String strTemp = br.readLine();
                // JSON格式转换
                JSONObject object = JSONObject.fromObject(strTemp);
//                System.out.println("Status: " + object.getBoolean("status"));
//                System.out.println("File Name: "+ object.getString("name"));
//                System.out.println("File Length: " + object.getLong("length"));
 
                // 获取文件名，本地查询
                fileName = object.getString("name");
                clientFilelength = object.getLong("length");
                System.out.println("服务器获取客户文件名称：" + fileName);
                System.out.println("客户端文件大小：" + clientFilelength);
 
                // 检查目录是否存在
                File directory = new File(filePath + pathChar + "receive" +pathChar);
                if(!(directory.exists())){
                    directory.mkdirs();
                }
                filePathName = filePath + pathChar + "receive" + pathChar + fileName;
                fileCopyPathName = fileCopydest + pathChar + fileName;
                File file = new File(filePathName);
                FileInfoPackage fileInfo = new FileInfoPackage();
 
                // 本地查询文件，判断是否存在
                if(file.exists()){
                    fileExist = 1;
                    fileLength = file.length();
                }else {
                    fileExist = 0;
                }
                // 数据包准备
                fileInfo.setStatus(fileExist);
                fileInfo.setName(fileName);
                fileInfo.setLength(fileLength);
                // 转换为JSON格式
                JSONObject sendObject = JSONObject.fromObject(fileInfo);
 
                // 输出对象初始化
                osm = new OutputStreamWriter(socket.getOutputStream());
                bw = new BufferedWriter(osm);
                // 发送对象
                bw.write(sendObject.toString());
                //bw.write("test for python");
                bw.flush();
 
                System.out.println("文件参数发送成功！");
//                System.out.println("Status: " + sendObject.getInt("status"));
//                System.out.println("File Name: " + sendObject.getString("name"));
//                System.out.println("File Length: " + sendObject.getLong("length"));
 
                System.out.println("服务器返回信息成功，准备传输数据......");
 
                // 开始传输文件
                //isr = new InputStreamReader(socket.getInputStream());
                dis = new DataInputStream(socket.getInputStream());
                // 传输参数
                int length = 0;
                byte[] bytes = new byte[1024];
                if(fileExist == 0){
                    fos = new FileOutputStream(file);
                    while((length = dis.read(bytes, 0, bytes.length)) != -1){
                        fos.write(bytes, 0, length);
                        fos.flush();
                        fileLength += length;
                        if(fileLength == clientFilelength){
                            break;
                        }
                    }
                    System.out.println("初次文件传输完成！");
                }else if (fileExist == 1){
                    Long filePoint = 0l;
                    fileLength = file.length();
                    if(clientFilelength >= fileLength){
                        // 文件断点续传
                        filePoint = fileLength;
                    }else{
                        // 出错，重新传输
                        filePoint = 0l;
                        file.delete();
                        file.createNewFile();
                    }
                    raf = new RandomAccessFile(file,"rw");
                    raf.seek(filePoint);
                    while((length = dis.read(bytes, 0, bytes.length)) != -1){
                        raf.write(bytes, 0, length);
                        fileLength += length;
                        if(fileLength == clientFilelength){
                            break;
                        }
                    }
                    System.out.println("断点文件续传成功！");
                }else{
                    System.out.println("状态错误！");
                }
                // 文件传输完成
                System.out.println("-------- 文件接收成功 [File Name：" + fileName + "] [Size：" + getFormatFileSize(file.length()) + "] --------");
                // 文件传输完成，拷贝并删除文件
                if (file.length() == clientFilelength) {
                    File dest = new File(fileCopyPathName);
                    copyFileUsingFileStreams(file, dest);
                    System.out.println("文件拷贝成功！");
                    if (fos != null){
                        fos.close();
                    }
                    if (raf != null){
                        raf.close();
                    }
                    deleteFile(file);
                    System.out.println("文件删除成功！");
                }
 
            }catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    if (dis != null){
                        dis.close();
                    }
                    if (isr != null){
                        isr.close();
                    }
                    if (osm != null){
                        osm.close();
                    }
                    socket.close();
                    System.out.println("Socket已关闭！");
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
 
    }
 
    /**
     * 拷贝文件
     *
     */
    public static void copyFileUsingFileStreams(File source, File dest) throws IOException {
        InputStream input = null;
        OutputStream output = null;
        try {
            input = new FileInputStream(source);
            output = new FileOutputStream(dest);
            byte[] buf = new byte[1024];
            int bytesRead;
            while ((bytesRead = input.read(buf)) > 0) {
                output.write(buf, 0, bytesRead);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        finally {
            input.close();
            output.close();
        }
    }
 
    /**
     * 删除文件
     *
     */
    public static void deleteFile(File file) throws IOException {
        try {
            file.delete();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 格式化文件大小
     *
     */
    public String getFormatFileSize(long length) {
        double size = ((double) length) / (1 << 30);
        if (size >= 1) {
            return df.format(size) + "GB";
        }
        size = ((double) length) / (1 << 20);
        if (size >= 1) {
            return df.format(size) + "MB";
        }
        size = ((double) length) / (1 << 10);
        if (size >= 1) {
            return df.format(size) + "KB";
        }
        return length + "B";
    }
 
    public static void main(String[] args) {
        try {
            FileUploadServer fileUploadServer = new FileUploadServer(8899);
            fileUploadServer.load();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端为每一个socket连接新建一个线程，结束后关闭socket，循环等待连接

3.文件断点上传客户端设计与实现

文件上传客户端设计：

(1)数据通信方式

socket

(2)断点上传方式

读取服务端返回的文件断点游标，实现断点续传


客户端使用Python编写，引入json包，将读取标识符转换为json格式，方便使用。

FileUploadClient.py

# -*- coding: utf-8 -*
import socket
import os
import json
import sys
 
def load():
    sk = socket.socket()
    sk.connect(('10.80.25.143', 30089))
    print ('连接服务器成功')
    file_name = input('请输入需要上传文件的文件名：').strip()
    file_size = os.stat(file_name).st_size
    file_point = 0
    print (file_name)
    print (file_size)
    # 文件信息
    send_data = dict(status=0, name=file_name, length=file_size)
    send_json = json.dumps(send_data)
    print (send_json)
    # 发送需上传文件信息
    sk.send((send_json + '\n').encode())
    # 接收服务器返回信息
    recv_data = sk.recv(1024).decode()
    print (recv_data)
    recv_json = json.loads(recv_data)
    print (recv_json)
    # 判断是否断点续传
    if recv_json['status'] == 0:
        print ('文件初次传输！')
        file_point = 0
    elif recv_json['status'] == 1:
        print ('文件已存在，继续传输！')
        file_point = recv_json['length']
    else:
        print ('状态码无效！')
    # 打开文件并传输
    f = open(file_name, 'rb')
    f.seek(file_point)
    while file_point < file_size:
        data = f.read(1024)
        sk.sendall(data)
        file_point += len(data)
        # print ('已发送Byte：' + str(file_point) + '\t' + '文件总Byte：' + str(file_size))
        percent = int(100*(file_point/file_size))
        print ('已发送文件比例：' + str(percent) + '%')
    f.close()
    print ('发送成功！')
 
while True:
    load()

其中客户端也设置为循环输入。

4.kubernetes部署服务

将服务端代码打包成jar包，通过Dockerfile生成镜像，最后通过k8s yaml文件实现服务部署

服务端打包：

mvn compile

mvn package

Dockerfile：

#使用java 8版本基础镜像
FROM java:8
 
#将jar包拷贝至容器内
ADD FileUploadServer.jar app.jar
RUN bash -c 'touch /app.jar'
 
#容器开放端口
EXPOSE 8899
 
#容器启动时执行的命令
ENTRYPOINT ["java","-jar","/app.jar"]
部署文件：fileupload.yaml 
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: fileupload-deployment
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: fileupload
    spec:
      containers:
      - name: fileupload-test
        image: caoxintest/fileuploadserver:1.0
        ports:
        - containerPort: 8899
        volumeMounts:
        - name: my-vol
          mountPath: /mnt
      volumes:
      - name: my-vol
        persistentVolumeClaim:
          claimName: mynfs-pvc       
 
---
apiVersion: v1
kind: Service
metadata:
  name: fileupload-service
  labels:
    app: fileupload
spec:
  selector:
    app: fileupload
  type: NodePort
  ports:
  - port: 8899
    nodePort: 30089

执行：

kubectl -f create fileupload.yaml

5.运行测试

python3 FileUploadClient.py

运行客户端：

输入test.rar，并在传输过程中强行终止


查看服务端：


继续上传直至结束：


服务端查看：自动拷贝至mnt目录


以上，测试完成。


xingyuzhe
关注
专栏目录
FileTransferThrift:Thrift的文件传输服务器和客户端，使用Java实现
04-29
`FileTransferThrift` 是一个基于Thrift框架实现的文件传输服务，它使用Java编程语言进行开发。Thrift是一种高效的、跨语言的服务开发工具，由Facebook开源，现在由Apache基金会维护。这个项目的核心目标是提供一个...
python传文件给java_python使用简单http协议来传送文件
weixin_39702559的博客
12-09 626
python使用简单http协议来传送文件！在ubuntu环境下，局域网内可以使用nc来传送文件，也可以使用基于Http协议的方式来下载文件我们可以使用python -m SimpleHTTPServer ${port}来启动服务默认的端口是8000，另外我们也可以指定端口，比如:python -m SimpleHTTPServer 15000这时我们就可以通过http://${ip}:15000...
python发送文件到服务器_将文件从Python服务器发送到Java客户端
weixin_39989443的博客
12-05 249
I am trying to send files from a Python server to Java client over a TCP socket. Here is what I have so far:Java Client (Note that all of the file transfer code is in the getFile() method):public clas...
JAVA 超大文件上传解决方案:分片断点上传(一)
最新发布
alisky119的博客
08-20 882
该说不说，最近这块挻火的。今天早上有网友加我微信，也是咨询这块的技术问题，最近不知道啥情况，加我的网友还是挻多的。实际上我的微信很早就在网上公开了，但是还是有很多网友说找不到。昨天晚上论坛里面有位网友发私信给我，聊了一下这个问题，这个网友是一个自由职业者，他也是刚开始学习这块，很多技术都不是很了解，平时也对技术比较感兴趣，他最近接了一个项目，也是有这个需求，需要传大文件，主要难点在于大文件和文件夹的下载。
python传文件给java_用java pyhont通过HTTP协议传输文件流
weixin_35723924的博客
01-29 518
// 代码网上抄的 忘记链接了 抱歉哈packageupload;importjava.io.BufferedReader;importjava.io.DataOutputStream;importjava.io.FileInputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStream...
python传文件到服务器_一个简单的python文件传输服务器
weixin_39608132的博客
12-04 350
服务器 代码，可以兼容python2 和 python3#!/usr/bin/python3# -*- coding: utf-8 -*-from socket import socket, AF_INET, SOCK_STREAMclass SimpleServer:def startServer(self,port):tcpSerSock=socket(AF_INET,SOCK_STREAM)...
大文件的分片上传和断点上传
Niucode的博客
04-25 432
前端将文件分片并逐个上传到后端，同时后端需要保存已上传的分片信息，以便在中断后能够恢复上传。
android 拍照 录像 本地文件上传客户端 服务端
02-02
- 服务端通常使用Java、Python、Node.js等后端语言开发，需要实现接收文件上传的接口，解析接收到的文件流，保存到服务器硬盘，并返回上传状态。 - 需要处理多线程接收、文件完整性校验、权限控制等问题。 7. **...
支持多线程断点续传的文件传输(FTP)程序（含服务端和客户端、支持蓝牙(Bluetooth)传输）.zip
06-19
本文将深入探讨一个特定的文件传输解决方案：支持多线程断点续传的FTP程序，该程序同时包含服务端和客户端，并且具备蓝牙传输功能。这样的系统设计能够显著提高文件传输效率，尤其是在网络不稳定或大文件传输时，其...
服务端实现断点续传
04-15
此外，压缩包中的"uploadbigfile"可能是示例代码或相关资源，用于演示如何在服务端处理大文件上传时实现断点续传。这部分可能包含了实现的关键函数、类或脚本，供读者参考和学习。 总之，服务端实现断点续传是一个...
多文件断点上传实例
07-04
在实现上，可以使用各种编程语言和技术，如JavaScript（配合Web APIs如FileReader和XMLHttpRequest或fetch API）实现浏览器端的断点上传，或者使用Python、Java、C#等服务端语言来处理服务器逻辑。还可以利用现有的...
Python实现大文件分片上传
热门推荐
Nxin的小抄本
08-25 2万+
想借着这篇文章简要谈谈WebUploader大文件上传与Python结合的实现。 WebUploader是百度团队对大文件上传的前端实现，而后端需要根据不同的语言自己实现。这里我采用Python语言的Flask框架搭建后端，配合使用Bootstrap前端框架渲染上传进度条。 http协议并不是非常适合上传大文件，所以要考虑分片，即把大文件分割后再上传，而WebUploader所做的事，正是将一个大文件分片，一部分一部分的上传到服务器。WebUploader是一个前端框架，所以接收文件的部分需要我们自己实现，
Python像JAVA发送图片_从url下载图片--java与python实现方式比较
weixin_39603598的博客
02-26 117
一、java的实现方式 首先读取图片 //方式一：直接根据url读取图片private static BufferedImage read(String imageUrl) throws IOException {URL url = new URL(imageUrl);BufferedImage image = ImageIO.read(url);return image;} //如果需要设置co...
python 视频断点续传
m0_46652894的博客
05-16 711
文章目录python 视频断点续传一、分割视频1、分割的每个小部分的大小：2、获取视频大小：3、分割视频：二、请求视频1、设置请求头2、保存视频三、断点续传1、获取保存视频的文件夹里面的文件的名称：2、请求一小段视频时，先判断当前文件夹里是否存在，不存在才下载四、合并视频五、完整代码：1、requests版本，多进程，没有进度条2、`asyncio`版本，异步，有进度条 python 视频断点续传 将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到
分片上传，断点上传 控制并发数量
wzy0507的博客
05-19 389
大文件上传-分片上传，断点上传，控制并发数量
前端分片点断上传的实现
weixin_34302561的博客
03-27 1851
一、前端大文件上传的痛点 1. 文件过大导致带宽资源资源紧张，请求速度降低；2. 可能导致后端进程卡死，请求无响应，前端页面卡顿，用户体验下降；3. 甚至导致用户因页面卡顿而一直重复上传同一个大文件，页面崩溃；4. 如果在上传过程中服务中断、网络中断、页面崩溃，可能文件要重新开始上传二、痛点分析首先分析一下上传流程: 前端选择文件后将文件上传，后端在处理文件过程中，首先会先将文件加载到运行内...
超大文件传输解决方案
Mr_Zang666的博客
08-19 1745
之前仿造uploadify写了一个HTML5版的文件上传插件，没看过的朋友可以点此先看一下~得到了不少朋友的好评，我自己也用在了项目中，不论是用户头像上传，还是各种媒体文件的上传，以及各种个性的业务需求，都能得到满足。小小开心了一把。 但无论插件再怎么灵活，也难以应付所有的需求，比如，你要上传一个2G的文件。以现在我们的网速，恐怕再快也得传半小时。要命的是，如果你在上传到90%的时候不小心关...
大文件上传下载、分片、断点续传教程
CY的博客
06-21 318
分片： 按照自定义缓冲区大小，将大文件分成多个小文件片段。 断点续传： 根据分片数量，给每个小文件通过循环起对应名称，当文件下载中断在续传时，判断小文件名称若存在则不存了，此时还需要判断文件若不是最后一个分片则大小为缓冲区固定大小，若没达到则证明小文件没传完需要重新传输。 合并： 下载时通过线程池创建任务进行下载或上传、当判断最后一个分片传完时，调用合并方法，根据之前定义的文件名称顺序进行合并，肯能出现最后一个分片传完，之前分片未传完的情况，需要使用while循环进行判断，多文件未传输完，则等待一会继续
python网络编程客户端向服务器传送图片的步骤
2302_77595648的博客
07-13 572
首先还是先创建TCP套接字表示使用IPv4地址，表示使用TCP协议进行通信。通过scoket对象连接服务器IP地址和端口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值