Conectar vía SFTP con Java

A continuación os vamos a explicar, a través de un ejemplo práctico, como establecer una conexión una SFTP con el lenguaje de programación Java. Intentaremos explicarlo mediante un código sencillo que pueda ser entendido por cualquier tipo de nivel de usuarios. No nos complicaremos mucho con esto y trataremos que la práctica sea entendible y puedas llevarla a cabo en los proyectos que implementes de aquí en adelante.

¿Cómo empezar?

Antes que nada, tenemos que agregar las dependencias que vamos a utilizar en el ejercicio.

Si habéis estado atentos, os habréis fijado que vamos a utilizar JCraft, una librería que nos ayudará a lo que queremos conseguir en este artículo, establecer una conexión SFTP con Java. Si queréis obtener más información sobre esta librería, no dudéis en visitar su web oficial.

¿Y ahora qué?

Pues ya lo siguiente será crear el componente de conexión y ejecutar los comandos SFTP:

package co.com.mm.sftp;
 
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;
import java.io.IOException;
 
/**
 * Clase encargada de establecer conexion y ejecutar comandos SFTP.
 */
public class SFTPConnector {
 
    /**
     * Sesion SFTP establecida.
     */
    private Session session;
 
    /**
     * Establece una conexion SFTP.
     *
     * @param username Nombre de usuario.
     * @param password Contrasena.
     * @param host     Host a conectar.
     * @param port     Puerto del Host.
     *
     * @throws JSchException          Cualquier error al establecer
     *                                conexión SFTP.
     * @throws IllegalAccessException Indica que ya existe una conexion
     *                                SFTP establecida.
     */
    public void connect(String username, String password, String host, int port)
        throws JSchException, IllegalAccessException {
        if (this.session == null || !this.session.isConnected()) {
            JSch jsch = new JSch();
 
            this.session = jsch.getSession(username, host, port);
            this.session.setPassword(password);
 
            // Parametro para no validar key de conexion.
            this.session.setConfig("StrictHostKeyChecking", "no");
 
            this.session.connect();
        } else {
            throw new IllegalAccessException("Sesion SFTP ya iniciada.");
        }
    }
 
    /**
     * Añade un archivo al directorio FTP usando el protocolo SFTP.
     *
     * @param ftpPath  Path del FTP donde se agregará el archivo.
     * @param filePath Directorio donde se encuentra el archivo a subir en
     *                 disco.
     * @param fileName Nombre que tendra el archivo en el destino.
     *
     * @throws IllegalAccessException Excepción lanzada cuando no hay
     *                                conexión establecida.
     * @throws JSchException          Excepción lanzada por algún
     *                                error en la ejecución del comando
     *                                SFTP.
     * @throws SftpException          Error al utilizar comandos SFTP.
     * @throws IOException            Excepción al leer el texto arrojado
     *                                luego de la ejecución del comando
     *                                SFTP.
     */
    public final void addFile(String ftpPath, String filePath,
        String fileName) throws IllegalAccessException, IOException,
        SftpException, JSchException {
        if (this.session != null && this.session.isConnected()) {
 
            // Abrimos un canal SFTP. Es como abrir una consola.
            ChannelSftp channelSftp = (ChannelSftp) this.session.
                openChannel("sftp");
 
            // Nos ubicamos en el directorio del FTP.
            channelSftp.cd(ftpPath);
            channelSftp.connect();
 
            System.out.println(String.format("Creando archivo %s en el " +
                "directorio %s", fileName, ftpPath));
            channelSftp.put(filePath, fileName);
 
            System.out.println("Archivo subido exitosamente");
 
            channelSftp.exit();
            channelSftp.disconnect();
        } else {
            throw new IllegalAccessException("No existe sesion SFTP iniciada.");
        }
    }
 
    /**
     * Cierra la sesion SFTP.
     */
    public final void disconnect() {
        this.session.disconnect();
    }
}

Finalmente, crearemos la clase que se encargará de utilizar el código que hemos publicado anteriormente para llevar a cabo la funcionalidad:

package co.com.mm.ssh;
 
package co.com.mm.sftp;
 
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.SftpException;
import java.io.IOException;
 
/**
 *
 * @author mmartinez
 */
public class SFTPConnection {
 
    private static final String USERNAME = "us_prog";
    private static final String HOST = "localhost";
    private static final int PORT = 22;
    private static final String PASSWORD = "programac";
 
    public static void main(String[] args) {
 
        try {
            SFTPConnector sshConnector = new SFTPConnector();
             
             
            sshConnector.connect(USERNAME, PASSWORD, HOST, PORT);
            sshConnector.addFile("/home/MyFiles", "C:/MyFiles/archivo.txt",
                "archivo.txt");
            sshConnector.disconnect();
        } catch (JSchException ex) {
            ex.printStackTrace();
             
            System.out.println(ex.getMessage());
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
             
            System.out.println(ex.getMessage());
        } catch (IOException ex) {
            ex.printStackTrace();
             
            System.out.println(ex.getMessage());
        } catch (SftpException ex) {
            ex.printStackTrace();
             
            System.out.println(ex.getMessage());
        }
    }
}

Por último, editad este código con vuestro host, usuario, contraseña y puerto para que funcione con vuestras propias credenciales. Y eso sería todo, ¿verdad que no ha sido tan difícil?

Y este ha sido el tutorial sobre conectar vía SFTP con Java, esperamos que te haya gustado y sepas aplicarlo en tus futuros proyectos. Ya sabes que si nos quieres proponer un tema que quieres ver reflejado como un tutorial o como una práctica, solo tienes que hacer uso del área de comentarios de un poco más abajo. Por el contrario, si quieres enviarnos tus propios tutoriales, puedes hacerlo a través de la intranet de usuarios que está habilitada para ello, a través del menú Enviar Tutorial. Ya sabes, ayúdanos a crecer con tus conocimientos. ¡Un saludo y feliz código!

Vía: aquiseprograma.co