网络编程

• Java基础：网络编程
• Uri、URL、UriMatcher、ContentUris详解
• Android应用开发：网络编程1
• Android应用开发：网络编程2

1. 使用HttpClient发送get请求

HttpClient是Apache开发的第三方框架，Google把它封装到了Android API中，用于发送HTTP请求。

在Android.jar包中，可以看到有很多java的API，这些都是被Android改写的API，也可以看到Android封装了大量的Apache API。

示例：res\layout\activity_main.xml

<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" tools:context=".MainActivity" android:orientation="vertical">
    <EditText android:id="@+id/et_name" android:layout_width="match_parent" android:layout_height="wrap_content"/>
    <EditText android:id="@+id/et_pass" android:layout_width="match_parent" android:layout_height="wrap_content"/>
    <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="get登陆" android:onClick="click1" />
    <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="post登陆" android:onClick="click2" />
</LinearLayout>

src/cn.itcast.getmethod/MainActivity.java

package cn.itcast.getmethod;
import java.io.InputStream;
import java.net.URLEncoder;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
import cn.itcast.getmethod.tool.Tools;
public class MainActivity extends Activity { 
        Handler handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                        Toast.makeText(MainActivity.this, (String)msg.obj, 0).show();
                }
        };
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
        }
        public void click1(View v){
                EditText et_name = (EditText)findViewById(R.id.et_name);
                EditText et_pass = (EditText)findViewById(R.id.et_pass);
                String name = et_name.getText().toString();
                String pass = et_pass.getText().toString();
                final String path = "http://192.168.1.100:8080/Web/servlet/Login?name="
                                      + URLEncoder.encode(name) + "&pass=" + pass;
                Thread t = new Thread(){
                        @Override
                        public void run() {
                                //1. 创建客户端对象
                                //HttpClient是一个接口，不要new一个HttpClient对象，否则要实现很多的方法
                                HttpClient client = new DefaultHttpClient();
                                //2. 创建Http GET请求对象
                                HttpGet get = new HttpGet(path);
                                try {
                                        //3. 使用客户端发送get请求
                                        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);
                                                //发送消息，让主线程刷新UI
                                                Message msg = handler.obtainMessage();
                                                msg.obj = text;
                                                handler.sendMessage(msg);
                                        }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                };
                t.start();
        }
}

添加权限：

点击get登陆按钮，运行结果：

2. 使用HttpClient发送post请求

src/cn.itcast.postmethod/MainActivity.java

package cn.itcast.postmethod;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
import cn.itcast.getmethod.R;
import cn.itcast.getmethod.tool.Tools;
public class MainActivity extends Activity { 
        Handler handler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                        Toast.makeText(MainActivity.this, (String)msg.obj, 0).show();
                }
        };
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
        }
        public void click2(View v){
                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();
                final String path = "http://:8080/Web/servlet/Login";
                Thread t = new Thread(){
                        @Override
                        public void run() {
                                //1. 创建客户端对象
                                HttpClient client = new DefaultHttpClient();
                                //2. 创建Http POST请求对象
                                HttpPost post = new HttpPost(path);
                                try{
                                        //通过此集合封装要提交的数据
                                        List<NameValuePair> parameters = new ArrayList<NameValuePair>();
                                        //集合的泛型是BasicNameValuePair类型，那么由此可以推算出，要提交的数据是封装在BasicNameValuePair对象中
                                        BasicNameValuePair bvp1 = new BasicNameValuePair("name", name);
                                        BasicNameValuePair bvp2 = new BasicNameValuePair("pass", pass);
                                        parameters.add(bvp1);
                                        parameters.add(bvp2);
                                        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters,"utf-8");
                                        //把实体类封装至post请求中，提交post请求时，实体中的数据就会用输出流写给服务器
                                        post.setEntity(entity);
                                        //客户端发送post请求
                                        HttpResponse response = client.execute(post);
                                        //获取状态行
                                       StatusLine line = response.getStatusLine();
                                       //从状态行中拿到状态码
                                       if(line.getStatusCode() == 200){
                                              //获取实体，实体里存放的是服务器返回的数据的相关信息
                                               HttpEntity et = response.getEntity();
                                               //获取服务器返回的输入流
                                               InputStream is = et.getContent();
                                               String text = Tools.getTextFromStream(is);
                                               //发送消息，让主线程刷新UI
                                               Message msg = handler.obtainMessage();
                                               msg.obj = text;
                                              handler.sendMessage(msg);
                                      }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                };
                t.start();
        }
}

