java读取ftp服务器中文件

框架以springboot为例：

pom依赖

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

yml配置

#FTP文件服务器配置 
ftp:
  ip: 192.168.30.113
  port: 8088
  name: admin
  pwd: 123456

使用方法自动注入此工具类，调用getFile方法即可

工具类代码

package com.njhn.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * @author ：07
 * @date ：Created in 8:48 2021/11/2
 * @Description：TODO    读取ftp文件服务器中的文件 报告单
 * @Modified By：
 * @Version: 1.0
 */
@Slf4j
@Component
public class FTPFiles {

    @Value("${ftp.ip}")
    private String ip;
    @Value("${ftp.port}")
    private int port;
    @Value("${ftp.name}")
    private String username;
    @Value("${ftp.pwd}")
    private String pwd;

    /** 本地字符编码  **/
    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";

    /** 设置缓冲区大小 **/
    private static final int BUFFER_SIZE = 1024 * 1024 * 10;

    /** FTPClient对象 **/
    private static FTPClient ftpClient = null;

    private FTPClient ftp(){
         FTPClient ftpClient = new FTPClient();
        try {
            ftpClient.connect(ip, port);
            ftpClient.login(username,pwd);
        } catch (IOException e) {
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
            log.info("ftp连接失败，检查bc服务器！");
        }
        return ftpClient;
    }

    /**
     * 从ftp服务器下载文件
     * @param pathName  路径
     * @param fileName  文件名
     * @return
     * @throws IOException
     */
    public byte[] getFile(String pathName, String fileName) throws IOException {
        ftpClient = ftp();
        byte[] bytes = null;
        InputStream input = null;
        if (ftpClient != null) {
            try {
                String path = changeEncoding(pathName,ftpClient);
                // 判断是否存在该目录
                if (!ftpClient.changeWorkingDirectory(path)) {
                    log.error(path+ "该目录不存在");
                    return null;
                }
                ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
                String[] fs = ftpClient.listNames();
                // 判断该目录下是否有文件
                if (fs == null || fs.length == 0) {
                    log.error(path + "该目录下没有文件");
                    return null;
                }
                for (String ff : fs) {
                    String ftpName = new String(ff.getBytes(CHARSET_UTF8), CHARSET_UTF8);
                    if (isWebJpgFile(ftpName)) {
                        int index = ftpName.indexOf(fileName);
                        if (index != -1) {
                            input = ftpClient.retrieveFileStream(ff);
                            bytes = toByteArray(input);
                            break;
                        }
                    }
                }
            } catch (IOException e) {
                log.error("获取文件失败", e);
            } finally {
                Boolean connect = closeConnect();
                log.info("连接关闭状态：" + connect);
            }
        }

        return bytes;
    }

    /**
     * 输入流转换转换自己byte[]
     * @param input
     * @return
     * @throws IOException
     */
    public byte[] toByteArray(InputStream input) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        byte[] buffer = new byte[4096];
        int n = 0;
        while (-1 != (n = input.read(buffer))) {
            output.write(buffer, 0, n);
        }
        return output.toByteArray();
    }


    /**
     * 关闭FTP连接
     *
     */
    public Boolean closeConnect() {
        Boolean b = false;
        if (ftpClient != null && ftpClient.isConnected()) {
            try {
                ftpClient.logout();
                b = true;
            } catch (IOException e) {
                log.error("关闭FTP连接失败", e);
            }
        }
        return b;
    }
    /**
     * FTP服务器路径编码转换
     *
     * @param ftpPath FTP服务器路径
     * @return String
     */
    private String changeEncoding(String ftpPath, FTPClient ftpClient) {
        String directory = null;
        try {
            if (FTPReply.isPositiveCompletion(ftpClient.sendCommand(OPTS_UTF8, "ON"))) {
                localCharset = CHARSET_UTF8;
            }
            directory = new String(ftpPath.getBytes(CHARSET_UTF8), CHARSET_UTF8);
        } catch (Exception e) {
            log.error("路径编码转换失败", e);
        }
        return directory;
    }

    /**
     * 判断文件是否是后缀为 web.jpg 文件
     * @param fileName
     * @return
     */
    private boolean isWebJpgFile(String fileName) {
        if (StringUtils.isNotBlank(fileName)) {
            int length = fileName.length();
            String name = fileName + "web";
            int index = fileName.indexOf(".");
            if (index == -1) {
                return false;
            }
            if (StringUtils.equals(name.substring(index + 1, length), "jpg")) {
                return true;
            }
        }
        return false;
    }

}