开发技术：关于使用 FTP连接池 上传文件的一些配置

1、maven依赖

  		<!-- FTP上传依赖-->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>
        <!-- 使用commons-pool 实现FTP连接池 -->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>

2、application.yml的配置

## FTP 服务器配置
FTP:
    ##  FTP 服务器的 ip
    HOSTNAME: ******
    ##　FTP 服务的端口号
    PORT:  ******
    ## FTP 服务器的登录用户账号
    USERNAME:  ******
    ## FTP 服务器的登录用户密码
    PASSWORD:  ******
    ## FTP 连接池的连接对象个数
    DEFAULT_POOL_SIZE: 10
    #连接超时(0表示一直连接)毫秒
    CLIENT_TIME_OUT: 60000
    #是否设置为被动模式(Linux下模式必须设置)
    IS_ENTER_LOCAL_PASSIVE_MODE: true

3、FTP 工厂

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.pool.PoolableObjectFactory;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * FTP工厂
 *
 * @author LIFULIN
 * @className FtpClientFactory
 * @description TODO
 * @date 2020/8/31-16:20
 */
@Component
@Slf4j
@SuppressWarnings("all")
public class FtpClientFactory implements PoolableObjectFactory<FTPClient> {

    /**
     * 创建FTP连接实体
     *
     * @return
     * @throws Exception
     */
    @Override
    public FTPClient makeObject() throws Exception {
        FtpConstant ftpConstant = new FtpConstant();

        FTPClient ftpClient = new FTPClient();
        ftpClient.setControlEncoding("utf-8");
        //连接超时
        ftpClient.setConnectTimeout(ftpConstant.getClientTimeOut());

        try {
            //log.info("连接ftp服务器:{}：{}", ftpConstant.getHostname(), ftpConstant.getPort());
            //连接ftp服务器
            if (!ftpClient.isConnected()) {
                ftpClient.connect(ftpConstant.getHostname(), ftpConstant.getPort());
            }
            //登录ftp服务器
            ftpClient.login(ftpConstant.getUsername(), ftpConstant.getPassword());
            //是否成功登录服务器
            int replyCode = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                ftpClient.disconnect();
                log.info("连接失败ftp服务器:{}：{}", ftpConstant.getHostname(), ftpConstant.getPort());
            }
         //   if (ftpConstant.getIsEnterLocalPassiveMode()) {
                //Linux下模式必须设置 将当前数据连接模式设置为被动连接模式
                ftpClient.enterLocalPassiveMode();
          //  }
            //确定应答代码是否是一个积极的完成响应
            FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"));
            //规定文件名编码
            ftpClient.setControlEncoding("UTF-8");
           // ftpClient.setControlEncoding("ISO-8859-1");
            // log.info("FTP服务器 >>>>>>> 连接成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ftpClient;
    }

    /**
     * 释放FTP连接资源,回收实体
     *
     * @param ftpClient
     * @throws Exception
     */
    @Override
    public void destroyObject(FTPClient ftpClient) throws Exception {
        try {
            if (ftpClient != null && ftpClient.isConnected()) {
                log.info("通过发送QUIT命令退出FTP服务器");
                ftpClient.logout();
            }
        } catch (Exception e) {
            log.error("ftp Exception , 错误信息：{}", e.toString());
            throw e;
        } finally {
            if (ftpClient != null) {
                log.info("关闭到FTP服务器的连接,连接参数恢复到默认值");
                ftpClient.disconnect();
            }
        }
    }

    /**
     * 验证 FTP连接对象 的有效性
     *
     * @param ftpClient
     * @return
     */
    @Override
    public boolean validateObject(FTPClient ftpClient) {
        try {
            return ftpClient.sendNoOp();
        } catch (Exception e) {
            log.error("验证客户端失败: {}", e.toString());
        }
        return false;
    }

    @Override
    public void activateObject(FTPClient ftpClient) throws Exception {
        //Do nothing
    }

    @Override
    public void passivateObject(FTPClient ftpClient) throws Exception {
        //Do nothing
    }
}

4、FTP 连接池

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * FTP连接池
 *
 * @author LIFULIN
 * @className FtpClientPool
 * @description TODO
 * @date 2020/8/31-16:22
 */
@Slf4j
public class FtpClientPool implements ObjectPool<FTPClient> {

    /**
     * FTP工厂
     */
    public static FtpClientFactory ftpClientFactory = new FtpClientFactory();

    /**
     * 连接池
     */
    public static BlockingQueue<FTPClient> blockingQueue;

