linux搭建ftp服务器

FTP，即：文件传输协议（File Transfer Protocol），基于客户端/服务器模式，默认使用20、21端口号，其
中端口20（数据端口）用于进行数据传输，端口21（命令端口）用于接受客户端发出的相关FTP命令与参
数。FTP服务器普遍部署于局域网中，具有容易搭建、方便管理的特点。而且有些FTP客户端工具还可以支
持文件的多点下载以及断点续传技术，因此FTP服务得到了广大用户的青睐。

FTP协议有以下两种工作模式：
主动模式（PORT）：FTP服务器主动向客户端发起连接请求。
被动模式（PASV）：FTP服务器等待客户端发起连接请求（FTP的默认工作模式）。
vsftpd是一款运行在Linux操作系统上的FTP服务程序，具有很高的安全性和传输速度。

vsftpd有以下三种认证模式：
匿名开放模式：是一种最不安全的认证模式，任何人都可以无需密码验证而直接登陆。
本地用户模式：是通过Linux系统本地的账户密码信息进行认证的模式，相较于匿名开放模式更安全，而且
配置起来简单。
虚拟用户模式：是这三种模式中最安全的一种认证模式，它需要为FTP服务单独建立用户数据库文件，虚
拟出用来进行口令验证的账户信息，而这些账户信息在服务器系统中实际上是不存在的，仅供FTP服务程
序进行认证使用。

下面以虚拟用户模式配置讲解

1.输入图中命令，若输出图中信息表示已安装vsftpd，否则输入命令：yum install -y vsftpd 进行安装

2.安装完成后

vsftpd缺省安装在/etc/vsftpd/目录中，进入该目录后如下所示

1.vsftpd.conf：为核心配置文件

2.user_list：指定允许使用vsftpd 的用户列表文件，即白名单

3.ftpusers：指定哪些用户不能访问FTP服务器，即黑名单

4.如需去掉配置文件里的注释行输入以下命令即可

mv /etc/vsftpd/vsftpd.conf /etc/vsftpd/vsftpd.conf.bak
grep -v "#" /etc/vsftpd/vsftpd.conf.bak > /etc/vsftpd/vsftpd.conf

5.vsftpd.conf常用配置参数讲解

listen=<YES/NO>  # YES: 服务以独立运行方式运行; NO: 运行在 xinetd 内。 默认为 YES

listen_address=<ip address> # 服务监听地址, 如果有多个网卡, 需要将服务绑定到指定 IP 地址

listen_port=<port> # 服务监听端口, 默认为 21

anonymous_enable=<YES/NO> # 是否允许匿名用户访问, 默认 NO

anon_mkdir_write_enable=<YES/NO> # 是否允许匿名用户创建文件夹, 默认 NO

anon_other_write_enable=<YES/NO> # 是否允许匿名用户其他的写权限, 创建文件、重命名、删除文件等权限 默认为 NO

anon_upload_enable=<YES/NO> # 是否允许匿名用户上传, 默认 NO

anon_umask=<nnn> # 匿名用户上传的文件的生成掩码, 默认为077

anon_max_rate=<n> # 匿名用户的最大传输速率, 单位为 Byte/s, 值为 0 表示不限制

anon_world_readable_only=<YES/NO> # 是否允许匿名用户只读浏览

local_enable=<YES/NO> # 是否支持本地用户帐号访问

write_enable=<YES/NO> # 是否开放本地用户的写权限

local_umask=<nnn> # 本地用户上传的文件的生成掩码, 默认为077

local_max_rate=<n> # 本地用户最大的传输速率, 单位为 Byte/s，值为0表示不限制

local_root=<file> # 本地用户登陆后的目录，默认为本地用户的主目录

chroot_local_user=<YES/NO> # 本地用户是否可以执行 chroot, 默认为 NO

chroot_list_enable=<YES/NO> # 是否只有指定的用户才能执行 chroot, 默认为 NO

chroot_list_file=<filename> # 当 chroot_local_user=NO 且 chroot_list_enable=YES 时,

　　　　　　　　　　           # 只有 filename 文件内指定的用户（每行一个用户名）可以执行 chroot,

　　　　　　　　　　　　    # 默认值为 /etc/vsftpd.chroot_list

