Transferir archivos de servidor a servidor en java

Buenos días a todos. Les traigo esta información que recientemente me acaba de llegar a las manos, resulta que me encuentro tratando de pasar archivos vía ftp de un servidor a otro utilizando java...

Pasa que después de tanto buscar y buscar me tope con esta manera de pasar archivos, cabe mencionar que es muy rápida la transferencia, muy fácil de utilizar y sobre todo de entender, sin mas, aquí esta.

Creando la clase TransfiereArchivo, las variables necesarias son: 

user: usuario para la conexion

host: host del server

pass: password para conectarse

port: el puerto por el cual se conectara por default casi siempre es el 22

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.SftpException;
import com.jcraft.jsch.UserInfo;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @Param rutaFinal... ruta donde se quedara el archivo en el servidor.
 * @Param rutaFile... ruta del archivo que se va a mover.
 */
public boolean putFile(String rutaFinal, String rutaFile){
        boolean rtn = false;
        try{
            JSch jsch = new JSch();
            Session session = jsch.getSession(user, host, port);
            UserInfo ui = new SUserInfo(pass, null);
            session.setUserInfo(ui);
            session.setPassword(pass);
            session.connect();
            ChannelSftp sftp = (ChannelSftp) session.openChannel("sftp");
            sftp.connect();
            File file = new File( rutaFile );
            sftp.cd( rutaFinal );
            sftp.put(new FileInputStream( file ), file.getName() );
            file.delete(); //opcional
            sftp.exit();
            sftp.disconnect();
            session.disconnect();
            rtn = true;
        }catch(JSchException | FileNotFoundException | SftpException jse){
            System.out.println(jse.getMessage());
        }
        return rtn;
    }

JSch: refiriéndose a JavaShellChannel crea la instancia para la conexión.

Session: en este caso al igual que un jdbc se genera una session con lo necesario para estar activos.

UserInfo: es una instancia de un POJO el cual contiene lo siguiente:

---

public class SUserInfo implements com.jcraft.jsch.UserInfo{
    
    private String password;
    private String passPhrase;

    public SUserInfo(String password, String passPhrase) {
        this.password = password;
        this.passPhrase = passPhrase;
    }

    @Override
    public String getPassphrase() {
        return passPhrase;
    }
 
    @Override
    public String getPassword() {
        return password;
    }
 
    @Override
    public boolean promptPassphrase(String arg0) {
        return true;
    }
 
    @Override
    public boolean promptPassword(String arg0) {
        return false;
    }
 
    @Override
    public boolean promptYesNo(String arg0) {
        return true;
    }
 
    @Override
    public void showMessage(String arg0) {
        System.out.println("SUserInfo.showMessage()");
    }
}

---
Una vez con esto podemos iniciar la conexión.

Abrimos el canal con la instancia:

ChannelSftp canal = (ChanelSftp) session.openchanel("");

canal.connect();

Inicializamos el archivo mediante un File, (nota: los comandos en ChannelSftp son muy similares a los de la linea de comandos de windows ) nos ubicamos en la carpeta donde quedara el archivo mediante el codigo
sftp.cd( rutafinal );
Y al final escribimos el archivo pasando el File, en conjunto con el nombre del archivo ( este ultimo es un String, para finalizar es necesario cerrar y desconectar el canal al igual que la sesión


De esta forma es como agregamos el archivo que queremos en el servidor.

Por el momento es todo, nos vemos en la próxima entrega para ver como extraer un archivo desde el servidor y depositario en una ruta en especifico.