socketthread.java

这是一个能够实现文件传输的用java开发的源程序

package daen.graduate.trans;

import java.net.Socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.*;
import java.net.*;

/**
 * Socket线程
 */
public class SocketThread extends Thread {
    public SocketThread() {
        try {
            jbInit();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public final static int CACHE_SIZE = 10240; //缓存大小

    public final static int FILE_TRANS_STATUS_FILENAME = 0x01; //文件名传输状态

    public final static int FILE_TRANS_STATUS_CONTEXT = 0x02; //文件内容传输状态

    public final static int FILE_TRANS_STATUS_WAITFORCONFIRM = 0x03; //等待确认接收文件

    public final static int FILE_TRANS_STATUS_SUCCESS = 0x04; //文件传输成功

    public final static int FILE_TRANS_STATUS_FAIL = 0x05; //文件传输失败

    public final static int FILE_TRANS_STATUS_CANCELTRANS = 0x06; //取消文件传输

    public final static int PACKAGE_TYPE_FILENAME = 0x01; //文件名包

    public final static int PACKAGE_TYPE_CONTEXT = 0x02; //文件内容包

    public final static int PACKAGE_TYPE_CONFIRMRECEIVE = 0x03; //是否接收文件

    private Socket aSocket; //套接字

    private String serverName; //服务器名称

    private DataInputStream dis; //输入流

    private DataOutputStream dos; //输出流

    private DataInputStream fDis; //文件输入流

    private RandomAccessFile raf; //文件输出流

    private boolean fileSender = false; //文件发送者

    private boolean running = false; //线程运行

    public int fileTransStatus = 0x0; //文件传输状态

    private File aFile; //传输的文件

    public long fileSize; //文件大小

    private String fileName; //文件名称

    private String errorMessage; //错误消息

    private long transFileLength = 0; //已传输字节数

    private byte [] dataBuf;

    private String message; //验证消息

    private String IP; //目标IP

    private int port; //目标端口

    private boolean fileTransed=false; //文件是否已经开始传输

    int count=0;

    //接收者构造函数
    public SocketThread(Socket aSocket) {
        this.aSocket = aSocket;
        try {
            aSocket.setSoTimeout(300000);
        } catch (SocketException ex) {
        }
        byte[] address = aSocket.getInetAddress().getAddress();
        IP = (address[0] & 0xff) + "." + (address[1] & 0xff) + "." +
             (address[2] & 0xff) + "." + (address[3] & 0xff);
        try {
            dis = new DataInputStream(aSocket.getInputStream());
            dos = new DataOutputStream(aSocket.getOutputStream());
            fileTransStatus = FILE_TRANS_STATUS_FILENAME;
        } catch (IOException ex) {
            setError("创建连接错误！");
        }

        try {
            aSocket.setReceiveBufferSize(CACHE_SIZE*2);
        } catch (SocketException ex1) {
            ex1.printStackTrace();
        }
        dataBuf=new byte[CACHE_SIZE+100];
    }

    //发送者构造函数
    public SocketThread(String serverName, int portNo, String fileName,
                        String message) {
            aFile = new File(fileName);
            this.fileName = aFile.getName();
            this.fileSize = fileSize;
            fileSender = true;
            if (message != null) {
                this.message = message;
            }
            this.IP = serverName;
            this.port = portNo;
            dataBuf=new byte[CACHE_SIZE];
    }

    //线程执行函数
    public void run() {
        running = true;
        if (fileSender) {
            try {
                aSocket = new Socket(IP, port);
                aSocket.setSoTimeout(300000);
                aSocket.setSendBufferSize(CACHE_SIZE*2);
                dos = new DataOutputStream(aSocket.getOutputStream());
                dis = new DataInputStream(aSocket.getInputStream());
                fDis = new DataInputStream(new FileInputStream(aFile));
                fileTransStatus = FILE_TRANS_STATUS_FILENAME;
            } catch (UnknownHostException ex1) {
                ex1.printStackTrace();
                setError("连接服务器错误！");
            } catch (IOException ex1) {
                ex1.printStackTrace();
                setError("创建连接错误！");
            }

        } while (running) {
            if (fileSender) {
                sendFile();
            } else {
                receiveFile();
            }
            try {
                Thread.sleep(6);
            } catch (InterruptedException ex) {
            }
        }
    }

    //从socket读
    private int readFromSocket(byte[] data) throws IOException {
        int length = 0;
        length = fDis.read(data);
        return length;
    }

    //从socket读
    private int readFromSocket() throws IOException {
        int buf = 0;
        buf = dis.readInt();
        return buf;
    }

    //从文件读
    private int readFromFile(byte[] data,int off,int length) {
        int len=0;
        try {
            len = fDis.read(data,off,length);
        } catch (IOException ex) {
            setError("文件读取错误！");
        }
        return len;
    }

    //写入socket
    private void writeToSocket(byte[] data) throws IOException {
        dos.write(data);
    }

    //写入文件
    private void writeToFile(byte[] data,int off,int length) throws IOException {
        raf.write(data,off,length);
    }

    //写入socket
    private void writeToSocket(int data) throws IOException {
        dos.writeInt(data);
    }

    private void writeToSocket(long data) throws IOException {
        dos.writeLong(data);
    }

    private long readLongFromSocket() throws IOException {
        return dis.readLong();
    }

    //打包
    private byte[] doPackage(byte[] data, int length) throws IOException {
        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream bufDos = new DataOutputStream(buf);
        DataOutputStream baosDos = new DataOutputStream(baos);
        switch (fileTransStatus) {
        case FILE_TRANS_STATUS_FILENAME: {
            bufDos.writeInt(PACKAGE_TYPE_FILENAME);
            bufDos.writeInt(fileName.getBytes().length);
            bufDos.write(fileName.getBytes());
            bufDos.writeLong(fileSize);
            if (message!=null) {
                bufDos.writeInt(message.getBytes().length);
                bufDos.write(message.getBytes());
            } else {
                bufDos.writeInt(-1);
            }
            baosDos.writeInt(buf.toByteArray().length);
            baosDos.write(buf.toByteArray());
            break;
        }
        case FILE_TRANS_STATUS_CONTEXT: {
            bufDos.writeInt(PACKAGE_TYPE_CONTEXT);
            if ((transFileLength + length) >= fileSize) {
                bufDos.writeInt(0);
            } else {
                bufDos.writeInt(1);
            }
            bufDos.writeInt(length);
            bufDos.write(data, 0, length);
            baosDos.writeInt(buf.toByteArray().length);
            baosDos.write(buf.toByteArray());
            break;
        }
        }
        return baos.toByteArray();
    }

    //停止线程
    public void stopThread() {
        running = false;
        try {
            if (dis != null) {
                dis.close();
            }
            if (dos != null) {
                dos.close();
            }
            if (fDis != null) {
                fDis.close();
            }
            if (raf != null) {
                raf.close();
            }
        } catch (Exception ex) {
        }
    }