java断点续传（基于socket与randomaccessfile的简单实现）

　　这是一个简单的c/s架构，基本实现思路是将服务器注册至某个空闲端口用来监视并处理每个客户端的传输请求。

　　客户端先获得用户给予的需传输文件与目标路径，之后根据该文件实例化randomaccessfile为只读，之后客户端向服务器发送需传输的文件名文件大小与目标路径，服务器没接收到一个客户端的请求就会建立一个新的线程去处理它，根据接收到的文件名到目标路径中去寻找目标路径中是否已经有该文件名的.temp临时文件（如果没有就创建它），之后服务器会将文件已经传输的大小（临时文件大小）返回给客户端（例如临时文件刚刚建立返回的便是0），客户端会将刚刚建立的randomaccessfile对象的文件指针指向服务器返回的位置，之后以1kb为一组向服务器传输需传输文件的内容数据，服务器则接收数据并将其写入临时文件中，并根据现有数据画出进度条。在文件传输完毕后客户端会将临时文件重命名为最初接收到的文件名。

　　服务器代码：

import java.awt.color;
import java.awt.container;
import java.awt.dimension;
import java.awt.flowlayout;
import java.awt.event.actionevent;
import java.awt.event.actionlistener;
import java.io.datainputstream;
import java.io.dataoutputstream;
import java.io.file;
import java.io.ioexception;
import java.io.randomaccessfile;
import java.net.serversocket;
import java.net.socket;

import javax.swing.boxlayout;
import javax.swing.jbutton;
import javax.swing.jframe;
import javax.swing.jlabel;
import javax.swing.joptionpane;
import javax.swing.jpanel;
import javax.swing.jprogressbar;
 
public class filetransferserver extends serversocket {
 
    private static final int server_port = 8899; // 服务端端口
 
    public filetransferserver() throws exception {
        super(server_port);
    }
 
    public void load() throws exception {
        while (true) {
            // server尝试接收其他socket的连接请求，server的accept方法是阻塞式的
            socket socket = this.accept();
           
            // 每接收到一个socket就建立一个新的线程来处理它
            new thread(new task(socket)).start();
        }
    }
     //处理客户端传输过来的文件线程类
    class task implements runnable {
 
        private socket socket;
        private datainputstream dis;
        private dataoutputstream dos;
        private randomaccessfile rad;
        private jframe frame;    //用来显示进度条
        private container contentpanel;
        private jprogressbar progressbar;
        private jlabel label;
            
        public task(socket socket) {
            frame = new jframe("文件传输");
            this.socket = socket;
        }
 
