使用套接字在java中传输文件的程序

Question

我编写了一个 java 代码，使用套接字编程的概念将文件从一台服务器传输到另一台服务器。我从另一个满足我要求的 java 论坛获得了代码。据说该程序可以将大型文件（如 .mkv 、.mprg 电影）从一台机器传输到另一台机器，并可用于传输所有格式的文件。但在运行代码后，我发现该程序无法传输大型文件，例如电影，甚至 80mb 或 111mb 的 pdf。该程序已使用字节缓冲区，但仍然出现错误。代码如下（我从这个网站http://www.coderpanda.com/java-socket-programming-transferring-large-sized-files-through-socket/得到的）

ClientMain.java

 import java.io.IOException; 
import java.net.Socket;   
public class ClientMain 
{     
private DirectoryTxr transmitter = null;     
Socket clientSocket = null;     
private boolean connectedStatus = false;     
private String ipAddress;     
String srcPath = null;     
String dstPath = "";     
public ClientMain() 
{       
}       
public void setIpAddress(String ip) 
{         
this.ipAddress = ip;     
}       
public void setSrcPath(String path) 
{         
this.srcPath = path;     
}       
public void setDstPath(String path) 
{         
this.dstPath = path;     
}       
private void createConnection() 
{         
Runnable connectRunnable = new Runnable() 
{             
public void run() 
{                 
while (!connectedStatus) 
{                     
try 
{                         
clientSocket = new Socket(ipAddress, 22);                         
connectedStatus = true;                         
transmitter = new DirectoryTxr(clientSocket, srcPath, dstPath);                     
} 
catch (IOException io) 
{                         
io.printStackTrace();                     
}                 
}               
}         
};         
Thread connectionThread = new Thread(connectRunnable);         
connectionThread.start();     
}       
public static void main(String[] args) 
{      
ClientMain main = new ClientMain();         
main.setIpAddress("localHost");         
main.setSrcPath("C:/Transfer/");         
main.setDstPath("C:/Receive");         
main.createConnection();       
} 
}

DirectoryTxr.java

import java.io.*; 
import java.net.Socket; 
import java.net.SocketException; 
import java.nio.ByteBuffer; 
import java.nio.channels.FileChannel;   

