Enviar archivo a FTP desde memoria

[Etrusco]

Buen día. Tengo una aplicación que va a enviar un archivo txt a un servidor de FTP. Especificamente lo que necesito es enviar el archivo desde memoria, me explico. Tengouna clase que genera un archivo datos.txt, y me gustaria mandar este archivo sin necesidad de pasarle la ruta de donde está guardado, simplemente tomandolo desde memoria. Esto porque si lo hago de forma local no va a haber problema, simplemente guardo mi archivo en una misma ubicación, pero vamos a estar generando el archivo en un servidor que no administro yo y no puedo garantizar que las carpetas donde se guarda el archivo no sean eliminadas. Estuve buscando en las FAQs de Java, pero no pude encontrar nada al respecto. Ojalá puedan darme una mano. Saludos.

[Wayern]

¿Q tal Etrusco? Estuve checando algunos proyectos e hice algo más o menos así.... Espero te funcione:

Una vez que tengas tu archivo txt creado vas a tratar de ponerlo en un array de bites, para poder escribirlo en el servidor ftp. Puedes hacer algo más o menos así:

Código:

private transient File file;

public changeFile(String fileName){
try{
			file=new File(fileName);
			InputStream is = new FileInputStream(file);
			long length = file.length();
		//No podemos generar arrays con longs, entonces checas el tamaño
               //del archivo, sino excede la capacidad de un tipo int, declaras el array.
	        if (length > Integer.MAX_VALUE) {
	            // File is too large
	        }
	        byte[] bytes = new byte[(int)length];
	        int offset = 0;
	        int numRead = 0;
	        while (offset < bytes.length&&(numRead=is.read(bytes, offset,            bytes.length-offset)) >= 0) {
	            offset += numRead;
	        }
	        if (offset < bytes.length) {
	            throw new IOException("Could not completely read file "+file.getName());
	        }
	        is.close();
	        connectionData.setHost("ftpHost");
	        connectionData.setUser("ftpUser");
	        connectionData.setPassword("ftpPassword");
	        connectionData.setPort(ftpPort);
	        connectionData.setRemotePath("/ftpPath");
	        connection.setConnectionData(connectionData);
	        connection.putFile(fileName, bytes);
	        connection.disconnect();
	        file.delete();
		}catch(IOException e){
			
		}
}

El método para escribir el archivo en el ftp no lo hice yo, es un wrapper de la clase que viene en el jar commons-net-2.0 que hizo un compañero, pero te pongo el código para ver si te sirve, igual si consideras que es demasiado darle vueltas puedes utilizar las clases que te da el jar de forma directa:

Código:

private final FTPClient ftpClient = new FTPClient();
public Response putFile(String fileName, byte[] bytes) {
        final String METHOD_NAME = "putFile";
         Response response = new Response();
        response.setResponseCode(ResponseCode.SUCCESS_CODE);
        if (bytes == null || bytes.length < 1) {
            response = util.createFTPErrorResponse(
                    FTPErrorId.BYTES_LIST_NULL_OR_EMPTY_ERROR,
                    FTPErrorType.INPUT_DATA_VALIDATION_ERROR,
                    FTPErrorId.BYTES_LIST_NULL_OR_EMPTY_ERROR.getEnumName());
            return response;
        }
        if (this.ftpClient == null || !this.ftpClient.isConnected()) {
            Response connectionRsponse = connect(this.connectionData);
            if (connectionRsponse.getResponseCode() == ResponseCode.ERR_CODE) {
                response.setResponseCode(connectionRsponse.getResponseCode());
                response.setErrors(connectionRsponse.getErrors());
                logger.info(Constants.LEAVING_METHOD.get()
                        + Constants.DELIMITER_CHARACTERS.get() + METHOD_NAME);
                return response;
            }
        }
        OutputStreamWriter writer = null;
        OutputStream oStream = null;
        try {
            oStream = this.ftpClient.storeFileStream(fileName);
        } catch (IOException e) {
            response = util
                    .createErrorResponse(FTPErrorId.GENERIC_REMOTE_ERROR,
                            FTPErrorType.REMOTE_COMMAND_EXECUTION_ERROR, e
                                    .getMessage());
           return response;
        }
        writer = new OutputStreamWriter(oStream);
        for (int myByte : bytes) {
            try {
                writer.write(myByte);
            } catch (IOException e) {
                System.out.println("Error :writing the stream of bytes in the remote server.");
                response = util.createErrorResponse(
                        FTPErrorId.GENERIC_REMOTE_ERROR,
                        FTPErrorType.REMOTE_COMMAND_EXECUTION_ERROR, e
                                .getMessage());

                Response closingResponse = closeOutputStream(oStream, writer);
                if (closingResponse.getResponseCode() == ResponseCode.ERR_CODE) {
                    response.getErrors().addAll(closingResponse.getErrors());
                }
               return response;

            }
        }
        Response closingResponse = closeOutputStream(oStream, writer);
        if (closingResponse.getResponseCode() == ResponseCode.ERR_CODE) {
            response.setResponseCode(closingResponse.getResponseCode());
            response.setErrors(closingResponse.getErrors());
            return response;
        }
        return response;
    }

En el código estoy obviando algunas cosas, como que vas a tener que hacer un bean para la conexión que tenga user, password, port y los demás campos.
Espero haberte ayudado, ojalá no te haya confundido más. Puedes checar si existe la posibilidad de imprimir cierto número de bytes de un jalón, por ejemplo de mil en mil, en lugar de estar recorriendo el arreglo. Te recomiendo que uses bytes, porque me tocó ver que a veces usan arreglos de int, sabiendo que un int puede guardar datos tipo byte, pero el byte está en hexadecimal, por lo que al menos para mí es más preciso. Si tienes cualquier duda, puedes preguntarme.
Salu2.