day05

1使用httpurlconnection方式把数据提交到服务器
    基于什么协议？http
    get方式：组拼URL地址把数据拼到url上 有大小限制 1kb  4kb
    post方式: post方式提交安全  没有大小限制
    post方式和get方式区别:
        [1]路径不同
        [2]请求方式不同
        [3]post方式要自己组拼请求体的内容
            post方式比get方式多了2个头(content-length和content-type)

get方式提交数据代码如下
  1. new Thread(){public void run() {
  2. 			try{
  3. 				//[2]获取用户名和密码
  4. 				String name = et_username.getText().toString().trim();
  5. 				String pwd = et_password.getText().toString().trim();
  6. 				//[2.1]定义get方式要提交的路径
  7. 				String path = "http://192.168.11.73:8000/login/loginServlet?username=" + name + "&password=" + pwd;
  8. 				//[2]
  9. 				URL url = new URL(path);
  10. 				HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  11. 				conn.setRequestMethod("GET");
  12. 				conn.setConnectTimeout(5000);
  13. 				int code = conn.getResponseCode();
  14. 				if(code == 200){
  15. 					InputStream inputStream = conn.getInputStream();
  16. 					
  17. 					String content = StreamTools.readStream(inputStream);
  18. 					
  19. 					//把服务器的数据展示到Toast上
  20. 					showToast(content);
  21. 				}
  22. 				}
  23. 				catch(Exception e)
  24. 				{
  25. 					e.printStackTrace();
  26. 				}
  27. 		};}.start();

post方式提交数据代码如下（主要☆☆☆☆☆处）
  1. new Thread(){public void run() {
  2. 			try{
  3. 				//[2]获取用户名和密码
  4. 				String name = et_username.getText().toString().trim();
  5. 				String pwd = et_password.getText().toString().trim();
  6. 				//☆☆☆☆☆和get方式提交数据区别四：设置请求体
  7. 				//String data = "username=" + name + "&password=" + pwd;
  8. 				//[2.1]定义get方式要提交的路径
  9. 				
  10. 				//☆☆☆☆☆和get方式提交数据区别一：路径不同
  11. 				//String path = "http://192.168.11.73:8000/login/loginServlet";
  12. 				String path = "http://192.168.11.73:8000/login/loginServlet?username=" + name + "&password=" + pwd;
  13. 				
  14. 				//[2]
  15. 				URL url = new URL(path);
  16. 				HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  17. 				//☆☆☆☆☆和get方式提交数据区别二：设置请求方式是post
  18. 				//conn.setRequestMethod("POST");
  19. 				conn.setRequestMethod("GET");
  20. 				conn.setConnectTimeout(5000);
  21. 				//☆☆☆☆☆和get方式提交数据区别三：多设置两个请求头信息
  22. 				//conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
  23. 				//conn.setRequestProperty("Content-Length", data.length() + "");
  24. 				
  25. 				//☆☆☆☆☆和get方式提交数据区别五：向服务器提交数据
  26. 				//设置一个标记 允许输出
  27. 				//conn.setDoOutput(true);
  28. 				//conn.getOutputStream().write(data.getBytes());
  29. 				
  30. 				int code = conn.getResponseCode();
  31. 				if(code == 200){
  32. 					InputStream inputStream = conn.getInputStream();
  33. 					
  34. 					String content = StreamTools.readStream(inputStream);
  35. 					
  36. 					//把服务器的数据展示到Toast上
  37. 					showToast(content);
  38. 				}
  39. 				}
  40. 				catch(Exception e)
  41. 				{
  42. 					e.printStackTrace();
  43. 				}
  44. 		};}.start();



2乱码问题解决

3以httpclient方式把数据提交到服务器
    [1]开源项目
    [2]谷歌一般以 base default simple 进行命名
    [3]对http请求的封装

get方式提交数据代码如下
  1. new Thread() {
  2. 			public void run() {
  3. 				try {
  4. 					// [2]获取用户名和密码
  5. 					String name = et_username.getText().toString().trim();
  6. 					String pwd = et_password.getText().toString().trim();
  7. 					name = URLEncoder.encode(name, "utf-8");
  8. 					pwd = URLEncoder.encode(pwd, "utf-8");
  9. 					String path = "http://192.168.11.73:8000/login/loginServlet?username="
  10. 							+ name + "&password=" + pwd;
  11. 					// 获取httpclient实例
  12. 					DefaultHttpClient client = new DefaultHttpClient();
  13. 					// 准备get请求 定义一个httpget实现
  14. 					HttpGet get = new HttpGet(path);
  15. 					// 执行一个get请求
  16. 					HttpResponse response = client.execute(get);
  17. 					// 获取服务器返回的状态码
  18. 					int code = response.getStatusLine().getStatusCode();
  19. 					if (code == 200) {
  20. 						InputStream inputStream = response.getEntity()
  21. 								.getContent();
  23. 						String content = StreamTools.readStream(inputStream);
  24. 						showToast(content + "");
  25. 					}
  26. 				} catch (Exception e) {
  27. 					e.printStackTrace();
  28. 				}
  30. 			};
  31. 		}.start();