    /**
     * FTP常量常量
     */
    public static FtpConstant ftpConstant = new FtpConstant();

    /**
     * 初始化FTP连接池
     *
     * @param maxPoolSize
     * @throws Exception
     */
    static {
        //初始化一个线程池
        blockingQueue = new ArrayBlockingQueue<>(ftpConstant.getDefaultPoolSize());
        //初始化工厂
        FtpClientFactory factory = new FtpClientFactory();

        int count = 0;
        while (count < ftpConstant.getDefaultPoolSize()) {
            try {
                blockingQueue.offer(factory.makeObject());
            } catch (Exception e) {
                log.error("初始化ftpClientPool 时 FtpFactory的makeObject()错误：", e);
            }
            count++;
        }
        log.info("ftpPool 中连接对象个数为：{}", blockingQueue.size());
    }

    /**
     * 从 ftpClientPool 中获取连接对象
     *
     * @return
     * @throws Exception
     */
    @Override
    public FTPClient borrowObject() throws Exception {
        log.info("ftpPool 取出连接前的个数为:" + getNumIdle());

        FTPClient client = blockingQueue.poll(1, TimeUnit.MINUTES);
        log.info("ftpPool 取出连接后的个数为:" + getNumIdle());
        if (client == null) {
            this.addObject();
            log.info("client==null ");
            client = borrowObject();
        } else if (!ftpClientFactory.validateObject(client)) {
            log.info("获取的连接对象无效");
            //invalidateObject(client);
            try {
                ftpClientFactory.destroyObject(client);
            } catch (Exception e) {
                //e.printStackTrace();
                log.info("invalidateObject error:{}", e.toString());
            }
            //制造并添加新对象到池中
            log.info("添加新的连接对象到 ftpClientPool 中");
            this.addObject();

            client = borrowObject();
        }
        return client;

    }

    /**
     * 将连接对象返回给池中
     *
     * @param ftpClient
     */
    @Override
    public void returnObject(FTPClient ftpClient) throws Exception {
        log.info("回收连接对象前的ftpClientPool池中连接数为：" + getNumIdle());
        if ((ftpClient != null)) {
            if (!blockingQueue.offer(ftpClient)) {
                try {
                    ftpClientFactory.destroyObject(ftpClient);
                    log.info("销毁无效连接对象");
                } catch (Exception e) {
                    throw e;
                }
            } else {
                log.info("回收连接对象后的ftpClientPool池中连接数为：" + getNumIdle());
            }

        }
    }


    /**
     * 删除失效的FTP连接对象
     *
     * @param ftpClient
     * @throws Exception
     */
    @Override
    public void invalidateObject(FTPClient ftpClient) throws Exception {
        blockingQueue.remove(ftpClient);
    }

    /**
     * 给ftpClientPool池中添加一个新的连接对象，且在超时后会从ftpClientPool池中删去
     *
     * @throws Exception
     * @throws IllegalStateException
     * @throws UnsupportedOperationException
     */
    @Override
    public void addObject() throws Exception, IllegalStateException, UnsupportedOperationException {
        //超时时间20秒
        blockingQueue.offer(ftpClientFactory.makeObject(), ftpConstant.getClientTimeOut(), TimeUnit.MINUTES);
    }


    /**
     * 获取空闲的 ftp连接数
     *
     * @return
     * @throws UnsupportedOperationException
     */
    @Override
    public int getNumIdle() throws UnsupportedOperationException {
        return blockingQueue.size();
    }


    /**
     * 获取正在被使用的 ftp连接数
     *
     * @return
     * @throws UnsupportedOperationException
     */
    @Override
    public int getNumActive() throws UnsupportedOperationException {
        return ftpConstant.getDefaultPoolSize() - getNumIdle();
    }

    @Override
    public void clear() throws Exception, UnsupportedOperationException {

    }


    /**
     * 关闭连接池
     *
     * @throws Exception
     */
    @Override
    public void close() throws Exception {
        try {
            while (blockingQueue.iterator().hasNext()) {
                FTPClient client = blockingQueue.take();
                ftpClientFactory.destroyObject(client);
            }
        } catch (Exception e) {
            log.error("关闭连接池错误：{}", e.toString());
        }
    }

    @Override
    public void setFactory(PoolableObjectFactory<FTPClient> poolAbleObjectFactory) throws IllegalStateException, UnsupportedOperationException {
    }
}

5、FTP 文件上传常量

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 文件上传常量
 *
 * @author LIFULIN
 * @className FtpConstant
 * @description TODO
 * @date 2020/6/24-17:21
 */
