linux 安装sftp及使用sftp工具类上传和下载

已于 2024-06-18 10:32:25 修改
阅读量580 收藏 2
点赞数 2
分类专栏： 功能模块 文章标签： linux 运维 服务器
于 2024-06-13 17:45:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30272167/article/details/139660545
版权

一、centos7 安装sftp

1.安装 OpenSSH 服务：

sudo yum install openssh-server

2.启动 SSH 服务，并设置为开机启动：

sudo systemctl start sshd
sudo systemctl enable sshd

3.创建一个新用户，用于SFTP连接（替换your_username为你想要的用户名）,设置密码（替换sftpadmin为你想要的密码）：

sudo adduser your_username

sudo passwd sftpadmin

注意：如果输入密码提示未知的用户，则把sftpadmin换成指定的用户，然后再设置新密码
在这里插入图片描述

4.创建一个目录，用于SFTP的根目录（替换/path/to/sftp_root为你想要的目录路径）：

sudo mkdir -p /path/to/sftp_root
sudo chown root:root /path/to/sftp_root
sudo chmod 755 /path/to/sftp_root

5.创建用户的SFTP目录：

sudo mkdir -p /path/to/sftp_root/your_username
sudo chown your_username:your_username /path/to/sftp_root/your_username
sudo chmod 755 /path/to/sftp_root/your_username

6.重启 SSH 服务以应用更改：

sudo systemctl restart sshd

现在，用户 your_username 可以通过 SFTP 连接到服务器，只需要使用他们的常规用户名和密码。确保为用户设置了合适的权限和所需的目录结构。

二、java sftp工具类

1.工具类

（1）引入manven

<dependency>
    <groupId>com.github.mwiede</groupId>
    <artifactId>jsch</artifactId>
    <version>0.2.18</version>
</dependency>

（2）sftp工具类

package com.dcqq.common.utils;

import cn.hutool.core.codec.Base64;
import com.google.common.base.Joiner;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;

import java.io.*;
import java.util.*;

/**
 * SFTP工具类
 */
@Slf4j
public class SftpUtils {
    private static Session sshSession = null;
    private static String sftpRootDir = "/home/sftp/upload/";//根目录
    private final static String host = "10.122.156.10";//ip
    private final static Integer port = 22;//端口
    private final static String username = "sftp_user";//用户名
    private final static String password = "sftp1122";//密码
    private final static int MAX_TIMES = 3;//重试次数

    public static ChannelSftp connect() {
        // 重试次数
        int count = 0;
        ChannelSftp sftp = SftpUtils.connect(host, port, username, password);
        while (sftp == null && count < MAX_TIMES) {
            count++;
            log.error("第[" + count + "]次重试连接FTP服务器：" + host);
            SftpUtils.sleep(RandomUtils.nextInt(3, 600));
            sftp = SftpUtils.connect(host, port, username, password);
        }
        if (sftp == null) {
            log.error("获取FTP连接失败：" + host);
        }
        return sftp;
    }

    /**
     * 获取ChannelSftp
     */
    public static ChannelSftp connect(String host, Integer port, String username, String password) {
        ChannelSftp sftp = null;
        try {
            JSch jsch = new JSch();
            jsch.getSession(username, host, port);
            sshSession = jsch.getSession(username, host, port);
            sshSession.setPassword(password);
            Properties sshConfig = new Properties();
            sshConfig.put("StrictHostKeyChecking", "no");
            sshSession.setConfig(sshConfig);
            sshSession.connect();
            Channel channel = sshSession.openChannel("sftp");
            channel.connect();
            sftp = (ChannelSftp) channel;
            SftpUtils.mkdirs(sftpRootDir, sftp);
            SftpUtils.cd(sftpRootDir, sftp);
//            System.out.println("连接成功");
            return sftp;
        } catch (Exception e) {
//            e.printStackTrace();
            log.error("连接FTP失败：" + host + "，异常信息：" + e);

        }
        return null;
    }

