java 连接ftp服务器从页面进行下载

青旅半醒 2022-05-22 02:47 162阅读 0赞

昨天来的个需求，我们的客户需要下载对账文件的话，需要自己去登录ftp 服务器去进行下载

本身是有商户后台，所以想吧这个功能直接添加到商户后台页面上，web进行下载。这是背景。

之前没有了解过这个，所以还是在网上查找了一番 ，找到了这篇博客

** 参考**：   [https://blog.csdn.net/rodge\_rom/article/details/78888541][https_blog.csdn.net_rodge_rom_article_details_78888541]

**我看了一下这个里面的方法，有个返回流的，我就看到希望了，所以，进行了一番修改**

**在这导入工具类之前，我们需要导入个jar包**

commons-net-3.6.jar

**我会附上链接，不需要兄弟们找了** [http://mvnrepository.com/artifact/commons-net/commons-net/3.6][http_mvnrepository.com_artifact_commons-net_commons-net_3.6]

看自己用的什么框架，引入方法我就不说了，需要下载的话，点击红框的jar就可以了

![70][]

下面是修改完后的工具类

工具类里只需要修改 两 处地方

ftp\_address=“你自己ftp服务器地址”

ftp\_port=“ftp服务器的端口”

其他都不用动

# 介绍在下面（工具类很长）所以使劲往下拉 #

package com.ecard.products.utils;
    
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPReply;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.util.HashMap;
    import java.util.Map;
    /**
     * FTP服务工具类 
     *  
     * @author：  DangYangFei
     * @time：    2018年6月12日 14:36:37
     * @version： V1.0.0 
     */  
    public class FTPUtil {
    
        /** 日志对象 **/
        private static final Logger LOGGER = LoggerFactory.getLogger(FTPUtil.class);
    
        /** FTP地址 **/
        private  String FTP_ADDRESS = "";
    
        /** FTP端口 **/
        private  int FTP_PORT = 0;
    
        /** FTP用户名 **/
        private  String FTP_USERNAME = "";
    
        /** FTP密码 **/
        private  String FTP_PASSWORD = "";
    
        /** FTP基础目录 **/
        private  String BASE_PATH = "";
        /** 初始化登录ftp 默认false 登录成功返回true **/
        private  Boolean b=false;
    
        public Boolean getB() {
            return b;
        }
    
        /**
         *  2018-6-13 12:39:55
         *   新添，初始化登录ftp，连接失败 返回b 为：false ,成功 为 ：true
         * @param FTP_USERNAME
         * @param FTP_PASSWORD
         * @param BASE_PATH
         */
        public FTPUtil(String FTP_ADDRESS, int FTP_PORT, String FTP_USERNAME, String FTP_PASSWORD, String BASE_PATH) {
            this.FTP_ADDRESS = FTP_ADDRESS;
            this.FTP_PORT = FTP_PORT;
            this.FTP_USERNAME = FTP_USERNAME;
            this.FTP_PASSWORD = FTP_PASSWORD;
            this.BASE_PATH = BASE_PATH;
            b = login(FTP_ADDRESS, FTP_PORT, this.FTP_USERNAME, this.FTP_PASSWORD);
        }
    
        /** 本地字符编码  **/
        private static String localCharset = "GBK";
    
        /** FTP协议里面，规定文件名编码为iso-8859-1 **/
        private static String serverCharset = "ISO-8859-1";
    
        /** UTF-8字符编码 **/
        private static final String CHARSET_UTF8 = "UTF-8";
    
        /** OPTS UTF8字符串常量 **/
        private static final String OPTS_UTF8 = "OPTS UTF8";
    
        /** 设置缓冲区大小4M **/
        private static final int BUFFER_SIZE = 1024 * 1024 * 4;
    
        /** FTPClient对象 **/
        private static FTPClient ftpClient = null;
    
        /**
         * 下载指定文件到本地
         *
         * @param ftpPath FTP服务器文件相对路径，例如：test/123
         * @param fileName 要下载的文件名，例如：test.txt
         * @param savePath 保存文件到本地的路径，例如：D:/test
         * @return 成功返回true，否则返回false
         */
        public boolean downloadFile(String ftpPath, String fileName, String savePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return flag;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            File file = new File(savePath + '/' + ftpName);
                            try {
                                OutputStream os = new FileOutputStream(file);
                                flag = ftpClient.retrieveFile(ff, os);
                            } catch (Exception e) {
                                System.out.println(e.getMessage());
                                LOGGER.error(e.getMessage(), e);
                            }
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("下载文件失败"+e);
                    LOGGER.error("下载文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return flag;
        }
    
        /**
         * 下载该目录下所有文件到本地
         *
         * @param ftpPath FTP服务器上的相对路径，例如：test/123
         * @param savePath 保存文件到本地的路径，例如：D:/test
         * @return 成功返回true，否则返回false
         */
        public boolean downloadFiles(String ftpPath, String savePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return flag;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        File file = new File(savePath + '/' + ftpName);
                        try  {
                            OutputStream os = new FileOutputStream(file);
                            ftpClient.retrieveFile(ff, os);
                        } catch (Exception e) {
                            System.out.println(e.getMessage()+e);
                            LOGGER.error(e.getMessage(), e);
                        }
                    }
                    flag = true;
                } catch (IOException e) {
                    System.out.println("下载文件失败"+e);
                    LOGGER.error("下载文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return flag;
        }
    
        /**
         * 获取该目录下所有文件,以字节数组返回
         *
         * @param ftpPath FTP服务器上文件所在相对路径，例如：test/123
         * @return Map<String, Object> 其中key为文件名，value为字节数组对象
         */
        public Map<String, byte[]> getFileBytes(String ftpPath) {
            // 登录
            Map<String, byte[]> map = new HashMap<String, byte[]>();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return map;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return map;
                    }
                    for (String ff : fs) {
                        try  {
                            InputStream is = ftpClient.retrieveFileStream(ff);
                            String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                            byte[] buffer = new byte[BUFFER_SIZE];
                            int readLength = 0;
                            while ((readLength = is.read(buffer, 0, BUFFER_SIZE)) > 0) {
                                byteStream.write(buffer, 0, readLength);
                            }
                            map.put(ftpName, byteStream.toByteArray());
                            ftpClient.completePendingCommand(); // 处理多个文件
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                            LOGGER.error(e.getMessage(), e);
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return map;
        }
    
        /**
         * 根据名称获取文件，以字节数组返回
         *
         * @param ftpPath FTP服务器文件相对路径，例如：test/123
         * @param fileName 文件名，例如：test.xls
         * @return byte[] 字节数组对象
         */
        public byte[] getFileBytesByName(String ftpPath, String fileName) {
            // 登录
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return byteStream.toByteArray();
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return byteStream.toByteArray();
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            try {
                                InputStream is = ftpClient.retrieveFileStream(ff);
                                byte[] buffer = new byte[BUFFER_SIZE];
                                int len = -1;
                                while ((len = is.read(buffer, 0, BUFFER_SIZE)) != -1) {
                                    byteStream.write(buffer, 0, len);
                                }
                            } catch (Exception e) {
                                System.out.println(e.getMessage()+e);
                                LOGGER.error(e.getMessage(), e);
                            }
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return byteStream.toByteArray();
        }
    
        /**
         * 获取该目录下所有文件,以输入流返回
         *
         * @param ftpPath FTP服务器上文件相对路径，例如：test/123
         * @return Map<String, InputStream> 其中key为文件名，value为输入流对象
         */
        public Map<String, InputStream> getFileInputStream(String ftpPath) {
            // 登录
            Map<String, InputStream> map = new HashMap<String, InputStream>();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return map;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return map;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        InputStream is = ftpClient.retrieveFileStream(ff);
                        map.put(ftpName, is);
                        ftpClient.completePendingCommand(); // 处理多个文件
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return map;
        }
    
        /**
         * 根据名称获取文件，以输入流返回
         *
         * @param ftpPath FTP服务器上文件相对路径，例如：test/123
         * @param fileName 文件名，例如：test.txt
         * @return InputStream 输入流对象
         */
        public InputStream getInputStreamByName(String ftpPath, String fileName) {
            // 登录
            InputStream input = null;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return input;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return input;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            input = ftpClient.retrieveFileStream(ff);
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean connect = closeConnect();
                    System.out.println("连接关闭状态：" + connect);
                }
            }
            return input;
        }
    
        /**
         * 根据文件夹，文件 名称，判断是否存在
         *
         * @param ftpPath FTP服务器上文件相对路径，例如：test/123
         * @param fileName 文件名，例如：test.txt
         * @return map
         */
        public Map checkoutFtpPathAndFileName(String ftpPath, String fileName) {
            // 登录
            Map<String,Boolean> map = new HashMap<String, Boolean>();
            map.put("filePath",false);
            map.put("fileName",false);
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                         map.put("filePath",false);
                    }else {
                        map.put("filePath",true);
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        map.put("fileName",false);
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            map.put("fileName",true);
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }
            }
            return map;
        }
        /**
         * 删除指定文件
         *
         * @param filePath 文件相对路径，例如：test/123/test.txt
         * @return 成功返回true，否则返回false
         */
        public boolean deleteFile(String filePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + filePath);
                    flag = ftpClient.deleteFile(path);
                } catch (IOException e) {
                    System.out.println("删除文件失败"+e);
                    LOGGER.error("删除文件失败", e);
                } finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return flag;
        }
    
        /**
         * 删除目录下所有文件
         *
         * @param dirPath 文件相对路径，例如：test/123
         * @return 成功返回true，否则返回false
         */
        public boolean deleteFiles(String dirPath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                    String path = changeEncoding(BASE_PATH + dirPath);
                    String[] fs = ftpClient.listNames(path);
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + dirPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + dirPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ftpFile : fs) {
                        ftpClient.deleteFile(ftpFile);
                    }
                    flag = true;
                } catch (IOException e) {
                    System.out.println("删除文件失败"+e);
                    LOGGER.error("删除文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭："+close);
                }
            }
            return flag;
        }
    
        /**
         * 连接FTP服务器
         *
         * @param address  地址，如：127.0.0.1
         * @param port     端口，如：21
         * @param username 用户名，如：root
         * @param password 密码，如：root
         */
        private Boolean login(String address, int port, String username, String password) {
            ftpClient = new FTPClient();
            try {
                ftpClient.connect(address, port);
                ftpClient.login(username, password);
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                int reply = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) {
                    closeConnect();
                    System.out.println("FTP服务器连接失败："+"地址："+address+"  端口："+port+"  用户名："+username+"  密码："+password);
                    LOGGER.error("FTP服务器连接失败");
                }else {
                    b=true;
                }
            } catch (Exception e) {
                System.out.println("FTP登录失败"+e);
                LOGGER.error("FTP登录失败", e);
            }
            return b;
        }
    
        /**
         * 关闭FTP连接
         *
         */
        public Boolean closeConnect() {
            Boolean b=false;
            if (ftpClient != null && ftpClient.isConnected()) {
                try {
                    ftpClient.logout();
                    b=true;
                } catch (IOException e) {
                    System.out.println("关闭FTP连接失败"+e);
                    LOGGER.error("关闭FTP连接失败", e);
                }
            }
            return b;
        }
    
        /**
         * FTP服务器路径编码转换
         *
         * @param ftpPath FTP服务器路径
         * @return String
         */
        private static String changeEncoding(String ftpPath) {
            String directory = null;
            try {
                if (FTPReply.isPositiveCompletion(ftpClient.sendCommand(OPTS_UTF8, "ON"))) {
                    localCharset = CHARSET_UTF8;
                }
                directory = new String(ftpPath.getBytes(localCharset), serverCharset);
            } catch (Exception e) {
                System.out.println("路径编码转换失败"+e);
                LOGGER.error("路径编码转换失败", e);
            }
            return directory;
        }
    
        /**
         * 在服务器上递归创建目录
         *
         * @param dirPath 上传目录路径
         * @return
         */
        private void createDirectorys(String dirPath) {
            try {
                if (!dirPath.endsWith("/")) {
                    dirPath += "/";
                }
                String directory = dirPath.substring(0, dirPath.lastIndexOf("/") + 1);
                ftpClient.makeDirectory("/");
                int start = 0;
                int end = 0;
                if (directory.startsWith("/")) {
                    start = 1;
                }else{
                    start = 0;
                }
                end = directory.indexOf("/", start);
                while(true) {
                    String subDirectory = new String(dirPath.substring(start, end));
                    if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                        if (ftpClient.makeDirectory(subDirectory)) {
                            ftpClient.changeWorkingDirectory(subDirectory);
                        } else {
                            System.out.println("创建目录失败");
                            LOGGER.info("创建目录失败");
                            return;
                        }
                    }
                    start = end + 1;
                    end = directory.indexOf("/", start);
                    //检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("上传目录创建失败"+e);
                LOGGER.error("上传目录创建失败", e);
            }
        }
    }

