java http大文件断点续传上传

最新推荐文章于 2025-06-19 16:15:33 发布
最新推荐文章于 2025-06-19 16:15:33 发布
阅读量7.5k 收藏 9
点赞数 2
本文介绍了一个基于HTML5的断点上传项目，通过文件切分实现分块上传，并利用CRC32校验确保数据完整性。支持暂停及继续上传功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1，项目调研

因为需要研究下断点上传的问题。找了很久终于找到一个比较好的项目。

在GoogleCode上面，代码弄下来超级不方便，还是配置hosts才好，把代码重新上传到了github上面。


https://github.com/freewebsys/java-large-file-uploader-demo

效果：

上传中，显示进度，时间，百分比。

20141113102839281.png

点击【Pause】暂停，点击【Resume】继续。

20141113102836532.png

2，代码分析

原始项目：

https://code.google.com/p/java-large-file-uploader/

这个项目最后更新的时间是 2012 年，项目进行了封装使用最简单的方法实现了http的断点上传。

因为html5 里面有读取文件分割文件的类库，所以才可以支持断点上传，所以这个只能在html5 支持的浏览器上面展示。

同时，在js 和 java 同时使用 cr32 进行文件块的校验，保证数据上传正确。

代码在使用了最新的servlet 3.0 的api，使用了异步执行，监听等方法。

