Java Socket - 通过套接字发送文件

Question

我一直在研究客户端/服务器项目而且我被困住了。我正在尝试编写备份服务器，以便将文件备份到远程计算机。问题是当我尝试备份我的/ home / user文件时，它在服务器端给出了以下错误：

java.io.UTFDataFormatException: malformed input around byte ...

我首先发送文件的大小，然后将文件读入字节数组，然后立即将此字节数组发送到服务器，服务器在使用文件大小构造的字节数组中接收它。将文件分成块还是错误仍然是更好的解决方案？

这通常发生在.zip文件中，但并不总是发生，所以这就是为什么我感到困惑。任何人都可以帮助我吗？

代码：

服务器：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {

private ServerSocket server;
private Socket acceptingSocket;

public Server(int port){
    try {
        server = new ServerSocket(port);
    } catch (IOException e) {
        System.out.println("Try again");
    }
}

public void run(){
    BufferedInputStream buffer = null;
    DataInputStream reader = null;
    int size = 0;
    try {
        acceptingSocket = server.accept();
        buffer = new BufferedInputStream(acceptingSocket.getInputStream());
        reader = new DataInputStream(buffer);
        size = reader.readInt();
    } catch (IOException e1) {
    }
    System.out.println("Size: " + size);
    for(int j = 0; j < size; j++){
        try {
            String path = reader.readUTF();
            System.out.println("Path: " + path);
            long length = reader.readLong();
            System.out.println("Length: "+length);
            boolean dir = reader.readBoolean();
            System.out.println("Dir? " + dir);
            path = "/backup" + path;
            File file = new File(path);
            if(!dir){
                int t = file.getAbsolutePath().lastIndexOf("/");
                String dirs = file.getAbsolutePath().substring(0, t);
                File direcs = new File(dirs);
                System.out.println(direcs.mkdirs());
                FileOutputStream fos = new FileOutputStream(file);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                byte[] b = new byte[(int) length];
                int bytes = reader.read(b, 0, (int)length);
                if(bytes != -1)
                    bos.write(b,0,(int)length);

                BufferedOutputStream out = new BufferedOutputStream(acceptingSocket.getOutputStream());
                DataOutputStream writer = new DataOutputStream(out);


                writer.writeUTF("File " + file.getAbsolutePath() + " is created!");
                writer.flush();

                bos.close();

            } else file.mkdirs();
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}

public static void main(String[] args){
    int port = Integer.parseInt(args[0]);
    Server server = new Server(port);
    while(true)
        server.run();
    }
}

客户端：

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.ArrayList;
import java.util.concurrent.CopyOnWriteArrayList;


public class Client {
private DataInputStream serverToClient;
private Socket client;
private DataOutputStream clientToServer;
private String name;

public Client(String name, int port){
    try {
        client = new Socket(name, port);
        //receive response server
        serverToClient = new DataInputStream(client.getInputStream());
        //send message to server
        clientToServer = new DataOutputStream(client.getOutputStream());
        this.name = name;
    }
    catch (IOException e) {
    }
}

public void backUp(String filePath){
    File file = new File(filePath);
    CopyOnWriteArrayList<File> files = new CopyOnWriteArrayList<File>();
    if(file.exists()){
        try{
            if(file.isDirectory()){
                ArrayList<File> f = setToList(file.listFiles());
                files.addAll(f);
                for(File sendF : files){
                    if(sendF.isDirectory()){
                        files.addAll(setToList(sendF.listFiles()));
                        if(!setToList(sendF.listFiles()).isEmpty()) files.remove(sendF);
                    }
                }
            } else{
                files.add(file);
            }

            clientToServer.writeInt(files.size());

            for(File fi : files){
                boolean dir = false;
                if(fi.isDirectory()) dir = true;
                clientToServer.writeUTF(fi.getAbsolutePath());
                System.out.println(fi.getAbsolutePath());
                long length = fi.length();
                clientToServer.writeLong(length);
                clientToServer.writeBoolean(dir);
                System.out.println(length);
                if(!dir){
                    FileInputStream fis = new FileInputStream(fi);
                    BufferedInputStream bis = new BufferedInputStream(fis);

                    byte[] buffer = new byte[(int)length];

                    bis.read(buffer, 0, (int)length);
                    clientToServer.write(buffer);
                    System.out.println(serverToClient.readUTF());
                    bis.close();
                    fis.close();
                }       
            }

        } catch(IOException e){

        }
    } else System.out.println("File doesn't exist");
}

private ArrayList<File> setToList(File[] listFiles) {
    ArrayList<File> newFiles = new ArrayList<File>();
    for(File lf : listFiles){
        newFiles.add(lf);
    }
    return newFiles;
}

public static void main(String[] args){
    String name = args[0];
    int port = Integer.parseInt(args[1]);
    System.out.println("Name: " + name + " Port: " + port);
    Client client = new Client(name, port);
    File file = new File(args[2]);
    if(file.exists())client.backUp(args[2]);
    else System.out.println("File doesn't exist");
}
}