SFTP的应用

最新推荐文章于 2023-05-28 23:25:03 发布
最新推荐文章于 2023-05-28 23:25:03 发布
阅读量176 收藏
点赞数
文章标签： sftp upload
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43303455/article/details/117114160
版权

SFTP的应用

封装utils,用SFTP方式上传/下载图像

maven

 <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>5.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
    <dependency>
        <groupId>com.jcraft</groupId>
        <artifactId>jsch</artifactId>
        <version>0.1.55</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.ant/ant -->
    <dependency>
        <groupId>org.apache.ant</groupId>
        <artifactId>ant</artifactId>
        <version>1.10.10</version>
    </dependency>

utils

package com.wh.sftp;

import com.jcraft.jsch.*;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import org.apache.log4j.Logger;
import org.apache.poi.util.IOUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class SFTPUtil {

    private ThreadLocal<Scope> threadLocal = new ThreadLocal<>();

    private ChannelSftp sftp;

    private Session session;
    /**
     * FTP 登录用户名
     */
    private String username;
    /**
     * FTP 登录密码
     */
    private String password;
    /**
     * 私钥
     */
    private String privateKey;
    /**
     * FTP 服务器地址IP地址
     */
    private String host;
    /**
     * FTP 端口
     */
    private int port;

    private String hostDir;

    private static Logger log = Logger.getLogger(SFTPUtil.class);

    /**
     * 构造基于密码认证的sftp对象
     *
     * @param username
     * @param password
     * @param host
     * @param port
     */
    public SFTPUtil(String username, String password, String host, int port, String hostDir) {
        this.username = username;
        this.password = password;
        this.host = host;
        this.port = port;
        this.hostDir = hostDir;
    }

    public SFTPUtil() {
//        String username = RedisUtils.getDictValue("SFTP_MEMBER", "SFTP_NAME");
//        String password = RedisUtils.getDictValue("SFTP_MEMBER", "SFTP_PASSWORD");
//        String host = RedisUtils.getDictValue("SFTP_MEMBER", "SFTP_HOST");
//        int port = Integer.parseInt(RedisUtils.getDictValue("SFTP_MEMBER", "SFTP_PORT"));
//        String hostDir = RedisUtils.getDictValue("SFTP_MEMBER", "SFTP_PATH");
//        String username = "sftp";
//        String password = "2020@newImage";
//        String host = "49.232.18.205";
//        int port = 22;
//        String hostDir = "/upload";
        this.username = "ergo_life_dev";
        this.password = "ergo_life_dev";
        this.host = "49.232.76.227";
        this.port = 22;
        this.hostDir = "/upload";
    }

    /**
     * 连接sftp服务器
     *
     * @throws Exception
     */
    public void login() {
        try {
            JSch jsch = new JSch();
            if (privateKey != null) {
                jsch.addIdentity(privateKey);// 设置私钥  
                log.info("sftp connect,path of private key file：{}");
            }
            log.info("sftp connect by host:{" + host + "} username:{" + username + "}");


            session = jsch.getSession(username, host, port);
            log.info("Session is build");
            if (password != null) {
                session.setPassword(password);
            }
            Properties config = new Properties();
            config.put("StrictHostKeyChecking", "no");

            session.setConfig(config);
            log.info(session.toString());
            session.connect();
            log.info("Session is connected");

            Channel channel = session.openChannel("sftp");
            channel.connect();
            log.info("channel is connected");

            sftp = (ChannelSftp) channel;
            log.info(String.format("sftp server host:[%s] port:[%s] is connect successfull", host, port));
        } catch (JSchException e) {
            e.printStackTrace();
            log.error("SFTP连接失败", e);
        }
    }

    /**
     * 关闭连接 server
     */
    public void logout() {
        if (sftp != null) {
            if (sftp.isConnected()) {
                sftp.disconnect();
                log.info("sftp is closed already");
            }
        }
        if (session != null) {
            if (session.isConnected()) {
                session.disconnect();
                log.info("sshSession is closed already");
            }
        }
    }

    public void cd(String directory) throws SftpException {
        sftp.cd(directory);
    }

    public Vector ls(String path) throws SftpException {
        return sftp.ls(path);
    }

    public String pwd() throws Exception {
        String pwd = sftp.pwd();
        return pwd;
    }

    /**
     * 将输入流的数据上传到sftp作为文件
     *
     * @param directory    上传到该目录
     * @param sftpFileName sftp端文件名
     * @param input        输入流
     * @throws SftpException
     * @throws Exception
     */
    public void upload(String directory, String sftpFileName, InputStream input) throws SftpException {
        try {
            sftp.cd(directory);
        } catch (SftpException e) {
            log.warn("directory is not exist");
            mkdirDirs(directory);
            sftp.cd(directory);
        }
        sftp.put(input, sftpFileName);
        log.info("file:{" + sftpFileName + "} is upload successful");
    }

    /**
     * 上传单个文件
     *
     * @param directory  上传到sftp目录
     * @param uploadFile 要上传的文件,包括路径
     * @throws FileNotFoundException
     * @throws SftpException
     * @throws Exception
     */
    public void upload(String directory, String uploadFile) throws FileNotFoundException, SftpException {
        File file = new File(uploadFile);
        upload(directory, file.getName(), new FileInputStream(file));
    }

    /**
     * 将byte[]上传到sftp，作为文件。注意:从String生成byte[]是，要指定字符集。
     *
     * @param directory    上传到sftp目录
     * @param sftpFileName 文件在sftp端的命名
     * @param byteArr      要上传的字节数组
     * @throws SftpException
     * @throws Exception
     */
    public void upload(String directory, String sftpFileName, byte[] byteArr) throws SftpException {
        upload(directory, sftpFileName, new ByteArrayInputStream(byteArr));
    }

    /**
     * 将字符串按照指定的字符编码上传到sftp
     *
     * @param directory    上传到sftp目录
     * @param sftpFileName 文件在sftp端的命名
     * @param dataStr      待上传的数据
     * @param charsetName  sftp上的文件，按该字符编码保存
     * @throws UnsupportedEncodingException
     * @throws SftpException
     * @throws Exception
     */
    public void upload(String directory, String sftpFileName, String dataStr, String charsetName) throws UnsupportedEncodingException, SftpException {
        upload(directory, sftpFileName, new ByteArrayInputStream(dataStr.getBytes(charsetName)));
    }


    /**
     * 下载文件
     *
     * @param directory    下载目录
     * @param downloadFile 下载的文件
     * @param saveFile     存在本地的路径
     * @throws SftpException
     * @throws FileNotFoundException
     * @throws Exception
     */
    public void download(String directory, String downloadFile, String saveFile) throws SftpException, FileNotFoundException {
        if (directory != null && !"".equals(directory)) {
            log.info("directory:" + directory);
            sftp.cd(directory);
        }
        File file = new File(saveFile + downloadFile);
        log.info("downloadFile" + downloadFile);
        sftp.get(downloadFile, saveFile);
        log.info("file:{" + downloadFile + "} is download successful");
    }

    /**
     * 下载文件
     *
     * @param directory    下载目录
     * @param downloadFile 下载的文件名
     * @return 字节数组
     * @throws SftpException
     * @throws IOException
     * @throws Exception
     */
    public byte[] download(String directory, String downloadFile) throws SftpException, IOException {
        if (directory != null && !"".equals(directory)) {
            sftp.cd(directory);
        }
        InputStream is = sftp.get(downloadFile);
        byte[] fileData = IOUtils.toByteArray(is);
        log.info("file:{" + downloadFile + "} is download successful");
        return fileData;
    }

    /**
     * 下载文件流
     *
     * @param directory    下载目录
     * @param downloadFile 下载的文件名
     * @return 字节流
     * @throws SftpException
     * @throws IOException
     * @throws Exception
     */
    public InputStream downloadStream(String directory, String downloadFile) throws SftpException, IOException {
        if (directory != null && !"".equals(directory)) {
            sftp.cd(directory);
        }
        InputStream is = sftp.get(downloadFile);
        return is;
    }

    public InputStream downloadStream(String downloadFile) throws SftpException, IOException {
        InputStream is = sftp.get(downloadFile);
        return is;
    }

    public boolean createFile(InputStream inputStream, String filePath) {
        try {
            sftp.put(inputStream, filePath);
            log.info("创建文件完成");
            return true;
        } catch (Exception e) {
            log.info("创建文件失败");
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除文件
     *
     * @param directory  要删除文件所在目录
     * @param deleteFile 要删除的文件
     * @throws SftpException
     * @throws Exception
     */
    public void delete(String directory, String deleteFile) throws SftpException {
        sftp.cd(directory);
        sftp.rm(deleteFile);
    }

    public void deleteFile(String deleteFile) {
        try {
            sftp.rm(deleteFile);
            sftp.ls(sftp.pwd());
        } catch (SftpException e) {
            e.printStackTrace();
        }
    }

    /**
     * 列出目录下的文件
     *
     * @param directory 要列出的目录
     * @return
     * @throws SftpException
     */
    public Vector<LsEntry> listFiles(String directory) throws SftpException {
        return sftp.ls(directory);
    }


    public static Map<String, String> zipPaths(String path) {
        //因为这里我的zip文件是存放在707的子目录下面的，所以在这里做了遍历
        File file = new File(path + "\\");
        String fileName = null;
        String filePath = null;
        //在这里声明一个Map，将遍历得到的zip文件的名字作为key，zip文件的路径作为value。
        Map<String, String> fileMap = new HashMap<String, String>();
        if (file.isDirectory()) {
            for (File files : file.listFiles()) {
                if (files.isDirectory()) {
                    for (File f : files.listFiles()) {
                        if (f.isDirectory()) {
                            for (File ff : f.listFiles()) {
                                fileName = ff.getName();
                                filePath = ff.getPath();
                                fileMap.put(fileName, filePath);
                            }
                        } else {
                            fileName = f.getName();
                            filePath = f.getPath();
                            fileMap.put(fileName, filePath);
                        }
                    }
                } else {
                    fileName = files.getName();
                    filePath = files.getPath();
                    fileMap.put(fileName, filePath);
                }
            }
        }
        //最后返回一个map给调用者。
        return fileMap;
    }


    /**
     * 解压  zipPath 压缩的zip文件夹，unZipPath 文件夹
     *
     * @param zipPath
     * @param unZipPath
     * @return
     * @throws Exception
     */
    public String unZip(String zipPath, String unZipPath) throws Exception {
        String zipFileName = null;
        String ZipFilePath = null;
        String outputDirectory = null;
        //调用上面zipPaths方法，拿到map。
        Map<String, String> fileMap = zipPaths(zipPath);
        for (Map.Entry<String, String> entry : fileMap.entrySet()) {
            //压缩文件的名字
            zipFileName = entry.getKey();
            //压缩文件的路径
            ZipFilePath = entry.getValue();
            File file = new File(ZipFilePath);
            //得到zip文件的父文件夹的名字
            String parentFolder = file.getParent().substring(file.getParent().lastIndexOf("\\"));
            //这个是存放解压之后的文件的路径
            outputDirectory = unZipPath + parentFolder;
            org.apache.tools.zip.ZipFile zipFile = new org.apache.tools.zip.ZipFile(ZipFilePath);
            try {
                Enumeration<?> e = zipFile.getEntries();
                org.apache.tools.zip.ZipEntry zipEntry = null;
                createDirectory(outputDirectory, "");
                while (e.hasMoreElements()) {
                    zipEntry = (org.apache.tools.zip.ZipEntry) e.nextElement();
                    System.out.println("解压：" + zipEntry.getName());
                    if (zipEntry.isDirectory()) {
                        String name = zipEntry.getName();
                        name = name.substring(0, name.length() - 1);
                        File f = new File(outputDirectory + File.separator + name);
                        f.mkdir();
                        System.out.println("创建目录：" + outputDirectory + File.separator + name);
                    } else {
                        String fileName = zipEntry.getName();
                        fileName = fileName.replace('\\', '/');
                        if (fileName.indexOf("/") != -1) {
                            createDirectory(outputDirectory, fileName.substring(0,
                                    fileName.lastIndexOf("/")));
                            fileName = fileName.substring(
                                    fileName.lastIndexOf("/") + 1,
                                    fileName.length());
                        }
                        File f = new File(outputDirectory + File.separator
                                + zipEntry.getName());
                        f.createNewFile();
                        InputStream in = zipFile.getInputStream(zipEntry);
                        FileOutputStream out = new FileOutputStream(f);
                        byte[] by = new byte[1024];
                        int c;
                        while ((c = in.read(by)) != -1) {
                            out.write(by, 0, c);
                        }
                        in.close();
                        out.close();
                    }
                }
                System.out.println("解压 [" + zipFileName + "] 完成！");
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            } finally {
                zipFile.close();
            }
        }
        return outputDirectory;
    }

    private static void createDirectory(String directory, String subDirectory) {
        String[] dir;
        File fl = new File(directory);
        try {
            if ("".equals(subDirectory) && fl.exists() != true) {
                fl.mkdir();
            } else if (!"".equals(subDirectory)) {
                dir = subDirectory.replace('\\', '/').split("/");
                for (int i = 0; i < dir.length; i++) {
                    File subFile = new File(directory + File.separator + dir[i]);
                    if (subFile.exists() == false) {
                        subFile.mkdir();
                    }
                    directory += File.separator + dir[i];
                }
            }
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
    }

    /**
     * 连接SFTP 获取文件
     *
     * @param pagePath
     * @param pageName
     * @return
     * @throws Exception
     */
    public InputStream getFileFromSFTP(String pagePath, String pageName) throws Exception {
        InputStream in = null;
        login();
        try {
            byte[] bytes = download(pagePath, pageName);
            in = new ByteArrayInputStream(bytes);
        } catch (Exception e) {
            logout();
            throw new Exception("获取文件失败");
        }
        logout();
        return in;
    }

    private void mkdir(String hostDir) throws SftpException {
        sftp.mkdir(hostDir);
    }

    public Map<String, String> getFilesFromSFTP() {
        login();
        Map<String, String> map = new HashMap<>();
        try {
            sftp.cd(hostDir);
            Vector<String> files = sftp.ls("*");
            getFileList(files, map);
        } catch (Exception e) {
            logout();
            e.printStackTrace();
            throw new Exception("获取文件失败");
        } finally {
            logout();
            return map;
        }
    }

    public void getFileList(Vector<String> files, Map<String, String> map) throws Exception {
        for (int i = 0; i < files.size(); i++) {
            Object obj = files.elementAt(i);
            if (obj instanceof com.jcraft.jsch.ChannelSftp.LsEntry) {
                LsEntry entry = (LsEntry) obj;
                if (!entry.getAttrs().isDir()) {
                    log.info("路径:" + sftp.pwd() + "---文件：" + entry.getFilename());
                    InputStream inputStream = downloadStream(entry.getFilename());
                    String result = new BufferedReader(new InputStreamReader(inputStream)).lines().collect(Collectors.joining(System.lineSeparator()));
                    map.put(sftp.pwd() + "/" + entry.getFilename(), result);
                }
                if (entry.getAttrs().isDir()) {
                    if (!".".equals(entry.getFilename()) && !"..".equals(entry.getFilename())) {
                        sftp.cd(entry.getFilename());
                        if (CollectionUtils.isEmpty(sftp.ls("*"))) {
                            log.info("路径:" + sftp.pwd() + "---文件夹：" + entry.getFilename());
                            sftp.cd("..");
                        } else {
                            log.info("路径:" + sftp.pwd() + "---文件夹：" + entry.getFilename());
                            getFileList(sftp.ls("*"), map);
                        }
                    }
                }
            }
            if (i == files.size() - 1) {
                sftp.cd("..");
            }
        }
    }

    public void isExist(String path, String name) throws Exception {
        try {
            sftp.cd(path);
            SftpATTRS stat = sftp.stat(name);
        } catch (Exception e) {
            throw new Exception("文件不存在");
        }

    }

    public static void main(String[] args) throws Exception {

        String username = "";
        String password = "";
        String host = "";
        int port = 22;
        String hostDir = "/upload";
        SFTPUtil sftpUtil = new SFTPUtil(username, password, host, port, hostDir);
        sftpUtil.login();
//        sftpUtil.isExist("/nfs/image/"+"a","ca30e214be8243eea7de9be8f015d807.jpg");
//        String s = "F:/新华/222/3/4/";
//        String[] dirs = s.split("/");
//        File file = new File("F:/新华/222/3/4/44");
//        if (!file.exists()) {
//            file.mkdirs();
//        }
        String newPath = "/upload/11";
        File file = new File("/upload/11");
        if (!file.exists()) {
            file.mkdirs();
        }
        String[] dirs = newPath.split("/");
        String tempPath = "";
        int index = 0;
//        mkdirDir(dirs, tempPath, dirs.length, index);
//        createDirectory("/upload/11","");
//      sftpUtil.upload("/upload/11/22","F:\\新华\\11.jpg");
//        sftpUtil.mkdirDir(dirs, tempPath, dirs.length, index);
//        sftpUtil.download("/nfs/image/applet/img/2021/05/21/idimg", "4d1ad761b55847c4a023c4ffed422fc5.jpg", "F:/新华/222/3/4/44");
        sftpUtil.logout();
    }

    /**
     * 递归根据路径创建文件夹--运用ThreadLocal方式
     *
     * @param path     目的路径
     * @return
     */
    public void mkdirDirs(String path) {
        Scope scope = threadLocal.get();
        // tempPath 拼接路径 第一次调用给默认值 "" 即可
        // index    数组下标 第一次调用给默认值 0 即可
        if (ObjectUtils.isEmpty(scope)) {
            scope = new Scope("", 0);
            threadLocal.set(scope);
        }
        String tempPath = scope.getTempPath();
        int index = scope.getIndex();
        String[] dirs = path.split("/");
        int length = dirs.length;

        // 以"/a/b/c/d"为例按"/"分隔后,第0位是"";顾下标从1开始
        index++;
        if (index < length) {
            // 目录不存在，则创建文件夹
            tempPath += "/" + dirs[index];
        }
        try {
            log.info("检测目录[" + tempPath + "]");
            sftp.cd(tempPath);
            if (index < length) {
                threadLocal.set(new Scope(tempPath, index));
                mkdirDirs(path);
            }
        } catch (SftpException ex) {
            log.warn("创建目录[" + tempPath + "]");
            try {
                sftp.mkdir(tempPath);
                sftp.cd(tempPath);
            } catch (SftpException e) {
                e.printStackTrace();
                log.error("创建目录[" + tempPath + "]失败,异常信息[" + e.getMessage() + "]");

            }
            log.info("进入目录[" + tempPath + "]");
            threadLocal.set(new Scope(tempPath, index));
            mkdirDirs(path);
        }
    }
    /**
     * 递归根据路径创建文件夹
     *
     * @param dirs     根据 / 分隔后的数组文件夹名称
     * @param tempPath 拼接路径
     * @param length   文件夹的格式
     * @param index    数组下标
     * @return
     */
    public void mkdirDir(String[] dirs, String tempPath, int length, int index) {
        // 以"/a/b/c/d"为例按"/"分隔后,第0位是"";顾下标从1开始
        index++;
        if (index < length) {
            // 目录不存在，则创建文件夹
            tempPath += "/" + dirs[index];
        }
        try {
            log.info("检测目录[" + tempPath + "]");
            sftp.cd(tempPath);
            if (index < length) {
                mkdirDir(dirs, tempPath, length, index);
            }
        } catch (SftpException ex) {
            log.warn("创建目录[" + tempPath + "]");
            try {
                sftp.mkdir(tempPath);
                sftp.cd(tempPath);
            } catch (SftpException e) {
                e.printStackTrace();
                log.error("创建目录[" + tempPath + "]失败,异常信息[" + e.getMessage() + "]");

            }
            log.info("进入目录[" + tempPath + "]");
            mkdirDir(dirs, tempPath, length, index);
        }
    }
}

class Scope {
    private String tempPath;
    private int index;

    public Scope(String tempPath, int index) {
        this.tempPath = tempPath;
        this.index = index;
    }

    public Scope() {
    }

    public String getTempPath() {
        return tempPath;
    }

    public void setTempPath(String tempPath) {
        this.tempPath = tempPath;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    @Override
    public String toString() {
        return "Scope{" +
                "tempPath='" + tempPath + '\'' +
                ", index=" + index +
                '}';
    }
}

测试

package com.wh.sftp;

import org.apache.log4j.Logger;

public class Demo {
    private static Logger log = Logger.getLogger(SFTPUtil.class);

    public static void main(String[] args) throws Exception {
        String username = "";
        String password = "";
        String host = "";
        int port = 22;
        String hostDir = "/upload";
        SFTPUtil sftpUtil = new SFTPUtil(username, password, host, port, hostDir);
        try {
            sftpUtil.login();
        } catch (Exception e) {
            //  sftpUtil.isExist("/nfs/image/"+"a","ca30e214be8243eea7de9be8f015d807.jpg");
            //  String s = "F:/新华/222/3/4/";
            //  String[] dirs = s.split("/");
            //  File file = new File("F:/新华/222/3/4/44");
            //  if (!file.exists()) {
            //      file.mkdirs();
            //  }
            String newPath = "/upload/69/88";
            //递归在sftp服务器上上传文件--ThreadLocal
            //sftpUtil.mkdirDirs(newPath);
            //sftpUtil.mkdirDir(dirs, tempPath, dirs.length, index);
            sftpUtil.upload("/upload/668/88", "F:\\新华\\11.jpg");
            //sftpUtil.download("/nfs/image/applet/img/2021/05/21/idimg", "4d1ad761b55847c4a023c4ffed422fc5.jpg", "F:/新华/222/3/4/44");
        } finally {
            sftpUtil.logout();
        }
    }
}
weixin_43303455
关注
强大的SFTP、FTP 文件传输软件
10-23
是一个基于 MS windows 平台的功能强大的SFTP、FTP 文件传输软件。使用了 Xftp 以后，MS windows 用户能安全地在 UNIX/Linux 和 Windows PC 之间传输文件。Xftp 能同时适应初级用户和高级用户的需要。它采用了标准的 Windows 风格的向导，它简单的界面能与其他 Windows 应用程序紧密地协同工作，此外它还为高级用户提供了众多强劲地功能特性
SFTP搭建软件
12-08
一个是WinSSHD，这个比较全面，能设置私钥检验什么的。另外两个是快速模拟用的，只能简单模拟出来，没有密钥的功能。
FTP的简单应用
dmj15053804366的博客
09-10 834
1.设置环境（软件安装k的环境） mkdir /mnt/yw mount /dev/sr0 /mnt/yw 两种安装方式： A.cd /mnt/yw/Packages ls | grep vsftp rpm -ivh vsftpd-3.0.2-9.el7.x86_64.rpm(安装) rpm -e vsftpd-3.0.2-9.el7（卸载） B.yum instal...
SFTP的基本定义、用途以及基本优势有哪些
ZhujiServer的博客
11-28 4051
用户可以使用不添加身份验证的SFTP、使用用户ID和密码的组合或使用一对SSH密钥来传输文件。身份验证：使用 SFTP接收文件的客户端必须先进行身份验证，然后才能解密和访问数据。传输中的数据使用SSH加密，确保数据合规。安全数据传输： SFTP允许用户传输关键文件和敏感数据，而没有将数据暴露给未授权方的风险。安全的数据传输在远程工作场景中尤为重要。扩展数据传输：像云SFTP这样的解决方案允许用户随着业务的增长扩展他们的数据传输能力。的虚拟主机提供了无限SFTP账户，在数据加密的过程中扮演着十分重要的角色。
javasftp应用和开发文档资料.pdf
11-22
Java SFTP 应用与开发涉及多个核心概念和技术，包括SFTP协议、非对称加密、密钥管理、SFTP服务器配置以及客户端编程接口。以下是对这些知识点的详细解释： 1. **SFTP（Secure File Transfer Protocol）**： SFTP是...
python sftp应用
11-01
Python SFTP应用是指使用Python编程语言实现SFTP（Secure File Transfer Protocol）协议的应用程序。SFTP是一种安全的文件传输协议，它使用SSH（Secure Shell）协议进行加密和身份验证，可以在不安全的网络上安全地...
python sftp应用sample
最新发布
11-01
这段代码展示了如何使用Python中的paramiko库来实现SFTP文件传输。通过获取连接、上传文件和下载文件三个方法，可以实现SFTP文件传输的基本功能。其中，获取连接方法需要传入SFTP服务器的IP地址、端口号、用户名和...
SFTP 源码浅析1
08-08
《SFTP 源码分析：理解...理解这些机制对于开发、调试或优化SFTP应用具有重要意义。在源码分析中，我们能够深入学习到如何构建安全可靠的文件传输系统，并了解到在处理大量数据时如何实现高效、可靠的数据交换策略。
使用C＃应用程序上传SFTP文件
04-01
标题 "使用C＃应用程序上传SFTP文件" 涉及的核心技术是使用C#编程语言在Visual Studio环境中创建一个能够通过安全文件传输协议（SFTP）上传文件的应用程序。SFTP是一种安全的数据通信协议，常用于在不安全的网络上...
sftp的基本使用
wang0907的博客
12-31 3046
在工作和学习中我们经常需要在linux和本地之间上传和下载文件，本文就一起来看下。
【Linux】搭建SFTP文件服务器
风高秋月白，雨霁晚霞红
05-28 1万+
Linux下SFTP文件服务器配置，使用winscp、手机app连接
sftp使用方法
2301_78008478的博客
05-10 2833
的是，用那个用户登陆就会登陆到那个用户的目录下，如用root登陆就是在/root 下，需要到哪个目录切换目录即可。比如要切换到 /home/wwwroot/lnmp.org 的网站目录下，直接在远程那边输入/home/wwwroot/lnmp.org 回车就切换过去了。在sftp的环境下的操作就和一般ftp的操作类似了，ls,rm,mkdir,dir,pwd,等指令都是对远端进行操作，如果要对本地操作，只需在上述的指令上加‘l’变为：lls,lcd, lpwd等。这次测试中，我用的是。
SFTP的使用
骑个小蜗牛的博客
09-12 1万+
SFTP与FTP区别 1.1 FTP 1.2 SFTP 1.3 二者对比 SFTP常用命令 1.1 登录SFTP 1.2 退出SFTP 1.3 显示指定目录下的文件（文件夹） 1.4 进入指定目录 1.5 查看当前目录 1.6 创建目录 1.7 删除目录 1.8 上传文件 1.9 下载文件 1.10 删除文件 1.11 重命名目录（文件） 1.12 SFTP版本 1.13 SFTP帮助文档 2.1 进入本地指定目录 2.2 显示本地指定目录下的文件（文件夹） 2.3 创建本地目录 2.4 查看本地当前目录
FTP SFTP工具类
菜鸟
11-11 1447
FTP package cn.greatlife.wechat.util; import cn.greatlife.wechat.common.config.FtpConfig; import org.apache.commons.net.ftp.FTP; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons...
SFTP的用法
热门推荐
zhouzying的博客
07-25 16万+
SFTP的概念 sftp是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的网络的加密方法。sftp 与 ftp 有着几乎一样的语法和功能。SFTP 为 SSH的其中一部分，是一种传输档案至 Blogger 伺服器的安全方式。其实在SSH软件包中，已经包含了一个叫作SFTP(Secure File Transfer Protocol)...
FTP/SFTP简单使用
lupeng0527的专栏
06-10 6820
SCP、SFTP命令基本使用
SFTP环境安装及应用
lightdancer的专栏
08-23 1997
文中描述的操作均在AIX 5.3环境 1. 下载安装包 为了与生产环境保持一致，请在22.7.14.55环境获取安装包： /tmp/openssl/openssl-fips-12.9.8.1302.tar /tmp/openssh/openssh_5.4p1.tar   2.安装OpenSSL 和OpenSSH 本步骤在root用户下执行 cd /tmp mkdir open
sftp使用
flying roc
03-30 2133
expect + sftp简易使用 /usr/bin/expect <<EOF spawn sftp -i identity_file -P port user@ip expect { "*yes/no*" { send "yes\r"; exp_continue; } "*password" { send "${password}\r" } } expect "sftp>" send "cd ${PATH}\r" expect { "*Permission*" {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值