    public static boolean upload(File file, String directory, String fileName) {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(file);
            return upload(inputStream, directory, fileName);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("FTP文件上传失败：" + directory + "/" + fileName + ",异常标题：" + e.getMessage());
        } finally {
            CloseUtils.closeQuietly(inputStream);
        }
        return false;
    }

    public static boolean upload(byte[] data, String directory, String fileName) {
        ByteArrayInputStream inputStream = null;
        try {
            inputStream = new ByteArrayInputStream(data);
            return upload(inputStream, directory, fileName);
        } finally {
            CloseUtils.closeQuietly(inputStream);
        }
    }

    public static boolean upload(InputStream inputStream, String directory, String fileName) {
        try {
            // 重试次数
            int count = 0;
            boolean success = doUpload(inputStream, directory, fileName);
            while (!success && count < MAX_TIMES) {
                count++;
                log.info("第[{}/{}]次重新上传文件:{}", count, MAX_TIMES, fileName);
                SftpUtils.sleep(RandomUtils.nextInt(1, 300));
                success = doUpload(inputStream, directory, fileName);
            }
            return success;
        } finally {
            CloseUtils.closeQuietly(inputStream);
        }
    }

    private static boolean doUpload(InputStream inputStream, String directory, String fileName) {
        ChannelSftp sftp = SftpUtils.connect();
        if (sftp == null) {
            return false;
        }
        try {
            SftpUtils.mkdirs(directory, sftp);
            sftp.put(inputStream, fileName, ChannelSftp.OVERWRITE);
            return true;
        } catch (Exception e) {
//            throw new RuntimeException(e);
            log.error("FTP文件上传失败：" + directory + "/" + fileName + ",异常标题：" + e.getMessage());
        } finally {
            SftpUtils.disconnect(sshSession);
            SftpUtils.disconnect(sftp);
        }
        return false;
    }

    public static String downloadAsBase64(String fileName) {
        ByteArrayOutputStream outputStream = download(fileName);
        try {
            if (outputStream == null || outputStream.toByteArray().length == 0) {
                return "";
            }
            return Base64.encode(outputStream.toByteArray());
        } finally {
            CloseUtils.closeQuietly(outputStream);
        }
    }

    public static ByteArrayOutputStream download(String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return null;
        }
        // 重试次数，最多6次
        int count = 0;
        ByteArrayOutputStream outputStream = doDownload(fileName);
        while (outputStream == null && count < MAX_TIMES) {
            count++;
            log.info("第[{}/2]次重新下载文件:{}", count, fileName);
            SftpUtils.sleep(RandomUtils.nextInt(1, 30));
            outputStream = doDownload(fileName);
        }
        return outputStream;
    }

    public static ByteArrayOutputStream doDownload(String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return null;
        }
        ChannelSftp sftp = SftpUtils.connect();
        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            sftp.get(fileName, outputStream);
            return outputStream;
        } catch (Exception e) {
//            throw new RuntimeException(e);
            log.error("FTP文件下载失败：" + fileName + ",异常标题：" + e.getMessage());
            if ("No such file.".equals(e.getMessage())) {
                return new ByteArrayOutputStream();
            }
        } finally {
            SftpUtils.disconnect(sshSession);
            SftpUtils.disconnect(sftp);
        }
        return null;
    }

    public static ChannelSftp cd(String directory, ChannelSftp sftp) {
        try {
            sftp.cd(directory);
        } catch (Exception e) {
        }
        return sftp;
    }

    public static ChannelSftp mkdir(String directory, ChannelSftp sftp) {
        try {
            sftp.mkdir(directory);
        } catch (Exception e) {
        }
        return sftp;
    }

    public static void disconnect(Session sshSession) {
        if (sshSession != null) {
            try {
                sshSession.disconnect();
            } catch (Exception e) {
            }
        }
    }

    public static void disconnect(ChannelSftp sftp) {
        if (sftp != null) {
            try {
                sftp.disconnect();
            } catch (Exception e) {
            }
        }
    }


    public static void mkdirs(String directory, ChannelSftp sftp) {

        String[] dirs = directory.split("/");
        for (int i = 0; i < dirs.length; i++) {
            String d = dirs[i];
            if (d.length() > 0) {

                SftpUtils.mkdir(d, sftp);
                SftpUtils.cd(d, sftp);
            }
        }
    }

    public static String datePath(String moduleName, Date dateTime) {
        return Joiner.on("/").join(moduleName, DateFormatUtils.format(dateTime, "yyyy/MM/dd"));
    }

    public static String datePath(String moduleName) {
        return Joiner.on("/").join(moduleName, DateFormatUtils.format(System.currentTimeMillis(), "yyyy/MM/dd"));
    }

    public static String fileFullPath(String filePath, String fileName) {
        return Joiner.on("/").join(filePath, fileName);
    }

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

    /**
     * 列出目录下的文件
     *
     * @param directory 要列出的目录
     * @return list 文件名列表
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static List<String> listFiles(String directory) throws Exception {
        ChannelSftp sftp = SftpUtils.connect();
        Vector fileList;
        List<String> fileNameList = new ArrayList<String>();
        fileList = sftp.ls(directory);
        Iterator it = fileList.iterator();
        while (it.hasNext()) {
            String fileName = ((ChannelSftp.LsEntry) it.next()).getFilename();
            if (".".equals(fileName) || "..".equals(fileName)) {
                continue;
            }
            fileNameList.add(fileName);
        }
        return fileNameList;
    }

    /**
     * @param millis *         the length of time to sleep in milliseconds
     */
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (Exception e) {
        }
    }

    public static void main(String[] args) throws Exception {
        //this.delete("/userReport/1/2022/ //删除
        //显示目录
        /*List<String> list = listFiles(sftpRootDir);
        for (String s : list) {
            System.out.println(s);
        }*/

        //上传文件
        File reportFile = new File("C:\\图片\\1.png");
        upload(reportFile, "upload", "1.png");

    }
}