post方式提交数据代码如下
  1. new Thread() {
  2. 			public void run() {
  4. 				try {
  5. 					// [2]获取用户名和密码
  6. 					String name = et_username.getText().toString().trim();
  7. 					String pwd = et_password.getText().toString().trim();
  9. 					// [3]以httpclient方式进行提交
  10. 					DefaultHttpClient client = new DefaultHttpClient();
  11. 					// [3.1]准备post请求
  12. 					String Path = "http://192.168.11.73:8080/login/LoginServlet";
  13. 					HttpPost post = new HttpPost(Path);
  14. 					
  15. 					
  16. 					//[3.1.0]准备parameters
  17. 					List<NameValuePair> lists = new ArrayList<NameValuePair>();
  18. 					//[3.1.1]准备NameValuePair 实际上就是我们要提交的用户名和密码
  19. 					BasicNameValuePair nameValuePair = new BasicNameValuePair("username", name);
  20. 					BasicNameValuePair pwdValuePair = new BasicNameValuePair("password", pwd);
  21. 					lists.add(nameValuePair);
  22. 					lists.add(pwdValuePair);
  23. 					//[3.1.2]准备entity
  24. 					UrlEncodedFormEntity entity = new UrlEncodedFormEntity(lists);
  25. 					post.setEntity(entity);
  26. 					
  27. 					HttpResponse response = client.execute(post);
  28. 					int code = response.getStatusLine().getStatusCode();
  29. 					if (code == 200) {
  30. 						InputStream inputStream = response.getEntity()
  31. 								.getContent();
  33. 						String content = StreamTools.readStream(inputStream);
  34. 						showToast(content + "");
  35. 					}
  36. 				} catch (Exception e) {
  37. 					e.printStackTrace();
  38. 				}
  39. 			};
  40. 		}.start();


4开源项目方式把数据提交到服务器
asynchttpclient
get方式提交数据代码如下
  1. String name = et_username.getText().toString().trim();
  2. 		String pwd = et_password.getText().toString().trim();
  3. 		name = URLEncoder.encode(name, "utf-8");
  4. 		pwd = URLEncoder.encode(pwd, "utf-8");
  5. 		path = "http://192.168.11.73:8000/login/loginServlet?username=" + name
  6. 				+ "&password=" + pwd;
  7. 		// [3]使用开源项目进行get请求
  8. 		// [3.1]创建asynchttpclient
  9. 		AsyncHttpClient client = new AsyncHttpClient();
  10. 		// [3.2]进行get请求
  11. 		client.get(path, new AsyncHttpResponseHandler() {
  12. 			//请求成功
  13. 			public void onSuccess(int statusCode, Header[] headers,
  14. 					byte[] responseBody) {
  15. 				Toast.makeText(getApplicationContext(), new String(responseBody,"gbk"), 1).show();
  16. 			}
  17. 				
  18. 			//请求失败
  19. 			public void onSuccess(int statusCode, Header[] headers,
  20. 					byte[] responseBody, Throwable error) {
  21. 				//Toast.makeText(getApplicationContext(), new String(responseBody,"gbk"), 1).show();
  22. 			}
  23. 		});

post方式提交数据代码如下
  1. String name = et_username.getText().toString().trim();
  2. 		String pwd = et_password.getText().toString().trim();
  3. 		String Path = "http://192.168.11.73:8080/login/LoginServlet";
  4. 		
  5. 		//[3.1]创建asyncHttpClient
  6. 		AsyncHttpClient client = new AsyncHttpClient();
  7. 		
  8. 		//[3.1.0]准备请求体的内容
  9. 		RequestParams params = new RequestParams();
  10. 		params.put("username", name);
  11. 		params.put("password", pwd);
  12. 		
  13. 		//[3.2]进行post请求
  14. 		client.post(Path, params, new AsyncHttpResponseHandler() {
  15. 			//请求成功
  16. 			public void onSuccess(int statusCode, Header[] headers,
  17. 					byte[] responseBody) {
  18. 				Toast.makeText(getApplicationContext(), new String(responseBody,"gbk"), 1).show();
  19. 			}
  20. 				
  21. 			//请求失败
  22. 			public void onSuccess(int statusCode, Header[] headers,
  23. 					byte[] responseBody, Throwable error) {
  24. 				//Toast.makeText(getApplicationContext(), new String(responseBody,"gbk"), 1).show();
  25. 			}
  26. 		});