@Component
@Data
public class FtpConstant {

    /**
     * 服务器地址
     */
    private static String hostname;

    /**
     * 服务器端口号默认为
     */
    private static Integer port;

    /**
     * 登录账号
     */
    private static String username;

    /**
     * 登录密码
     */
    private static String password;

    /**
     * ftp连接池的连接对象个数
     */
    private static Integer defaultPoolSize;

    /**
     * 连接超时(0表示一直连接)
     */
    private static Integer clientTimeOut;

    /**
     * 是否设置为被动模式(Linux下模式必须设置)
     */
    private static Boolean isEnterLocalPassiveMode;



    @Value("${FTP.HOSTNAME}")
    public void setHostname(String hostname) {
        FtpConstant.hostname = hostname;
    }

    @Value("${FTP.PORT}")
    public void setPort(Integer port) {
        FtpConstant.port = port;
    }


    @Value("${FTP.USERNAME}")
    public void setUsername(String username) {
        FtpConstant.username = username;
    }


    @Value("${FTP.PASSWORD}")
    public void setPassword(String password) {
        FtpConstant.password = password;
    }


    @Value("${FTP.DEFAULT_POOL_SIZE}")
    public void setDefaultPoolSize(Integer defaultPoolSize) {
        FtpConstant.defaultPoolSize = defaultPoolSize;
    }


    @Value("${FTP.CLIENT_TIME_OUT}")
    public void setClientTimeOut(Integer clientTimeOut) {
        FtpConstant.clientTimeOut = clientTimeOut;
    }


    @Value("${FTP.IS_ENTER_LOCAL_PASSIVE_MODE}")
    public void setIsEnterLocalPassiveMode(Boolean isEnterLocalPassiveMode) {
        FtpConstant.isEnterLocalPassiveMode = isEnterLocalPassiveMode;
    }

    public String getHostname() {
        return hostname;
    }

    public Integer getPort() {
        return port;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public Integer getDefaultPoolSize() {
        return defaultPoolSize;
    }

    public Integer getClientTimeOut() {
        return clientTimeOut;
    }

    public Boolean getIsEnterLocalPassiveMode() {
        return isEnterLocalPassiveMode;
    }
}

6、FTP 具体上传下载工具类

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * Ftp文件上传、下载、删除工具类
 *
 * @author by LFL
 * @date 2020/1/6.
 */
@Slf4j
public class FtpTemplateUtils {

    /**
     * FTP连接池
     */
    public static FtpClientPool ftpClientPool;

    static {
        ftpClientPool = new FtpClientPool();
    }

    /**
     * 处理上传的文件是否符合格式并上传文件
     *
     * @param filePath      文件路径
     * @param suffix        验证的格式，示例 doc/DOC/docx/DOCX/pdf/PDF/xlsx/xls/
     * @param multipartFile 文件
     * @return
     * @throws Exception
     */
    public static int checkFileType(String filePath, String suffix, MultipartFile multipartFile) throws Exception {
        /*
         *  1.文件上传成功
         * -1.文件类型不正确
         * -2.文件上传失败
         * -3.上传的文件数量为空
         * */
        try (// 将文件转换为字节
             InputStream inputStream = multipartFile.getInputStream()) {
            boolean status;
            //获取文件名字
            String fileName = multipartFile.getOriginalFilename();
            //获取文件后缀
            String fileNameSuffix = null;
            if (fileName != null) {
                fileNameSuffix = fileName.substring(fileName.lastIndexOf(".") + 1);
            }
            boolean checkSuffix = true;
            //判断上传文件的格式
            if (fileNameSuffix != null && !suffix.contains(fileNameSuffix)) {
                checkSuffix = false;
            }
            if (checkSuffix) {
                //上传文件
                status = uploadFile(filePath, fileName, inputStream);
            } else {
                return -1;
            }
            if (status) {
                return 1;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return -2;
        }
        return -3;
    }

    /**
     * 上传文件
     *
     * @param filePath    文件路径
     * @param fileName    文件名
     * @param inputStream 输入文件流
     * @return
     */
    public static boolean uploadFile(String filePath, String fileName, InputStream inputStream) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();
        try {
            log.info("开始上传文件");
            //设置传输类型
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
            createDirecroty(ftpClient, filePath);
            //创建子目录
            ftpClient.makeDirectory(filePath);
            //更改当前目录
            ftpClient.changeWorkingDirectory(filePath);
            //写入文件
            boolean b = ftpClient.storeFile(fileName, inputStream);
            if (b) {
                log.info("上传文件成功");
            } else {
                log.info("上传文件失败");
            }
            return b;
        } catch (Exception e) {
            log.info("上传文件失败");
            e.printStackTrace();
            return false;
        } finally {
            // 将连接对象返回给池中
            ftpClientPool.returnObject(ftpClient);
        }
    }

