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;
    }

}