总结:
    [1]    httpurlconnection
    [2]    httpclient    (了解 没人用)
    [3]    开源项目(asynchttpclient)

5javase多线程下载
    设置请求服务器文件的位置
    conn.setRequestProperty("Range", "bytes="+startIndex+"-"+endIndex);

为什么多线程能加速下载？
    [1]不是说线程开的越多下载越快
    [2]还受服务器带宽的影响
    [3]获得更多的cup资源

 每个线程下载的计算公式
  1. package com.phone.download;
  3. import java.io.InputStream;
  4. import java.io.RandomAccessFile;
  5. import java.net.HttpURLConnection;
  6. import java.net.URL;
  8. public class MutiDownLoad {
  10. 	// 定义下载路径
  11. 	static String path = "http://192.168.11.73:8080/feiq.exe";
  12. 	private static final int threadCount = 3;//线程数
  13. 	
  14. 	public static void main(String[] args){
  15. 		
  16. 		
  17. 		//[2]获取服务器文件的大小
  18. 		try
  19. 		{
  20. 			URL url = new URL(path);
  21. 			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  22. 			conn.setRequestMethod("GET");
  23. 			conn.setReadTimeout(5000);
  24. 			int code = conn.getResponseCode();
  25. 			if(code == 200)
  26. 			{
  27. 				//[☆☆☆☆]一、获取服务器文件的大小 要计算每个线程下载的开始位置和结束位置
  28. 				int length = conn.getContentLength();
  29. 				
  30. 				//[☆☆☆☆]二、创建一个大小和服务器一模一样的文件 目的是提前把空间申请出来
  31. 				RandomAccessFile rafAccessFile = new RandomAccessFile("temp.exe", "rw");
  32. 				rafAccessFile.setLength(length);
  33. 				
  34. 				//算出每个线程下载的大小
  35. 				int blocksize = length / threadCount;
  36. 				
  37. 				
  38. 				//[☆☆☆☆]三、计算每个线程下载的开始位置和结束位置
  39. 				for(int i=0; i<threadCount; i++)
  40. 				{
  41. 					//每个线程下载的开始位置
  42. 					int startIndex = i*blocksize;
  43. 					//每个线程下载的结束位置
  44. 					int endIndex = (i+1)*blocksize - 1;
  45. 					if(i == threadCount - 1)
  46. 					{
  47. 						//说明是最后一个线程
  48. 						endIndex = length-1;
  49. 					}
  50. 					
  51. 					//[☆☆☆☆]四、开启线程去服务器下载文件
  52. 					DownLoadThread downLoadThread = new DownLoadThread(startIndex, endIndex, i);
  53. 					downLoadThread.start();
  54. 				}
  55. 			}
  56. 		}
  57. 		catch(Exception e)
  58. 		{
  59. 			e.printStackTrace();
  60. 		}
  61. 	}
  62. 	
  63. 	//定义线程去服务器下载文件
  64. 	private static class DownLoadThread extends Thread
  65. 	{
  66. 		//通过构造方法把每个线程下载的开始位置和结束位置传递过来
  67. 		private int startIndex;
  68. 		private int endIndex;
  69. 		private int threadId;
  70. 		public DownLoadThread(int startIndex,int endIndex,int threadId){
  71. 			this.startIndex = startIndex;
  72. 			this.endIndex = endIndex;
  73. 			this.threadId = threadId;
  74. 			
  75. 		}
  76. 		
  77. 		public void run() {
  78. 			//四、开启线程去服务器下载文件
  79. 			try {
  80. 				URL url = new URL(path);
  81. 				HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  82. 				conn.setRequestMethod("GET");
  83. 				conn.setConnectTimeout(5000);
  84. 				//设置一个请求头Range(作用告诉服务器每个线程下载的开始位置和结束位置)
  85. 				conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
  86. 				
  87. 				int code = conn.getResponseCode();
  88. 				//200代表获取服务器资源全部成功
  89. 				//206请求部分资源成功
  90. 				//if(code == 200)
  91. 				if(code == 206)
  92. 				{
  93. 					//[6]创建随机读写文件对象
  94. 					RandomAccessFile rafAccessFile = new RandomAccessFile("temp.exe", "rw");
  95. 					//[6]每个线程要从自己的位置开始写
  96. 					rafAccessFile.seek(startIndex);
  97. 					
  98. 					InputStream inputStream = conn.getInputStream();
  99. 					
  100. 					//[7]把数据写到文件中
  101. 					int len = -1;
  102. 					byte[] Buffer = new byte[1024];
  103. 					while((len = inputStream.read(Buffer))!=-1)
  104. 					{
  105. 						rafAccessFile.write(Buffer,0,len);
  106. 					}
  107. 					rafAccessFile.close();
  108. 				}
  109. 			} catch (Exception e) {
  110. 				e.printStackTrace();
  111. 			}
  112. 			
  113. 		}
  114. 	}
  115. }

