正在下载的效果图
下载完成效果图
小编的下载路径是放在sd卡的绝对路径中，方便验证！
工程目录图
介绍下每个类是干什么的
DownloadCallback：下载完成回调接口，包含三个方法 void onSuccess(File file)、void onFailure(Exception e)、void onProgress(long progress,long currentLength);
DownloadDispatcher：负责创建线程池，连接下载的文件；
DownloadRunnable：每个线程的执行对应的任务；
DownloadTask：每个apk的下载，这个类需要复用的；
ircleProgressbar:自定义的圆形进度条；具体思路：
1、首先自定义一个圆形进度条CircleProgressbar，实时更新进度
2、创建线程池，计算每个线程对应的不同的Range
3、每个线程下载完毕之后的回调，若出现了异常怎么处理OkHttpManager类
public class OkHttpManager {
private static final OkHttpManager sOkHttpManager = new OkHttpManager();
private OkHttpClient okHttpClient;
private OkHttpManager() {
okHttpClient = new OkHttpClient();
}
public static OkHttpManager getInstance() {
return sOkHttpManager;
}
public Call asyncCall(String url) {
Request request = new Request.Builder()
.url(url)
.build();
return okHttpClient.newCall(request);
}
public Response syncResponse(String url, long start, long end) throws IOException {
Request request = new Request.Builder()
.url(url)
//Range 请求头格式Range: bytes=start-end
.addHeader("Range", "bytes=" + start + "-" + end)
.build();
return okHttpClient.newCall(request).execute();
}
}大家可能会看到这个Range很懵，Range是啥？
什么是Range？
当用户在听一首歌的时候，如果听到一半（网络下载了一半），网络断掉了，用户需要继续听的时候，文件服务器不支持断点的话，则用户需要重新下载这个文件。而Range支持的话，客户端应该记录了之前已经读取的文件范围，网络恢复之后，则向服务器发送读取剩余Range的请求，服务端只需要发送客户端请求的那部分内容，而不用整个 文件发送回客户端，以此节省网络带宽。
例如：
Range: bytes=10- ：第10个字节及最后个字节的数据 。
Range: bytes=40-100 ：第40个字节到第100个字节之间的数据。
注意，这个表示[start,end]，即是包含请求头的start及end字节的，所以，下一个请求，应该是上一个请求的[end+1, nextEnd]
DownloadCallback类
public interface DownloadCallback {
/**
* 下载成功
*
* @param file
*/
void onSuccess(File file);
/**
* 下载失败
*
* @param e
*/
void onFailure(Exception e);
/**
* 下载进度
*
* @param progress
*/
void onProgress(long progress,long currentLength);
}DownloadCallback：下载完成回调接口，包含三个方法 void onSuccess(File file)下载文件成功回调、void onFailure(Exception e)下载文件失败回调、void onProgress(long progress,long currentLength) 下载文件实时更新下圆形进度条。
DownloadDispatcher 类
public class DownloadDispatcher {
private static final String TAG = "DownloadDispatcher";
private static volatile DownloadDispatcher sDownloadDispatcher;
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int THREAD_SIZE = Math.max(3, Math.min(CPU_COUNT - 1, 5));
//核心线程数
private static final int CORE_POOL_SIZE = THREAD_SIZE;
//线程池
private ExecutorService mExecutorService;
//private final Deque<DownloadTask> readyTasks = new ArrayDeque<>();
private final Deque<DownloadTask> runningTasks = new ArrayDeque<>();
//private final Deque<DownloadTask> stopTasks = new ArrayDeque<>();
private DownloadDispatcher() {
}
public static DownloadDispatcher getInstance() {
if (sDownloadDispatcher == null) {
synchronized (DownloadDispatcher.class) {
if (sDownloadDispatcher == null) {
sDownloadDispatcher = new DownloadDispatcher();
}
}
}
return sDownloadDispatcher;
}
/**
* 创建线程池
*
* @return mExecutorService
*/
public synchronized ExecutorService executorService() {
if (mExecutorService == null) {
mExecutorService = new ThreadPoolExecutor(CORE_POOL_SIZE, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), new ThreadFactory() {
@Override
public Thread newThread(@NonNull Runnable r) {
Thread thread = new Thread(r);
thread.setDaemon(false);
return thread;
}
});
}
return mExecutorService;
}
/**
* @param name 文件名
* @param url 下载的地址
* @param callBack 回调接口
*/
public void startDownload(final String name, final String url, final DownloadCallback callBack) {
Call call = OkHttpManager.getInstance().asyncCall(url);
call.enqueue(new Callback() {
@Override
public void onFailure(@NonNull Call call, @NonNull IOException e) {
callBack.onFailure(e);
}
@Override
public void onResponse(@NonNull Call call, @NonNull Response response) {
//获取文件的大小
long contentLength = response.body().contentLength();
Log.i(TAG, "contentLength=" + contentLength);
if (contentLength <= -1) {
return;
}
DownloadTask downloadTask = new DownloadTask(name, url, THREAD_SIZE, contentLength, callBack);
downloadTask.init();
runningTasks.add(downloadTask);
}
});
}
/**
* @param downLoadTask 下载任务
*/
public void recyclerTask(DownloadTask downLoadTask) {
runningTasks.remove(downLoadTask);
//参考OkHttp的Dispatcher()的源码
//readyTasks.
}
public void stopDownLoad(String url) {
//这个停止是不是这个正在下载的
}
}DownloadDispatcher这个类主要负责创建线程池，连接下载的文件，如果你要控制下载文件的个数，比如3-5个，可以在这个类控制，比如你最大允许同时下载三个文件，每个文件有五个线程去下载，那么maxRequest只有15个线程，其余的可以放到readyTasks 中，有一个线程下载完毕了可以remove()掉，总结起来说一句话，去仿照okhttp的Dispatcher源码去写，runningTasks、readyTasks、stopTasks。
DownloadTask类
public class DownloadTask {
private static final String TAG = "DownloadTask";
//文件下载的url
private String url;
//文件的名称
private String name;
//文件的大小
private long mContentLength;
//下载文件的线程的个数
private int mThreadSize;
//线程下载成功的个数,变量加个volatile，多线程保证变量可见性
private volatile int mSuccessNumber;
//总进度=每个线程的进度的和
private long mTotalProgress;
private List<DownloadRunnable> mDownloadRunnables;
private DownloadCallback mDownloadCallback;
public DownloadTask(String name, String url, int threadSize, long contentLength, DownloadCallback callBack) {
this.name = name;
this.url = url;
this.mThreadSize = threadSize;
this.mContentLength = contentLength;
this.mDownloadRunnables = new ArrayList<>();
this.mDownloadCallback = callBack;
}
public void init() {
for (int i = 0; i < mThreadSize; i++) {
//初始化的时候，需要读取数据库
//每个线程的下载的大小threadSize
long threadSize = mContentLength / mThreadSize;
//开始下载的位置
long start = i * threadSize;
//结束下载的位置
long end = start + threadSize - 1;
if (i == mThreadSize - 1) {
end = mContentLength - 1;
}
DownloadRunnable downloadRunnable = new DownloadRunnable(name, url, mContentLength, i, start, end, new DownloadCallback() {
@Override
public void onFailure(Exception e) {
//有一个线程发生异常，下载失败，需要把其它线程停止掉
mDownloadCallback.onFailure(e);
stopDownload();
}
@Override
public void onSuccess(File file) {
mSuccessNumber = mSuccessNumber + 1;
if (mSuccessNumber == mThreadSize) {
mDownloadCallback.onSuccess(file);
DownloadDispatcher.getInstance().recyclerTask(DownloadTask.this);
//如果下载完毕，清除数据库 todo
}
}
@Override
public void onProgress(long progress, long currentLength) {
//叠加下progress，实时去更新进度条
//这里需要synchronized下
synchronized (DownloadTask.this) {
mTotalProgress = mTotalProgress + progress;
//Log.i(TAG, "mTotalProgress==" + mTotalProgress);
mDownloadCallback.onProgress(mTotalProgress, currentLength);
}
}
});
//通过线程池去执行
DownloadDispatcher.getInstance().executorService().execute(downloadRunnable);
mDownloadRunnables.add(downloadRunnable);
}
}
/**
* 停止下载
*/
public void stopDownload() {
for (DownloadRunnable runnable : mDownloadRunnables) {
runnable.stop();
}
}DownloadTask负责每个apk的下载，这个类需要复用的。计算每个线程下载范围的大小，具体的每个变量是啥？注释写的很清楚。注意的是这个变量mSuccessNumber，线程下载成功的个数,变量加个volatile，多线程保证变量可见性。还有的就是叠加下progress的时候mTotalProgress = mTotalProgress + progress，需要synchronized(DownloadTask.this)下，保证这个变量mTotalProgress内存可见，并同步下。
DownloadRunnable类
public class DownloadRunnable implements Runnable {
private static final String TAG = "DownloadRunnable";
private static final int STATUS_DOWNLOADING = 1;
private static final int STATUS_STOP = 2;
//线程的状态
private int mStatus = STATUS_DOWNLOADING;
//文件下载的url
private String url;
//文件的名称
private String name;
//线程id
private int threadId;
//每个线程下载开始的位置
private long start;
//每个线程下载结束的位置
private long end;
//每个线程的下载进度
private long mProgress;
//文件的总大小 content-length
private long mCurrentLength;
private DownloadCallback downloadCallback;
public DownloadRunnable(String name, String url, long currentLength, int threadId, long start, long end, DownloadCallback downloadCallback) {
this.name = name;
this.url = url;
this.mCurrentLength = currentLength;
this.threadId = threadId;
this.start = start;
this.end = end;
this.downloadCallback = downloadCallback;
}
@Override
public void run() {
InputStream inputStream = null;
RandomAccessFile randomAccessFile = null;
try {
Response response = OkHttpManager.getInstance().syncResponse(url, start, end);
Log.i(TAG, "fileName=" + name + " 每个线程负责下载文件大小contentLength=" + response.body().contentLength()
+ " 开始位置start=" + start + "结束位置end=" + end + " threadId=" + threadId);
inputStream = response.body().byteStream();
//保存文件的路径
File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath(), name);
randomAccessFile = new RandomAccessFile(file, "rwd");
//seek从哪里开始
randomAccessFile.seek(start);
int length;
byte[] bytes = new byte[10 * 1024];
while ((length = inputStream.read(bytes)) != -1) {
if (mStatus == STATUS_STOP)
break;
//写入
randomAccessFile.write(bytes, 0, length);
//保存下进度，做断点 todo
mProgress = mProgress + length;
//实时去更新下进度条，将每次写入的length传出去
downloadCallback.onProgress(length, mCurrentLength);
}
downloadCallback.onSuccess(file);
} catch (IOException e) {
e.printStackTrace();
downloadCallback.onFailure(e);
} finally {
Utils.close(inputStream);
Utils.close(randomAccessFile);
//保存到数据库 怎么存？？ todo
}
}
public void stop() {
mStatus = STATUS_STOP;
}
}DownloadRunnable负责每个线程的执行对应的任务，使用RandomAccessFile写入文件。最后看一张截图
哈，看到最后断点下载并没有实现，这个不急，小编还没写，但是实现多线程下载文件整体的思路和代码都已经出来了，至于断点怎么弄，其实具体的思路，在代码注解也已经写出来了，主要是DownloadRunnable 这个类，向数据库保存下文件的下载路径url，文件的大小currentLength，每个线程id，对应的每个线程的start位置和结束位置，以及每个线程的下载进度progress。用户下次进来可以读取数据库的内容，有网的情况下重新发请请求，对应Range: bytes=start-end；
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