    /**
     * 删除文件
     *
     * @param path     FTP服务器保存目录
     * @param fileName 要删除的文件名称
     * @return
     */
    public static Integer deleteFile(String path, String fileName) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();

        //  1.文件删除成功
        // -1.文件删除失败
        // -2.文件已经删除
        try {
            log.info("开始删除文件");
            //判断文件是否存在
            if (existFile(ftpClient, path + "/" + fileName)) {
                //切换FTP目录
                ftpClient.changeWorkingDirectory(path);
                boolean b = ftpClient.deleteFile(fileName);
                if (b) {
                    log.info("文件删除成功");
                    return 1;
                } else {
                    log.info("文件删除失败");
                    return -1;
                }
            } else {
                log.info("文件已被删除");
                return -2;
            }
        } catch (Exception e) {
            log.info("删除文件失败");
            e.printStackTrace();
        } finally {
            // 将连接对象返回给池中
            ftpClientPool.returnObject(ftpClient);
        }
        return -1;
    }

    /**
     * 删除文件夹
     *
     * @param filePath 文件路径
     * @param pathName 要删除的文件名称
     * @return
     */
    public static boolean removeDirectory(String filePath, String pathName) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();
        try {
            log.info("开始删除文件");
            //切换FTP目录
            ftpClient.changeWorkingDirectory(filePath);
            removeDirectoryALLFile(ftpClient, filePath, pathName);
            log.info("删除文件成功");
            return true;
        } catch (Exception e) {
            log.error("删除文件失败{}", e.toString());
            return false;
        } finally {
            // 将连接对象返回给池中
            ftpClientPool.returnObject(ftpClient);
        }
    }

    /**
     * 下载文件为InputStream
     *
     * @param remotePath FTP服务器上的相对路径
     * @param fileName   要下载的文件名
     * @return
     */
    public static InputStream downFileToInputStream(String remotePath, String fileName) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();
        try {
            // 转移到FTP服务器目录
            ftpClient.changeWorkingDirectory(remotePath);
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile ftpFile : ftpFiles) {
                if (ftpFile.getName().equals(fileName)) {
                    InputStream inputStream = ftpClient.retrieveFileStream(ftpFile.getName());
                    if (inputStream != null) {
                        return inputStream;
                    }
                }
            }
        } catch (IOException e) {
            log.error("下载文件失败{}", e.toString());
        } finally {
            // 将连接对象返回给池中
            ftpClientPool.returnObject(ftpClient);
        }
        return null;
    }

    /**
     * 下载文件为File
     *
     * @param filePath  FTP服务器文件目录
     * @param fileName  文件名称
     * @param localPath 下载后的文件路径
     * @return
     */
    public static File downloadFile(String filePath, String fileName, String localPath) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();
        try {
            File localFile = null;
            //切换FTP目录
            ftpClient.changeWorkingDirectory(filePath);
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile file : ftpFiles) {
                if (fileName.equalsIgnoreCase(file.getName())) {
                    log.info("开始下载");
                    //创建不同的文件夹目录
                    File file2 = new File(localPath);
                    //判断文件夹是否存在
                    if (!file2.exists()) {
                        //如果文件夹不存在，则创建新的的文件夹
                        file2.mkdirs();
                    }
                    localFile = new File(localPath + "/" + file.getName());
                    try (OutputStream os = new FileOutputStream(localFile);) {
                        ftpClient.retrieveFile(file.getName(), os);
                        log.info("下载成功，文件路径：" + localPath);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            return localFile;
        } catch (IOException e) {
            log.error("下载文件失败{}", e.toString());
        } finally {
            // 将连接对象返回给池中
            ftpClientPool.returnObject(ftpClient);
        }
        return null;
    }

    /**
     * 判断TFP服务器文件是否存在
     *
     * @param fileName 文件名称
     * @param filePath 文件路径
     * @return
     * @author LIFULIN
     **/
    public static boolean determineFileExist(String fileName, String filePath) throws Exception {
        //从 ftpClientPool 中获取连接对象
        FTPClient ftpClient = ftpClientPool.borrowObject();
        return existFile(ftpClient, filePath + "/" + fileName);

    }


    //——————————————————————————————————————————————私有方法————————————————————————————————————————————————————————————————————————————

    /**
     * 切换到父目录，不然删不掉文件夹
     *
     * @param path
     * @param fileName
     */
    private static void removeDirectoryALLFile(FTPClient ftpClient, String path, String fileName) {
        try {
            FTPFile[] files = ftpClient.listFiles(fileName);
            if (null != files && files.length > 0) {
                for (FTPFile file : files) {
                    String newpath = path + "/" + fileName;
                    String newfileName = fileName + "/" + file.getName();
                    if (file.isDirectory()) {
                        ftpClient.changeWorkingDirectory(newpath);
                        //切换到父目录
                        removeDirectoryALLFile(ftpClient, newpath, newfileName);
                    } else {
                        ftpClient.deleteFile(newfileName);
                    }
                }
            }
            // 切换到父目录，不然删不掉文件夹
            ftpClient.changeWorkingDirectory(path);
            ftpClient.removeDirectory(fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建目录
     *
     * @param ftpClient
     * @param dir
     * @return
     * @author LIFULIN
     **/
    private static boolean makeDirectory(FTPClient ftpClient, String dir) {
        try {
            boolean flag = ftpClient.makeDirectory(dir);
            if (flag) {
                log.info("创建文件夹" + dir + " 成功！");
                return true;
            } else {
                log.info("创建文件夹" + dir + " 失败！");
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 改变目录路径
     *
     * @param directory 文件夹
     * @return
     */
    private static boolean changeWorkingDirectory(FTPClient ftpClient, String directory) {
        try {
            boolean flag = ftpClient.changeWorkingDirectory(directory);
            if (flag) {
                log.info("进入文件夹" + directory + " 成功！");
                return true;
            } else {
                log.info("进入文件夹" + directory + " 失败！开始创建文件夹");
                return false;
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return false;
    }

    /**
     * 创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
     *
     * @param remote
     * @return
     * @throws IOException
     */
    private static void createDirecroty(FTPClient ftpClient, String remote) throws IOException {
        String directory = remote + "/";
        // 如果远程目录不存在，则递归创建远程服务器目录
        if (!"/".equalsIgnoreCase(directory) && !changeWorkingDirectory(ftpClient, directory)) {
            int start;
            int end;
            if (directory.startsWith("/")) {
                start = 1;
            } else {
                start = 0;
            }
            end = directory.indexOf("/", start);
            String path = "";
            do {
                String subDirectory = new String(remote.substring(start, end).getBytes("GBK"), StandardCharsets.ISO_8859_1);
                path = path + "/" + subDirectory;
                //判断文件是否存在
                if (!existFile(ftpClient, path)) {
                    //创建目录
                    if (!makeDirectory(ftpClient, subDirectory)) {
                        log.info("创建目录[" + subDirectory + "]失败");
                    }
                }
                //改变目录路径
                changeWorkingDirectory(ftpClient, subDirectory);
                start = end + 1;
                end = directory.indexOf("/", start);
                // 检查所有目录是否创建完毕
            } while (end > start);
        }

    }

    /**
     * 判断ftp服务器文件是否存在
     *
     * @param filePath
     * @return
     * @author LIFULIN
     **/
    private static boolean existFile(FTPClient ftpClient, String filePath) {
        boolean flag = false;
        FTPFile[] ftpFileArr = new FTPFile[0];
        try {
            ftpFileArr = ftpClient.listFiles(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (ftpFileArr.length > 0) {
            flag = true;
        }
        return flag;
    }

}

7、测试类

import com.example.ftppool.util.FtpTemplateUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;


/**
 * 
 *
 * @author LIFULIN
 * @className RepoetController
 * @description TODO
 * @date 2020/6/15-11:09
 */

@RestController
@RequestMapping("/ftp")
@Slf4j
public class FtpFileController {

    /**
     * 下载文件
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/downloadFile", method = RequestMethod.GET)
    public String downloadFile(String fileName) throws Exception {
        String remotePath = "/develop/deploy/front/hainan-gis/tmp";
        String localPath = "C:\\";
        File file1 = FtpTemplateUtils.downloadFile(remotePath, fileName, localPath);
        return file1.getName();
    }


    /**
     * 上传文件
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
    public Integer uploadFile(MultipartFile file) throws Exception {
        String remotePath = "/ftpFile/data/hainan/report";
        String suffix = "doc/DOC/docx/DOCX/pdf/PDF/xlsx/xls/";
        return FtpTemplateUtils.checkFileType(remotePath,suffix, file);
    }

}