6断点续传实现
  1. package com.phone.download;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.io.RandomAccessFile;
  10. import java.net.HttpURLConnection;
  11. import java.net.URL;
  13. public class MutiDownLoad {
  15. 	// 定义下载路径
  16. 	static String path = "http://192.168.11.73:8080/feiq.exe";
  17. 	private static final int threadCount = 3;//线程数
  18. 	//代表当前正在运行的线程
  19. 	private static int runningThread;
  20. 	
  21. 	public static void main(String[] args){
  22. 		
  23. 		
  24. 		//[2]获取服务器文件的大小
  25. 		try
  26. 		{
  27. 			URL url = new URL(path);
  28. 			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  29. 			conn.setRequestMethod("GET");
  30. 			conn.setReadTimeout(5000);
  31. 			int code = conn.getResponseCode();
  32. 			if(code == 200)
  33. 			{
  34. 				//[☆☆☆☆]一、获取服务器文件的大小 要计算每个线程下载的开始位置和结束位置
  35. 				int length = conn.getContentLength();
  36. 				
  37. 				//把线程的数量赋值给正在运行的线程
  38. 				runningThread = threadCount;
  39. 				
  40. 				//[☆☆☆☆]二、创建一个大小和服务器一模一样的文件 目的是提前把空间申请出来
  41. 				RandomAccessFile rafAccessFile = new RandomAccessFile("temp.exe", "rw");
  42. 				rafAccessFile.setLength(length);
  43. 				
  44. 				//算出每个线程下载的大小
  45. 				int blocksize = length / threadCount;
  46. 				
  47. 				
  48. 				//[☆☆☆☆]三、计算每个线程下载的开始位置和结束位置
  49. 				for(int i=0; i<threadCount; i++)
  50. 				{
  51. 					//每个线程下载的开始位置
  52. 					int startIndex = i*blocksize;
  53. 					//每个线程下载的结束位置
  54. 					int endIndex = (i+1)*blocksize - 1;
  55. 					if(i == threadCount - 1)
  56. 					{
  57. 						//说明是最后一个线程
  58. 						endIndex = length-1;
  59. 					}
  60. 					
  61. 					//[☆☆☆☆]四、开启线程去服务器下载文件
  62. 					DownLoadThread downLoadThread = new DownLoadThread(startIndex, endIndex, i);
  63. 					downLoadThread.start();
  64. 				}
  65. 			}
  66. 		}
  67. 		catch(Exception e)
  68. 		{
  69. 			e.printStackTrace();
  70. 		}
  71. 	}
  72. 	
  73. 	//定义线程去服务器下载文件
  74. 	private static class DownLoadThread extends Thread
  75. 	{
  76. 		//通过构造方法把每个线程下载的开始位置和结束位置传递过来
  77. 		private int startIndex;
  78. 		private int endIndex;
  79. 		private int threadId;
  80. 		public DownLoadThread(int startIndex,int endIndex,int threadId){
  81. 			this.startIndex = startIndex;
  82. 			this.endIndex = endIndex;
  83. 			this.threadId = threadId;
  84. 			
  85. 		}
  86. 		
  87. 		public void run() {
  88. 			//四、开启线程去服务器下载文件
  89. 			try {
  90. 				URL url = new URL(path);
  91. 				HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  92. 				conn.setRequestMethod("GET");
  93. 				conn.setConnectTimeout(5000);
  94. 				
  95. 				//如果中间断过 继续上次的位置继续下载 从文件中读取上次下载的位置
  96. 				File file = new File(getFilename(path) + threadId + ".txt");
  97. 				if(file.exists() && file.length()>0)
  98. 				{
  99. 					FileInputStream fis = new FileInputStream(file);
  100. 					BufferedReader bufr = new BufferedReader(new InputStreamReader(fis));
  101. 					//读取出的内容就是上一次下载的位置
  102. 					String lastPositionn = bufr.readLine();
  103. 					int lastPosition = Integer.parseInt(lastPositionn);
  104. 					
  105. 					//改变startIndex位置
  106. 					startIndex = lastPosition;
  107. 					fis.close();
  108. 					
  109. 				}
  110. 				
  111. 				//设置一个请求头Range(作用告诉服务器每个线程下载的开始位置和结束位置)
  112. 				conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
  113. 				
  114. 				int code = conn.getResponseCode();
  115. 				//200代表获取服务器资源全部成功
  116. 				//206请求部分资源成功
  117. 				//if(code == 200)
  118. 				if(code == 206)
  119. 				{
  120. 					//[6]创建随机读写文件对象
  121. 					RandomAccessFile rafAccessFile = new RandomAccessFile(getFilename(path), "rw");
  122. 					//[6]每个线程要从自己的位置开始写
  123. 					rafAccessFile.seek(startIndex);
  124. 					
  125. 					InputStream inputStream = conn.getInputStream();
  126. 					
  127. 					//[7]把数据写到文件中
  128. 					int len = -1;
  129. 					byte[] Buffer = new byte[1024*1024];
  130. 					
  131. 					//代表当前线程下载的大小
  132. 					int total = 0;
  133. 					
  134. 					while((len = inputStream.read(Buffer))!=-1)
  135. 					{
  136. 						rafAccessFile.write(Buffer,0,len);
  137. 						
  138. 						total += len;
  139. 						//[8]实现断点续传 就是把当前线程下载的位置给存起来 下次再下载的时候按照上次下载的位置继续下载就可以了
  140. 						//存到一个普通的.txt文本中
  141. 						int currentThreadPosition = startIndex + total;
  142. 						
  143. 						//[9]用来存当前线程下载的位置
  144. 						RandomAccessFile raff = new RandomAccessFile(getFilename(path) + threadId + ".txt", "rwd");
  145. 						raff.write(String.valueOf(currentThreadPosition).getBytes());
  146. 						raff.close();
  147. 						
  2. 						
  3. 						/*
  4. 						 * 用这种方法有时候可能存不成功，因为硬盘有个缓存区
  5. 						File file = new File(threadId + ".txt");
  6. 						FileOutputStream fos = new FileOutputStream(file);
  7. 						fos.write(String.valueOf(currentThreadPosition).getBytes());
  8. 						fos.close();
  9. 						 */
  10. 						
  11. 					}
  12. 					rafAccessFile.close();
  13. 					
  14. 					synchronized(DownLoadThread.class){
  15. 						runningThread--;
  16. 						if(runningThread == 0)
  17. 						{
  18. 							//说明所有的线程都执行完毕了 就把.txt文件删除
  19. 							for(int i = 0; i < threadCount; i++)
  20. 							{
  21. 								File delFile = new File(getFilename(path) + i + ".txt");
  22. 								delFile.delete();
  23. 							}
  24. 						}
  25. 					}
  26. 				}
  27. 			} catch (Exception e) {
  28. 				e.printStackTrace();
  29. 			}
  30. 			
  31. 		}
  32. 	}
  33. 	
  34. 	/*
  35. 	 * 获取文件的名字
  36. 	 */
  37. 	public static String getFilename(String path){
  38. 		int start = path.lastIndexOf("/");
  39. 		return path.substring(start);
  40. 		
  41. 	}
  42. }

