import com.jcraft.jsch.*;
import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import java.util.Vector;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class SftpService {
    private static final int TEMP_DIR_ATTEMPTS = 10000;
    private final FtpOptions ftpOptions;

    SftpService(@Value("${sftp.host:''}") String host,
            @Value("${sftp.port:#{null}}") Integer port,
            @Value("${sftp.login:''}") String login,
            @Value("${sftp.password:''}") String password,
            @Value("${sftp.ftpPathFileName:''}") String ftpPathFileName) {
        this.ftpOptions = new FtpOptions()
                .setHost(host)
                .setPort(port)
                .setLogin(login)
                .setPassword(password)
                .setFtpPathFileName(ftpPathFileName);
    }

    public void uploadFileToSftp(List<File> files) throws Exception {
        uploadFileToSftp(files, ftpOptions);
    }

    public void uploadFileToSftp(List<File> files, FtpOptions ftpOptions) throws Exception {
        log.info("Upload files to SFTP server");
        ChannelSftp sftpChannel = createSftpChanel(ftpOptions.getLogin(), ftpOptions.getPassword(),
                ftpOptions.getHost(), ftpOptions.getPort());
        try {
            for (File file : files) {
                String remoteFileName = ftpOptions.getFtpPathFileName() + file.getName();

                log.info("Upload file: {} to {}", file.getName(), remoteFileName);

                sftpChannel.put(new FileInputStream(file), remoteFileName);
            }
        } finally {
            log.info("Close SFTP connection");
            sftpChannel.disconnect();
        }
    }

    public List<File> downloadFileFromSftp(String fileMask) throws Exception {
        return downloadFileFromSftp(fileMask, ftpOptions);
    }

    public List<File> downloadFileFromSftp(String fileMask, FtpOptions ftpOptions) throws Exception {
        log.info("Download files from SFTP server");
        ChannelSftp sftpChannel = createSftpChanel(ftpOptions.getLogin(), ftpOptions.getPassword(),
                ftpOptions.getHost(), ftpOptions.getPort());
        List<File> result = new ArrayList<>();
        try {
            Vector<ChannelSftp.LsEntry> lsEntries = sftpChannel.ls(
                    new StringBuilder(ftpOptions.getFtpPathFileName()).append("/").append(fileMask).toString());
            File myTempDir = createTempDir();
            // Iterating the list of entries to download the file(s) from the sftp
            for (ChannelSftp.LsEntry entry : lsEntries) {
                try {
                    // Downloading the specified file from the sftp to the specified folder path
                    String destFileName = new StringBuilder(myTempDir.getAbsolutePath()).append(File.separator)
                            .append(entry.getFilename()).toString();
                    sftpChannel.get(new StringBuilder(ftpOptions.getFtpPathFileName()).append("/")
                            .append(entry.getFilename()).toString(), destFileName);
                    result.add(new File(destFileName));
                } catch (SftpException sftpException) {
                    log.error("Failed to download the file the sftp folder location. {}", sftpException.getMessage());
                }                
            }
            // Iterating the list of entries to delete the file(s) from the sftp 
            for (ChannelSftp.LsEntry entry : lsEntries) {
                try {
                    // Deleting the specified file from the sftp
                    sftpChannel.rm(new StringBuilder(ftpOptions.getFtpPathFileName())
                            .append("/").append(entry.getFilename()).toString());
                } catch (SftpException sftpException) {
                    log.error("Failed to delete the file from the sftp folder location. {}", sftpException.getMessage());                    
                }                
            }
        } catch (SftpException ex) {
            log.error(ex.getMessage());
        } finally {
            log.info("Close SFTP connection");
            sftpChannel.disconnect();
        }
        return result;
    }
    
    private File createTempDir() {
        File baseDir = new File(System.getProperty("java.io.tmpdir"));
        String baseName = System.currentTimeMillis() + "-";

        for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
          File tempDir = new File(baseDir, baseName + counter);
          if (tempDir.mkdir()) {
            return tempDir;
          }
        }
        throw new IllegalStateException("Failed to create directory within "
            + TEMP_DIR_ATTEMPTS + " attempts (tried "
            + baseName + "0 to " + baseName + (TEMP_DIR_ATTEMPTS - 1) + ')');
    }

    private ChannelSftp createSftpChanel(String sftpUser, String sftpPassword, String sftpHost, Integer sftpPort)
            throws JSchException {
        log.info("Connect to SFTP server: {} {} {} {}", new Object[]{
            sftpUser, sftpPassword, sftpHost, sftpPort
        });
        JSch jsch = new JSch();
        Session session = jsch.getSession(sftpUser, sftpHost, (Objects.isNull(sftpPort) ? 22 : sftpPort));

        session.setPassword(sftpPassword);
        Properties config = new Properties();
        config.put("StrictHostKeyChecking", "no");
        session.setConfig(config);
        session.connect();
        Channel channel = session.openChannel("sftp");
        channel.connect();
        return (ChannelSftp) channel;
    }

    public FtpOptions getFtpOptions() {
        return ftpOptions;
    }
}

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.*;
import org.junit.Test;

public class SftpServiceTest {
    
    @Test
    public void uploadAndDownloadFileToSftp() throws Exception {
        SftpService sftpService = new SftpService("host",
            22, "login", "password", "/");
        File newFile = Files.write(Paths.get("./test.csv"), "data".getBytes(StandardCharsets.UTF_8)).toFile();
        sftpService.uploadFileToSftp(Collections.singletonList(newFile));
        List<File> files = sftpService.downloadFileFromSftp("test.csv", sftpService.getFtpOptions());
        assertThat(files, hasSize(1));
        files.get(0).deleteOnExit();
    }
}

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.experimental.Accessors;

@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@Getter
@Setter
public class FtpOptions {
    String host;
    Integer port;
    String login;
    String password;
    String ftpPathFileName;
}