（3）相关代码

CloseUtils

package com.dcqq.common.utils;

import java.io.Closeable;
import java.util.zip.ZipInputStream;

/**
 * 关闭文件流
 *
 */
public class CloseUtils {

    /**
     * 关闭文件流
     *
     * @param closeables
     */
    public static void closeQuietly(Closeable... closeables) {
        if (closeables != null && closeables.length > 0) {

            for (Closeable closeable : closeables) {

                if (closeable != null) {
                    try {
                        closeable.close();
                    } catch (Exception e) {}
                }
            }
        }
    }

    public static void closeEntryQuietly(ZipInputStream... closeables) {
        if (closeables != null && closeables.length > 0) {
            for (ZipInputStream closeable : closeables) {
                if (closeable != null) {
                    try {
                        closeable.closeEntry();
                    } catch (Exception e) { }
                }
            }
        }
    }
}

2.使用

（1）controller层，CommFileManagerController 公共文件管理层

package com.dcqq.common;

import com.dcqq.system.service.IFileService;
import com.dcqq.web.controller.common.CommonController;
import io.swagger.annotations.Api;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 文件下载
 */
@RestController
@Api(tags = "文件下载")
@RequestMapping("/fileManager")
public class CommFileManagerController {
    private static final Logger log = LoggerFactory.getLogger(CommFileManagerController .class);
    
    @Autowired
    private IFileService fileService;
    @Autowired
    private ServerConfig serverConfig;

	/**
     * 文件上传
     */
    @ApiOperation(value = "文件上传", notes = "文件上传")
    @PostMapping("/uploadFile")
    public AjaxResult uploadFile(MultipartFile file) {
        FileForm form = new FileForm();
        form.setUrl(serverConfig.getUrl());
        return fileService.uploadFile(file, form);
    }

    /**
     * 文件读取
     * @param request
     * @param response
     * @throws IOException
     *  访问示例：https://test.tt.com.cn/prod-api/fileManager/upload/2024/06/18/1_20240618103039A005.png
     */
    @GetMapping(value = "/upload/**")
    public void upload(HttpServletRequest request, HttpServletResponse response){
        log.info("============upload");
        fileService.download(request,response);
    }
}

（2）service业务层

IFileService

package com.dcqq.system.service;

import com.dcqq.common.core.domain.AjaxResult;
import com.dcqq.form.FileForm;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 文件
 * 
 * @author dcqq
 * @date 2024-04-03
 */
public interface IFileService {

    /**
     * 文件上传
     * @param file
     * @return
     */
    AjaxResult uploadFile(MultipartFile file, FileForm form);
    
    /**
     * 文件下载
     * @param request
     * @param response
     */
    void download(HttpServletRequest request, HttpServletResponse response);
}

FileServiceImpl

package com.dcqq.common;

import cn.hutool.core.io.file.FileNameUtil;
import cn.hutool.core.net.URLDecoder;
import com.dcqq.common.core.domain.AjaxResult;
import com.dcqq.common.utils.*;
import com.dcqq.common.utils.file.MimeTypeUtils;
import com.dcqq.form.FileForm;
import com.dcqq.system.service.IFileService;
import org.apache.commons.io.FilenameUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Objects;

/**
 * 文件
 * 
 * @author dcqq
 * @date 2024-04-03
 */
@Service
public class FileServiceImpl implements IFileService {

    public AjaxResult uploadFile(MultipartFile file, FileForm form) {
        try {
            String url = form.getUrl()+"/prod-api"+"/fileManager/upload";
            String dir=DateUtils.datePath();
            
            //获取文件后缀名
			String extension = FilenameUtils.getExtension(file.getOriginalFilename());
	        if (StringUtils.isEmpty(extension)) {
	            extension = MimeTypeUtils.getExtension(Objects.requireNonNull(file.getContentType()));
	        }

			//获取文件名+后缀
			String fileName = file.getOriginalFilename()+"."+extension;
			
            SftpUtils.upload(file.getBytes(), dir, fileName);
            
            AjaxResult ajax = AjaxResult.success();
			
			url=url+dir+fileName;

            ajax.put("url", url);
            ajax.put("newFileName", fileName);
            ajax.put("originalFilename", file.getOriginalFilename());
            return ajax;
        } catch (Exception e) {
            return AjaxResult.error(e.getMessage());
        }
    }