7断点续传逻辑移植到Android上
MainActivity.java
  1. package com.phone.download;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.io.RandomAccessFile;
  9. import java.net.HttpURLConnection;
  10. import java.net.URL;
  11. import java.util.ArrayList;
  12. import java.util.List;
  14. import android.os.Bundle;
  15. import android.os.Environment;
  16. import android.support.v7.app.ActionBarActivity;
  17. import android.view.View;
  18. import android.widget.EditText;
  19. import android.widget.LinearLayout;
  20. import android.widget.ProgressBar;
  22. public class MainActivity extends ActionBarActivity {
  24. 	private EditText et_path;
  25. 	private String path;
  26. 	private EditText et_threadCount;
  27. 	private LinearLayout ll_pb_layout;
  28. 	// 代表当前正在运行的线程
  29. 	private static int runningThread;
  30. 	//用来存进度条的引用
  31. 	private List<ProgressBar> pbLists;
  33. 	@Override
  34. 	protected void onCreate(Bundle savedInstanceState) {
  35. 		super.onCreate(savedInstanceState);
  36. 		setContentView(R.layout.activity_main);
  38. 		// [1]获取控件
  39. 		et_path = (EditText) findViewById(R.id.et_path);
  40. 		et_threadCount = (EditText) findViewById(R.id.et_threadCount);
  41. 		ll_pb_layout = (LinearLayout) findViewById(R.id.ll_pb);
  42. 		
  43. 		pbLists = new ArrayList<ProgressBar>();
  45. 	}
  47. 	// 点击按钮实现下载的逻辑
  48. 	public void click(View v) {
  49. 		// 获取下载的路径
  50. 		path = et_path.getText().toString().trim();
  52. 		// [3]获取线程的数量
  53. 		String threadCountt = et_threadCount.getText().toString().trim();
  55. 		// [3.0]先移除进度条再添加
  56. 		ll_pb_layout.removeAllViews();
  58. 		final int threadCount = Integer.parseInt(threadCountt);
  59. 		pbLists.clear();
  60. 		for (int i = 0; i < threadCount; i++) {
  61. 			// [3.1]把我定义的item布局转换成一个View对象
  62. 			ProgressBar child = (ProgressBar) View.inflate(getApplicationContext(), R.layout.item,
  63. 					null);
  64. 			
  65. 			//把child添加到集合中
  66. 			pbLists.add(child);
  67. 			
  68. 			// [4]动态的添加进度条
  69. 			ll_pb_layout.addView(child);
  71. 		}
  73. 		// [5]开始移植
  74. 		new Thread() {
  75. 			public void run() {
  76. 				// [2]获取服务器文件的大小
  77. 				try {
  78. 					URL url = new URL(path);
  79. 					HttpURLConnection conn = (HttpURLConnection) url
  80. 							.openConnection();
  81. 					conn.setRequestMethod("GET");
  82. 					conn.setReadTimeout(5000);
  83. 					int code = conn.getResponseCode();
  84. 					if (code == 200) {
  85. 						// [☆☆☆☆]一、获取服务器文件的大小 要计算每个线程下载的开始位置和结束位置
  86. 						int length = conn.getContentLength();
  88. 						// 把线程的数量赋值给正在运行的线程
  89. 						runningThread = threadCount;
  91. 						// [☆☆☆☆]二、创建一个大小和服务器一模一样的文件 目的是提前把空间申请出来
  92. 						RandomAccessFile rafAccessFile = new RandomAccessFile(
  93. 								"temp.exe", "rw");
  94. 						rafAccessFile.setLength(length);
  96. 						// 算出每个线程下载的大小
  97. 						int blocksize = length / threadCount;
  99. 						// [☆☆☆☆]三、计算每个线程下载的开始位置和结束位置
  100. 						for (int i = 0; i < threadCount; i++) {
  101. 							// 每个线程下载的开始位置
  102. 							int startIndex = i * blocksize;
  103. 							// 每个线程下载的结束位置
  104. 							int endIndex = (i + 1) * blocksize - 1;
  105. 							if (i == threadCount - 1) {
  106. 								// 说明是最后一个线程
  107. 								endIndex = length - 1;
  108. 							}
  110. 							// [☆☆☆☆]四、开启线程去服务器下载文件
  111. 							DownLoadThread downLoadThread = new DownLoadThread(
  112. 									startIndex, endIndex, i);
  113. 							downLoadThread.start();
  114. 						}
  115. 					}
  116. 				} catch (Exception e) {
  117. 					e.printStackTrace();
  118. 				}
  119. 			};
  120. 		}.start();
  122. 	}
  124. 	// 定义线程去服务器下载文件
  125. 	private class DownLoadThread extends Thread {
  126. 		// 通过构造方法把每个线程下载的开始位置和结束位置传递过来
  127. 		private int startIndex;
  128. 		private int endIndex;
  129. 		private int threadId;
  130. 		
  131. 		//代表当前线程下载的最大值
  132. 		private int PbMaxSize;
  133. 		
  134. 		//如果中断过 获取上次下载的位置
  135. 		private int PbLastPosition;
  137. 		public DownLoadThread(int startIndex, int endIndex, int threadId) {
  138. 			this.startIndex = startIndex;
  139. 			this.endIndex = endIndex;
  140. 			this.threadId = threadId;
  142. 		}
  2. 		public void run() {
  3. 			// 四、开启线程去服务器下载文件
  4. 			try {
  5. 				//计算当前进度条的最大值
  6. 				PbMaxSize = endIndex - startIndex;
  7. 				URL url = new URL(path);
  8. 				HttpURLConnection conn = (HttpURLConnection) url
  9. 						.openConnection();
  10. 				conn.setRequestMethod("GET");
  11. 				conn.setConnectTimeout(5000);
  13. 				// 如果中间断过 继续上次的位置继续下载 从文件中读取上次下载的位置
  14. 				File file = new File(getFilename(path) + threadId + ".txt");
  15. 				if (file.exists() && file.length() > 0) {
  16. 					FileInputStream fis = new FileInputStream(file);
  17. 					BufferedReader bufr = new BufferedReader(
  18. 							new InputStreamReader(fis));
  19. 					// 读取出的内容就是上一次下载的位置
  20. 					String lastPositionn = bufr.readLine();
  21. 					int lastPosition = Integer.parseInt(lastPositionn);
  22. 					
  23. 					//赋值给我们定义的进度条进度位置
  24. 					PbLastPosition = lastPosition - startIndex;
  25. 					
  26. 					
  27. 					// 改变startIndex位置
  28. 					startIndex = lastPosition;
  29. 					fis.close();
  31. 				}
  33. 				// 设置一个请求头Range(作用告诉服务器每个线程下载的开始位置和结束位置)
  34. 				conn.setRequestProperty("Range", "bytes=" + startIndex + "-"
  35. 						+ endIndex);
  37. 				int code = conn.getResponseCode();
  38. 				// 200代表获取服务器资源全部成功
  39. 				// 206请求部分资源成功
  40. 				// if(code == 200)
  41. 				if (code == 206) {
  42. 					// [6]创建随机读写文件对象
  43. 					RandomAccessFile rafAccessFile = new RandomAccessFile(
  44. 							getFilename(path), "rw");
  45. 					// [6]每个线程要从自己的位置开始写
  46. 					rafAccessFile.seek(startIndex);
  48. 					InputStream inputStream = conn.getInputStream();
  50. 					// [7]把数据写到文件中
  51. 					int len = -1;
  52. 					byte[] Buffer = new byte[1024 * 1024];
  54. 					// 代表当前线程下载的大小
  55. 					int total = 0;
  57. 					while ((len = inputStream.read(Buffer)) != -1) {
  58. 						rafAccessFile.write(Buffer, 0, len);
  60. 						total += len;
  61. 						// [8]实现断点续传 就是把当前线程下载的位置给存起来 下次再下载的时候按照上次下载的位置继续下载就可以了
  62. 						// 存到一个普通的.txt文本中
  63. 						int currentThreadPosition = startIndex + total;
  65. 						// [9]用来存当前线程下载的位置
  66. 						RandomAccessFile raff = new RandomAccessFile(
  67. 								getFilename(path) + threadId + ".txt", "rwd");
  68. 						raff.write(String.valueOf(currentThreadPosition)
  69. 								.getBytes());
  70. 						raff.close();
  72. 						/*
  73. 						 * 用这种方法有时候可能存不成功，因为硬盘有个缓存区 File file = new
  74. 						 * File(threadId + ".txt"); FileOutputStream fos = new
  75. 						 * FileOutputStream(file);
  76. 						 * fos.write(String.valueOf(currentThreadPosition
  77. 						 * ).getBytes()); fos.close();
  78. 						 */
  79. 						
  80. 						//设置当前进度条的最大值和当前进度
  81. 						pbLists.get(threadId).setMax(PbMaxSize);
  82. 						pbLists.get(threadId).setProgress(PbLastPosition+total);
  83. 						
  84. 					}
  85. 					rafAccessFile.close();
  86. 					
  87. 					// 获取线程的数量
  88. 					String threadCountt = et_threadCount.getText().toString().trim();
  89. 					final int threadCount = Integer.parseInt(threadCountt);
  91. 					synchronized (DownLoadThread.class) {
  92. 						runningThread--;
  93. 						if (runningThread == 0) {
  94. 							// 说明所有的线程都执行完毕了 就把.txt文件删除
  95. 							for (int i = 0; i < threadCount; i++) {
  96. 								File delFile = new File(getFilename(path) + i
  97. 										+ ".txt");
  98. 								delFile.delete();
  99. 							}
  100. 						}
  101. 					}
  102. 				}
  103. 			} catch (Exception e) {
  104. 				e.printStackTrace();
  105. 			}
  107. 		}
  108. 	}
  109. 	
  110. 	/*
  111. 	 * 获取文件的名字
  112. 	 */
  113. 	public static String getFilename(String path){
  114. 		int start = path.lastIndexOf("/");
  115. 		String substring = path.substring(start);
  116. 		String fileName = Environment.getExternalStorageDirectory().getPath() + "/" + substring;
  117. 		return fileName;
  118. 		
  119. 	}
  120. }
