Java TCP BufferedOutputStream reconnection strategy

Question

I have an application that has to send data via TCP socket to another application. This is a 1 way stream from client to server. When sending data the client must retry/reconnect and try to insure all data is sent should the receiver/listener/server die/disappear or drop the connection. My code is as follow:

public class TCPSocket implements Closeable {

    private static final int SIXTY_FOUR_KB = 65536;

    private final String ip;
    private final int port;
    private Socket socket;
    private BufferedOutputStream writer;

    public TCPSocket(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public TCPSocket connect() throws ConnectException {
        try {
            socket = new Socket(ip, port);
            socket.setSendBufferSize(SIXTY_FOUR_KB);
            writer = new BufferedOutputStream(socket.getOutputStream(), SIXTY_FOUR_KB);
        } catch (Exception e) {
            throw new ConnectException(e.getMessage());
        }
        return this;
    }

    public void write(String message) throws InterruptedException {
        boolean succeeded = true;
        do {
            try {
                writer.write(message.getBytes(StandardCharsets.UTF_8));
                writer.write("\n".getBytes(StandardCharsets.UTF_8));
   
            } catch (Exception e) {
                System.out.println(e.getMessage());
                succeeded = false;
                // Exponential backoff to go here
                try {
                    System.out.println("Attempting reconnection");
                    tryClose();
                    connect();
                } catch (ConnectException connectException) {
                    System.out.println(connectException.getMessage());
                }
            }
        } while (!succeeded);
    }

    private void tryClose() {
        try {
            close();
        } catch (Exception ex) {
            System.out.println("Failed closing TCPSocket");
        }
    }


    @Override
    public void close() throws IOException {


        if (writer != null) {
            writer.flush();
            writer.close();
            writer = null;
        }

        if (socket != null && !socket.isClosed()) {
            socket.close();
            socket = null;
        }

    }
}

N.B: Reason for using the BufferedOutputStream is because I'm sending small messages and all other methods couldn't get the same throughput in real world test scenario.

This all works as expected for me however I have a few points.

1. Is this the right way to do this or totally insane and will cause serious problems?

2. When trying to clean up and close connections and the writer before opening a new connection the following error is thrown and I am unable to close the bufferedOutputStream

   java.net.SocketException: Connection reset by peer: socket write error

   If I socket.shutdownOutput(); before attempting to close the output stream then that also throws an exception. What is the correct way to clean up and reconnect?