• 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




    只言片语任我说，提笔句句无需忖。落笔不知寄何人，唯有邀友共斟酌。
  • 相关阅读:
    Flexslider解决多图片刷新闪烁问题
    记一次MySQL授权问题
    AtCoder Beginner Contest 252
    021 指针思考
    Centos 7 添加Wifi驱动
    Java多线程对象内置锁（ObjectMonitor）
    卸载卸载
    mysql8.0安装终结版(mysql忘了密码操作步骤511步骤)
    Oracle实现统计一天的时候记录缺失哪一个时间（以分钟为单位处理的）
    腾讯云配置nginx跳转服务器内部服务
  • 原文地址：https://www.cnblogs.com/phonecom/p/e1e6e17f89d0c4d5e321744a9a169aa8.html
Copyright © 2020-2023  润新知