java实现大文件下载(http方式)

最新推荐文章于 2024-06-05 16:50:15 发布
最新推荐文章于 2024-06-05 16:50:15 发布
阅读量1.2w 收藏 10
点赞数 1
分类专栏： JAVA基础

java实现大文件下载，基于http方式，控件神马的就不说了。

思路：下载文件无非要读取文件然后写文件，主要这两个步骤，主要难点：

    1.读文件，就是硬盘到内存的过程，由于jdk内存限制，不能读的太大。

    2.写文件，就是响应到浏览器端的过程，http协议是短链接，如果写文件太慢，时间过久，会造成浏览器死掉。


知识点：

    1.org.apache.http.impl.client.CloseableHttpClient  模拟httpClient客户端发送http请求，可以控制到请求文件的字节位置。

    2.BufferedInputStream都熟悉，用它接受请求来的流信息缓存。

    3.RandomAccessFile文件随机类，可以向文件写入指定位置的流信息。


基于以上信息，我的实现思路就是首先判断下载文件大小，配合多线程分割定制http请求数量和请求内容，响应到写入到RandomAccessFile指定位置中。在俗点就是大的http分割成一个个小的http请求，相当于每次请求一个网页。

废话不说，上代码。



DownLoadManagerTest类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
package  xxxx;
 
import  java.io.File;
import  java.io.IOException;
import  java.io.RandomAccessFile;
import  java.net.HttpURLConnection;
import  java.net.URL;
import  java.util.concurrent.CountDownLatch;
import  org.apache.commons.lang.exception.ExceptionUtils;
import  org.apache.http.impl.client.CloseableHttpClient;
import  org.apache.http.impl.client.HttpClients;
import  org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import  org.junit.After;
import  org.junit.Before;
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.slf4j.Logger;
import  org.slf4j.LoggerFactory;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.core.task.TaskExecutor;
import  org.springframework.test.context.ActiveProfiles;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
  * 
  * 文件下载管理类
  */
 
@RunWith (SpringJUnit4ClassRunner. class )
@ActiveProfiles ( "test" )
@ContextConfiguration (locations={ "classpath:test/applicationContext.xml" })
public  class  DownLoadManagerTest  extends  AbstractTransactionalJUnit4SpringContextTests{
     
     private  static  final  Logger LOGGER = LoggerFactory.getLogger(DownLoadManagerTest. class );
 
     /**
      * 
      * 每个线程下载的字节数
      */
 
     private  long  unitSize =  1000  *  1024 ;
     
     @Autowired
     private  TaskExecutor taskExecutor;
     
     private  CloseableHttpClient httpClient;
     
     private  Long starttimes;
     
     private  Long endtimes;
     
     @Before
     public  void  setUp()  throws  Exception
     {
         starttimes = System.currentTimeMillis();
         System.out.println( "测试开始...." );
     }
     
     @After
     public  void  tearDown()  throws  Exception
     {
         endtimes = System.currentTimeMillis();
         System.out.println( "测试结束!!" );
         System.out.println( "********************" );
         System.out.println( "下载总耗时:" +(endtimes-starttimes)/ 1000 + "s" );
         System.out.println( "********************" );
     }
 
     public  DownLoadManagerTest() {
         
         System.out.println( "初始化测试类...." );
         PoolingHttpClientConnectionManager cm =  new  PoolingHttpClientConnectionManager();
         cm.setMaxTotal( 100 );
         httpClient = HttpClients.custom().setConnectionManager(cm).build();
         
     }
 