上传类UploadServlet

    @Component("javaLargeFileUploaderServlet")  
    @WebServlet(name = "javaLargeFileUploaderServlet", urlPatterns = { "/javaLargeFileUploaderServlet" })  
    public class UploadServlet extends HttpRequestHandlerServlet  
            implements HttpRequestHandler {  
      
        private static final Logger log = LoggerFactory.getLogger(UploadServlet.class);  
      
        @Autowired  
        UploadProcessor uploadProcessor;  
      
        @Autowired  
        FileUploaderHelper fileUploaderHelper;  
      
        @Autowired  
        ExceptionCodeMappingHelper exceptionCodeMappingHelper;  
      
        @Autowired  
        Authorizer authorizer;  
      
        @Autowired  
        StaticStateIdentifierManager staticStateIdentifierManager;  
      
      
      
        @Override  
        public void handleRequest(HttpServletRequest request, HttpServletResponse response)  
                throws IOException {  
            log.trace("Handling request");  
      
            Serializable jsonObject = null;  
            try {  
                // extract the action from the request  
                UploadServletAction actionByParameterName =  
                        UploadServletAction.valueOf(fileUploaderHelper.getParameterValue(request, UploadServletParameter.action));  
      
                // check authorization  
                checkAuthorization(request, actionByParameterName);  
      
                // then process the asked action  
                jsonObject = processAction(actionByParameterName, request);  
      
      
                // if something has to be written to the response  
                if (jsonObject != null) {  
                    fileUploaderHelper.writeToResponse(jsonObject, response);  
                }  
      
            }  
            // If exception, write it  
            catch (Exception e) {  
                exceptionCodeMappingHelper.processException(e, response);  
            }  
      
        }  
      
      
        private void checkAuthorization(HttpServletRequest request, UploadServletAction actionByParameterName)  
                throws MissingParameterException, AuthorizationException {  
      
            // check authorization  
            // if its not get progress (because we do not really care about authorization for get  
            // progress and it uses an array of file ids)  
            if (!actionByParameterName.equals(UploadServletAction.getProgress)) {  
      
                // extract uuid  
                final String fileIdFieldValue = fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId, false);  
      
                // if this is init, the identifier is the one in parameter  
                UUID clientOrJobId;  
                String parameter = fileUploaderHelper.getParameterValue(request, UploadServletParameter.clientId, false);  
                if (actionByParameterName.equals(UploadServletAction.getConfig) && parameter != null) {  
                    clientOrJobId = UUID.fromString(parameter);  
                }  
                // if not, get it from manager  
                else {  
                    clientOrJobId = staticStateIdentifierManager.getIdentifier();  
                }  
      
                  
                // call authorizer  
                authorizer.getAuthorization(  
                        request,  
                        actionByParameterName,  
                        clientOrJobId,  
                        fileIdFieldValue != null ? getFileIdsFromString(fileIdFieldValue).toArray(new UUID[] {}) : null);  
      
            }  
        }  
      
      
        private Serializable processAction(UploadServletAction actionByParameterName, HttpServletRequest request)  
                throws Exception {  
            log.debug("Processing action " + actionByParameterName.name());  
      
            Serializable returnObject = null;  
            switch (actionByParameterName) {  
                case getConfig:  
                    String parameterValue = fileUploaderHelper.getParameterValue(request, UploadServletParameter.clientId, false);  
                    returnObject =  
                            uploadProcessor.getConfig(  
                                    parameterValue != null ? UUID.fromString(parameterValue) : null);  
                    break;  
                case verifyCrcOfUncheckedPart:  
                    returnObject = verifyCrcOfUncheckedPart(request);  
                    break;  
                case prepareUpload:  
                    returnObject = prepareUpload(request);  
                    break;  
                case clearFile:  
                    uploadProcessor.clearFile(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)));  
                    break;  
                case clearAll:  
                    uploadProcessor.clearAll();  
                    break;  
                case pauseFile:  
                    List<UUID> uuids = getFileIdsFromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId));  
                    uploadProcessor.pauseFile(uuids);  
                    break;  
                case resumeFile:  
                    returnObject =  
                            uploadProcessor.resumeFile(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)));  
                    break;  
                case setRate:  
                    uploadProcessor.setUploadRate(UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId)),  
                            Long.valueOf(fileUploaderHelper.getParameterValue(request, UploadServletParameter.rate)));  
                    break;  
                case getProgress:  
                    returnObject = getProgress(request);  
                    break;  
            }  
            return returnObject;  
        }  
      
      
        List<UUID> getFileIdsFromString(String fileIds) {  
            String[] splittedFileIds = fileIds.split(",");  
            List<UUID> uuids = Lists.newArrayList();  
            for (int i = 0; i < splittedFileIds.length; i++) {  
                uuids.add(UUID.fromString(splittedFileIds[i]));  
            }   
            return uuids;  
        }  
      
      
        private Serializable getProgress(HttpServletRequest request)  
                throws MissingParameterException {  
            Serializable returnObject;  
            String[] ids =  
                    new Gson()  
                            .fromJson(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId), String[].class);  
            Collection<UUID> uuids = Collections2.transform(Arrays.asList(ids), new Function<String, UUID>() {  
      
                @Override  
                public UUID apply(String input) {  
                    return UUID.fromString(input);  
                }  
      
            });  
            returnObject = Maps.newHashMap();  
            for (UUID fileId : uuids) {  
                try {  
                    ProgressJson progress = uploadProcessor.getProgress(fileId);  
                    ((HashMap<String, ProgressJson>) returnObject).put(fileId.toString(), progress);  
                }  
                catch (FileNotFoundException e) {  
                    log.debug("No progress will be retrieved for " + fileId + " because " + e.getMessage());  
                }  
            }  
            return returnObject;  
        }  
      
      
        private Serializable prepareUpload(HttpServletRequest request)  
                throws MissingParameterException, IOException {  
      
            // extract file information  
            PrepareUploadJson[] fromJson =  
                    new Gson()  
                            .fromJson(fileUploaderHelper.getParameterValue(request, UploadServletParameter.newFiles), PrepareUploadJson[].class);  
      
            // prepare them  
            final HashMap<String, UUID> prepareUpload = uploadProcessor.prepareUpload(fromJson);  
      
            // return them  
            return Maps.newHashMap(Maps.transformValues(prepareUpload, new Function<UUID, String>() {  
      
                public String apply(UUID input) {  
                    return input.toString();  
                };  
            }));  
        }  
      
      
        private Boolean verifyCrcOfUncheckedPart(HttpServletRequest request)  
                throws IOException, MissingParameterException, FileCorruptedException, FileStillProcessingException {  
            UUID fileId = UUID.fromString(fileUploaderHelper.getParameterValue(request, UploadServletParameter.fileId));  
            try {  
                uploadProcessor.verifyCrcOfUncheckedPart(fileId,  
                        fileUploaderHelper.getParameterValue(request, UploadServletParameter.crc));  
            }  
            catch (InvalidCrcException e) {  
                // no need to log this exception, a fallback behaviour is defined in the  
                // throwing method.  
                // but we need to return something!  
                return Boolean.FALSE;  
            }  
            return Boolean.TRUE;  
        }  
    }