这里有很多方法，但是现在我的这个需要返回流的形式，所以只用的这个

### 开始介绍用法 ###

利用有参构造 进行初始化登录ftp  如果登录成功了会返回true 否则返回false

#####      **有参构造最后面的ftp\_base\_path 这个参数说一下        这个参数传的是你当前账号登录以后所能看到的当前路径，也就是说直接给他个空串就可以了** #####

**    链接成功以后呢，b 返回的就是true ，我们就可以继续往下进行操作了**

String ftpUserName = "";
            String ftpPassword = "";
            String ftpPath = "/"+"文件夹名"+"/";
            String fileName = "文件名";
            FTPUtil ftpUtil = new FTPUtil(ftpUserName, ftpPassword, "");
            Boolean b = ftpUtil.getB();

校验一下文件夹和文件是否存在, 这个是我自己改了一下，你们可以自己去工具类里进行修改成自己想要的字段

**这里的返回也是，两个参数 ，false 代表不存在，true代表存在**

添加这个方法是因为实际业务需要进行判断返回前端进行提示，所以故此添加

Map map = ftpUtil.checkoutFtpPathAndFileName(ftpPath, fileName)
            Boolean filePahtBoolean = map.get("filePath")
            Boolean fileNameBoolean = map.get("fileName")

这个方法需要手动自己关闭连接，所以 ftpUtil.closeConnect(),成功返回true， 失败返回false