     /**
      * 
      * 启动多个线程下载文件
      */
     @Test
     public  void   doDownload()  throws  IOException {
 
         String remoteFileUrl= "http://{host}:{port}/{project}/xx.xml" ;
         String localPath= "E://test//" ;
         
         String fileName =  new  URL(remoteFileUrl).getFile();
 
         System.out.println( "远程文件名称：" +fileName);
         fileName = fileName.substring(fileName.lastIndexOf( "/" ) +  1 ,
                 fileName.length()).replace( "%20" ,  " " );
         System.out.println( "本地文件名称：" +fileName);
         long  fileSize =  this .getRemoteFileSize(remoteFileUrl);
 
         this .createFile(localPath+System.currentTimeMillis()+fileName, fileSize);
 
         Long threadCount = (fileSize/unitSize)+(fileSize % unitSize!= 0 ? 1 : 0 );
         long  offset =  0 ;
         
         CountDownLatch end =  new  CountDownLatch(threadCount.intValue());
         
         if  (fileSize <= unitSize) { // 如果远程文件尺寸小于等于unitSize
 
             DownloadThreadTest downloadThread =  new  DownloadThreadTest(remoteFileUrl,
 
                     localPath+fileName, offset, fileSize,end,httpClient);
 
             taskExecutor.execute(downloadThread);
 
         }  else  { // 如果远程文件尺寸大于unitSize
 
             for  ( int  i =  1 ; i < threadCount; i++) {
 
                 DownloadThreadTest downloadThread =  new  DownloadThreadTest(
 
                 remoteFileUrl, localPath+fileName, offset, unitSize,end,httpClient);
 
                 taskExecutor.execute(downloadThread);
 
                 offset = offset + unitSize;
 
             }
 
             if  (fileSize % unitSize !=  0 ) { // 如果不能整除，则需要再创建一个线程下载剩余字节
 
                 DownloadThreadTest downloadThread =  new  DownloadThreadTest(remoteFileUrl, localPath+fileName, offset, fileSize - unitSize * (threadCount- 1 ),end,httpClient);
                 taskExecutor.execute(downloadThread);
             }
 
         }
         try  {
             end.await();
         }  catch  (InterruptedException e) {
             LOGGER.error( "DownLoadManager exception msg:{}" ,ExceptionUtils.getFullStackTrace(e));
             e.printStackTrace();
         }
//      System.out.println("111111");
         LOGGER.debug( "下载完成！{} " ,localPath+fileName);
         //return localPath+fileName;
     }
 
     /**
      * 
      * 获取远程文件尺寸
      */
 
     private  long  getRemoteFileSize(String remoteFileUrl)  throws  IOException {
 
         long  fileSize =  0 ;
 
         HttpURLConnection httpConnection = (HttpURLConnection)  new  URL(
 
         remoteFileUrl).openConnection();
 
         httpConnection.setRequestMethod( "HEAD" );
 
         int  responseCode = httpConnection.getResponseCode();
 
         if  (responseCode >=  400 ) {
 
             LOGGER.debug( "Web服务器响应错误!" );
 
             return  0 ;
 
         }
 
         String sHeader;
 
         for  ( int  i =  1 ;; i++) {
 
             sHeader = httpConnection.getHeaderFieldKey(i);
 
             if  (sHeader !=  null  && sHeader.equals( "Content-Length" )) {
 
                 System.out.println( "文件大小ContentLength:"
                         + httpConnection.getContentLength());
 
                 fileSize = Long.parseLong(httpConnection
                         .getHeaderField(sHeader));
 
                 break ;
 
             }
 
         }
 
         return  fileSize;
 
     }
 
     /**
      * 
      * 创建指定大小的文件
      */
 
     private  void  createFile(String fileName,  long  fileSize)  throws  IOException {
 
         File newFile =  new  File(fileName);
 
         RandomAccessFile raf =  new  RandomAccessFile(newFile,  "rw" );
 
         raf.setLength(fileSize);
 
         raf.close();
 
     }
 
 
     public  TaskExecutor getTaskExecutor() {
         return  taskExecutor;
     }
 
     public  void  setTaskExecutor(TaskExecutor taskExecutor) {
         this .taskExecutor = taskExecutor;
     }
     
}

DownloadThreadTest类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package  xxxx;
 
import  java.io.BufferedInputStream;
import  java.io.File;
import  java.io.IOException;
import  java.io.RandomAccessFile;
import  java.util.concurrent.CountDownLatch;
import  org.apache.commons.lang.exception.ExceptionUtils;
import  org.apache.http.client.ClientProtocolException;
import  org.apache.http.client.methods.CloseableHttpResponse;
import  org.apache.http.client.methods.HttpGet;
import  org.apache.http.impl.client.CloseableHttpClient;
import  org.apache.http.protocol.BasicHttpContext;
import  org.apache.http.protocol.HttpContext;
import  org.slf4j.Logger;
import  org.slf4j.LoggerFactory;
 
/**
  * 
  * 负责文件下载的类
  */
 
public  class  DownloadThreadTest  extends  Thread {
 
     private  static  final  Logger LOGGER = LoggerFactory
             .getLogger(DownloadThreadTest. class );
 
     /**
      * 
      * 待下载的文件
      */
 
     private  String url =  null ;
 
     /**
      * 
      * 本地文件名
      */
 
     private  String fileName =  null ;
 
     /**
      * 
      * 偏移量
      */
 
     private  long  offset =  0 ;
 
     /**
      * 
      * 分配给本线程的下载字节数
      */
 
     private  long  length =  0 ;
 
     private  CountDownLatch end;
 
     private  CloseableHttpClient httpClient;
 
     private  HttpContext context;
 