public class DirectoryTxr 
{    
Socket clientSocket = null;     
String srcDir = null;     
String dstDir = null;     
byte[] readBuffer = new byte[1024];     
private InputStream inStream = null;     
private OutputStream outStream = null;     
int state = 0;     
final int permissionReqState = 1;     
final int initialState = 0;     
final int dirHeaderSendState = 2;     
final int fileHeaderSendState = 3;     
final int fileSendState = 4;     
final int fileFinishedState = 5;     
private boolean isLive = false;     
private int numFiles = 0;     
private int filePointer = 0;     
String request = "May I send?";     
String respServer = "Yes,You can";     
String dirResponse = "Directory created...Please send files";     
String fileHeaderRecvd = "File header received ...Send File";     
String fileReceived = "File Received";     
String dirFailedResponse = "Failed";     
File[] opFileList = null;       

public DirectoryTxr(Socket clientSocket, String srcDir, String dstDir) 
{           
try 
{             
this.clientSocket = clientSocket;             
inStream = clientSocket.getInputStream();             
outStream = clientSocket.getOutputStream();             
isLive = true;             
this.srcDir = srcDir;             
this.dstDir = dstDir;             
state = initialState;            
readResponse();             
sendMessage(request);             
state = permissionReqState;         
} 
catch (IOException io) 
{             
io.printStackTrace();         
}         
}       
private void sendMessage(String message) 
{         
try 
{             
sendBytes(request.getBytes("UTF-8"));         
} 
catch (UnsupportedEncodingException e) 
{             
e.printStackTrace();         
}     
}      
private void readResponse() 
{        
Runnable readRunnable = new Runnable() 
{             
public void run() 
{                 
while (isLive) 
{                     
try 
{                         
int num = inStream.read(readBuffer);                         
if (num > 0) 
{                             
byte[] tempArray = new byte[num];                             
System.arraycopy(readBuffer, 0, tempArray, 0, num);                             
processBytes(tempArray);                         
}                     
} 
catch (SocketException se) 
{                         
System.exit(0);                     
} 
catch (IOException io) 
{                         
io.printStackTrace();                         
isLive = false;                     
}                 
}             
}         
};         
Thread readThread = new Thread(readRunnable);         
readThread.start();       
}       
private void sendDirectoryHeader() 
{         
File file = new File(srcDir);         
if (file.isDirectory()) 
{             
try 
{                 
String[] childFiles = file.list();                 
numFiles = childFiles.length;                 
String dirHeader = "$" + dstDir + "#" + numFiles + "&";                 
sendBytes(dirHeader.getBytes("UTF-8"));             
} 
catch (UnsupportedEncodingException en) 
{                 
en.printStackTrace();             
}         
} 
else 
{             
System.out.println(srcDir + " is not a valid directory");         
}    
}         
private void sendFile(String dirName) 
{         
File file = new File(dirName);           
if (!file.isDirectory()) 
{             
try 
{                 
int len = (int) file.length();                 
int buffSize = len / 8;                                 
RandomAccessFile raf = new RandomAccessFile(file, "rw");                 
FileChannel channel = raf.getChannel();                   
int numRead = 0;                 
while (numRead >= 0) 
{                     
ByteBuffer buf = ByteBuffer.allocate(1024 * 100000);                     
numRead = channel.read(buf);                     
if (numRead > 0) 
{                         
byte[] array = new byte[numRead];                         
System.arraycopy(buf.array(), 0, array, 0, numRead);                         
sendBytes(array);                     
}                 
}                 
System.out.println("Finished");               
} 
catch (IOException io) 
{                 
io.printStackTrace();             
}           
}      
}       
private void sendHeader(String fileName) 
{         
try 
{             
File file = new File(fileName);             
if (file.isDirectory())                 
return;          
String header = "&" + fileName + "#" + file.length() + "*";             
sendHeader(header);               
sendBytes(header.getBytes("UTF-8"));         
} 
catch (UnsupportedEncodingException e) 
{             
e.printStackTrace();         
}     
}       
private void sendBytes(byte[] dataBytes) 
{         
synchronized (clientSocket) 
{             
if (outStream != null) 
{                 
try 
{                     
outStream.write(dataBytes);                     
outStream.flush();                 
} 
catch (IOException io) 
{                     
io.printStackTrace();                 
}             
}         
}       
}       
private void processBytes(byte[] data) 
{         
try 
{             
String parsedMessage = new String(data, "UTF-8");             
System.out.println(parsedMessage);             
setResponse(parsedMessage);         
} 
catch (UnsupportedEncodingException u) 
{             
u.printStackTrace();         
}     
}       
private void setResponse(String message) 
{         
if (message.trim().equalsIgnoreCase(respServer) && state == permissionReqState) 
{             
state = dirHeaderSendState;             
sendDirectoryHeader();             
} 
else if (message.trim().equalsIgnoreCase(dirResponse) && state == dirHeaderSendState) 
{             
state = fileHeaderSendState;             
if (LocateDirectory()) 
{                 
createAndSendHeader();             
} 
else 
{                 
System.out.println("Vacant or invalid directory");             
}             
} 
else if (message.trim().equalsIgnoreCase(fileHeaderRecvd) && state == fileHeaderSendState) 
{             
state = fileSendState;             
sendFile(opFileList[filePointer].toString());             
state = fileFinishedState;             
filePointer++;           
} 
else if (message.trim().equalsIgnoreCase(fileReceived) && state == fileFinishedState) 
{             
if (filePointer < numFiles) 
{                 
createAndSendHeader();             
}             
System.out.println("Successfully sent");           
} 
else if (message.trim().equalsIgnoreCase(dirFailedResponse)) 
{             
System.out.println("Going to exit....Error ");                  
} 
else if (message.trim().equalsIgnoreCase("Thanks")) 
{             
System.out.println("All files were copied");         
}       
}       
private void closeSocket() 
{         
try 
{             
clientSocket.close();         
} 
catch (IOException e) 
{             
e.printStackTrace();         
}     
}         
private boolean LocateDirectory() 
{         
boolean status = false;         
File file = new File(srcDir);         
if (file.isDirectory()) 
{             
opFileList = file.listFiles();             
numFiles = opFileList.length;             
if (numFiles <= 0) 
{                 
System.out.println("No files found");             
} 
else 
{                 
status = true;             
}           
}         
return status;     
}       
private void createAndSendHeader() 
{         
File opFile = opFileList[filePointer];         
String header = "&" + opFile.getName() + "#" + opFile.length() + "*";         
try 
{             
state = fileHeaderSendState;             
sendBytes(header.getBytes("UTF-8"));           
} 
catch (UnsupportedEncodingException e) 
{           
}     
}       
private void sendListFiles() 
{         
createAndSendHeader();       
} 
} 