点击post登陆按钮，运行结果：

3. 异步HttpClient框架

从github上下载android-async-http-master开源jar包，拷贝library/src/main/java目录下的内容到我们自己的项目中。

拷贝后，发现有错误，这是由于Base64.java中的BuildConfig类导包问题，Ctrl+Shift+O自动导包即可修复。

使用异步HttpClient框架实现上面示例中的功能，activity.xml与上面的示例相同，修改MainActivity.java代码。
src/cn.itcast.asynchttpclient/MainActivity.java

package cn.itcast.asynchttpclient;
import org.apache.http.Header;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
import com.loopj.android.http.AsyncHttpClient;
import com.loopj.android.http.AsyncHttpResponseHandler;
import com.loopj.android.http.RequestParams;
public class MainActivity extends Activity { 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
        }
        public void click1(View v){
                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();
                final String path = "http://192.168.1.100:8080/Web/servlet/Login";
                //使用异步HttpClient发送get请求
                AsyncHttpClient client = new AsyncHttpClient();
                //定义一个请求参数对象，封装要提交的数据
                RequestParams rp = new RequestParams();
                rp.add("name", name);
                rp.add("pass", pass);
                //发送get请求
                client.get(path, rp, new MyResponseHandler());
        }
        public void click2(View v){
                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();
                final String path = "http://192.168.1.100:8080/Web/servlet/Login";
                AsyncHttpClient client = new AsyncHttpClient();
                RequestParams rp = new RequestParams();
                rp.add("name", name);
                rp.add("pass", pass);
                //发送post请求
                client.post(path, rp, new MyResponseHandler());
        }
        class MyResponseHandler extends AsyncHttpResponseHandler{
                //请求成功时（响应码为200开头），此方法调用
                //登陆成功或者登录失败，只要请求成功，都会调用onSuccess方法
                @Override
                public void onSuccess(int statusCode, Header[] headers,
                                byte[] responseBody) {
                        Toast.makeText(MainActivity.this, new String(responseBody), 0).show();
                }
                //请求失败时（响应码非200开头）调用
                @Override
                public void onFailure(int statusCode, Header[] headers,
                                byte[] responseBody, Throwable error) {
                        //请求不成功，也显示登录失败
                        Toast.makeText(MainActivity.this, "登陆失败", 0).show();
                }
        }
}

添加权限：

运行结果：分别点击“get登陆”和“post登陆”按钮。

4. 多线程下载的原理和过程

断点续传：上次下载到哪，这次就从哪开始下。
多线程：下载速度更快。
原理：抢占服务器资源。例如：带宽为20M/s，3个人去下载同一部电影，那么每人分别占6.66M/s带宽。如果有一人A开了3个线程同时下载，那么5个线程，各占4M/s带宽，那么A所占带宽就是4*3=12M/s，其他两人各占4M/s带宽。也就是说A抢占了更多的服务器资源。

多线程下载示例说明：
例如有一个10KB的文件，分成0~10，3个线程去下载，第0个线程下载0~2，也就是3KB数据，第1个线程下载3~5，也就是3KB数据，余下的6~9，4KB的数据由最后一个线程下载。

总结出公式就是：
每个线程下载的数据开始点：threadId*size，结束点：(threadId + 1) * size -1。

最后一个线程除外，下载结束点：length - 1。

计算每条线程的下载区间

多线程断点续传的API全部都是Java API，Java项目测试比较容易，所以，我们先创建一个Java项目。
将待下载的资源放入Tomcat服务器中。

src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        //打开连接对象，做初始化设置
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                //获取要下载的目标文件的总长度
                                int length = conn.getContentLength();
                                //计算每条线程要下载的长度
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                //计算每条线程下载的开始位置和结束位置
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        //如果是最后一条线程，那么需要把余数也一块下载
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
}

运行结果：

创建临时文件
src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.io.File;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                int length = conn.getContentLength();
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                //创建一个与目标文件大小一致的临时文件
                                File file = new File(getFileNameFromPath(path));
                                //打开文件的访问模式设置为rwd，表示除了读取和写入，还要求对文件内容的每个更新都同步写入到底层存储设备。
                                //设计到下载的程序，文件访问模式一定要使用rwd，不经过缓冲区，直接写入硬盘。
                                //如果下载到的数据让写入到缓冲区，一旦断电，缓冲区数据丢失，并且下次服务器断点续传也不会再传输这部分数据，那么下载的文件就不能用了
                                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                //设置临时文件的大小
                                raf.setLength(length);
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
        public static String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
}