userlist_enable=<YES/NO> # 是否启用 userlist_file 白/黑名单用户列表, 默认为 NO

userlist_deny=<YES/NO> # 当 userlist_enable=YES（即启用 userlist_file ）时, 则该字段才有效。

userlist_deny=YES: userlist_file 为 黑名单, 即在该文件内的用户均不可登录, 其他用户可以登录

userlist_deny=NO: userlist_file 为 白名单, 即在该文件内的用户才可以登录, 其他用户均不可登录

userlist_file=<filename> # 黑/白名单用户列表文件（每行一个用户名）

　　　　　　　　　　　  # 是黑名单还是白名单, 根据 userlist_deny 的值决定

　　　　　　　　　　     # 默认值为 /etc/vsftpd.user_list

ftpd_banner=<message> # 客户端连接服务器后显示的欢迎信息

connect_timeout=<n> # 远程客户端响应端口数据连接超时时间, 单位为秒, 默认 60

accept_connection_timeout=<n> # 空闲的数据连接超时时间, 单位为秒, 默认 120

data_connection_timeout=<n> # 空闲的用户会话超时时间, 单位为秒, 默认 300

max_clients=<n> # 在独立模式运行时, 最大连接数, 0 表示无限制

max_per_ip=<n> # 在独立模式运行时, 每 IP 的最大连接数, 0表示无限制

pasv_min_port=45000 # PASV模式最小端口

pasv_max_port=49999  # PASV模式最大端口

3.配置防火墙开放vsftpd命令端口与PASV模式下的端口

firewall-cmd --zone=public --add-port=21/tcp --permanent

firewall-cmd --zone=public --add-port=45000-49000/tcp --permanent

firewall-cmd --reload

4.创建用于FTP认证的用户数据库文件

vim /etc/vsftpd/vuser.txt

其中奇数行为用户名，偶数行为密码

如：

xuyuanyuan

123456

chendanting

123456

明文信息不安全，需要使用db_load命令用哈希（hash）算法将明文信息转换成数据文件，然后将明文信息文件删除

db_load -T -t hash -f /etc/vsftpd/vuser.txt /etc/vsftpd/vuser.db
chmod 600 /etc/vsftpd/vuser.db
rm -f /etc/vsftpd/vuser.txt

5.创建虚拟用户映射的系统本地用户和FTP根目录

输入命令：

useradd -d /ftp_data -s /sbin/nologin virtual

chmod -Rf 755 /ftp_data

6.建立用于支持虚拟用户的PAM文件

PAM（可插拔认证模块）是一种认证机制，通过一些动态链接库和统一的API把系统提供的服务与认证方式分
开，使得系统管理员可以根据需求灵活调整服务程序的不同认证方式。PAM采用了分层设计（应用程序层、
应用接口层、鉴别模块层）的思想，其结构如下图所示。

vim /etc/pam.d/vsftpd.vu

添加以下信息
auth         required    pam_userdb.so    db=/etc/vsftpd/vuser
account   required    pam_userdb.so    db=/etc/vsftpd/vuser

6.为vuser.txt里的用户配置相关参数

(1) 创建存放用户的目录

mkdir /etc/vsftpd/vusers_dir

(2) 为各用户创建文件，文件名即为用户名

vim /etc/vsftpd/vusers_dir/xuyuanyuan

vim /etc/vsftpd/vusers_dir/chendanting

(3) 按各用户需要加入参数配置

local_root=/ftp_data/xuyuanyuan

anon_upload_enable=YES

anon_mkdir_write_enable=YES

anon_other_write_enable=YES

anon_world_readable_only=YES

6.修改核心配置文件vsftpd.conf为以下内容

anonymous_enable=NO

local_enable=YES

# 开启虚拟用户模式
guest_enable=YES

# 指定虚拟用户对应的系统用户
guest_username=virtual

# 允许对ftp根目录执行写入操作
allow_writeable_chroot=YES

write_enable=YES

local_umask=022

dirmessage_enable=YES

xferlog_enable=YES

connect_from_port_20=YES

xferlog_std_format=YES

listen_port=21

listen=NO

listen_ipv6=YES

#PAM文件

pam_service_name=vsftpd.vu

userlist_enable=YES

tcp_wrappers=YES