     /**
      * 
      * @param url
      *            下载文件地址
      * 
      * @param fileName
      *            另存文件名
      * 
      * @param offset
      *            本线程下载偏移量
      * 
      * @param length
      *            本线程下载长度
      * 
      * 
      * 
      * @author Angus.wang
      * 
      * */
 
     public  DownloadThreadTest(String url, String file,  long  offset,  long  length,
             CountDownLatch end, CloseableHttpClient httpClient) {
 
         this .url = url;
 
         this .fileName = file;
 
         this .offset = offset;
 
         this .length = length;
 
         this .end = end;
 
         this .httpClient = httpClient;
 
         this .context =  new  BasicHttpContext();
 
         LOGGER.debug( "偏移量="  + offset +  ";字节数="  + length);
 
     }
 
     public  void  run() {
 
         try  {
 
             HttpGet httpGet =  new  HttpGet( this .url);
             httpGet.addHeader( "Range" ,  "bytes="  +  this .offset +  "-"
                     + ( this .offset +  this .length -  1 ));
             CloseableHttpResponse response = httpClient.execute(httpGet,
                     context);
             ;
             BufferedInputStream bis =  new  BufferedInputStream(response
                     .getEntity().getContent());
 
             byte [] buff =  new  byte [ 1024 ];
 
             int  bytesRead;
 
             File newFile =  new  File(fileName);
 
             RandomAccessFile raf =  new  RandomAccessFile(newFile,  "rw" );
 
             while  ((bytesRead = bis.read(buff,  0 , buff.length)) != - 1 ) {
                 raf.seek( this .offset);
                 raf.write(buff,  0 , bytesRead);
                 this .offset =  this .offset + bytesRead;
             }
             raf.close();
             bis.close();
         }  catch  (ClientProtocolException e) {
             LOGGER.error( "DownloadThread exception msg:{}" ,ExceptionUtils.getFullStackTrace(e));
         }  catch  (IOException e) {
             LOGGER.error( "DownloadThread exception msg:{}" ,ExceptionUtils.getFullStackTrace(e));
         }  finally  {
             end.countDown();
             LOGGER.info(end.getCount() +  " is go on!" );
             System.out.println(end.getCount() +  " is go on!" );
         }
     }
 
}

application.xml

?
1
2
3
4
5
6
7
8
9
10
11
12
13
<bean id= "taskExecutor"
         class = "org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" >
         <!-- 线程池活跃的线程数 -->
         <property name= "corePoolSize"  value= "5"  />
         <!-- 线程池最大活跃的线程数 -->
         <property name= "maxPoolSize"  value= "10"  />
         <!-- 队列的最大容量 -->
         <property name= "queueCapacity"  value= "600"  />
     </bean>
     <bean id= "downLoadManager"
         class = "xx.DownLoadManagerTest" >
         <property name= "taskExecutor"  ref= "taskExecutor"  />
     </bean>

测试运行，500M,我这网速得半个小时左右。要想下载更大的文件，只要jdk内存够大，就无限更改队列最大容量吧。

如果不同意见，欢迎各位大神指正。




尊重原创，多谢作者分享，转载自：http://my.oschina.net/zmf/blog/336961