        @override
        public void run() {
            try {
                dis = new datainputstream(socket.getinputstream());
                dos = new dataoutputstream(socket.getoutputstream());
                string targetpath = dis.readutf();    //接收目标路径
                string filename = dis.readutf();    //接收文件名
                //system.out.println("服务器：接收文件名");
                long filelength = dis.readlong();    //接收文件长度
                //system.out.println("服务器：接收文件长度");
                file directory = new file(targetpath);    //目标地址
                if(!directory.exists()) {    //目标地址文件夹不存在则创建该文件夹
                    directory.mkdir();
                }
                file file = new file(directory.getabsolutepath() + file.separatorchar + filename + ".temp");    //建立临时数据文件.temp
                //system.out.println("服务器：加载temp文件");
                rad = new randomaccessfile(directory.getabsolutepath() + file.separatorchar + filename + ".temp", "rw");
                long size = 0;
                if(file.exists() && file.isfile()){    //如果目标路径存在且是文件，则获取文件大小
                    size = file.length();
                }
                //system.out.println("服务器：获的当前已接收长度");
                dos.writelong(size);    //向客户端发送当前数据文件大小
                dos.flush();
                //system.out.println("服务器：发送当前以接收文件长度");
                int barsize = (int)(filelength / 1024);    //进度条当前进度
                int baroffset = (int)(size / 1024);        //进度条总长
                frame.setsize(300,120); //传输界面
                contentpanel = frame.getcontentpane();
                contentpanel.setlayout(new boxlayout(contentpanel, boxlayout.y_axis));
                progressbar = new jprogressbar();    //进度条
                label = new jlabel(filename + " 接收中");
                contentpanel.add(label);
                progressbar.setorientation(jprogressbar.horizontal);    //进度条为水平
                progressbar.setminimum(0);    //进度条最小值
                progressbar.setmaximum(barsize);    //进度条最大值
                progressbar.setvalue(baroffset);    //进度条当前值
                progressbar.setstringpainted(true); //显示进度条信息
                progressbar.setpreferredsize(new dimension(150, 20));    //进度条大小
                progressbar.setborderpainted(true);    //为进度条绘制边框
                progressbar.setbackground(color.pink);    //进度条颜色为骚粉
                jbutton cancel = new jbutton("取消");    //取消按钮
                jpanel barpanel = new jpanel();
                barpanel.setlayout(new flowlayout(flowlayout.left));
                barpanel.add(progressbar);
                barpanel.add(cancel);
                contentpanel.add(barpanel);
                cancel.addactionlistener(new cancelactionlistener());
                //为取消按钮注册监听器
                frame.setdefaultcloseoperation(jframe.exit_on_close);
                frame.setvisible(true);
                rad.seek(size);    //移动文件指针
                //system.out.println("服务器：文件定位完成");
                int length;
                byte[] bytes=new byte[1024];
                while((length = dis.read(bytes, 0, bytes.length)) != -1){
                    rad.write(bytes,0, length);    //写入文件
                    progressbar.setvalue(++baroffset);    //更新进度条（由于进度条每个单位代表大小为1kb，所以太小的文件就显示不出啦）
                }
                if (baroffset >= barsize) {    //传输完成后的重命名
                    if(rad != null)
                         rad.close();
                    if(!file.renameto(new file(directory.getabsolutepath() + file.separatorchar + filename))) {
                        file.delete();
                        //防御性处理删除临时文件
                    }
                    //system.out.println("服务器：临时文件重命名完成");
                }        
            } catch (exception e) {
                e.printstacktrace();
            } finally {
                try {    //关闭资源
                    if(rad != null)
                         rad.close();
                    if(dis != null)
                        dis.close();
                    if(dos != null)
                        dos.close();
                    frame.dispose();
                    socket.close();
                } catch (exception e) {}
            }
        }
        class cancelactionlistener implements actionlistener{    //取消按钮监听器
            public void actionperformed(actionevent e){
                try {
                    //system.out.println("服务器：接收取消");
                    if(dis != null)
                        dis.close();
                    if(dos != null)
                        dos.close();
                    if(rad != null)
                        rad.close();
                    frame.dispose();
                    socket.close();
                    joptionpane.showmessagedialog(frame, "已取消接收，连接关闭！", "提示：", joptionpane.information_message);    
                    label.settext(" 取消接收,连接关闭");
                } catch (ioexception e1) {
                    
                }
            }
        }
    }  
}

　　客户端代码：

import java.awt.event.actionevent;
import java.awt.event.actionlistener;
import java.io.datainputstream;
import java.io.dataoutputstream;
import java.io.file;
import java.io.ioexception;
import java.io.randomaccessfile;
import java.net.socket; 

public class filetransferclient extends socket {
 
    private static final string server_ip = "127.0.0.1"; // 服务端ip
    private static final int server_port = 8899; // 服务端端口
    private socket client;
    private dataoutputstream dos;
    private datainputstream dis;  
    private randomaccessfile rad;  

    public filetransferclient() throws exception {
        super(server_ip, server_port);
        this.client = this;
        //system.out.println("客户端：成功连接服务端");
    }
    
    public void sendfile(string filepath, string targetpath) throws exception {
        try {
            file file = new file(filepath);
            
            if(file.exists()) {
                dos = new dataoutputstream(client.getoutputstream());     //发送信息 getoutputstream方法会返回一个java.io.outputstream对象
                dis = new datainputstream(client.getinputstream());    //接收远程对象发送来的信息  getinputstream方法会返回一个java.io.inputstream对象
                dos.writeutf(targetpath); //发送目标路径
                dos.writeutf(file.getname()); //发送文件名
                //system.out.println("客户端：发送文件名");
                rad = new randomaccessfile(file.getpath(), "r");
                /*
                 * randomaccessfile是java输入输出流体系中功能最丰富的文件内容访问类，既可以读取文件内容，也可以向文件输出数据。
                 * 与普通的输入/输出流不同的是，randomaccessfile支持跳到文件任意位置读写数据，randomaccessfile对象包含一个记录指针，用以标识当前读写处的位置。
                 * 当程序创建一个新的randomaccessfile对象时，该对象的文件记录指针对于文件头 r代表读取
                 */
                dos.flush();    //作用见下方介绍
                dos.writelong(file.length()); //发送文件长度
                //system.out.println("客户端：发送文件长度");
                dos.flush();
                long size = dis.readlong();    //读取当前已发送文件长度
                //system.out.println("客户端：开始传输文件 ");
                int length = 0;
                byte[] bytes = new byte[1024];    //每1kb发送一次
                if (size < rad.length()) {
                    rad.seek(size);
                    //system.out.println("客户端：文件定位完成");
                    //移动文件指针
                    while((length = rad.read(bytes)) > 0){
                        dos.write(bytes, 0, length);                            
                        dos.flush();
                        //每1kb清空一次缓冲区
                        //为了避免每读入一个字节都写一次，java的输流有了缓冲区，读入数据时会首先将数据读入缓冲区，等缓冲区满后或执行flush或close时一次性进行写入操作
                    }
                }
                //system.out.println("客户端：文件传输成功 ");
            }
        } catch (exception e) {
            e.printstacktrace();
        } finally {    //关闭资源
            if(dos != null)
                dos.close();
            if(dis != null)
                dis.close();
            if(rad != null)
                rad.close();
            client.close();
        }
        
    }
 