# 虚拟用户配置文件目录
user_config_dir=/etc/vsftpd/vuser_dir

# 被动模式端口范围
pasv_min_port=45000

pasv_max_port=49000

chroot_local_user=YES

7.最后启动服务即可访问

systemctl start vsftpd.serivce 启动服务

systemctl stop vsftpd.serivce 停止服务

systemctl status vsftpd.serivce 查看服务状态

systemctl restart vsftpd.serivce 查看服务状态

在浏览器输入 ftp://ip:21 就可访问了

最后配上操作ftp的工具类

maven依赖

<dependency>
　　<groupId>commons-net</groupId>
　　<artifactId>commons-net</artifactId>
　　<version>3.6</version>
</dependency>

/**
 * @author Medusa
 * @Date 12-14-19
 * @Description ftp工具类
 */
public class FtpUtil {

    /**
     * ftp服务器的ip
     */
    private String ip;

    /**
     * ftp服务器的端口，缺省为21
     */
    private int port;

    /**
     * 连接ftp服务器的用户名
     */
    private String userName;

    /**
     * 用户名对应通行证
     */
    private String password;

    /**
     * 客户端编码
     */
    private String clientCharset = "GBK";

    /**
     * 服务端编码，缺省为ISO8859-1
     */
    private String serverCharset = "ISO8859-1";

    private FTPClient ftpClient;

    public FtpUtil(String ip, int port, String userName, String password) {
        this.ip = ip;
        this.port = port;
        this.userName = userName;
        this.password = password;
    }

