Android学习记录（6）—将java中的多线程下载移植到Android中（即多线程下载在Android中的使用）

在这一节中，我们就来讲多线程下载以及断点续传在android中怎么使用，前两节是为本节做准备的，没有看前两节的同学，最好看完前面的两篇文章再来看这篇。其实在android端的应用和java基本上是差不多的，只不过在android端我建议对于断点续传的记录的保存放在android的sqlite3的数据库中，这样是最好的，当然保存在sd卡中也行，我为了方便起见，我没有建立数据库，而是直接保存到了sd卡中。先看一下我在android中运行的效果图，如下：

我在这里的代码加上了进度条的显示和下载进度百分比的显示，为了让进度条和百分比不混乱，我为下载线程中计算下载进度的代码加上了锁。如下：

还有就是下边的一段代码我把记录下载进度的文件保存到了SD卡中，我建议最好用数据库。这段代码如下：

其它的我倒是没有什么好解释的了，跟上一篇文章的内容差不多，而且我在代码中已经写得很详细了，那么就请大家看代码吧！

MainActivity中的代码如下：

[java] view plain copy

 

1. package net.loonggg.android.downloader;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.InputStream;  
6. import java.io.RandomAccessFile;  
7. import java.net.HttpURLConnection;  
8. import java.net.URL;  
9.   
10. import android.annotation.SuppressLint;  
11. import android.app.Activity;  
12. import android.os.Bundle;  
13. import android.os.Handler;  
14. import android.os.Message;  
15. import android.view.View;  
16. import android.view.Window;  
17. import android.widget.Button;  
18. import android.widget.EditText;  
19. import android.widget.ProgressBar;  
20. import android.widget.TextView;  
21. import android.widget.Toast;  
22.   
23. @SuppressLint("HandlerLeak")  
24. public class MainActivity extends Activity {  
25.     public int currentProcess = 0;// 下载文件的当前进度  
26.     // 开启的线程的个数  
27.     public static final int THREAD_COUNT = 3;  
28.     public static int runningThread = 3;// 记录正在运行的下载文件的线程数  
29.     private EditText et;  
30.     private Button btn;  
31.     private TextView tv;  
32.     private ProgressBar pb;// 下载进度条  
33.   
34.     private Handler handler = new Handler() {  
35.         public void handleMessage(android.os.Message msg) {  
36.             switch (msg.arg1) {  
37.             case 0:  
38.                 Toast.makeText(getApplicationContext(), "下载失败！",  
39.                         Toast.LENGTH_SHORT).show();  
40.                 break;  
41.             case 1:  
42.                 Toast.makeText(getApplicationContext(), "下载完成！",  
43.                         Toast.LENGTH_SHORT).show();  
44.                 break;  
45.             case 2:  
46.                 tv.setText("下载进度:" + pb.getProgress() * 100 / pb.getMax() + "%");  
47.                 break;  
48.             default:  
49.                 break;  
50.             }  
51.         };  
52.     };  
53.   
54.     @Override  
55.     protected void onCreate(Bundle savedInstanceState) {  
56.         super.onCreate(savedInstanceState);  
57.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
58.         setContentView(R.layout.activity_main);  
59.         et = (EditText) findViewById(R.id.et);  
60.         pb = (ProgressBar) findViewById(R.id.pb);  
61.         btn = (Button) findViewById(R.id.btn);  
62.         tv = (TextView) findViewById(R.id.tv_process);  
63.         btn.setOnClickListener(new View.OnClickListener() {  
64.   
65.             @Override  
66.             public void onClick(View v) {  
67.                 downLoad();  
68.             }  
69.         });  
70.     }  
71.   
72.     /** 
73.      * 下载文件的方法 
74.      */  
75.     private void downLoad() {  
76.         final String path = et.getText().toString();  
77.         new Thread() {  
78.             public void run() {  
79.                 try {  
80.                     // 1、连接服务器，获取一个文件，获取文件的长度，在本地创建一个大小跟服务器文件大小一样的临时文件  
81.                     URL url = new URL(path);  
82.                     HttpURLConnection conn = (HttpURLConnection) url  
83.                             .openConnection();  
84.                     conn.setConnectTimeout(5000);  
85.                     conn.setRequestMethod("GET");  
86.                     int code = conn.getResponseCode();  
87.                     if (code == 200) {  
88.                         // 服务器返回的数据的长度，实际就是文件的长度  
89.                         int length = conn.getContentLength();  
90.                         pb.setMax(length);// 为进度条设置最大值  
91.                         System.out.println("----文件总长度----" + length);  
92.                         // 在客户端本地创建出来一个大小跟服务器端文件一样大小的临时文件  
93.                         RandomAccessFile raf = new RandomAccessFile(  
94.                                 "/sdcard/temp.apk", "rwd");  
95.                         // 指定创建的这个文件的长度  
96.                         raf.setLength(length);  
97.                         // 关闭raf  
98.                         raf.close();  
99.                         // 假设是3个线程去下载资源  
100.                         // 平均每一个线程下载的文件的大小  
101.                         int blockSize = length / THREAD_COUNT;  
102.                         for (int threadId = 1; threadId <= THREAD_COUNT; threadId++) {  
103.                             // 第一个线程开始下载的位置  
104.                             int startIndex = (threadId - 1) * blockSize;  
105.                             int endIndex = threadId * blockSize - 1;  
106.                             if (threadId == THREAD_COUNT) {  
107.                                 endIndex = length;  
108.                             }  
109.                             System.out.println("----threadId---"  
110.                                     + "--startIndex--" + startIndex  
111.                                     + "--endIndex--" + endIndex);  
112.                             new DownloadThread(path, threadId, startIndex,  
113.                                     endIndex).start();  
114.                         }  
115.                     }  
116.                 } catch (Exception e) {  
117.                     e.printStackTrace();  
118.                     Message msg = new Message();  
119.                     msg.arg1 = 0;  
120.                     handler.sendMessage(msg);  
121.                 }  
122.             };  
123.         }.start();  
124.     }  
125.   
126.     /** 
127.      * 下载文件的子线程，每一个线程下载对应位置的文件 
128.      *  
129.      * @author loonggg 
130.      *  
131.      */  
132.     public class DownloadThread extends Thread {  
133.         private int threadId;  
134.         private int startIndex;  
135.         private int endIndex;  
136.         private String path;  
137.   
138.         /** 
139.          * @param path 
140.          *            下载文件在服务器上的路径 
141.          * @param threadId 
142.          *            线程id 
143.          * @param startIndex 
144.          *            线程下载的开始位置 
145.          * @param endIndex 
146.          *            线程下载的结束位置 
147.          */  
148.         public DownloadThread(String path, int threadId, int startIndex,  
149.                 int endIndex) {  
150.             this.path = path;  
151.             this.threadId = threadId;  
152.             this.startIndex = startIndex;  
153.             this.endIndex = endIndex;  
154.         }  
155.   
156.         @Override  
157.         public void run() {  
158.             try {  
159.                 // 检查是否存在记录下载长度的文件，如果存在读取这个文件的数据  
160.                 // -------------------------替换成数据库----------------------------  
161.                 File tempFile = new File("/sdcard/" + threadId + ".txt");  
162.                 if (tempFile.exists() && tempFile.length() > 0) {  
163.                     FileInputStream fis = new FileInputStream(tempFile);  
164.                     byte[] temp = new byte[1024 * 10];  
165.                     int leng = fis.read(temp);  
166.                     // 已经下载的长度  
167.                     String downloadLen = new String(temp, 0, leng);  
168.                     int downloadInt = Integer.parseInt(downloadLen);  
169.                     // ------------------这两行代码是关于断点续传时，设置进度条的起点时的关键代码-------------------  
170.                     int alreadyDownloadInt = downloadInt - startIndex;  
171.                     currentProcess += alreadyDownloadInt;// 计算每个线程上次断点已经下载的文件的长度  
172.                     // ---------------------------------------------------------------------------------  
173.                     startIndex = downloadInt;  
174.                     fis.close();  
175.                 }  
176.                 // ---------------------------------------------------------------  
177.   
178.                 URL url = new URL(path);  
179.                 HttpURLConnection conn = (HttpURLConnection) url  
180.                         .openConnection();  
181.                 conn.setRequestMethod("GET");  
182.                 // 重要：请求服务器下载部分的文件 指定文件的位置  
183.                 conn.setRequestProperty("Range", "bytes=" + startIndex + "-"  
184.                         + endIndex);  
185.                 conn.setConnectTimeout(5000);  
186.                 // 从服务器请求全部资源的状态码200 ok 如果从服务器请求部分资源的状态码206 ok  
187.                 int code = conn.getResponseCode();  
188.                 System.out.println("---code---" + code);  
189.                 InputStream is = conn.getInputStream();// 已经设置了请求的位置，返回的是当前位置对应的文件的输入流  
190.                 RandomAccessFile raf = new RandomAccessFile("/sdcard/temp.apk",  
191.                         "rwd");  
192.                 // 随机写文件的时候从哪个位置开始写  
193.                 raf.seek(startIndex);// 定位文件  
194.                 int len = 0;  
195.                 byte[] buffer = new byte[1024];  
196.                 int total = 0;// 记录已经下载的数据的长度  
197.                 while ((len = is.read(buffer)) != -1) {  
198.                     RandomAccessFile recordFile = new RandomAccessFile(  
199.                             "/sdcard/" + threadId + ".txt", "rwd");// 记录每个线程的下载进度，为断点续传做标记  
200.                     raf.write(buffer, 0, len);  
201.                     total += len;  
202.                     recordFile.write(String.valueOf(startIndex + total)  
203.                             .getBytes());  
204.                     recordFile.close();  
205.                     // 同步加锁，防止混乱  
206.                     synchronized (MainActivity.this) {  
207.                         currentProcess += len;// 获取当前的总进度  
208.                         // 特殊情况，ProgressBarH和ProgressDialog进度条和对话框可以在子线程里面更新UI，系统内部代码特殊处理  
209.                         pb.setProgress(currentProcess);// 更改界面上进度条的进度  
210.                         Message msg = Message.obtain();  
211.                         msg.arg1 = 2;  
212.                         // 发送更新消息，更新进度的百分比  
213.                         handler.sendMessage(msg);  
214.                     }  
215.                 }  
216.                 is.close();  
217.                 raf.close();  
218.                 System.out.println("线程：" + threadId + "下载完毕了！");  
219.             } catch (Exception e) {  
220.                 e.printStackTrace();  
221.                 Message msg = handler.obtainMessage();  
222.                 msg.arg1 = 0;  
223.                 handler.sendMessage(msg);  
224.             } finally {  
225.                 threadFinish();  
226.             }  
227.         }  
228.   
229.         /** 
230.          * 我个人认为不锁定也可以，但是锁定可能更安全，如果谁有好的建议，到底用不用锁定，请给我留言 
231.          */  
232.         private synchronized void threadFinish() {  
233.             runningThread--;  
234.             if (runningThread == 0) {// 所有的线程已经执行完毕  
235.                 for (int i = 1; i <= THREAD_COUNT; i++) {// 删除记录下载进度的文件  
236.                     File file = new File("/sdcard/" + i + ".txt");  
237.                     file.delete();  
238.                     Message msg = handler.obtainMessage();  
239.                     msg.arg1 = 1;  
240.                     handler.sendMessage(msg);  
241.                 }  
242.             }  
243.         }  
244.     }  
245.   
246. }  