异步上传UploadServletAsync 
    @Component("javaLargeFileUploaderAsyncServlet")  
    @WebServlet(name = "javaLargeFileUploaderAsyncServlet", urlPatterns = { "/javaLargeFileUploaderAsyncServlet" }, asyncSupported = true)  
    public class UploadServletAsync extends HttpRequestHandlerServlet  
            implements HttpRequestHandler {  
      
        private static final Logger log = LoggerFactory.getLogger(UploadServletAsync.class);  
      
        @Autowired  
        ExceptionCodeMappingHelper exceptionCodeMappingHelper;  
      
        @Autowired  
        UploadServletAsyncProcessor uploadServletAsyncProcessor;  
          
        @Autowired  
        StaticStateIdentifierManager staticStateIdentifierManager;  
      
        @Autowired  
        StaticStateManager<StaticStatePersistedOnFileSystemEntity> staticStateManager;  
      
        @Autowired  
        FileUploaderHelper fileUploaderHelper;  
      
        @Autowired  
        Authorizer authorizer;  
      
        /** 
         * Maximum time that a streaming request can take.<br> 
         */  
        private long taskTimeOut = DateUtils.MILLIS_PER_HOUR;  
      
      
        @Override  
        public void handleRequest(final HttpServletRequest request, final HttpServletResponse response)  
                throws ServletException, IOException {  
      
            // process the request  
            try {  
      
                //check if uploads are allowed  
                if (!uploadServletAsyncProcessor.isEnabled()) {  
                    throw new UploadIsCurrentlyDisabled();  
                }  
                  
                // extract stuff from request  
                final FileUploadConfiguration process = fileUploaderHelper.extractFileUploadConfiguration(request);  
      
                log.debug("received upload request with config: "+process);  
      
                // verify authorization  
                final UUID clientId = staticStateIdentifierManager.getIdentifier();  
                authorizer.getAuthorization(request, UploadServletAction.upload, clientId, process.getFileId());  
      
                //check if that file is not paused  
                if (uploadServletAsyncProcessor.isFilePaused(process.getFileId())) {  
                    log.debug("file "+process.getFileId()+" is paused, ignoring async request.");  
                    return;  
                }  
                  
                // get the model  
                StaticFileState fileState = staticStateManager.getEntityIfPresent().getFileStates().get(process.getFileId());  
                if (fileState == null) {  
                    throw new FileNotFoundException("File with id " + process.getFileId() + " not found");  
                }  
      
                // process the request asynchronously  
                final AsyncContext asyncContext = request.startAsync();  
                asyncContext.setTimeout(taskTimeOut);  
      
      
                // add a listener to clear bucket and close inputstream when process is complete or  
                // with  
                // error  
                asyncContext.addListener(new UploadServletAsyncListenerAdapter(process.getFileId()) {  
      
                    @Override  
                    void clean() {  
                        log.debug("request " + request + " completed.");  
                        // we do not need to clear the inputstream here.  
                        // and tell processor to clean its shit!  
                        uploadServletAsyncProcessor.clean(clientId, process.getFileId());  
                    }  
                });  
      
                // then process  
                uploadServletAsyncProcessor.process(fileState, process.getFileId(), process.getCrc(), process.getInputStream(),  
                        new WriteChunkCompletionListener() {  
      
                            @Override  
                            public void success() {  
                                asyncContext.complete();  
                            }  
      
      
                            @Override  
                            public void error(Exception exception) {  
                                // handles a stream ended unexpectedly , it just means the user has  
                                // stopped the  
                                // stream  
                                if (exception.getMessage() != null) {  
                                    if (exception.getMessage().equals("Stream ended unexpectedly")) {  
                                        log.warn("User has stopped streaming for file " + process.getFileId());  
                                    }  
                                    else if (exception.getMessage().equals("User cancellation")) {  
                                        log.warn("User has cancelled streaming for file id " + process.getFileId());  
                                        // do nothing  
                                    }  
                                    else {  
                                        exceptionCodeMappingHelper.processException(exception, response);  
                                    }  
                                }  
                                else {  
                                    exceptionCodeMappingHelper.processException(exception, response);  
                                }  
      
                                asyncContext.complete();  
                            }  
      
                        });  
            }  
            catch (Exception e) {  
                exceptionCodeMappingHelper.processException(e, response);  
            }  
      
        }  
      
    }

