The problem, as I see it, is you're writing 8000 bytes, regardless of the actual size of the output. You're not even trying to check what size the file might be, so you could be writing garbage if the file is less then 8000 bytes or truncating it if it's over 8000 bytes.

Instead, you should be reading the file till there are no more bytes to be read and ensuring that you're only writing the number bytes which were actual read (as a read might read less than the buffer lengths number of bytes).

This is really basic I/O.

So, the following example strips back the concept to bare bones, focusing only on the transmission of the file between the client and the server. For comparison, I added a MD5 check on each end, so it's easy to compare the file result.

One important aspect of programming is, never assume anything. Always look at what you are been given and make determinations about it at run time (the exception would be if it's documented and agreed upon in advanced, but even then, I'd be double checking, because I trust no one 😉)

Server

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.NoSuchAlgorithmException;

public class Server {
    public static void main(String[] args) {
        try (ServerSocket server = new ServerSocket(7104)) {
            Socket socket = server.accept();
            read(socket);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    protected static void read(Socket socket) {
        File target = new File("Target.file");
        try (InputStream is = socket.getInputStream(); OutputStream os = new FileOutputStream(target)) {
            byte bytes[] = new byte[1024];
            int bytesRead = -1;
            while ((bytesRead = is.read(bytes)) != -1) {
                os.write(bytes, 0, bytesRead);
            }
            System.out.println("Server MD5 = " + Util.getMD5Checksum(target));
        } catch (IOException | NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
    }

}

Client

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.security.NoSuchAlgorithmException;

public class Client {

    public static void main(String[] args) {
        try {
            File source = new File(<BYO own file>);
            System.out.println("Client MD5 = " + Util.getMD5Checksum(source));
            try (Socket socket = new Socket("127.0.0.1", 7104); OutputStream os = socket.getOutputStream(); FileInputStream fis = new FileInputStream(source)) {
                byte bytes[] = new byte[1024];
                int bytesRead = -1;
                while ((bytesRead = fis.read(bytes)) != -1) {
                    os.write(bytes, 0, bytesRead);
                }
            } catch (IOException exp) {

            }
        } catch (IOException | NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
    }
}

MD5

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Util {

    protected static byte[] createChecksum(File filename) throws IOException, NoSuchAlgorithmException {
        try (InputStream fis = new FileInputStream(filename)) {

            byte[] buffer = new byte[1024];
            MessageDigest complete = MessageDigest.getInstance("MD5");
            int numRead;

            do {
                numRead = fis.read(buffer);
                if (numRead > 0) {
                    complete.update(buffer, 0, numRead);
                }
            } while (numRead != -1);

            return complete.digest();
        }
    }

    // see this How-to for a faster way to convert
    // a byte array to a HEX string
    public static String getMD5Checksum(File filename) throws IOException, NoSuchAlgorithmException {
        byte[] b = createChecksum(filename);
        String result = "";

        for (int i = 0; i < b.length; i++) {
            result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
        }
        return result;
    }
}

I highly recommend taking the time to go through Basic I/O, these are concepts you will re-use all the time.