上面的都齐全了，下面我们开始页面进行下载了

这个方法只需要把文件所在的    路径  和  文件名   传进去就可以了，返回的是一个InputStream

InputStream inputStream = ftpUtil.getInputStreamByName(ftpPath, fileName)

页面进行下载弹出框

这个就不多介绍了， 弹出框文件的名称  修改成功自己的命名规则就可以了

/**
     *
     * @param fileName  文件名称
     * @param inputStream 读取文件返回流
     * @param response
     */
        public static void downloadFtpFile(String fileName,InputStream inputStream ,HttpServletResponse response) {
            try {
                BufferedInputStream br = new BufferedInputStream(inputStream);
                byte[] buf = new byte[1024];
                int len = 0;
                response.reset();
                response.setContentType("application/x-msdownload");
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
                OutputStream out = response.getOutputStream();
                while ((len = br.read(buf)) > 0) out.write(buf, 0, len);
                br.close();
                out.close();
            } catch (IOException e) {
                System.out.println("文件读取错误。");
            }
        }

[https_blog.csdn.net_rodge_rom_article_details_78888541]: https://blog.csdn.net/rodge_rom/article/details/78888541
[http_mvnrepository.com_artifact_commons-net_commons-net_3.6]: http://mvnrepository.com/artifact/commons-net/commons-net/3.6
[70]: /images/20220522/fdbcf04d713c401996853dad2bb8d31f.png