多線程
1. 亂碼問題
1.1. GET向服務器端提交中文數據亂碼
服務器端返回中文數據亂碼解決：android
出現緣由：因爲tomcat服務器編碼格式是ISO8859-1，因此當返回中文的時候，會默認使用此編碼。可是此編碼不包含中文，因此在這個碼錶中找不到會到本地碼錶查找，本地碼錶是gbk，安卓客戶端是以UTF-8編碼格式的，因此會出現亂碼。
解決方案：
(1) 服務器端：使用UTF-8編碼git
URLEncoder.encode(name, "utf-8");
(2) 服務器端：github
new String(name.getBytes("iso-8859-1"),"utf-8");
1.2. POST向服務器端提交中文數據亂碼
解決方法：在客戶端中對中文進行URL編碼web
URLEncoder.encode(name, "utf-8");
1.3. 總結
不論是使用GET仍是POST方式提交，解決辦法都是保證服務器端和客戶端使用的字符集編碼一致。apache
2. HttpClient
2.1. HttpClient開源項目簡介
HttpClient相比傳統JDK自帶的URLConnection，增長了易用性和靈活性，使客戶頓發送http請求變得容易。HttpClient是Apache Jakarta Common下的子項目，用來提供高效的、最新的、功能豐富的支持HTTP協議的客戶端編程工具包，而且它支持HTTP協議最新的版本和建議。編程
2.2. 使用HttpClient發送get請求
//拼接get請求路徑
String url = "http://192.168.14.79/Web2/servlet/LoginServlet?name=" + URLEncoder.encode(name) + "&pass=" + pass;
//建立HttpClient客戶端對象
HttpClient client = new DefaultHttpClient();
//建立Get請求對象，參數傳入請求地址
HttpGet get = new HttpGet(url);
try {
//調用客戶端的execute()方法執行請求，獲取HttpResponse響應對象。Response對象中有服務器返回的信息
HttpResponse response = client.execute(get);
//獲取響應中的狀態行，根據狀態行能夠判斷請求成功失敗等信息
StatusLine line = response.getStatusLine();
if(line.getStatusCode() == 200){
//獲去請求實體
HttpEntity entity = response.getEntity();
//從實體中獲取輸入流，也就是服務器返回給客戶端的流信息
InputStream is = entity.getContent();
//獲取流信息
String text = Tools.getTextFromStream(is);
Message msg = handler.obtainMessage();
msg.obj = text;
handler.sendMessage(msg);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
運行效果：
api
2.3. 使用HttpClient發送post請求
//封裝請求提交的參數，建立NameValuePair對象用於封裝要提交的參數
String url = "http://192.168.14.79/Web2/servlet/LoginServlet";
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(url);
BasicNameValuePair bnvp1 = new BasicNameValuePair("name", name);
BasicNameValuePair bnvp2 = new BasicNameValuePair("pass", pass);
//建立集合用來存放封裝後的提交參數
List<NameValuePair> parameters = new ArrayList<NameValuePair>();
//將封裝後的提交參數存入到集合中
parameters.add(bnvp1);
parameters.add(bnvp2);
try {
//建立表單實體UrlEncodedFormEntity，參數1表明須要提交數據的集合，參數2表明編碼格式
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters,"utf-8");
//給post對象設置請求實體，post.setEntity(entity)
post.setEntity(entity);
//調用client的execute(post)方法獲取響應對象
HttpResponse response = client.execute(post);
if(response.getStatusLine().getStatusCode() == 200){
//從響應中獲取響應體而後獲取其中的內容，也就是咱們的輸入流。
InputStream is = response.getEntity().getContent();
String text = Tools.getTextFromStream(is);
Message msg = handler.obtainMessage();
msg.obj = text;
handler.sendMessage(msg);
}
} catch (Exception e) {
e.printStackTrace();
}
效果以下：
瀏覽器
3. AsyncHttpClient
3.1. 簡介以及框架下載
AsyncHttpClient是一個開源的網絡請求框架，它是專門針對Android在Apache的HttpClient基礎上構建的異步的callback based http client。全部的請求全在UI線程以外，而callback發生在建立它的線程中，應用了Android的Handler發送消息機制。
下載能夠在github上面下載，使用的時候直接在Android工程中導入AsyncHttpClient的jar包或者源碼。tomcat
3.2. GET方式向服務器提交數據
EditText et_name = (EditText) findViewById(R.id.et_name);
EditText et_pass = (EditText) findViewById(R.id.et_pass);
final String name = et_name.getText().toString();
final String pass = et_pass.getText().toString();
String url = "http://192.168.14.79/Web2/servlet/LoginServlet";
//建立AsyncHttpClient對象
AsyncHttpClient client = new AsyncHttpClient();
//建立RequestParams對象，封裝須要提交的數據
RequestParams params = new RequestParams();
params.put("name", name);
params.put("pass", pass);
//調用AsyncHttpClient對象的get方法來提交get請求，參數1是請求Url，參數2是提交的參數，參數3是請求回調
client.get(url, params, new MyHandler());
請求回調，繼承自AsyncHttpResponseHandler安全
class MyHandler extends AsyncHttpResponseHandler{
//onSuccess()當請求成功時回調
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
super.onSuccess(statusCode, headers, responseBody);
Toast.makeText(MainActivity.this, new String(responseBody), 0).show();
}
//onFailuure()當請求失敗時回調
@Override
public void onFailure(int statusCode, Header[] headers,byte[] responseBody, Throwable error) {
super.onFailure(statusCode, headers, responseBody, error);
Toast.makeText(MainActivity.this, "請求失敗", 0).show();
}
}
3.3. POST方式向服務器提交數據
//獲取數據
EditText et_name = (EditText) findViewById(R.id.et_name);
EditText et_pass = (EditText) findViewById(R.id.et_pass);
final String name = et_name.getText().toString();
final String pass = et_pass.getText().toString();
String url = "http://192.168.14.79/Web2/servlet/LoginServlet";
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.put("name", name);
params.put("pass", pass);
//調用AsyncHttpClient的post方法來提交post請求，其中第一個參數是訪問Url，第二個參數是提交的參數，第三個參數是請求響應回調
client.post(url, params, new MyHandler());
建立請求處理類，繼承自AsyncHttpResponseHandler：
class MyHandler extends AsyncHttpResponseHandler{
//當請求成功會回調onSuccess()方法
@Override
public void onSuccess(int statusCode, Header[] headers,byte[] responseBody) {
super.onSuccess(statusCode, headers, responseBody);
Toast.makeText(MainActivity.this, new String(responseBody), 0).show();
}
//當請求失敗會回調onFailure()方法
@Override
public void onFailure(int statusCode, Header[] headers,byte[] responseBody, Throwable error) {
super.onFailure(statusCode, headers,responseBody, error);
Toast.makeText(MainActivity.this, "請求失敗", 0).show();
}
}
4. 文件上傳
分析服務器端Web工程UploadFileServlet接收上傳文件的代碼：
首先判斷上傳的數據是表單數據仍是一個帶文件的數據，若是是帶文件的數據，拿到Servlet真實路徑，建立目錄，若是目錄不存在則建立目錄，而後利用ServletFileUpload進行上傳文件。
@WebServlet("/UploadServlet")
public class UploadServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public UploadServlet() {
super();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
boolean isMultipart = ServletFileUpload.isMultipartContent(request);
//判斷上傳的數據是表單數據仍是一個帶文件的數據
if (isMultipart) {
//獲取Servlet真實路徑，在路徑後面加上/files
String realpath = request.getSession().getServletContext().getRealPath("/files");
//建立File對象，判斷是否存在目錄，若是不存在，則建立目錄
File dir = new File(realpath);
if (!dir.exists())
dir.mkdirs();
FileItemFactory factory = new DiskFileItemFactory();
//建立文件上傳類，設置頭的編碼格式爲utf-8
ServletFileUpload upload = new ServletFileUpload(factory);
upload.setHeaderEncoding("UTF-8");
try {
//調用ServletFileUpLoad類的parserRequest()方法，解析請求，返回文件項的集合
List<FileItem> items = upload.parseRequest(request);
//遍歷集合，判斷FileItem的類型，若是是表單數據（26-30），咱們就獲取請求參數，若是是文件類型（30-35行），咱們就調用FileItem的write方法，將文件上傳到指定目錄。
for (FileItem item : items) {
if (item.isFormField()) {
String name1 = item.getFieldName();
String value = item.getString("UTF-8");
System.out.println(name1 + "=" + value);
} else {
item.write(new File(dir,System.currentTimeMillis() + item.getName().substring(item.getName().lastIndexOf("."))));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
以上是服務器的代碼，那手機客戶端如何上傳文件呢？利用httpwatch查看上傳文件時請求信息，若是是本身實現文件上傳比較複雜。
4.1. 利用AsyncHttpClient上傳文件
建立佈局：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<EditText
android:id="@+id/et_path"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="請輸入上傳文件的路徑" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="click"
android:text="上傳" />
</LinearLayout>
上傳邏輯代碼：
//獲取EditText中輸入的路徑，建立File對象
String path = et_path.getText().toString().trim();
File file = new File(path);
//判斷file是不是存在而且file的長度不爲0
if (file.exists() && file.length() > 0) {
String uploadUrl = "http://192.168.19.28:8080/upload/UploadServlet";
//建立AsyncHttpClient對象
AsyncHttpClient client = new AsyncHttpClient();
//建立請求參數類，加入請求參數
RequestParams params = new RequestParams();
params.put("username", "james");
params.put("password", "123456");
try {
//傳入file，就是咱們須要上傳的文件對象
params.put("profile_picture", file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
client.post(uploadUrl, params, new AsyncHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
System.out.println("請求成功");
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
}
});
}}
運行結果：
服務器控制檯輸出：
5. 多線程加速下載的原理
司馬光砸缸的例子：砸的口子越多，流出的水越快。
小細節：並非說開的線程越多下載速度越快，如手機迅雷（簡稱手雷）推薦線程3-5；此外下載速度還受到真實帶寬的影響。
在單位時間內，服務器更多的cpu資源給了你，速度越快。
那麼咱們如何實現多線程下載呢？下面這張圖表示客戶端開啓3個線程去服務器端下載相對應部分的文件：
多線程下載步驟：
客戶端：
（a）建立一個文件，大小和服務器文件的大小同樣；
（b）開啓多個線程去下載服務器上對應部分的資源。
這時候咱們須要考慮如下幾個問題：
（c）如何等分服務器的資源？
（d）如何建立一個大小和服務器如出一轍的文件？
（e）如何開啓多個線程？
（f）如何知道每一個線程都下載完畢了？
6. JavaSE多線程下載實現
步驟：
1. 部署服務端；
2. 獲取服務器的資源；
3. 獲取文件的大小，利用conn.getContentLength();
4. 建立隨機文件（RandomAccessFile），大小和服務器文件大小一致；
5. 計算出每一個線程下載的大小，而後算出每一個線程下載的開始位置以及結束位置；
6. 開啓多個線程去下載。
6.1. 部署服務端
運行tomcat服務器，在tomcat安裝路徑的ROOT目錄下放置下載資源（參考：當前計算機的C:\軟件\apache-tomcat-7.0.68\webapps\ROOT），以下圖所示：
咱們須要下載的資源是feiq.exe，啓動tomcat，在瀏覽器中訪問該下載資源（路徑爲：http://localhost:8080/feiq.exe），效果以下圖所示：
從上圖能夠看出，服務端部署完畢。
6.2. 編寫下載核心代碼
在Eclipse中建立Java工程，工程名爲「多線程下載」，實現多線程下載文件feiq.exe。
1. 建立工程
【File】->【new】->【Java Project】命名爲：多線程下載
2. 使用默認包名，建立一個類MultiDownload，工程目錄結構以下圖所示：
3. 在MultiDownload類中編寫下載方法。具體實現步驟以下：
（a）聯網獲取網絡資源，獲取文件長度。
public class MutilDownLoad {
//定義服務器端資源訪問路徑
private static String path = "http://192.168.19.28:8080/feiq.exe";
//定義下載線程數爲3
private static int threadCount = 3;
public static void main(String[] args) {
try {
//網絡請求數據
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection)url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
int code = conn.getResponseCode();
if (code == 200) {
//經過getContentLenght()方法能夠獲取服務器文件的大小
int length = conn.getContentLength();
System.out.println(length);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
運行結果以下圖：
咱們查看服務器上的文件詳情，能夠看到大小和咱們網絡獲取獲得的大小同樣，以下圖：
（b）在本地建立一個文件，大小和服務器文件大小同樣。
//建立RandomAccessFile對象
RandomAccessFile ras = new RandomAccessFile("temp.exe","rw");
//setLength()方法設置文件的大小，傳入的大小就是以前從服務器獲取的文件的大小
ras.setLength(length);
運行程序，能夠看到工程目錄下多了一個文件temp.exe，查看文件大小和咱們服務器的文件大小一致，以下圖：
咱們使用編輯器打開temp.exe，能夠看到裏面沒有數據，所有爲null，這樣證實了咱們建立的文件是一個大小和服務器同樣的空文件。以下圖：
（c）定義下載線程的個數，根據文件總大小計算每一個線程下載的開始位置和結束位置。
根據推理，咱們能夠得出如下公式：
獲取每一個線程下載的開始位置和結束位置：
public class MutilDownLoad {
private static String path = "http://192.168.19.28:8080/feiq.exe";
//定義下載的線程數爲3
private static int threadCount = 3;
public static void main(String[] args) {
try {
//聯網獲取服務器資源
... ...
if (code == 200) {
int length = conn.getContentLength();
//計算每一個線程須要下載的長度
int blockSize = length / threadCount;
for (int i = 0; i < threadCount; i++) {
//根據公式計算出每一個線程的開始位置
int startIndex = i * blockSize;
//根據公式計算出每一個線程的結束位置（除去最後一個線程）
int endIndex = (i + 1) * blockSize - 1;
//若是是最後一個線程，根據公式，該線程的結束位置爲（文件總長度-1）
if (i == threadCount - 1) {
endIndex = length - 1;
}
System.out.println("線程id："+id+"下載位置："+startindex+"~"+endindex);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
運行結果以下圖：
（d）定義下載子線程，下載對應區域的文件，寫入到建立的本地文件中。該類因爲是一個子線程，因此咱們須要繼承Thread類。
private static class DownLoadThread extends Thread {
//定義下載路徑
private String path;
//定義當前線程下載的開始位置和結束位置
private int startIndex;
private int endIndex;
//定義threadId表示當前是哪個線程
private int threadId;
//定義構造函數
public DownLoadThread(String path, int startIndex, int endIndex, int threadId) {
this.path = path;
this.startIndex = startIndex;
this.endIndex = endIndex;
this.threadId = threadId;
}
//開啓子線程下載文件
@Override
public void run() {
try {
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
//設置Range頭信息，告訴服務器每一個線程下載的開始位置和結束位置；第24行，判斷請求碼是不是206，表明請求服務器部分資源成功，200表明請求服務器所有資源成功
conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
int code = conn.getResponseCode();
if (code == 206) {
InputStream in = conn.getInputStream();
//建立RandomAccessFile對象，和咱們以前建立的文件對接
RandomAccessFile ras = new RandomAccessFile("temp.exe", "rw");
//seek()方法設置文件寫入的初始位置，因爲每一個線程開始下載的位置不同，因此咱們須要調用該方法指定線程下載數據開始存放的位置
ras.seek(startIndex);
int len = -1;
byte buffer[] = new byte[1024];
while ((len = in.read(buffer)) != -1) {
ras.write(buffer, 0, len);
}
ras.close();
System.out.println("線程id" + threadId + "下載完畢了");
}
} catch (Exception e) {
e.printStackTrace();
}
super.run();
}
}
（e）在咱們計算每一個線程下載初始位置和結束位置時，調用下載線程下載對應區域的文件數據。
for (int i = 0; i < threadCount; i++) {
int startIndex = i * blockSize;
int endIndex = (i + 1) * blockSize - 1;
if (i == threadCount - 1) {
endIndex = length - 1;
}
//建立下載線程，參數1表示下載路徑，參數2表示下載文件開始位置，參數3表示下載文件結束位置，參數4表示當前線程的標識
DownLoadThread downLoadThread = new DownLoadThread(path, startIndex, endIndex, i);
//開啓線程
downLoadThread.start();
}
測試結果：
咱們查看工程目錄下的文件，點擊可使用，說明下載成功。以下圖：
7. 多線程下載斷點續傳
原理：把每次下載的位置給存起來，下次從這個位置繼續下載。
本案例和上一節多線程下載有不少類似之處，不一樣點在於如何斷點續傳，因此這裏將對斷點續傳代碼作詳細解釋。
斷點續傳最關鍵的是下載的時候，要知道上次下載的位置。那麼咱們能夠定一個變量total來記錄當前線程已經下載的文件大小，每次往本地文件中寫如lenth長度數據後，total也須要加上這個lenth長度變成新的total長度。此外，還須要定義一個變量來記錄當前線程下載的位置currentThreadPosition，當前線程下載的位置currentThreadPosition=startIndex(初始位置)+total(已經下載的大小)，將當前下載位置保存到文件中。
（a）保存當前線程下載的位置
//total表示當前下載的總大小
int total = 0;
while ((len = in.read(buffer)) != -1) {
ras.write(buffer, 0, len);
//每次向本地文件寫入數據時，total要加上寫入數據的長度len
total += len;
//計算出當前線程下載的位置
int currentThreadPosition = startIndex + total;
//建立保存當前線程下載位置的文件,getFileName(path)方法獲取文件名稱(見下方)
RandomAccessFile rass = new RandomAccessFile(getFileName(path) + threadId + ".txt", "rwd");
rass.write(String.valueOf(currentThreadPosition).getBytes());
rass.close();
}
獲取文件名稱，將路徑截取最後一個/獲取後面的文件名：
public static String getFileName(String path) {
int start = path.lastIndexOf("/") + 1;
return path.substring(start);
}
咱們這邊模擬下載過程當中斷掉下載，查看下載目錄：
從上圖能夠看出，咱們第0個線程下載到的位置在4186000。那麼咱們下次下載的時候就須要讀取文件中的這個位置，從這個位置繼續下載。
（b）讀取文件中下載的位置，以這個位置爲開始位置，以計算的每一個線程的結束位置進行第n次下載。
private static class DownLoadThread extends Thread {
@Override
public void run() {
try {
//聯網獲取網絡數據
......
//建立咱們保存線程讀取數據大小的文件對象
File file = new File(getFileName(path) + threadId + ".txt");
//如過保存線程下載位置的文件存在而且大小大於0，就說明是斷點續傳
if (file.exists() && file.length() > 0) {
//讀取線程上次寫入數據的大小
FileInputStream fis = new FileInputStream(file);
BufferedReader bfr = new BufferedReader(new InputStreamReader(fis));
String lastPosition = bfr.readLine();
//設置當前線程下載的開始和結束位置
conn.setRequestProperty("Range", "bytes=" + lastPosition + "-" + endIndex);
startIndex = Integer.parseInt(lastPosition);
fis.close();
System.out.println("線程id真實的-" + threadId + ":" + startIndex + "----" + endIndex);
} else {
//若是是第一次開始下載，那麼就從咱們以前計算的開始位置和結束位置進行下載
conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
}
//下載邏輯
......
} catch (Exception e) {
e.printStackTrace();
}
super.run();
}
}
咱們測試一下，當第一次下載時，咱們斷一下下載，咱們查看控制檯輸出：
咱們接下來繼續下載，查看控制檯輸出：
從上面能夠看出，第二次下載，線程的起始位置發生了改變。
（c）下載完畢刪除記錄當前線程下載位置的文件。
因爲是多線程下載，咱們須要知道是哪個線程下載完成了。咱們定義一個變量runningThread來記錄運行的線程個數。runningThread初始化的值就是咱們線程的數量，當下載完成以後runningThread自減，當runningThread小於等於0就表示所有下載完成，這時候刪除記錄文件。
synchronized (DownLoadThread.class) {
runningThread--;
if (runningThread <= 0) {
for (int i = 0; i < threadCount; i++) {
File deleteFile = new File(getFileName(path) + i + ".txt");
deleteFile.delete();
}
}
}
因爲是多線程，因此runningThread–；會有線程安全問題，因此咱們須要將這句話加上同步語句。
8. Android上多線程下載
Android工程中多線程下載的邏輯和JavaSE中多線程下載邏輯相似。這裏把JavaSE中已實現的功能代碼移植到Android工程中，而且添加添加下載的進度條來實時查看線程下載進度。
界面佈局：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<EditText
android:id="@+id/et_path"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="請輸入上傳文件的路徑" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="click"
android:text="上傳" />
</LinearLayout>
MainActivity邏輯，EditText中輸入下載線程個數，點擊下載按鈕開始下載，而且根據線程個數建立對應的ProgressBar。
public class MainActivity extends Activity {
//定義成員變量
......
//線性佈局用來添加ProgressBar
private LinearLayout ll_layout;
//用來存放ProgressBar集合
private List<ProgressBar> pbs;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//初始化控件
......
pbs = new ArrayList<ProgressBar>();
}
public void click(View v) {
......
ll_layout.removeAllViews();
pbs.clear();
//根據下載線程數量來建立ProgressBar添加到線性佈局，而且添加到ProgressBar的集合
for (int i = 0; i < threadCount; i++) {
ProgressBar pbBar = (ProgressBar)
View.inflate(getApplicationContext(), R.layout.item, null);
ll_layout.addView(pbBar);
pbs.add(pbBar);
}
new Thread() {
public void run() {
try {
//聯網獲取數據
......
if (code == 200) {
int length = conn.getContentLength();
RandomAccessFile ras = new RandomAccessFile(Environment.getExternalStorageDirectory().getPath() + "/" + getFileName(path), "rw");
ras.setLength(length);
runningThread = threadCount;
int blockSize = length / threadCount;
for (int i = 0; i < threadCount; i++) {
int startIndex = i * blockSize;
int endIndex = (i + 1) * blockSize - 1;
if (i == threadCount - 1) {
endIndex = length - 1;
}
DownLoadThread downLoadThread = new DownLoadThread(path, startIndex, endIndex, i);
// 開啓線程
downLoadThread.start();
}
}
} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}
private class DownLoadThread extends Thread {
//成員變量
......
private int pbmaxSize;
private int pbCurrentSize;
//構造函數
......
@Override
public void run() {
try {
pbmaxSize = endIndex - startIndex;
//鏈接網絡獲取資源
......
File file = new File(Environment.getExternalStorageDirectory().getPath() + "/" + getFileName(path) + threadId + ".txt");
if (file.exists() && file.length() > 0) {
FileInputStream fis = new FileInputStream(file);
BufferedReader bfr = new BufferedReader(new InputStreamReader(fis));
String lastPosition = bfr.readLine();
conn.setRequestProperty("Range", "bytes=" + lastPosition + "-" + endIndex);
pbCurrentSize = Integer.parseInt(lastPosition) - startIndex;
startIndex = Integer.parseInt(lastPosition);
fis.close();
} else {
conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
}
int code = conn.getResponseCode();
if (code == 206) {
InputStream in = conn.getInputStream();
RandomAccessFile ras = new RandomAccessFile(Environment.getExternalStorageDirectory().getPath()
+ "/" + getFileName(path), "rw");
ras.seek(startIndex);
int len = -1;
byte buffer[] = new byte[1024 * 1024]; // 1kb
int total = 0;
while ((len = in.read(buffer)) != -1) {
ras.write(buffer, 0, len);
total += len;
int currentThreadPosition = startIndex + total;
RandomAccessFile rass = new RandomAccessFile(Environment.getExternalStorageDirectory().getPath() + "/" + getFileName(path) + threadId + ".txt", "rwd");
rass.write(String.valueOf(currentThreadPosition).getBytes());
rass.close();
pbs.get(threadId).setMax(pbmaxSize);
pbs.get(threadId).setProgress(pbCurrentSize + total);
}
ras.close();
......
//刪除保存線程下載位置文件
}
} catch (Exception e) {
e.printStackTrace();
}
super.run();
}
}
}
9. 使用xUtils實現多線程下載
9.1. xUtils開源項目簡介及框架下載
（1）xUtils包含了不少實用的android工具。
（2）xUtils最初源於Afinal框架，進行了大量重構，使得xUtils支持大文件上傳，擁有更加靈活的ORM，更多的事件註解支持且不受混淆影響。
（3）xUitls最低兼容android 2.2 (api level 8)
（4）xUtils主要有如下四大模塊：
DbUtils模塊、ViewUtils模塊、HttpUtils模塊、BitmapUtils模塊。
（5）xUtils能夠在github上搜索進行下載：
9.2. 使用xUtils下載
界面佈局：點擊下載進行下載，下方progressbar顯示下載進度。
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="click"
android:text="下載" />
<ProgressBar
android:id="@+id/progressBar1"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
</LinearLayout>
下載邏輯：
public class MainActivity extends Activity {
private ProgressBar pb;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//更新下載的進度
pb = (ProgressBar) findViewById(R.id.progressBar1);
}
public void click(View v){
//建立HttpUtils對象
HttpUtils http = new HttpUtils();
String url = "http://192.168.19.28:8080/feiq.exe";
//調用HttpUtils的download方法下載文件，第一個參數是下載的路徑，第二個參數是是否支持斷點續傳，第三個參數是下載回調
http.download(url, "/mnt/sdcard/fei.exe", true, new RequestCallBack<File>() {
//下載成功的回調
@Override
public void onSuccess(ResponseInfo<File> responseInfo) {
Toast.makeText(getApplicationContext(), "sucess",0).show();
}
//下載失敗
@Override
public void onFailure(HttpException error, String msg) {
}
//更新當前的進度
@Override
public void onLoading(long total, long current, boolean
isUploading) {
pb.setMax((int) total);
pb.setProgress((int) current);
super.onLoading(total, current, isUploading);
}
});
}
}
運行結果：
10. ProgressDialog的使用
點擊按鈕彈出ProgressDialog對話框。
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void click(View v) {
//建立ProgressDialog實例
final ProgressDialog dialog = new ProgressDialog(MainActivity.this);
//設置標題
dialog.setTitle("正在玩命加載ing");
//設置ProgressDialog的樣式是橫向的樣式
dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
new Thread() {
public void run() {
//設置ProgressDialog的最大進度
dialog.setMax(100);
for (int i = 0; i <= 100; i++) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//設置ProgressDialog當前的進度
dialog.setProgress(i);
}
// 關閉對話框
dialog.dismiss();
};
}.start();
dialog.show();
}
}
相關文章
- 1. 多進程、多線程、java多線程
- 2. 進程、線程、多線程、多進程
- 3. 進程、線程、多進程、多線程
- 4. JAVA多線程——(一)多線程編程
- 5. 進程，線程，多線程
- 6. 進程、線程、多線程
- 7. 多線程(多線程原理)
- 8. Java多線程：Java多線程基礎
- 9. [iOS 多線程] iOS多線程-概念
- 10. 多線程學習---多線程理解
- 更多相關文章...
- • C# 多線程 - C#教程
- • 多對多關聯查詢 - MyBatis教程
- • Java 8 Stream 教程
- • YAML 入門教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 多進程、多線程、java多線程
- 2. 進程、線程、多線程、多進程
- 3. 進程、線程、多進程、多線程
- 4. JAVA多線程——(一)多線程編程
- 5. 進程，線程，多線程
- 6. 進程、線程、多線程
- 7. 多線程(多線程原理)
- 8. Java多線程：Java多線程基礎
- 9. [iOS 多線程] iOS多線程-概念
- 10. 多線程學習---多線程理解