3，请求流程图：


主要思路就是将文件切分，然后分块上传。
20141113114708718.jpg
moonpure
关注
java大文件断点续传
Mr_Zang666的博客
08-14 824
java两台服务器之间，大文件上传（续传），采用了Socket通信机制以及JavaIO流两个技术点，具体思路如下： 实现思路： 1、服：利用ServerSocket搭建服务器，开启相应端口，进行长连接操作 2、服：使用ServerSocket.accept()方法进行阻塞，接收客户端请求 3、服：每接收到一个Socket就建立一个新的线程来处理它 4、客：利用Socket进行远程连...
java大文件分块上传断点续传demo
09-29
本示例"java大文件分块上传断点续传demo"提供了一个完整的解决方案，它允许用户将大文件分块上传，并在上传过程中支持断点续传。 首先，理解"分块上传"的概念。分块上传是将一个大文件分割成多个小块，然后逐个上传...
java http大文件上传，断点续传项目研究，Github上传源代码
热门推荐
freewebsys的专栏
11-13 2万+
1，项目调研 因为需要研究下断点上传的问题。找了很久终于找到一个比较好的项目。 在GoogleCode上面，代码弄下来超级不方便，还是配置hosts才好，把代码重新上传到了github上面。 https://github.com/freewebsys/java-large-file-uploader-demo 效果： 上传中，显示进度，时间，百分比。 点击【Paus
Java编程实现文件断点续传技术详解
最新发布
weixin_42627459的博客
06-19 412
HTTP请求头的定义和设置在多数现代Web开发框架中都得到了很好的支持。以Java中的HttpClient为例，可以通过以下方式定义和设置请求头：.build();在这个例子中，我们创建了一个带有两个请求头字段（”User-Agent”和”Accept”）的HTTP GET请求。这些字段向服务器提供了有关客户端请求的信息。Spring MVC是Spring框架的一个模块，它提供了一种基于Java的、可扩展的MVC（Model-View-Controller）实现，用于构建Web应用程序。
JSP大文件分片上传
weixin_52041354的博客
07-01 168
需求：项目要支持大文件上传功能，经过讨论，初步将文件上传大小控制在20G内，因此自己需要在项目中进行文件上传部分的调整和配置，自己将大小都以20G来进行限制。PC端全平台支持，要求支持Windows,Mac,Linux支持所有浏览器。支持文件批量上传支持文件夹上传，且要求在服务端保留层级结构。文件夹数量要求支持到10W。支持大文件断点续传，要求刷新浏览器，重启浏览器，重启电脑后仍然能够继续上传。文件大小要求能够支持到20个G。支持自动加载本地文件，要求能够自动加载指定的本地文件。支持文件批量下载，要求不要在
jsp实现浏览器大文件分片上传
weixin_52041354的博客
07-01 122
以ASP.NET Core WebAPI 作后端 API ，用 Vue 构建前端页面，用 Axios 从前端访问后端 API ,包括文件的上传和下载。准备文件上传的API#region 文件上传 可以带参数 [HttpPost("upload")] public JsonResult uploadProject(IFormFile file, string userId) { if (file != null) {
JSP断点续传多线程链接下载
05-02 124
<% //你可以使用你服务器上的文件及其路径 String s = "E:\\resin-2.1.14\\webapps\\ROOT\\reg.bat"; //RandomAccessFile 方式 java.io.RandomAccessFile raf = new java.i...
基于Java的FastDFS大文件上传与断点续传设计源码
04-16
本源码项目是基于Java的FastDFS大文件上传与断点续传设计，包含36个文件，主要使用Java、JavaScript和CSS编程语言。该项目旨在实现h5与fastdfs之间的高性能断点续传、秒传、大文件上传以及使用redis文件锁。系统提供...
基于Vue和Java的断点续传与大文件上传系统设计源码
04-10
本项目是一个基于Vue和Java的断点续传与大文件上传系统设计源码，共包含563个文件，其中包括258个Java文件、82个SVG文件等。系统采用了Vue-uploader和若依框架，为用户提供了一个便捷的文件上传解决方案。系统支持多...
java实现大文件上传分片上传断点续传.zip
10-25
综上所述，这个项目涵盖了Java文件处理、SpringBoot应用开发、RESTful API设计、前端交互、错误处理等多个核心知识点，旨在提供一个高效、稳定的大文件上传解决方案。通过学习和实践这个项目，开发者可以深入了解和...
[JSP]断点续传多线程链接下载! JSP/Servlet 实现
sosoft_dzz的专栏
02-09 964
% /*    文件名可存为: Download.jsp    HTTP 协议的请求与响应的会话过程可通过使用 FlashGet 下载 Http:// 连接的过程监视:    蓝色部分为: 客户端请求    紫色部分为: 服务器端响应    如图:    http://blog.youkuaiyun.com/images/blog_youkuaiyun.com/playyuer/30110
java 文件上传下载 断点续传 断点上传
08-14
完整的java上传下载源码。包含两种实现方式：1.web端上传下载 2.java接口实现断点上传。绝对可用。研究了好久总结的代码。
jsp 大文件分片上传处理
weixin_45525177的博客
12-08 130
4. 上传文件不能使用 request.getParameter("")获取参数了，而是直接将request解析，通过判断每一项是文件还是非文件，然后进行相应的操作（文件的话就是用流来读取，非文件的话，暂时保存到一个map中。1. 上面的java部分的代码可以直接使用，只需要将上传的图片路径及收集数据并将数据写入到数据库即可。这里需要处理一个MD5秒传的逻辑，当服务器存在相同文件时，不需要用户再上传，而是直接通知用户秒传。通过监控工具可以看到控件提交的数据，非常的清晰，调试也非常的简单。
前端大文件断点续传
weixin_52041354的博客
10-28 137
无论是前端还是服务端，都必须要生成文件和切片的 hash，之前我们使用文件名 + 切片下标作为切片 hash，这样做文件名一旦修改就失去了效果，而事实上只要文件内容不变，hash 就不应该变化，所以正确的做法是根据文件内容生成 hash，所以我们修改一下 hash 的生成规则。由于当文件切片上传后，服务端会建立一个文件夹存储所有上传的切片，所以每次前端上传前可以调用一个接口，服务端将已上传的切片的切片名返回，前端再跳过这些已经上传切片，这样就实现了“续传”的效果。
java+上传文件夹
Mr_Zang666的博客
08-22 792
我们平时经常做的是上传文件，上传文件夹与上传文件类似，但也有一些不同之处，这次做了上传文件夹就记录下以备后用。 首先我们需要了解的是上传文件三要素： 1.表单提交方式:post (get方式提交有大小限制,post没有) 2.表单的enctype属性:必须设置为multipart/form-data. 3.表单必须有文件上传项:file，且文件项需要给定name值 上传文件夹需要增加一个...
jsp http大文件断点续传上传
weixin_45525177的博客
06-02 142
java两台服务器之间，大文件上传（续传），采用了Socket通信机制以及JavaIO流两个技术点，具体思路如下： 实现思路： 1、服：利用ServerSocket搭建服务器，开启相应端口，进行长连接操作 2、服：使用ServerSocket.accept()方法进行阻塞，接收客户端请求 3、服：每接收到一个Socket就建立一个新的线程来处理它 4、客：利用Socket进行远程连接，询问已上传进度 5、客：使用FileInputStream.skip(long length)从指定位置读.
jsp之大文件分段上传、断点续传
weixin_52041354的博客
08-01 120
但是在实际场景中，会出现一种情况，即在终端发起续传请求时，URL对应的文件内容在服务端已经发生变化，此时续传的数据肯定是错误的。如何解决这个问题了？服务端在收到续传请求时，通过If-Range中的内容进行校验，校验一致时返回206的续传回应，不一致时服务端则返回200回应，回应的内容为新的文件的全部数据。用于响应头，指定整个实体中的一部分的插入位置，他也指示了整个实体的长度。(2)“Rangebytes=-200”，它不是表示请求文件开始位置的201个字节，而是表示要请求文件结尾处的200个字节。...
java httpclient 断点续传_java http大文件断点续传上传
05-14
下面是一个简单的Java代码示例，演示了如何使用HttpClient库实现HTTP大文件的断点续传上传： ```java import java.io.IOException; import java.io.InputStream; import java.io.RandomAccessFile; import org....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值