还有就是对应的Activity_main.xml的代码如下：

[html] view plain copy

 

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     android:orientation="vertical" >  
6.   
7.     <EditText  
8.         android:id="@+id/et"  
9.         android:layout_width="fill_parent"  
10.         android:layout_height="wrap_content"  
11.         android:text="http://dl1.byme001.com/phone_android.apk" />  
12.   
13.     <ProgressBar  
14.         android:id="@+id/pb"  
15.         style="?android:attr/progressBarStyleHorizontal"  
16.         android:layout_width="fill_parent"  
17.         android:layout_height="wrap_content" />  
18.   
19.     <TextView  
20.         android:id="@+id/tv_process"  
21.         android:layout_width="wrap_content"  
22.         android:layout_height="wrap_content"  
23.         android:text="下载进度"  
24.         android:textSize="30sp" />  
25.   
26.     <Button  
27.         android:id="@+id/btn"  
28.         android:layout_width="fill_parent"  
29.         android:layout_height="wrap_content"  
30.         android:text="下载" />  
31.   
32. </LinearLayout>  

当然大家别忘了在清单文件中设置网络权限和读写SD卡的权限：

[html] view plain copy

 

1. <uses-permission android:name="android.permission.INTERNET" />  
2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  

到这里就完了！大家如果有什么不明白的，可以在下面留言！

转载请注明出处：http://blog.csdn.net/loongggdroid/article/details/17846085