ServerMain.java

public class ServerMain {      
 public ServerMain() {    
   }    
   public static void main(String[] args) {        
   DirectoryRcr dirRcr = new DirectoryRcr();     
  } 
} 

DirectoryRcr.java

import java.io.*; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.net.SocketException;   

public class DirectoryRcr 
{      
 String request = "May I send?";     
String respServer = "Yes,You can";     
String dirResponse = "Directory created...Please send files";     
String dirFailedResponse = "Failed";     
String fileHeaderRecvd = "File header received ...Send File";     
String fileReceived = "File Received";     
Socket socket = null;     
OutputStream ioStream = null;     
InputStream inStream = null;     
boolean isLive = false;    
int state = 0;     
final int initialState = 0;     
final int dirHeaderWait = 1;     
final int dirWaitState = 2;     
final int fileHeaderWaitState = 3;    
final int fileContentWaitState = 4;     
final int fileReceiveState = 5;     
final int fileReceivedState = 6;    
final int finalState = 7;     
byte[] readBuffer = new byte[1024 * 100000];     
long fileSize = 0;     
String dir = "";     
FileOutputStream foStream = null;     
int fileCount = 0;     
File dstFile = null;       
public DirectoryRcr() 
{         
acceptConnection();     
} 
private void acceptConnection() 
{         
try 
{             
ServerSocket server = new ServerSocket(22);             
socket = server.accept();             
isLive = true;             
ioStream = socket.getOutputStream();             
inStream = socket.getInputStream();            
state = initialState;             
startReadThread();           
} 
catch (IOException io) 
{             
io.printStackTrace();         
}     
}       
private void startReadThread() 
{         
Thread readRunnable = new Thread() 
{             
public void run() 
{                 
while (isLive) 
{                     
try 
{                         
int num = inStream.read(readBuffer);                         
if (num > 0) 
{                             
byte[] tempArray = new byte[num];                             
System.arraycopy(readBuffer, 0, tempArray, 0, num);                             
processBytes(tempArray);                         
}                         
sleep(100);                       
} catch (SocketException s) 
{                      
}
catch (IOException e)
 {                         
e.printStackTrace();                     
} 
catch (InterruptedException i) 
{                         
i.printStackTrace();                     
}                 
}             
}         
};         
Thread readThread = new Thread(readRunnable);         
readThread.start();     
}       
private void processBytes(byte[] buff) throws InterruptedException 
{         
if (state == fileReceiveState || state == fileContentWaitState) 
{                      
if (state == fileContentWaitState)                 
state = fileReceiveState;             
fileSize = fileSize - buff.length;             
writeToFile(buff);                 
if (fileSize == 0) 
{                 
state = fileReceivedState;                 
try 
{                     
foStream.close();                 
} 
catch (IOException io) 
{                     
io.printStackTrace();                 
}                 
System.out.println("Received " + dstFile.getName());                 
sendResponse(fileReceived);                 
fileCount--;                 
if (fileCount != 0) 
{                     
state = fileHeaderWaitState;                 
} 
else 
{                     
System.out.println("Finished");                     
state = finalState;                     
sendResponse("Thanks");                     
Thread.sleep(2000);                     
System.exit(0);                 
}                   
System.out.println("Received");             
}         
} 
else 
{             
parseToUTF(buff);         
}       
}       
private void parseToUTF(byte[] data) 
{         
try 
{             
String parsedMessage = new String(data, "UTF-8");             
System.out.println(parsedMessage);             
setResponse(parsedMessage);        
 } 
catch (UnsupportedEncodingException u) {             
u.printStackTrace();         
}       
}       
private void setResponse(String message) 
{         
if (message.trim().equalsIgnoreCase(request) && state == initialState) 
{             
sendResponse(respServer);             
state = dirHeaderWait;           
} 
else if (state == dirHeaderWait) 
{             
if (createDirectory(message)) 
{                 
sendResponse(dirResponse);                 
state = fileHeaderWaitState;             
} 
else 
{                 
sendResponse(dirFailedResponse);                 
System.out.println("Error occurred...Going to exit");                 
System.exit(0);             
}             
} else if (state == fileHeaderWaitState) 
{             
createFile(message);             
state = fileContentWaitState;             
sendResponse(fileHeaderRecvd);           
} 
else if (message.trim().equalsIgnoreCase(dirFailedResponse)) 
{             
System.out.println("Error occurred ....");             
System.exit(0);         
}       
}       
private void sendResponse(String resp) 
{         
try 
{             
sendBytes(resp.getBytes("UTF-8"));         
} 
catch (UnsupportedEncodingException e) 
{             
e.printStackTrace();         
}     
}       
private boolean createDirectory(String dirName) 
{         
boolean status = false;         
dir = dirName.substring(dirName.indexOf("$") + 1, dirName.indexOf("#"));         
fileCount = Integer.parseInt(dirName.substring(dirName.indexOf("#") + 1, dirName.indexOf("&")));         
if (new File(dir).mkdir()) 
{             
status = true;             
System.out.println("Successfully created directory  " + dirName);         
} 
else if (new File(dir).mkdirs()) 
{             
status = true;             
System.out.println("Directories were created " + dirName);           
} 
else if (new File(dir).exists()) 
{             
status = true;             
System.out.println("Directory exists" + dirName);        
 } 
else 
{             
System.out.println("Could not create directory " + dirName);             
status = false;         
}           
return status;     
}       
private void createFile(String fileName) 
{           
String file = fileName.substring(fileName.indexOf("&") + 1, fileName.indexOf("#"));         
String lengthFile = fileName.substring(fileName.indexOf("#") + 1, fileName.indexOf("*"));         
fileSize = Integer.parseInt(lengthFile);         
dstFile = new File(dir + "/" + file);         
try 
{             
foStream = new FileOutputStream(dstFile);             
System.out.println("Starting to receive " + dstFile.getName());         
} 
catch (FileNotFoundException fn) 
{             
fn.printStackTrace();         
}       
}       
private void writeToFile(byte[] buff) 
{         
try 
{             
foStream.write(buff);         
} 
catch (IOException io) 
{             
io.printStackTrace();         
}     
}       
private void sendBytes(byte[] dataBytes) 
{         
synchronized (socket) 
{             
if (ioStream != null) 
{                 
try 
{                     
ioStream.write(dataBytes);                 
} 
catch (IOException io) 
{                    
 io.printStackTrace();                
}             
}         
}       
}   
} 