    /**
     * 建立连接并登陆服务器
     */
    public boolean connectFtp() {
        ftpClient = new FTPClient();

        try {
            ftpClient.connect(ip, port);

            // 是否连接成功
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                System.out.println("create connect fail");
                ftpClient.disconnect();
                return false;
            }

            if (!ftpClient.login(userName, password)) {
                System.out.println("login server fail");
                ftpClient.disconnect();
                return false;
            }

            // 开启服务器对UTF-8的支持，如果服务器支持就用UTF-8编码，否则使用本地编码
            if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))) {
                clientCharset = "UTF-8";
            }
            ftpClient.setControlEncoding(clientCharset);
            ftpClient.enterLocalPassiveMode(); // 设置被动模式
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); // 设置文件传输类型
        } catch (IOException e) {
            System.out.println("create connect or close connect error");
            return false;
        }
        return true;
    }

    /**
     * 退出登陆并关闭连接
     */
    public boolean closeFtp() {
        if (ftpClient != null && ftpClient.isConnected()) {
            try {
                ftpClient.logout();
                ftpClient.disconnect();
                return true;
            } catch (IOException e) {
                System.out.println("logout or close connect error");
                return false;
            }
        }
        return false;
    }

    /**
     * 客户端转服务端编码
     */
    private String clientCharsetToServer(String path) {
        try {
            return new String(path.getBytes(clientCharset), serverCharset);
        } catch (UnsupportedEncodingException e) {
            System.out.println("client to server encode error");
            return null;
        }
    }

    /**
     * 服务端转客户端编码
     */
    private String serverCharsetToClient(String path) {
        try {
            return new String(path.getBytes(serverCharset), clientCharset);
        } catch (UnsupportedEncodingException e) {
            System.out.println("server to client encode error");
            return null;
        }
    }

    /**
     * 获取当前工作目录
     */
    private String getWorkDirectory() {
        try {
            return serverCharsetToClient(ftpClient.printWorkingDirectory());
        } catch (IOException e) {
            System.out.println("get work directory error");
            return null;
        }
    }

    /**
     * 获取当前工作目录下的所有文件名
     */
    private String[] getWorkDirectoryFileNames() {
        try {
            FTPFile[] ftpFiles = ftpClient.listFiles();
            if (ftpFiles.length > 0) {
                String[] fileNames = new String[ftpFiles.length];
                int i = 0;

                for (FTPFile ftpFile: ftpFiles) fileNames[i++] = ftpFile.getName();

                return fileNames;
            }
            return null;
        } catch (IOException e) {
            System.out.println("get work directory files error");
            return null;
        }
    }

    /**
     * 根据从根目录开始的完整文件路径，切换工作目录
     */
    private boolean changeWorkDirectory(String path) {
        try {
            return ftpClient.changeWorkingDirectory(clientCharsetToServer(path));
        } catch (IOException e) {
            System.out.println("change directory error");
            return false;
        }
    }

    /**
     * 当前工作目录下是否有查询的文件
     */
    private boolean isWorkDirectoryHasFile(String fileName) {
        try {
            FTPFile[] ftpFiles = ftpClient.listFiles();

            for (FTPFile ftpFile : ftpFiles) {
                if (ftpFile.getName().equals(fileName)) return true;
            }

            return false;
        } catch (IOException e) {
            System.out.println("get work directory files error");
            return false;
        }
    }

    /**
     *获取对应路径下的文件(根目录除外)，并切换工作目录至此文件的父目录
     */
    private FTPFile getFTPFile(String path) {
        if (path.equals("/")) {
            System.out.println("invalid root directory");
            return null;
        }

        String fileName = path;
        if (!path.equals("/") && path.indexOf("/") != -1) {
            String[] split = path.split("/");
            fileName = split[split.length - 1];
        }
        if (changeWorkDirectory(path.substring(0, path.length() - fileName.length()))) {
            try {
                for (FTPFile ftpFile : ftpClient.listFiles()) {
                    if (ftpFile.getName().equals(fileName)) return ftpFile;
                }
            } catch (IOException e) {
                System.out.println("get work directory files error");
                return null;
            }
        }
        return null;
    }

    /**
     * 获取服务端文件夹下所有文件路径
     */
    public List<List<String>> getDirectoryUnderAllFile(String path) throws IOException {
        // 存放目录和文件的路径
        List<List<String>> directoryAndFilePaths = new ArrayList<>();
        // 存放目录的路径
        List<String> directoryPaths = new ArrayList<>();
        // 存放文件的路径
        List<String> filePaths = new ArrayList<>();
        // 待遍历处理的文件夹路径
        Queue<String> ergodicDirPaths = new LinkedList<>();
        ergodicDirPaths.offer(path);
        directoryPaths.add(path);
        
        while (ergodicDirPaths.size() > 0) {
            String entry = ergodicDirPaths.poll();
            if (changeWorkDirectory(entry)) {
                entry = "/".endsWith(entry) ? "" : entry;
                FTPFile[] ftpFiles = ftpClient.listFiles();
                for (FTPFile ftpFile : ftpFiles) {
                    if (ftpFile.isFile()) {
                        filePaths.add(entry + "/" + ftpFile.getName());
                    } else {
                        directoryPaths.add(entry + "/" + ftpFile.getName());
                        ergodicDirPaths.offer(entry + "/" + ftpFile.getName());
                    }
                }
            } else {
                System.out.println("切换目录失败");
                return null;
            }
        }

        directoryAndFilePaths.add(directoryPaths);
        directoryAndFilePaths.add(filePaths);
        return directoryAndFilePaths;
    }

    /**
     * 获取客户端文件夹下所有文件路径
     */
    public List<List<String>> getDirectoryUnderAllFile1(String path) {
        // 存放目录和文件的路径
        List<List<String>> directoryAndFilePaths = new ArrayList<>();
        // 存放目录的路径
        List<String> directoryPaths = new ArrayList<>();
        // 存放文件的路径
        List<String> filePaths = new ArrayList<>();
        // 待遍历处理的文件夹路径
        Queue<String> ergodicDirPaths = new LinkedList<>();
        ergodicDirPaths.offer(path);
        directoryPaths.add(path);

        while (ergodicDirPaths.size() > 0) {
            String entry = ergodicDirPaths.poll();

            File dir = new File(entry);
            for (File file : dir.listFiles()) {
                if (file.isFile()) {
                    filePaths.add(entry + "/" + file.getName());
                } else {
                    directoryPaths.add(entry + "/" + file.getName());
                    ergodicDirPaths.offer(entry + "/" + file.getName());
                }
            }
        }

        directoryAndFilePaths.add(directoryPaths);
        directoryAndFilePaths.add(filePaths);
        return directoryAndFilePaths;
    }

    /**
     * 下载文件，若客户端已存在则覆盖它
     */
    public boolean download(String serverPath, String clientPath) {
        // 判断服务端文件是否存在
        FTPFile ftpFile = getFTPFile(serverPath);
        if (ftpFile == null) {
            System.out.println("server file not exist");
            return false;
        }

        // 若客户端目录不存在，就创建它,否则清空目录
        File clientDirectory = new File(clientPath);
        if (!clientDirectory.exists()) {
            if (!clientDirectory.mkdirs()) {
                System.out.println("client create directory fail");
                return false;
            }
        } else {
            if (!clientDirectory.isDirectory()) {
                System.out.println("clientPath is not directory");
                return false;
            } else {
                if (!emptyDirectory(clientDirectory)) {
                    System.out.println("empty client directory fail");
                    return false;
                }
            }
        }

        if (ftpFile.isFile()) {
            executeDownload(serverPath, clientPath + serverPath.substring(serverPath.lastIndexOf("/")));
        } else {
            try {
                List<List<String>> allFile = getDirectoryUnderAllFile(serverPath);
                // 获取所有目录路径
                List<String> directoryPaths = allFile.get(0);
                if (directoryPaths.size() > 0) {
                    directoryPaths.forEach(path -> new File(clientPath + path).mkdir());
                } else {
                    System.out.println("get all directory fail");
                    return false;
                }

                // 获取所有文件路径
                List<String> filePaths = allFile.get(1);
                for (String path : filePaths) {
                    executeDownload(path, clientPath + path);
                }
            } catch (IOException e) {
                System.out.println("error getting all files under this path");
                return false;
            }
        }
        return true;
    }

    /**
     * 执行下载文件
     */
    private void executeDownload(String serverPath, String clientPath) {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = ftpClient.retrieveFileStream(clientCharsetToServer(serverPath));
            File file = new File(clientPath);
            if (!file.createNewFile()) {
                System.out.println("client create file fail");
                return;
            }
            os = new FileOutputStream(file);
            byte[] by = new byte[1024];
            int len = 0;
            while ((len = is.read(by)) != -1) os.write(by, 0, len);
        } catch (IOException e) {
            System.out.println("stream handle file fail");
            return;
        } finally {
            try {
                if (is != null) {
                    is.close();
                    // 必须调用此方法，否则第二次调用retrieveFileStream()方法时，返回null
                    ftpClient.completePendingCommand();
                }
                if (os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 执行上传文件
     */
    private void executeUpload(String serverPath, String clientPath) {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream(clientPath);
            os = ftpClient.storeFileStream(clientCharsetToServer(serverPath));

            byte[] by = new byte[1024];
            int len = 0;
            while ((len = is.read(by)) != -1) os.write(by, 0, len);
        } catch (FileNotFoundException e) {
            System.out.println("client file not found");
            return;
        } catch (IOException e) {
            System.out.println("stream handle file fail");
            return;
        } finally {
            try {
                if (is != null) is.close();
                if (os != null) {
                    os.close();
                    ftpClient.completePendingCommand();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 上传文件，若服务端已存在则覆盖它
     */
    public boolean upload(String serverPath, String clientPath) {
        File clientFile = new File(clientPath);
        if (!clientFile.exists()) {
            System.out.println("client file not exist");
            return false;
        }

        if (!"/".equals(serverPath)) {
            FTPFile ftpFile = getFTPFile(serverPath);
            if (ftpFile == null) {
                String[] split = serverPath.split("/");
                changeWorkDirectory("/");
                try {
                    for (int i = 1; i < split.length; i++) {
                        ftpClient.makeDirectory(clientCharsetToServer(split[i]));
                        changeWorkDirectory(getWorkDirectory() + "/" + split[i]);
                    }
                } catch (IOException e) {
                    System.out.println("create server directory error");
                    return false;
                }
            }
        }

        serverPath = "/".endsWith(serverPath) ? "" : serverPath;
        if (clientFile.isFile()) {
            try {
                String filePath = serverPath + clientPath.substring(clientPath.lastIndexOf("/"));
                ftpClient.deleteFile(filePath);
                executeUpload(filePath, clientPath);
            } catch (IOException e) {
                System.out.println("delete server file error");
                return false;
            }
        } else {
            List<List<String>> allFile = getDirectoryUnderAllFile1(clientPath);
            List<String> directoryPaths = allFile.get(0);
            String path2;
            if (directoryPaths.size() > 0) {
                try {
                    String firstDir = directoryPaths.get(0);
                    String path1 = firstDir.substring(firstDir.lastIndexOf("/"));
                    path2 = firstDir.substring(0, firstDir.lastIndexOf("/"));
                    ftpClient.makeDirectory(clientCharsetToServer(serverPath + path1));
                    for (int i = 1; i < directoryPaths.size(); i++) {
                        String tempPath = directoryPaths.get(i).substring(path2.length());
                        ftpClient.makeDirectory(clientCharsetToServer(serverPath + tempPath));
                    }
                } catch (IOException e) {
                    System.out.println("create server directory error");
                    return false;
                }
            } else {
                System.out.println("get all directory fail");
                return false;
            }
            List<String> filePaths = allFile.get(1);
            for (String path : filePaths) {
                String tempPath = path.substring(path2.length());
                executeUpload(serverPath + tempPath, path);
            }
        }
        return true;
    }

    /**
     * 清空目录
     */
    private boolean emptyDirectory(File dir) {
        File[] oneLevelFile = dir.listFiles();
        if (oneLevelFile.length > 0) {
            Stack<File> willDeleteFile = new Stack<>();
            for (int i = 0; i < oneLevelFile.length; i++) {
                willDeleteFile.push(oneLevelFile[i]);
            }

            while (willDeleteFile.size() > 0) {
                File entry = willDeleteFile.pop();
                if (entry.isFile()) {
                    if (!entry.delete()) return false;
                } else {
                    File[] lowerLevelFile = entry.listFiles();
                    if (lowerLevelFile.length > 0) {
                        willDeleteFile.push(entry);
                        for (int i = 0; i < lowerLevelFile.length; i++) {
                            willDeleteFile.push(lowerLevelFile[i]);
                        }
                    } else {
                        if (!entry.delete()) return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     * web端上传
     */
    public boolean webUpload(MultipartFile file, String serverPath) {
        if (!"/".equals(serverPath)) {
            FTPFile ftpFile = getFTPFile(serverPath);
            if (ftpFile == null) {
                String[] split = serverPath.split("/");
                changeWorkDirectory("/");
                try {
                    for (int i = 1; i < split.length; i++) {
                        ftpClient.makeDirectory(clientCharsetToServer(split[i]));
                        changeWorkDirectory(getWorkDirectory() + "/" + split[i]);
                    }
                } catch (IOException e) {
                    System.out.println("create server directory error");
                    return false;
                }
            }
        }
        String filePath;
        try {
            serverPath = "/".endsWith(serverPath) ? "" : serverPath;
            filePath = serverPath + "/" + file.getOriginalFilename();
            ftpClient.deleteFile(filePath);
        } catch (IOException e) {
            System.out.println("delete server file error");
            return false;
        }

        InputStream is = null;
        OutputStream os = null;
        try {
            is = file.getInputStream();
            os = ftpClient.storeFileStream(clientCharsetToServer(filePath));

            byte[] by = new byte[1024];
            int len = 0;
            while ((len = is.read(by)) != -1) os.write(by, 0, len);
        } catch (FileNotFoundException e) {
            System.out.println("client file not found");
            return false;
        } catch (IOException e) {
            System.out.println("stream handle file fail");
            return false;
        } finally {
            try {
                if (is != null) is.close();
                if (os != null) {
                    os.close();
                    ftpClient.completePendingCommand();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    /**
     * web端下载
     */
    public boolean webDownload(HttpServletResponse response, String serverPath) {
        FTPFile ftpFile = getFTPFile(serverPath);
        if (ftpFile == null) {
            System.out.println("server file not exist");
            return false;
        }

        InputStream is = null;
        try {
            is = ftpClient.retrieveFileStream(clientCharsetToServer(serverPath));
            ServletOutputStream sos = response.getOutputStream();
            byte[] by = new byte[1024];
            int len = 0;
            while ((len = is.read(by)) != -1) sos.write(by, 0, len);
        } catch (IOException e) {
            System.out.println("stream handle file fail");
            return false;
        } finally {
            try {
                if (is != null) {
                    is.close();
                    ftpClient.completePendingCommand();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return true;
    }

}