activity_main.xml
  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.     tools:context="com.phone.download.MainActivity" >
  8.     <EditText 
  9.         android:id="@+id/et_path"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="wrap_content"
  12.         android:hint="请输入下载路径"/>
  14.     <EditText 
  15.         android:id="@+id/et_threadCount"
  16.         android:layout_width="match_parent"
  17.         android:layout_height="wrap_content"
  18.         android:hint="请输入线程的数量"/>
  19.     
  20.     <Button 
  21.         android:onClick="click"
  22.         android:layout_width="wrap_content"
  23.         android:layout_height="wrap_content"
  24.         android:hint="下载"/>
  25.     
  26.     <LinearLayout 
  27.         android:id="@+id/ll_pb"
  28.         android:layout_width="match_parent"
  29.         android:layout_height="match_parent"
  30.         android:orientation="vertical">
  31.         
  32.     </LinearLayout>
  33. </LinearLayout>

item.xml
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ProgressBar xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:id="@+id/progressBar1"
  4.     style="?android:attr/progressBarStyleHorizontal"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="wrap_content" />

8开源项目实现多线程下载(xutils)
  1. package com.phone.opensourcedownload;
  3. import java.io.File;
  5. import android.app.Activity;
  6. import android.os.Bundle;
  7. import android.view.View;
  8. import android.widget.EditText;
  9. import android.widget.ProgressBar;
  10. import android.widget.Toast;
  12. import com.lidroid.xutils.HttpUtils;
  13. import com.lidroid.xutils.exception.HttpException;
  14. import com.lidroid.xutils.http.ResponseInfo;
  15. import com.lidroid.xutils.http.callback.RequestCallBack;
  18. public class MainActivity extends Activity {
  20.     private EditText et_path;
  21. 	private ProgressBar pb;
  23. 	@Override
  24.     protected void onCreate(Bundle savedInstanceState) {
  25.         super.onCreate(savedInstanceState);
  26.         setContentView(R.layout.activity_main);
  27.         
  28.         //[0]获取控件
  29.         et_path = (EditText) findViewById(R.id.et_path);
  30.         pb = (ProgressBar) findViewById(R.id.progressBar1);
  31.         
  32.     }
  33. 	
  34. 	//点击按钮实现断点续传下载逻辑
  35. 	public void click(View v){
  36. 		//[1]获取下载路径
  37. 		String path = et_path.getText().toString().trim();
  38. 		//[2]创建httputils对象HttpUtils http = new HttpUtils();
  39. 		HttpUtils http = new HttpUtils();
  40. 		//[3]实现断点下载
  41. 		/**
  42. 		 * path:路径
  43. 		 * target：下载文件的路径，即下载到哪
  44. 		 * autoResume：是否支持断点续传的逻辑
  45. 		 * 
  46. 		 */
  47. 		http.download(path, "/mnt/sdcard/haha.exe", true, new RequestCallBack<File>() {
  48. 			
  49. 			//下载成功
  50. 			@Override
  51. 			public void onSuccess(ResponseInfo<File> responseInfo) {
  52. 				Toast.makeText(getApplicationContext(), "下载成功", 1);
  53. 			}
  54. 			
  55. 			@Override
  56. 			/**
  57. 			 * total:代表总进度
  58. 			 * current：代表当前进度
  59. 			 */
  60. 			public void onLoading(long total, long current, boolean isUploading) {
  61. 				pb.setMax((int)total);
  62. 				pb.setProgress((int)current);
  63. 			}
  64. 			
  65. 			//下载失败的回调函数
  66. 			@Override
  67. 			public void onFailure(HttpException error, String msg) {
  68. 				
  69. 			}
  70. 		});
  71. 	}
  72. }
  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.     tools:context="com.phone.download.MainActivity" >
  8.     <EditText
  9.         android:id="@+id/et_path"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="wrap_content"
  12.         android:hint="请输入下载路径" />
  14.     <Button
  15.         android:layout_width="wrap_content"
  16.         android:layout_height="wrap_content"
  17.         android:hint="下载"
  18.         android:onClick="click" />
  20.     <ProgressBar
  21.         android:id="@+id/progressBar1"
  22.         style="?android:attr/progressBarStyleHorizontal"
  23.         android:layout_width="match_parent"
  24.         android:layout_height="wrap_content" />
  26. </LinearLayout>
9今日总结
   [1]httpurlConnection 用于发送或者接收数据(掌握)
        get    组拼url地址
        post    要自己组拼请求正文    请求头信息
   [2]httpClient(了解)
   [3]asyncHttpClient(掌握)
   [4]多线程下载
        1.获取文件大小
        2.在客户端创建一个大小和服务器一模一样的文件(为了提前申请控件)
        3.算出每个线程下载的开始位置和结束位置
                需要考虑    最后一个线程    文件长度-1
        4.开启一个线程去实现下载逻辑    httpurlConnection
                设置Range    还要注意服务器返回的状态码不是200而是206
        5.断点的逻辑    就是把当前线程下载的位置给保存起来    RandomAccessFile    直接同步到底层设备
        6.移植到Android    算出进度条的进度    集合存进度条的引用
        7.与进度有关的都可以在子线程直接更新UI




只言片语任我说，提笔句句无需忖。落笔不知寄何人，唯有邀友共斟酌。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/phonecom/p/e1e6e17f89d0c4d5e321744a9a169aa8.html