    class cancelactionlistener implements actionlistener{    //关闭按钮监听器
        public void actionperformed(actionevent e3){
            try {
                //system.out.println("客户端：文件传输取消");
                if(dis != null)
                    dis.close();
                if(dos != null)
                    dos.close();
                if(rad != null)
                    rad.close();
                client.close();
            } catch (ioexception e1) {
                
            }
        }
    }   
}

　　传输文件是一个耗时操作，若直接实例化客户端对服务器发送数据会造成ui假死的情况，直到文件传输完成后才会恢复，所以建议在实例化客户端时单独建立一个新线程。

　　测试代码：

import javax.swing.jframe;
import javax.swing.jbutton;
import javax.swing.jfilechooser;
import java.awt.event.actionlistener;
import java.awt.event.mouseadapter;
import java.awt.event.mouseevent;
import java.awt.event.actionevent;

public class mainframe extends jframe{
    public mainframe() {
        this.setsize(1280, 768);
        getcontentpane().setlayout(null);
        
        jbutton btnnewbutton = new jbutton("传输文件");    //点击按钮进行文件传输
        btnnewbutton.addmouselistener(new mouseadapter() {
            @override
            public void mouseclicked(mouseevent e) {
                // todo 自动生成的方法存根
                super.mouseclicked(e);
                jfilechooser filechooser = new jfilechooser();    //filechooser用来选择要传输的文件
                filechooser.setdialogtitle("选择要传输的文件");
                int stfile = filechooser.showopendialog(null);
                if(stfile == filechooser.approve_option){    //选择了文件
                    jfilechooser targetpathchooser = new jfilechooser();    //targetpathchooser用来选择目标路径
                    targetpathchooser.setdialogtitle("选择目标路径");
                    targetpathchooser.setfileselectionmode(jfilechooser.directories_only);    //只能选择路径
                    int stpath = targetpathchooser.showopendialog(null);
                    if(stpath == targetpathchooser.approve_option) {    //选择了路径
                        //新建一个线程实例化客户端
                        new thread(new newclient( filechooser.getselectedfile().getpath(), targetpathchooser.getselectedfile().getpath())).start();
                    }
                }
            }
        });
        btnnewbutton.setbounds(526, 264, 237, 126);
        getcontentpane().add(btnnewbutton);
    }
    class newclient implements runnable {    //用于实例化客户端的线程
        private string filep;    //需复制文件路径
        private string targetp;    //目标路径
        public newclient(string filep, string targetp) {    //构造函数
            this.filep = filep;
            this.targetp = targetp;
        }
        @override
        public void run() {
            // todo 自动生成的方法存根
            try {
                @suppresswarnings("resource")
                filetransferclient ftc = new filetransferclient();
                //实例化客户端
                ftc.sendfile(filep, targetp);
            } catch (exception e1) {
                // todo 自动生成的 catch 块
                e1.printstacktrace();
            }
        }
    }
    public static void main(string[] args) {
        // todo 自动生成的方法存根
        mainframe mainframe = new mainframe();
        mainframe.setvisible(true);
        mainframe.setdefaultcloseoperation(jframe.exit_on_close);
        try {
             @suppresswarnings("resource")
            filetransferserver server = new filetransferserver(); // 启动服务端
             server.load();
        } catch (exception e) {
              e.printstacktrace();
        }
    }
}

　　演示：

　　1运行mainfame

　　2点击传输文件

　　3选择要传输的文件

　　4选择目标路径

　　5点击打开

　　点击取消

　　之后重复2 - 5的操作。

　　啊我手速慢，问题不大，你会发现断点续传已经实现了。