开启多个线程下载文件

src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.io.File;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                int length = conn.getContentLength();
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                                        DownLoadThread dt = new DownLoadThread(threadId, startIndex, endIndex);
                                        dt.start();
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
        public static String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
}
class DownLoadThread extends Thread{
        int threadId;
        int startIndex;
        int endIndex;
        public DownLoadThread(int threadId, int startIndex, int endIndex) {
                super();
                this.threadId = threadId;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
        }
        public void run(){
                URL url;
                try{
                        url = new URL(Main.path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        //Range表示指定请求的数据区间
                        conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
                        //请求部分数据，返回的是206
                        if(conn.getResponseCode() == 206){
                                InputStream is = conn.getInputStream();
                                //打开临时文件的IO流
                                File file = new File(Main.getFileNameFromPath(Main.path));
                                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                //修改写入临时文件的开始位置
                                raf.seek(startIndex);
                                byte[] b = new byte[1024];
                                int len = 0;
                                //当前线程下载的总进度
                                int total = 0;
                                while((len = is.read(b)) != -1){
                                        //把读取到的字节写入临时文件中
                                        raf.write(b, 0, len);
                                        total += len;
                                        System.out.println("线程" + threadId + "下载的进度为：" + total);
                                }
                                raf.close();
                        }
                        System.out.println("线程" + threadId + "下载完毕---------------------");
                }catch(Exception e){
                        e.printStackTrace();
                }
        }
}

运行结果：刷新，即可看到文件已经下载好了

创建进度临时文件保存下载进度

src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.io.File;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                int length = conn.getContentLength();
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                                        DownLoadThread dt = new DownLoadThread(threadId, startIndex, endIndex);
                                        dt.start();
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
        public static String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
}
class DownLoadThread extends Thread{
        int threadId;
        int startIndex;
        int endIndex;
        public DownLoadThread(int threadId, int startIndex, int endIndex) {
                super();
                this.threadId = threadId;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
        }
        public void run(){
                URL url;
                try{
                        url = new URL(Main.path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
                        if(conn.getResponseCode() == 206){
                                InputStream is = conn.getInputStream();
                                File file = new File(Main.getFileNameFromPath(Main.path));
                                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                raf.seek(startIndex);
                                byte[] b = new byte[1024];
                                int len = 0;
                                int total = 0;
                                while((len = is.read(b)) != -1){
                                        raf.write(b, 0, len);
                                        total += len;
                                        System.out.println("线程" + threadId + "下载的进度为：" + total);
                                        //创建一个进度临时文件，保存下载进度
                                        File fileProgress = new File(threadId + ".txt");
                                        RandomAccessFile rafProgress = new RandomAccessFile(fileProgress, "rwd");
                                        rafProgress.write((total + "").getBytes());
                                        rafProgress.close();
                                }
                                raf.close();
                        }
                        System.out.println("线程" + threadId + "下载完毕---------------------");
                }catch(Exception e){
                        e.printStackTrace();
                }
        }
}

运行结果：执行程序，然后，在没下载完成时，就点击右上角的停止按钮。

刷新，可以看到记录文件已经产生。

完成断点续传下载

src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                int length = conn.getContentLength();
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        DownLoadThread dt = new DownLoadThread(threadId, startIndex, endIndex);
                                        dt.start();
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
        public static String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
}
class DownLoadThread extends Thread{
        int threadId;
        int startIndex;
        int endIndex;
        public DownLoadThread(int threadId, int startIndex, int endIndex) {
                super();
                this.threadId = threadId;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
        }
        public void run(){
                URL url;
                try{
                        int lastProgress = 0;
                        //下载之前，先判断进度临时文件是否存在
                        File fileProgress1 = new File(threadId + ".txt");
                        if(fileProgress1.exists()){
                                FileInputStream fis = new FileInputStream(fileProgress1);
                                BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                                //读取进度临时文件中的值
                                lastProgress = Integer.parseInt(br.readLine());
                                //把上一次下载的进度加到下载开始位置
                                startIndex += lastProgress;
                                fis.close();
                        }
                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                        url = new URL(Main.path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
                        if(conn.getResponseCode() == 206){
                                InputStream is = conn.getInputStream();
                                File file = new File(Main.getFileNameFromPath(Main.path));
                                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                raf.seek(startIndex);
                                byte[] b = new byte[1024];
                                int len = 0;
                                //从之前下载的地方开始下载
                                int total = lastProgress;
                                while((len = is.read(b)) != -1){
                                        raf.write(b, 0, len);
                                        total += len;
                                        System.out.println("线程" + threadId + "下载的进度为：" + total);
                                        File fileProgress = new File(threadId + ".txt");
                                        RandomAccessFile rafProgress = new RandomAccessFile(fileProgress, "rwd");
                                        rafProgress.write((total + "").getBytes());
                                        rafProgress.close();
                                }
                                raf.close();
                                System.out.println("线程" + threadId + "下载完毕---------------------");
                        }
                }catch(Exception e){
                        e.printStackTrace();
                }
        }
}

运行结果：

执行Main.java程序，然后，在还没有下载完，停止。然后，再次执行Main.java，可以看到如下显示，也就是实现了断点续传。

下载后删除进度临时文件
src/cn.itcast.MultiDownLoad/Main.java

package cn.itcast.MultiDownLoad;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
public class Main { 
        //记录当前已经下载完成的线程的数量
        static int finishedThreadCount = 0;
        static int threadCount = 3;
        static String path = "http://localhost:8080/QQPlayer.exe";
        public static void main(String[] args) {
                URL url;
                try {
                        url = new URL(path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        if(conn.getResponseCode() == 200){
                                int length = conn.getContentLength();
                                int size = length / threadCount;
                                System.out.println("size:" + size);
                                for(int threadId = 0; threadId < threadCount; threadId++){
                                        int startIndex = threadId * size;
                                        int endIndex = (threadId + 1) * size - 1;
                                        if(threadId == threadCount - 1){
                                                endIndex = length - 1;
                                        }
                                        DownLoadThread dt = new DownLoadThread(threadId, startIndex, endIndex);
                                        dt.start();
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
        public static String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
}
class DownLoadThread extends Thread{
        int threadId;
        int startIndex;
        int endIndex;
        public DownLoadThread(int threadId, int startIndex, int endIndex) {
                super();
                this.threadId = threadId;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
        }
        public void run(){
                URL url;
                try{
                        int lastProgress = 0;
                        File fileProgress1 = new File(threadId + ".txt");
                        if(fileProgress1.exists()){
                                FileInputStream fis = new FileInputStream(fileProgress1);
                                BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                                lastProgress = Integer.parseInt(br.readLine());
                                startIndex += lastProgress;
                                fis.close();
                        }
                        System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                        url = new URL(Main.path);
                        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(8000);
                        conn.setReadTimeout(8000);
                        conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
                        if(conn.getResponseCode() == 206){
                                InputStream is = conn.getInputStream();
                                File file = new File(Main.getFileNameFromPath(Main.path));
                                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                raf.seek(startIndex);
                                byte[] b = new byte[1024];
                                int len = 0;
                                int total = lastProgress;
                                while((len = is.read(b)) != -1){
                                        raf.write(b, 0, len);
                                        total += len;
                                        System.out.println("线程" + threadId + "下载的进度为：" + total);
                                        File fileProgress = new File(threadId + ".txt");
                                        RandomAccessFile rafProgress = new RandomAccessFile(fileProgress, "rwd");
                                        rafProgress.write((total + "").getBytes());
                                        rafProgress.close();
                                }
                                raf.close();
                                System.out.println("线程" + threadId + "下载完毕---------------------");
                                //在所有线程都下载完毕后，一起删除所有进度临时文件
                                //有一个线程完成下载，已经下载完成的线程的数量+1
                                Main.finishedThreadCount++;
                                synchronized(Main.path){
                                        if(Main.finishedThreadCount == 3){
                                                //删除所有进度临时文件
                                                for(int i = 0; i < Main.finishedThreadCount; i++){
                                                        File f = new File(i + ".txt");
                                                        f.delete();
                                                }
                                                //为了防止所有线程都执行到上面的Main.finishedThreadCount++;，然后三个线程都执行删除所有临时文件的代码。
                                                //所以，一方面使用同步代码块，另一方面将Main.finishedThreadCount设置为0。
                                                Main.finishedThreadCount = 0;
                                        }
                                }
                        }
                }catch(Exception e){
                        e.printStackTrace();
                }
        }
}

运行结果：运行Main.java，断点续传完成后，刷新。可以看到，临时文件已经被删除。

5. Android版多线程断点续传下载

res/layout/activity.xml

<RelativeLayout 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" tools:context=".MainActivity" >
    <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="下载" android:onClick="click" />
</RelativeLayout>

src/cn.itcast.androidmultidownload/MainActivity.xml

package cn.itcast.androidmultidownload;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
public class MainActivity extends Activity { 
        int finishedThreadCount = 0;
        int threadCount = 3;
        String path = "http://192.168.1.100:8080/QQPlayer.exe";
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
        }
    public void click(View v){
            Thread t = new Thread(){
                    @Override
                    public void run() {
                            URL url;
                            try {
                                    url = new URL(path);
                                    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                                    conn.setConnectTimeout(8000);
                                    conn.setReadTimeout(8000);
                                    if(conn.getResponseCode() == 200){
                                            int length = conn.getContentLength();
                                            int size = length / threadCount;
                                            System.out.println("size:" + size);
                                            for(int threadId = 0; threadId < threadCount; threadId++){
                                                    int startIndex = threadId * size;
                                                    int endIndex = (threadId + 1) * size - 1;
                                                    if(threadId == threadCount - 1){
                                                            endIndex = length - 1;
                                                    }
                                                    DownLoadThread dt = new DownLoadThread(threadId, startIndex, endIndex);
                                                    dt.start();
                                            }
                                    }
                            } catch (Exception e) {
                                    e.printStackTrace();
                            }
                    }
            };
            t.start();
    }
        public String getFileNameFromPath(String path){
                int index = path.lastIndexOf("/");
                return path.substring(index + 1);
        }
        class DownLoadThread extends Thread{
                int threadId;
                int startIndex;
                int endIndex;
                public DownLoadThread(int threadId, int startIndex, int endIndex) {
                        super();
                        this.threadId = threadId;
                        this.startIndex = startIndex;
                        this.endIndex = endIndex;
                }
                public void run(){
                        URL url;
                        try{
                                int lastProgress = 0;
                                //修改文件路径，存在外部存储器中
                                File fileProgress1 = new File(Environment.getExternalStorageDirectory(), threadId + ".txt");
                                if(fileProgress1.exists()){
                                        FileInputStream fis = new FileInputStream(fileProgress1);
                                        BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                                        lastProgress = Integer.parseInt(br.readLine());
                                        startIndex += lastProgress;
                                        fis.close();
                                }
                                System.out.println("线程" + threadId + "，下载区间为：" + startIndex + "-" + endIndex);
                                url = new URL(path);
                                HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                                conn.setConnectTimeout(8000);
                                conn.setReadTimeout(8000);
                                conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
                                if(conn.getResponseCode() == 206){
                                        InputStream is = conn.getInputStream();
                                        File file = new File(Environment.getExternalStorageDirectory(), getFileNameFromPath(path));
                                        RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                                        raf.seek(startIndex);
                                        byte[] b = new byte[1024];
                                        int len = 0;
                                        int total = lastProgress;
                                        while((len = is.read(b)) != -1){
                                                raf.write(b, 0, len);
                                                total += len;
                                                System.out.println("线程" + threadId + "下载的进度为：" + total);
                                                File fileProgress = new File(Environment.getExternalStorageDirectory(), threadId + ".txt");
                                                RandomAccessFile rafProgress = new RandomAccessFile(fileProgress, "rwd");
                                                rafProgress.write((total + "").getBytes());
                                                rafProgress.close();
                                        }
                                        raf.close();
                                        System.out.println("线程" + threadId + "下载完毕---------------------");
                                        finishedThreadCount++;
                                        synchronized(path){
                                                if(finishedThreadCount == 3){
                                                        for(int i = 0; i < finishedThreadCount; i++){
                                                                File f = new File(Environment.getExternalStorageDirectory(), i + ".txt");
                                                                f.delete();
                                                        }
                                                        finishedThreadCount = 0;
                                                }
                                        }
                                }
                        }catch(Exception e){
                                e.printStackTrace();
                        }
                }
        }
}