In -depth understanding of the technical principle of SFTP transmission framework in the Java class library
SFTP (Secure File Transfer Protocol) is a safe file transmission protocol for transmission files between remote systems.In the Java class library, there are some SFTP transmission framework technology to use in order to achieve file transmission and management of remote systems by programming.This article will explore the technical principles of these transmission frameworks and provide some Java code examples to illustrate its usage.
The implementation of SFTP transmission framework technology is based on SSH (Secure Shell) protocol for security communication and file transmission.SSH is an encrypted protocol that can be used to protect sensitive information in network transmission.SFTP uses the SSH protocol to establish a security communication channel to transmit files on this channel.
The SFTP transmission framework technology commonly used in the Java library includes JSCH, Apache SSHD, Apache Commons VFS, etc.Below will introduce their technical principles and uses one by one.
1. Jsch ：
JSCH is an open source Java Secure Channel library that is used to implement the SSH2 protocol client.It provides APIs for connecting to remote servers, authentication, transmission files, etc.The following is an example code that uses JSCH to implement SFTP files:
import com.jcraft.jsch.*;
public class SftpExample {
public static void main(String[] args) {
String host = "remote_host";
int port = 22;
String username = "username";
String password = "password";
String remoteFile = "path_to_remote_file";
String localFile = "path_to_local_file";
try {
JSch jsch = new JSch();
Session session = jsch.getSession(username, host, port);
session.setConfig("StrictHostKeyChecking", "no");
session.setPassword(password);
session.connect();
ChannelSftp sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
sftpChannel.put(localFile, remoteFile);
sftpChannel.disconnect();
session.disconnect();
} catch (JSchException | SftpException e) {
e.printStackTrace();
}
}
}
2. Apache SSHD：
Apache SSHD is a SSH server and client implemented in Java, which provides highly scalable SSH protocol support.You can use the Apache SSHD library to implement the SFTP file transmission. The following is an example code that uses Apache SSHD to implement SFTP files:
import org.apache.sshd.client.SshClient;
import org.apache.sshd.client.channel.ChannelShell;
import org.apache.sshd.client.channel.ChannelSubsystem;
import org.apache.sshd.client.subsystem.sftp.SftpClient;
import org.apache.sshd.common.channel.channel.InitialChannelConfiguration;
import org.apache.sshd.common.file.FileSystemFactory;
import org.apache.sshd.common.file.nativefs.NativeFileSystemFactory;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.nio.file.Paths;
public class SftpExample {
public static void main(String[] args) {
String host = "remote_host";
int port = 22;
String username = "username";
String password = "password";
String remoteFile = "path_to_remote_file";
String localFile = "path_to_local_file";
try (SshClient client = SshClient.setUpDefaultClient()) {
client.start();
try (ChannelShell shell = client.session().createShellChannel();
ChannelSubsystem subsystem = client.session().createSubsystemChannel("sftp")) {
shell.open();
subsystem.open();
try (OutputStream output = new FileOutputStream(localFile);
SftpClient sftpClient = client.session().createSftpClient()) {
sftpClient.setFileSystemFactory(new NativeFileSystemFactory());
sftpClient.start();
try (SftpClient.CloseableHandle handle = sftpClient.open(remoteFile, null)) {
sftpClient.read(handle, 0, output, 0);
}
}
subsystem.close();
shell.close();
}
client.stop();
} catch (Exception e) {
e.printStackTrace();
}
}
}
3. Apache Commons VFS：
Apache Commons VFS is a Java API for accessing different storage resources (such as local file systems, FTP servers, SFTP servers, etc.).It provides a unified interface to handle different types of file transmission.Here are a sample code that uses Apache Commons VFS to implement SFTP files:
import org.apache.commons.vfs2.*;
import org.apache.commons.vfs2.impl.DefaultFileSystemManager;
import org.apache.commons.vfs2.provider.sftp.SftpFileSystemConfigBuilder;
public class SftpExample {
public static void main(String[] args) {
String host = "remote_host";
int port = 22;
String username = "username";
String password = "password";
String remoteFile = "path_to_remote_file";
String localFile = "path_to_local_file";
try {
FileSystemManager manager = new DefaultFileSystemManager();
manager.init();
FileObject localFileObj = manager.resolveFile(localFile);
FileSystemOptions opts = new FileSystemOptions();
SftpFileSystemConfigBuilder.getInstance().setStrictHostKeyChecking(opts, "no");
String sftpUrl = "sftp://" + username + ":" + password + "@" + host + ":" + port + remoteFile;
FileObject remoteFileObj = manager.resolveFile(sftpUrl, opts);
remoteFileObj.copyFrom(localFileObj, Selectors.SELECT_SELF);
localFileObj.close();
remoteFileObj.close();
manager.close();
} catch (FileSystemException e) {
e.printStackTrace();
}
}
}
By using these SFTP transmission framework technology, we can easily achieve safe and reliable file transmission.Whether it is uploaded files to the remote server or downloading files from the remote server, these technologies provide simple and powerful APIs to meet various needs.Although the implementation of each framework is slightly different, their core principles are to establish a security channel based on the SSH protocol, and file transmission on this channel.
