说明
主要功能:
1) 分割文件, 生成下载任务;
2) 定时任务: 检索需要下载的任务, 利用多线程下载并限制下载速度;
3) 定时任务: 检索可合并的文件, 把n个文件合并为完整的文件.
GitHub: https://github.com/vergilyn/SpringBootDemo
代码结构:
一、获取远程资源ContentLength、FileName
本来以为很容易, 但如果想较好的得到contentLength、fileName其实很麻烦,主要要看download-url是怎么样的. 大致有3种:
1) download-url: www.xxx.com/xxxx.exe,这种是最简单的.直接通过HttpURLConnection.getContentLength()就可以获取到, FileName则直接解析download-url(或从Content-Disposition中解析得到fileName).
2) download-url: www.xxx.com/download.html?fileId=xxx, 这个实际响应的和1)一样, 只是无法直接解析download-url得到fileName, 只能从Content-Disposition中解析得到fileName.
3) download-url跟2)类似, 但会"重定向"或"响应"一个真实下载地址, 那么就需要具体分析.
二、分割下载文件
原意: 把一个大文件分割成n个小文件, 分别下载这n个小文件. 尽可能减少需要重新下载的大小. 其实就是想要"断点下载"(或称"断点续传");
但是, 后面想了下这种"分块"感觉好蠢.更理想的实现思路可能是:
直接往完整文件file.exe.tmp写,每次启动下载的时候读取这个file.exe.tmp的size,请求下载的Range就是bytes={size}-{contentLength}.
代码说明: 生成n个下载任务, 保存每个下载任务的Range: bytes={beginOffse}-{endOffset}
private void createSplitFile(CompleteFileBean fileBean){
String key = ConstantUtils.keyBlock(fileBean.getId());
String fileId = fileBean.getId();
String fileName = fileBean.getFileName();
String url = fileBean.getDownloadUrl();
long contentLength = fileBean.getContentLength();
BlockFileBean block;
List blocks = new ArrayList<>();
if(contentLength <= ConstantUtils.UNIT_SIZE){
block = new BlockFileBean(fileId, getBlockName(fileName, 1), url, 0, contentLength );
blocks.add(JSON.toJSONString(block));
}else{
long begin = 0;
int index = 1;
while(begin < contentLength){
long end = begin + ConstantUtils.UNIT_SIZE <= contentLength ? begin + ConstantUtils.UNIT_SIZE : contentLength;
block = new BlockFileBean(fileId, getBlockName(fileName, index++), url, begin, end );
blocks.add(JSON.toJSONString(block));
begin += ConstantUtils.UNIT_SIZE;
}
}
if(blocks.size() > 0){
// 模拟保存数据库: 生成每个小块的下载任务, 待定时器读取任务下载
redisTemplate.opsForList().rightPushAll(key, blocks);
// 保存需要执行下载的任务, 实际应用中是通过sql得到.
redisTemplate.opsForList().rightPushAll(ConstantUtils.keyDownloadTask(), key);
}
} 三、多线程下载
线程池、线程的知识请自行baidu/google;(我也不是很了解啊 >. 实际中我只特别去了解了下:ArrayBlockingQueue、CallerRunsPolicy, 根据我的理解(不一定对): 只有CallerRunsPolicy比较适用, 但当ArrayBlockingQueue等待队列达到满值时并且有新任务A-TASK进来时,CallerRunsPolicy会强制中断当前主线程去执行这个新任务A-TASK, 见：https://www.cnblogs.com/lic309/p/4564507.html.
这是否意味着我可能有"某块"下到一半被强制中断了?虽然这下载任务并未被标记成已下载完, 但如果有大量这种中断操作, 意味着会重新去下载这部分数据.(这也反映出另外中"断点下载"思路可能更好)
所以, 实际中我把任务等待队列设置成一定比总任务数大. 因为实际中我每天只执行一次下载定时任务, 每次只下载700个小块(即700条下载任务), 所以ArrayBlockingQueue我设置的800. 并且我没有保留核心线程
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2,
6,
30,
TimeUnit.MINUTES,
new ArrayBlockingQueue(100),
new ThreadPoolExecutor.CallerRunsPolicy()
);
executor.allowCoreThreadTimeOut(true); 分块下载, 只需用到Http请求的Range: bytes={beginOffse}-{endOffset}.
至于哪种"下载"写法更好, 并未有太多的深究, 所以不知道具体那种"下载"的写法会更好, 但看到很多都是RandomAccessFile实现的:
@Override
public void run() {
byte[] buffer = new byte[1024]; // 缓冲区大小
long totalSize = block.getEndOffset() - block.getBeginOffset();
long begin = System.currentTimeMillis();
InputStream is = null;
RandomAccessFile os = null;
try {
URLConnection conn = new URL(block.getDownloadUrl()).openConnection();
// -1: 因为bytes=0-499, 表示contentLength=500.
conn.setRequestProperty(HttpHeaders.RANGE, "bytes=" + block.getBeginOffset() + "-" + (block.getEndOffset() - 1));
conn.setDoOutput(true);
is = conn.getInputStream();
File file = new File(tempPath + File.separator + block.getBlockFileName());
os = new RandomAccessFile(file, "rw");
int len;
while((len = is.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
os.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println(block.getBlockFileName() + " download error: " + e.getMessage());
return; // 注意要return
} finally {
IOUtils.closeQuietly(is);
IOUtils.closeQuietly(os);
}
long end = System.currentTimeMillis() ;
// 简单计算下载速度, 我把连接时间也算在内了
double speed = totalSize / 1024D / (end - begin + 1) * 1000D; // +1: 避免0
System.out.println(block.getBlockFileName() + " aver-speed: " + speed + " kb/s");
// FIXME: 实际中需要更新表BlockFileBean的信息, 标记分块已下载完成, 记录平均下载速度、下载完成时间等需要的信息
// (省略)更新表BlockFileBean
}四、限制下载速度
看了下网上说的如何现在下载速度, 思路:
假设下载速度上限是m(kb/s), 发送n个字节的理论耗时: n / 1024 / m (kb/s); 然而实际耗时 t(s), 那么则线程需要休眠 n / 1024 / m - t;
我也只是看到都是用这种方式来限速, 但我怎么觉得"很蠢", (个人理解)这种实现其实实际下载速度还是满速, 而且会频繁的存在线程的调度.
public class SpeedLimit {
private final Long speed;
// 已下载大小
private Long writeSize = 0L;
private long beginTime;
private long endTime;
public SpeedLimit(Long speed, long beginTime) {
this.speed = speed;
this.beginTime = beginTime;
this.endTime = beginTime;
}
public void updateWrite(int size){
this.writeSize += size;
}
public void updateEndTime(long endTime) {
this.endTime = endTime;
}
public Long getTotalSize() {
return totalSize;
}
public Long getSpeed() {
return speed;
}
public Long getWriteSize() {
return writeSize;
}
public long getBeginTime() {
return beginTime;
}
public long getEndTime() {
return endTime;
}
} @Override
public void run() {
byte[] buffer = new byte[1024]; // 缓冲区大小
long totalSize = block.getEndOffset() - block.getBeginOffset();
long begin = System.currentTimeMillis();
InputStream is = null;
RandomAccessFile os = null;
try {
// FIXME: 对下载(对文件操作)并没有太多了解, 所以不知道具体那种"下载"的写法会更好, 但看到很多都是RandomAccessFile实现的.
URLConnection conn = new URL(block.getDownloadUrl()).openConnection();
// -1: 因为bytes=0-499, 表示contentLength=500.
conn.setRequestProperty(HttpHeaders.RANGE, "bytes=" + block.getBeginOffset() + "-" + (block.getEndOffset() - 1));
conn.setDoOutput(true);
is = conn.getInputStream();
File file = new File(tempPath + File.separator + block.getBlockFileName());
os = new RandomAccessFile(file, "rw");
int len;
// 是否限制下载速度
if(ConstantUtils.IS_LIMIT_SPEED){ // 限制下载速度
/* 思路:
* 假设下载速度上限是m(kb/s), 发送n个字节的理论耗时: n / 1024 / m; 然而实际耗时 t(s), 那么则需要休眠 n / 1024 / m - t;
*/
// 需要注意: System.currentTimeMillis(), 可能多次得到的时间相同, 详见其API说明.
SpeedLimit sl = new SpeedLimit(ConstantUtils.DOWNLOAD_SPEED, System.currentTimeMillis());
while((len = is.read(buffer)) != -1) {
os.write(buffer, 0, len);
sl.updateWrite(len);
sl.updateEndTime(System.currentTimeMillis());
long timeConsuming = sl.getEndTime() - sl.getBeginTime() + 1; // +1: 避免0
// 当前平均下载速度: kb/s, 实际中可以直接把 b/ms 约等于 kb/ms (减少单位转换逻辑)
double currSpeed = sl.getWriteSize() / 1024D / timeConsuming * 1000D;
if(currSpeed > sl.getSpeed()){ // 当前下载速度超过限制速度
// 休眠时长 = 理论限速时常 - 实耗时常;
double sleep = sl.getWriteSize() / 1024D / sl.getSpeed() * 1000D - timeConsuming;
if(sleep > 0){
try {
Thread.sleep((long) sleep);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}else{
while((len = is.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
}
os.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println(block.getBlockFileName() + " download error: " + e.getMessage());
return; // 注意要return
} finally {
IOUtils.closeQuietly(is);
IOUtils.closeQuietly(os);
}
long end = System.currentTimeMillis() ;
// 简单计算下载速度, 我把连接时间也算在内了
double speed = totalSize / 1024D / (end - begin + 1) * 1000D; // +1: 避免0
System.out.println(block.getBlockFileName() + " aver-speed: " + speed + " kb/s");
// FIXME: 实际中需要更新表BlockFileBean的信息, 标记分块已下载完成, 记录平均下载速度、下载完成时间等需要的信息
// (省略)更新表BlockFileBean
}五、合并文件
需要注意:
1) 合并文件的顺序;
2) stream一定要关闭;
3) 不要把一个大文件读取到内存中.
我乱七八糟写了(或看到)以下4种写法,并没去深究哪种更理想.可能比较推荐的RandomAccessFile或者channelTransfer的形式.
(以下代码中的stream并不一定都关闭了, 可以检查一遍)
public class FileMergeUtil {
/**
* 利用FileChannel.write()合并文件
*
* @param dest 最终文件保存完整路径
* @param files 注意排序
* @param capacity {@link ByteBuffer#allocate(int)}
* @see http://blog.csdn.net/skiof007/article/details/51072885
* @see ByteBuffer.allocate()与ByteBuffer.allocateDirect()方法的区别
*/
public static void channelWrite(String dest, File[] files, int capacity) {
capacity = capacity <= 0 ? 1024 : capacity;
FileChannel outChannel = null;
FileChannel inChannel = null;
FileOutputStream os = null;
FileInputStream is = null;
try {
os = new FileOutputStream(dest);
outChannel = os.getChannel();
for (File file : files) {
is = new FileInputStream(file);
inChannel = is.getChannel();
ByteBuffer bb = ByteBuffer.allocate(capacity);
while (inChannel.read(bb) != -1) {
bb.flip();
outChannel.write(bb);
bb.clear();
}
inChannel.close();
is.close();
}
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
try {
if (outChannel != null) {
outChannel.close();
}
if (inChannel != null) {
inChannel.close();
}
if (os != null) {
os.close();
}
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 利用FileChannel.transferFrom()合并文件
* @param dest 最终文件保存完整路径
* @param files 注意排序
* @see http://blog.csdn.net/tobacco5648/article/details/52958046
*/
public static void channelTransfer(String dest, File[] files) {
FileChannel outChannel = null;
FileChannel inChannel = null;
FileOutputStream os = null;
FileInputStream is = null;
try {
os = new FileOutputStream(dest);
outChannel = os.getChannel();
for (File file : files) {
is = new FileInputStream(file);
inChannel = is.getChannel();
outChannel.transferFrom(inChannel, outChannel.size(), inChannel.size());
inChannel.close();
is.close();
}
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
try {
if (outChannel != null) {
outChannel.close();
}
if (inChannel != null) {
inChannel.close();
}
if (os != null) {
os.close();
}
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 利用apache common-IO, {@link IOUtils#copyLarge(Reader, Writer, char[])}.
* 看实现代码, 不就是普通write()? 没发现又什么特别的优化, 所以感觉此方式性能/效率可能并不好.
* @param dest
* @param files
* @param buffer
*/
public static void apache(String dest, File[] files, int buffer){
OutputStream os = null;
try {
byte[] buf = new byte[buffer];
os = new FileOutputStream(dest);
for (File file : files) {
InputStream is = new FileInputStream(file);
IOUtils.copyLarge(is, os, buf);
is.close();
}
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 利用randomAccessFile合并文件.
* 虽然用了RandomAccessFile, 但还是普通的write(), 未了解其性能....
* @param dest
* @param files
* @param buffer
*/
public static void randomAccessFile(String dest, List files, int buffer){
RandomAccessFile in = null;
try {
in = new RandomAccessFile(dest, "rw");
in.setLength(0);
in.seek(0);
byte[] bytes = new byte[buffer];
int len = -1;
for (File file : files) {
RandomAccessFile out = new RandomAccessFile(file, "r");
while((len = out.read(bytes)) != -1) {
in.write(bytes, 0, len);
}
out.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(in != null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}