    @Override
    public void download(HttpServletRequest request, HttpServletResponse response) {
        try {
            String requestURI = URLDecoder.decode(request.getRequestURI(), StandardCharsets.UTF_8);
            // ContentType，即告诉客户端所发送的数据属于什么类型
            String ext = FileNameUtil.extName(requestURI);
            MediaTypeEnum mediaType = MediaTypeEnum.byCode(ext);
            response.setContentType(mediaType.getName());
            String ftpPath = StringUtils.substringAfter(requestURI, "/download/");
            ByteArrayOutputStream out = SftpUtils.download(ftpPath);
            response.getOutputStream().write(out.toByteArray());
            response.flushBuffer();
            CloseUtils.closeQuietly(out, response.getOutputStream());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

（3）相关代码

MediaTypeEnum

package com.dcqq.common.utils;

import lombok.Getter;
import org.springframework.http.MediaType;

import java.util.HashMap;
import java.util.Map;

/**
 * 媒体类型
 */
@Getter
public enum MediaTypeEnum {
    PNG("png", MediaType.IMAGE_PNG_VALUE),
    JPG("jpg", "image/jpg"),
    JPEG("jpeg", MediaType.IMAGE_JPEG_VALUE),
    PDF("pdf", MediaType.APPLICATION_PDF_VALUE),
    ZIP("zip", "application/zip"),
    DOCX("docx", MediaType.APPLICATION_OCTET_STREAM_VALUE),
    STREAM("other", MediaType.APPLICATION_OCTET_STREAM_VALUE),
    XML("xml", MediaType.APPLICATION_XML_VALUE),
    JSON("json", MediaType.APPLICATION_JSON_VALUE)
    ;
    private String code;
    private String name;

    private static Map<String, MediaTypeEnum> cacheEnum = new HashMap<>();

    static {
        for(MediaTypeEnum dictEnum:MediaTypeEnum.values()){
            cacheEnum.put(dictEnum.code, dictEnum);
        }
    }
    public static MediaTypeEnum byCode(String code){
        if(cacheEnum.containsKey(code)){
            return cacheEnum.get(code);
        }
        return STREAM;
    }

    MediaTypeEnum(String code, String name){
        this.code = code;
        this.name = name;
    }
}

ServerConfig

package com.dcqq.framework.config;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Component;
import com.dcqq.common.utils.ServletUtils;

/**
 * 服务相关配置
 *
 * @author ruoyi
 */
@Component
public class ServerConfig {
    /**
     * 获取完整的请求路径，包括：域名，端口，上下文访问路径
     *
     * @return 服务地址
     */
    public String getUrl() {
        HttpServletRequest request = ServletUtils.getRequest();
        return getDomain(request);
    }

    public static String getDomain(HttpServletRequest request) {
        StringBuffer url = request.getRequestURL();
        String contextPath = request.getServletContext().getContextPath();
        return url.delete(url.length() - request.getRequestURI().length(), url.length()).append(contextPath).toString();
    }
}

FileForm

package com.dcqq.form;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
public class FileForm {
    @ApiModelProperty("请求路径")
    private String url;
}
万变不离其宗_8
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ftp和Sftp上传下载工具类
08-02
该工具支持ftp和sftp的上传和下载 1
Sftp服务器搭建（linux）
weixin_50565644的博客
03-04 2359
linux环境下搭建sftp服务器
Windows环境sftp安装包
11-29
Windows环境sftp安装包
Linux安装sftp服务
weixin_44147924的博客
12-01 4014
disabled;# 把文件中的SELINUX=enforcing 改为SELINUX=disabled。
【Linux】搭建SFTP文件服务器
热门推荐
满堂花醉三千客，一剑霜寒十四州
05-28 1万+
Linux下SFTP文件服务器配置，使用winscp、手机app连接
如何在 Linux 服务器上安装和使用 SFTP？
qq_41819851的博客
06-26 3555
此外，您还学习了如何为 SFTP 用户设置 chroot 目录并学习了基本的 sftp 客户端命令。要添加更多用户，请重复第2 和第 3 阶段，最重要的是，所有 SFTP 用户必须在组 ' sftpgroup ' 中，并且不能通过 SSH 访问 shell。要在 OpenSSH 上启用 SFTP 服务器，您必须编辑 SSH 配置“/etc/ssh/sshd_config”。如果您的 SFTP 和/或 SSH 服务器在自定义端口上运行，您可以使用 sftp 命令，如下所示。
Linux安装sftp
云在青天水在瓶
06-08 4363
Linux安装sftp
java SFTP下载工具类 可上传,下载
10-23
需要配合com.jcraft.jsch包使用 下载地址:http://sourceforge.net/projects/jsch/files/jsch.jar/0.1.51/jsch-0.1.51.jar/download
连接SSH远程服务器-FTP和SFTP工具类(C#源码)
01-08
连接SSH远程服务器，SFTP、FTP工具类。IFTP为接口，接口基本满足日常项目需要，派生MyFTPClient、MySFTPClient，方便应用扩展及整合到项目，提供例子拿来即用。sftp基于sshNet实现、Renci.SshNet是目前最为强大的C#...
Python使用sftp实现上传和下载功能(实例代码)
12-23
以下将详细解释如何使用paramiko库实现在Python中执行SFTP上传和下载功能： 1. **paramiko库的安装**： 在Python环境中，首先需要通过pip安装paramiko库： ``` pip install paramiko ``` 2. **SFTP上传**： ...
SFTP工具类
06-06
SFTP 方式 文件上传、文件下载 文件列表。。。。。。。。。
Linux搭建SFTP服务器
q1372302825的博客
03-02 3180
最简单，最实用的Linux搭建SFTP教程。SFTP（SSH文件传输协议）是一种安全的文件传输协议，用于在计算机之间传输文件。它基于SSH（安全外壳协议）的子系统，提供了加密的、可靠的数据传输通道，用于在客户端和服务器之间安全地传输文件。
【日常积累】Linux下sftp搭建
margu_168的博客
08-25 2397
SFTP是Secure File Transfer Protocol的缩写，是安全文件传送协议。可以为传输文件提供一种安全的加密方法。跟ftp几乎语法功能一样。SFTP是SSH的一部分，是一种传输档案至Blogger伺服器的安全方式。它本身没有单独的守护进程，必须使用sshd守护进程来完成相应的连接操作，所以从某种意义上来说，SFTP并不像一个服务器程序，而更像是一个客户端程序。SFTP同样是使用加密传输认证信息和传输的数据，所以使用SFTP是十分安全的。
Windows环境下使用SSH的开源图形化SFTP工具客户端 简介和基本使用
u013558123的博客
02-23 1168
Windows环境下使用SSH的开源图形化SFTP工具客户端 简介和基本使用
sftp客户端工具汇总
bigfanofloT的博客
11-22 2819
SecureFXMobaXtermWinSCP。
linux搭建sftp服务器教程！
高性价比服务器就选：蓝易云
07-01 1286
现在，您已经成功在Linux上搭建了SFTP服务器。使用您创建的SFTP用户名和密码，您可以通过SFTP客户端连接到服务器并进行文件传输。请确保在配置SFTP用户时使用正确的用户名，并根据需要进行必要的权限和目录设置。搭建SFTP（Secure File Transfer Protocol）服务器在Linux上非常简单。在终端中执行以下命令以创建一个SFTP用户（将。在终端中执行以下命令以为用户设置密码（将。找到以下行并取消注释（删除行首的。
linux上搭建sftp服务器
qq_36305027的博客
09-13 1687
​ 创建一个用户组，组名是。​ 创建一个用户，用户名。，所有者有写入权限，所有组无写入权限。**注意：**此目录如果用于后续的。​ 新建一个目录供。的活动目录，目录所有者必须是。：不允许shell登录。
linux使用sftp上传文件
最新发布
03-28
SFTP（Secure File Transfer Protocol）是一种安全的文件传输协议，可以在客户端和服务器之间进行文件的上传和下载。在Linux系统中，可以使用sftp命令行工具来进行文件的上传。 以下是使用sftp上传文件的步骤： 1. 打开终端，输入以下命令连接到远程服务器： ``` sftp username@hostname ``` 其中，username是你在远程服务器上的用户名，hostname是远程服务器的主机名或IP地址。 2. 输入密码以完成身份验证。 3. 连接成功后，你将看到一个类似于shell的提示符。你可以使用以下命令进行文件的上传： ``` put local_file remote_directory ``` 其中，local_file是本地文件的路径，remote_directory是远程服务器上目标文件夹的路径。 4. 文件上传完成后，可以使用以下命令退出sftp会话： ``` exit ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值