lanqibaoer
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 大文件下载
qq_37713521的博客
04-05 359
【代码】java 大文件下载。
java大文件上传，大文件下载解决方案
weixin_52041354的博客
09-18 2053
分片上传： 将大文件分成小块，分别上传，然后在服务器端将这些块合并成一个完整的文件。普通的Servlet文件上传： 使用Java Servlet技术，通过表单提交文件，然后在服务器端使用流将文件写入磁盘。这适用于小文件，但不太适合大文件，因为需要将整个文件加载到内存中。大文件分片上传是一种常见的策略，它可以减少单次上传的负担，并且支持在上传过程中断点续传。使用NIO（New I/O）： 使用Java的NIO库，可以使用FileChannel来高效地进行文件的读取和传输，适用于大文件。
java+超大文件上传与下载
最新发布
weixin_45525177的博客
06-05 618
java+超大文件上传与下载，java+超大文件上传与下载解决方案，java+超大文件上传与下载思路，java+超大文件上传与下载实例，java+超大文件上传与下载源码，java+超大文件分块上传与下载，java+超大文件分片上传与下载，java+超大文件切片上传与下载，痛点就是刷新继续，批量上传，批量下载。实现原理，就是在每个文件上传前，就获取到文件MD5取值，在上传文件前调用接口，如果获取的文件状态是未完成，则返回所有的还没上传的分块的编号，然后前端进行条件筛算出哪些没上传的分块，然后进行上传。
java http下载到本地文件
hanjiaqian的博客
07-13 3569
java http下载到本地文件
java http远程调用接口下载文件
a1k2l45k的博客
07-12 2660
远程调用http接口下载文件，接口返回流。二、将接收到流直接返回。
java从http地址下载文件
svygh123的专栏
11-23 2708
import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.n...
java实现文件下载的两种方式
08-28
Java 实现文件下载的两种方式是指通过 Java 语言实现文件下载的两种方法，主要分为本地文件下载和网络文件下载两种方式。下面将对这两种方式进行详细的介绍。 本地文件下载 本地文件下载是指从本地文件系统中下载...
VUE + java 文件下载
03-29
实现在浏览器前端点击后的文件下载。 不是整个工程代码，只把涉及到下载用的前端的代码和后端的代码贴出来了，可以直接复制使用，有详细的步骤。 包含了前端在执行post请求的关键的参数哦！responseType: "blob
Java实现的文件上传下载工具类完整实例【上传文件自动命名】
08-28
Java文件上传下载工具类是Java编程语言中实现文件上传下载操作的重要组件。以下是对Java实现的文件上传下载工具类的详细介绍。 一、文件上传下载工具类的实现 Java文件上传下载工具类是使用Java语言实现的，旨在...
Java 利用多线程实现文件的分片下载
01-15
大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而自己网络又非常好的情况下，不建议使用线程池进行下载，因为...
java实现服务器文件打包zip并下载的示例(边打包边下载)
09-04
总结来说，这个Java实现利用了HTTP的chunked传输机制和ZIP压缩功能，实现在服务器端即时打包文件并提供给客户端下载，整个过程中不依赖任何缓存，实现了真正的边打包边下载。这样的设计不仅高效，还能减少服务器资源...
org.apache.commons.httpclient 远程下载文件
03-31
NULL 博文链接：https://sunshuaij2ee.iteye.com/blog/1354467
http大文件断点续传
09-15
http大文件断点续传，理论上传文件大小无限制。
httpclient下载文件
11-19
apache httpclient 的几个简单封装，基于httpclient4.3. 示例代码: long len = HttpUtil.download("http://localhost/upload/817.mov", "D:/test.mov"); 内部含有源码jar和lib,请翻阅 httpdownloadutil.jar
JAVA 实现多线程下载大文件
qq_43021813的博客
12-28 4564
JAVA 实现多线程下载大文件 开发中遇到一个问题，下载大文件到本地，导致等待时间过长，然后就寻找一个可以多线程下载的办法，受下载软件启发，想到多线程下载， 原理，首先查到这个文件的大小，然后根据线程数量去分配每个线程下载多大的片段，然后将每个线程的组合到一起，就是最终的下载文件。如图 然后就是代码时间， 必不可少的控制层 @Override @ApiOperation(value = "多线程获取大文件", httpMethod = "POST") @BodyValida
java http 下载文件_JAVA通过HttpURLConnection 上传和下载文件的方法
weixin_33923901的博客
02-12 1054
本文介绍了JAVA通过HttpURLConnection 上传和下载文件的方法，分享给大家，具体如下：HttpURLConnection文件上传HttpURLConnection采用模拟浏览器上传的数据格式，上传给服务器上传代码如下：package com.util;import java.io.BufferedInputStream;import java.io.BufferedReader;i...
java 下载加速_一种基于Java的大文件下载加速方法与流程
weixin_39541869的博客
02-16 1023
本发明涉及java/多线程技术领域，涉及一种加速文件下载装置，具体提供一种基于java的大文件下载加速方法。背景技术：现有的常用下载方式是基于浏览器的单线程下载。这种单线程下载的方式，是通过http传输协议请求下载。一般而言，把需要下载的文件放在服务器的某个路径下，或者服务端通过数据库拼接文件，当客户端请求服务器进行下载的时候，服务端通过对应路径或者数据库拼接文件返回给客户端文件字节流。客户端进行...
基于curl 使用http多线程下载大文件
零落年华的专栏
12-07 941
7、检验文件MD5是否一致。如需完整代码，可评论区留言。6、获取服务器文件MD5。四、等待所有线程完成。
C# http下载大文件，支持断点下载
努力学习中的博客
05-20 1385
C# http下载大文件，支持断点下载
Java实现大文件上传下载
05-22
Java实现大文件上传下载可以使用Apache的HttpClient库，它提供了一个方便的方式来处理HTTP请求和响应。下面介绍一下具体实现。 上传： 1. 创建HttpClient对象。 ``` CloseableHttpClient httpClient = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值