注意：-

1. ClientMain.java 和 DirectoryTxr.java 是客户端应用程序下的两个类。
2. ServerMain.java 和 DirectoryRcr.java 是 Server 应用下的两个类。
3. 同时运行 ClientMain.java 和 ServerMain.java

还要在 ClientMain.java 中指定运行服务器的机器的源目录、目标目录和主机地址（根据您的计算机）。这里我们没有指定源文件，而是指定了源目录或文件夹。所以源目录的整个文件都会被传输。

如果有人能帮我解决这个问题，我将不胜感激。

Answer 1

您可以检查此代码。此代码可以发送文件直到 2GB 的文件大小。检查并工作。基本上我在这里做的是首先我在一个对象中发送文件大小和文件名，然后我开始发送文件。首先让我向您展示其对象将携带文件详细信息并将其发送到接收器的类。

文件传输类：

public class FileDetails implements Serializable {

String name;
long size;

public void setDetails(String name, long size) {
    this.name = name;
    this.size = size;
}

public String getName() {
    return name;
}

public long getSize() {
    return size;
}
}

发件人：

ServerSocket sendServer = null;
    Socket sendSocket;
    FileDetails details;
    byte data[];
    try {
        File file = new File("File Url");

        // Getting file name and size
        if (file.length() > Integer.MAX_VALUE) {
            System.out.println("File size exceeds 2 GB");
        } else {
            sendServer = new ServerSocket(5050);
            System.out.println("Waiting for Client...");
            sendSocket = sendServer.accept();
            // File Object for accesing file Details
            System.out.println("Connected to Client...");
            data = new byte[2048]; // Here you can increase the size also which will send it faster
            details = new FileDetails();
            details.setDetails(file.getName(), file.length());

            // Sending file details to the client
            System.out.println("Sending file details...");
            ObjectOutputStream sendDetails = new ObjectOutputStream(sendSocket.getOutputStream());
            sendDetails.writeObject(details);
            sendDetails.flush();
            // Sending File Data 
            System.out.println("Sending file data...");
            FileInputStream fileStream = new FileInputStream(file);
            BufferedInputStream fileBuffer = new BufferedInputStream(fileStream);
            OutputStream out = sendSocket.getOutputStream();
            int count;
            while ((count = fileBuffer.read(data)) > 0) {
                System.out.println("Data Sent : " + count);
                out.write(data, 0, count);
                out.flush();
            }
            out.close();
            fileBuffer.close();
            fileStream.close();
        }
    } catch (Exception e) {
        System.out.println("Error : " + e.toString());
    }

收货人代码：

int port = 5050;
    try {
        System.out.println("Connecting to Server...");
        Socket receiveSocket = new Socket("IP of Server", port);
        System.out.println("Connected to Server...");
        // Getting file details

        System.out.println("Getting details from Server...");
        ObjectInputStream getDetails = new ObjectInputStream(receiveSocket.getInputStream());
        FileDetails details = (FileDetails) getDetails.readObject();
        System.out.println("Now receiving file...");
        // Storing file name and sizes

        String fileName = details.getName();
        System.out.println("File Name : " + fileName);
        byte data[] = new byte[2048]; // Here you can increase the size also which will receive it faster
        FileOutputStream fileOut = new FileOutputStream("D:\\" + fileName);
        InputStream fileIn = receiveSocket.getInputStream();
        BufferedOutputStream fileBuffer = new BufferedOutputStream(fileOut);
        int count;
        int sum = 0;
        while ((count = fileIn.read(data)) > 0) {
            sum += count;
            fileBuffer.write(data, 0, count);
            System.out.println("Data received : " + sum);
            fileBuffer.flush();
        }
        System.out.println("File Received...");
        fileBuffer.close();
        fileIn.close();
    } catch (Exception e) {
        System.out.println("Error : " + e.toString());
    }

希望对你有所帮助。

Answer 2

你不需要这一切。在 Java 中复制流的规范方法如下。它适用于任何大于零的缓冲区大小。我一般使用8192。当然没有必要将整个文件读入内存。只是浪费时间和空间。

while ((count = in.read(buffer)) > 0)
{
    out.write(buffer, 0, count);
}

如果您事先知道大小，并且需要保持套接字打开以进行另一次传输：

while (total < length && (count = in.read(buffer, 0, length-total > buffer.length ? buffer.length : (int)(length-total))) > 0)
{
    out.write(buffer, 0, count);
    total += count;
}

其中total 是在此循环之前初始化为零的long，length 是您预先知道的长度。