springboot快速启动插件ftp篇-连接池

浅浅的花香味﹌ 2022-05-11 00:36 328阅读 0赞

之前已经介绍过如何编写自定义starter，如不明白请参考[springboot自定义Starter][springboot_Starter]

功能点：

*  初始化ftp连接池
 *  封装ftp基础操作

## 1.创建maven工程 ##

略

## 2.编写pom文件 ##

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>iotstarter</artifactId>
            <groupId>com.iot</groupId>
            <version>0.0.1-RELEASES</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <packaging>jar</packaging>
        <groupId>com.iot</groupId>
        <artifactId>iot-ftp-spring-boot-starter</artifactId>
        <version>0.0.1-RELEASES</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>commons-net</groupId>
                <artifactId>commons-net</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
        </dependencies>
    </project>

# 3.编写配置实体（读取配置文件信息） #

package com.iot.ftp.properties;
    
    import lombok.Data;
    import org.apache.commons.net.ftp.FTPClient;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(prefix = "iot-ftp")
    @Data
    public class FtpOptionProperties {
        private String host;
        private int port= FTPClient.DEFAULT_PORT;
        private String username;
        private String password;
        private int bufferSize = 8096;
        /**
         * 初始化连接数
         */
        private Integer initialSize = 0;
        private String encoding;
    
    
    }

# 4.编写总配置类（初始化单例bean） #

package com.iot.ftp.config;
    
    import com.iot.ftp.properties.FtpOptionProperties;
    import com.iot.ftp.service.IotFtpService;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.pool2.ObjectPool;
    import org.apache.commons.pool2.PooledObject;
    import org.apache.commons.pool2.PooledObjectFactory;
    import org.apache.commons.pool2.impl.DefaultPooledObject;
    import org.apache.commons.pool2.impl.GenericObjectPool;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.annotation.PreDestroy;
    
    /**
     * 描述: els快捷操作配置
     * @author: myx
     * @date: 2018/5/3
     * Copyright © 2018-hotpot. All rights reserved.
     */
    @Configuration//开启配置
    @EnableConfigurationProperties(FtpOptionProperties.class)//开启使用映射实体对象
    @ConditionalOnClass({IotFtpService.class,GenericObjectPool.class, FTPClient.class})//存在IotFtpService时初始化该配置类
    @ConditionalOnProperty//存在对应配置信息时初始化该配置类
            (
                    prefix = "iot-ftp",//存在配置前缀hello
                    name = "isopen",
                    havingValue = "true",//开启
                    matchIfMissing = true//缺失检查
            )
    public class FtpConfiguration {
        private Logger log = LoggerFactory.getLogger(this.getClass());
        @Autowired
        private FtpOptionProperties ftpOptionProperties;
    
        private ObjectPool<FTPClient> pool;
    
        /**
         * 预先加载FTPClient连接到对象池中
         * @param initialSize 初始化连接数
         * @param maxIdle 最大空闲连接数
         */
        private void preLoadingFtpClient(Integer initialSize, int maxIdle) {
            if (initialSize == null || initialSize <= 0) {
                return;
            }
    
            int size = Math.min(initialSize.intValue(), maxIdle);
            for (int i = 0; i < size; i++) {
                try {
                    pool.addObject();
                } catch (Exception e) {
                    log.error("preLoadingFtpClient error...", e);
                }
            }
        }
        @PreDestroy
        public void destroy() {
            if (pool != null) {
                pool.close();
                log.info("销毁ftpClientPool...");
            }
        }
        /**
         * 根据条件判断不存在ElsService时初始化新bean到SpringIoc
         * @return
         */
        @Bean//创建HelloService实体bean
        @ConditionalOnMissingBean(IotFtpService.class)//缺失HelloService实体bean时，初始化HelloService并添加到SpringIoc
        public IotFtpService iotFtpService()
                throws Exception{
            log.info(">>>The IotFtpService Not Found，Execute Creat New Bean.");
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            poolConfig.setTestOnBorrow(true);
            poolConfig.setTestOnReturn(true);
            poolConfig.setTestWhileIdle(true);
            poolConfig.setMinEvictableIdleTimeMillis(60000);
            poolConfig.setSoftMinEvictableIdleTimeMillis(50000);
            poolConfig.setTimeBetweenEvictionRunsMillis(30000);
            pool = new GenericObjectPool<>(new FtpClientPooledObjectFactory(ftpOptionProperties), poolConfig);
            preLoadingFtpClient(ftpOptionProperties.getInitialSize(), poolConfig.getMaxIdle());
            IotFtpService iotFtpService =new IotFtpService();
            iotFtpService.setFtpClientPool(pool);
            iotFtpService.setHasInit(true);
            return iotFtpService;
        }
    
    
        /**
         * FtpClient对象工厂类
         */
        static class FtpClientPooledObjectFactory implements PooledObjectFactory<FTPClient> {
            private Logger log = LoggerFactory.getLogger(this.getClass());
    
            private FtpOptionProperties props;
    
            public FtpClientPooledObjectFactory(FtpOptionProperties props) {
                this.props = props;
            }
    
            @Override
            public PooledObject<FTPClient> makeObject() throws Exception {
                FTPClient ftpClient = new FTPClient();
                try {
                    ftpClient.connect(props.getHost(), props.getPort());
                    ftpClient.login(props.getUsername(), props.getPassword());
                    log.info("连接FTP服务器返回码{}", ftpClient.getReplyCode());
                    ftpClient.setBufferSize(props.getBufferSize());
                    ftpClient.setControlEncoding(props.getEncoding());
                    ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                    ftpClient.enterLocalPassiveMode();
                    return new DefaultPooledObject<>(ftpClient);
                } catch (Exception e) {
                    log.error("建立FTP连接失败", e);
                    if (ftpClient.isAvailable()) {
                        ftpClient.disconnect();
                    }
                    ftpClient = null;
                    throw new Exception("建立FTP连接失败", e);
                }
            }
    
            @Override
            public void destroyObject(PooledObject<FTPClient> p) throws Exception {
                FTPClient ftpClient = getObject(p);
                if (ftpClient != null && ftpClient.isConnected()) {
                    ftpClient.disconnect();
                }
            }
    
            @Override
            public boolean validateObject(PooledObject<FTPClient> p) {
                FTPClient ftpClient = getObject(p);
                if (ftpClient == null || !ftpClient.isConnected()) {
                    return false;
                }
                try {
                    ftpClient.changeWorkingDirectory("/");
                    return true;
                } catch (Exception e) {
                    log.error("验证FTP连接失败::{}",e.getMessage());
                    return false;
                }
            }
    
            @Override
            public void activateObject(PooledObject<FTPClient> p) throws Exception {
            }
    
            @Override
            public void passivateObject(PooledObject<FTPClient> p) throws Exception {
            }
    
            private FTPClient getObject(PooledObject<FTPClient> p) {
                if (p == null || p.getObject() == null) {
                    return null;
                }
                return p.getObject();
            }
    
        }
    }

# 5.编写ftp操作类（核心） #

package com.iot.ftp.service;
    
    import cn.hutool.core.util.ArrayUtil;
    import cn.hutool.core.util.StrUtil;
    import lombok.Data;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.apache.commons.pool2.ObjectPool;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.util.Assert;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Objects;
    import java.util.stream.Collectors;
    
    /**
     * 描述:ftp服务端
     * @author: myx
     * @date: 2018/5/3
     * Copyright © 2018-hotpot. All rights reserved.
     */
    @Data
    public class IotFtpService {
    
        private Logger log = LoggerFactory.getLogger(this.getClass());
    
        /**
         * ftpClient连接池初始化标志
         */
        private boolean hasInit = false;
        /**
         * ftpClient连接池
         */
        private ObjectPool<FTPClient> ftpClientPool;
    
        /**
         * 上传文件
         * @param pathname ftp服务保存地址
         * @param fileName 上传到ftp的文件名
         *  @param originfilename 待上传文件的名称（绝对地址） *
         * @return
         */
        public boolean uploadFile( String pathname, String fileName,String originfilename){
            boolean flag = false;
            InputStream inputStream = null;
            FTPClient ftpClient = getFtpClient();
            try{
                log.info("开始上传文件");
                inputStream = new FileInputStream(new File(originfilename));
                ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
                CreateDirecroty(pathname,ftpClient);
                ftpClient.makeDirectory(pathname);
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.storeFile(fileName, inputStream);
                inputStream.close();
                flag = true;
                log.info("上传文件成功");
            }catch (Exception e) {
                log.error("上传文件失败");
                e.printStackTrace();
            }finally{
                releaseFtpClient(ftpClient);
            }
            return flag;
        }
    
    
        /**
         * 上传文件
         * @param pathname ftp服务保存地址
         * @param fileName 上传到ftp的文件名
         * @param inputStream 输入文件流
         * @return
         */
        public boolean uploadFile( String pathname, String fileName,InputStream inputStream){
            boolean flag = false;
            FTPClient ftpClient = getFtpClient();
            try{
                log.info("开始上传文件");
                ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
                CreateDirecroty(pathname,ftpClient);
                ftpClient.makeDirectory(pathname);
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.storeFile(fileName, inputStream);
                inputStream.close();
                flag = true;
                log.info("上传文件成功");
            }catch (Exception e) {
                log.error("上传文件失败");
                e.printStackTrace();
            }finally{
                releaseFtpClient(ftpClient);
            }
            return flag;
        }
    
        /** * 下载文件 *
         * @param pathname FTP服务器文件目录 *
         * @param filename 文件名称 *
         * @param localpath 下载后的文件路径 *
         * @return */
        public  boolean downloadFile(String pathname, String filename, String localpath){
            boolean flag = false;
            OutputStream os=null;
            FTPClient ftpClient = getFtpClient();
            try {
                log.info("开始下载文件");
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathname);
                FTPFile[] ftpFiles = ftpClient.listFiles();
                for(FTPFile file : ftpFiles){
                    if(filename.equalsIgnoreCase(file.getName())){
                        File localFile = new File(localpath + "/" + file.getName());
                        os = new FileOutputStream(localFile);
                        ftpClient.retrieveFile(file.getName(), os);
                        os.close();
                    }
                }
                flag = true;
                log.info("下载文件成功");
            } catch (Exception e) {
                log.error("下载文件失败");
                e.printStackTrace();
            } finally{
                releaseFtpClient(ftpClient);
                if(null != os){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return flag;
        }
    
        /** * 删除文件 *
         * @param pathname FTP服务器保存目录 *
         * @param filename 要删除的文件名称 *
         * @return */
        public boolean deleteFile(String pathname, String filename){
            boolean flag = false;
            FTPClient ftpClient = getFtpClient();
            try {
                log.info("开始删除文件");
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.dele(filename);
                ftpClient.logout();
                flag = true;
                log.info("删除文件成功");
            } catch (Exception e) {
                log.error("删除文件失败");
                e.printStackTrace();
            } finally {
                releaseFtpClient(ftpClient);
            }
            return flag;
        }
    
        /**
         * 按行读取FTP文件
         *
         * @param remoteFilePath 文件路径（path+fileName）
         * @return
         * @throws IOException
         */
        public List<String> readFileByLine(String remoteFilePath) throws IOException {
            FTPClient ftpClient = getFtpClient();
            try (InputStream in = ftpClient.retrieveFileStream(encodingPath(remoteFilePath));
                 BufferedReader br = new BufferedReader(new InputStreamReader(in))) {
                return br.lines().map(line -> StrUtil.trimToEmpty(line))
                        .filter(line -> StrUtil.isNotEmpty(line)).collect(Collectors.toList());
            } finally {
                ftpClient.completePendingCommand();
                releaseFtpClient(ftpClient);
            }
        }
    
        /**
         * 获取指定路径下FTP文件
         *
         * @param remotePath 路径
         * @return FTPFile数组
         * @throws IOException
         */
        public FTPFile[] retrieveFTPFiles(String remotePath) throws IOException {
            FTPClient ftpClient = getFtpClient();
            try {
                return ftpClient.listFiles(encodingPath(remotePath + "/"),
                        file -> file != null && file.getSize() > 0);
            } finally {
                releaseFtpClient(ftpClient);
            }
        }
    
        /**
         * 获取指定路径下FTP文件名称
         *
         * @param remotePath 路径
         * @return ftp文件名称列表
         * @throws IOException
         */
        public List<String> retrieveFileNames(String remotePath) throws IOException {
            FTPFile[] ftpFiles = retrieveFTPFiles(remotePath);
            if (ArrayUtil.isEmpty(ftpFiles)) {
                return new ArrayList<>();
            }
            return Arrays.stream(ftpFiles).filter(Objects::nonNull)
                    .map(FTPFile::getName).collect(Collectors.toList());
        }
    
        /**
         * 编码文件路径
         */
        private static String encodingPath(String path) throws UnsupportedEncodingException {
            // FTP协议里面，规定文件名编码为iso-8859-1，所以目录名或文件名需要转码
            return new String(path.replaceAll("//", "/").getBytes("GBK"), "iso-8859-1");
        }
    
        /**
         * 获取ftpClient
         *
         * @return
         */
        private FTPClient getFtpClient() {
            checkFtpClientPoolAvailable();
            FTPClient ftpClient = null;
            Exception ex = null;
            // 获取连接最多尝试3次
            for (int i = 0; i < 3; i++) {
                try {
                    ftpClient = ftpClientPool.borrowObject();
                    ftpClient.enterLocalPassiveMode();//被动模式
                    ftpClient.changeWorkingDirectory("/");
                    break;
                } catch (Exception e) {
                    ex = e;
                }
            }
            if (ftpClient == null) {
                throw new RuntimeException("Could not get a ftpClient from the pool", ex);
            }
            return ftpClient;
        }
    
        /**
         * 释放ftpClient
         */
        private void releaseFtpClient(FTPClient ftpClient) {
            if (ftpClient == null) {
                return;
            }
    
            try {
                ftpClientPool.returnObject(ftpClient);
            } catch (Exception e) {
                log.error("Could not return the ftpClient to the pool", e);
                // destoryFtpClient
                if (ftpClient.isAvailable()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException io) {
                    }
                }
            }
        }
    
        /**
         * 检查ftpClientPool是否可用
         */
        private void checkFtpClientPoolAvailable() {
            Assert.state(hasInit, "FTP未启用或连接失败！");
        }
    
    
        /**
         * 创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
         * @param remote
         * @param ftpClient
         * @return
         * @throws IOException
         */
        public boolean CreateDirecroty(String remote,FTPClient ftpClient) throws IOException {
            boolean success = true;
            String directory = remote + "/";
            // 如果远程目录不存在，则递归创建远程服务器目录
            if (!directory.equalsIgnoreCase("/") && !changeWorkingDirectory(new String(directory),ftpClient)) {
                int start = 0;
                int end = 0;
                if (directory.startsWith("/")) {
                    start = 1;
                } else {
                    start = 0;
                }
                end = directory.indexOf("/", start);
                String path = "";
                String paths = "";
                while (true) {
                    String subDirectory = new String(remote.substring(start, end).getBytes("GBK"), "iso-8859-1");
                    path = path + "/" + subDirectory;
                    if (!existFile(path,ftpClient)) {
                        if (makeDirectory(subDirectory,ftpClient)) {
                            changeWorkingDirectory(subDirectory,ftpClient);
                        } else {
                            System.out.println("创建目录[" + subDirectory + "]失败");
                            changeWorkingDirectory(subDirectory,ftpClient);
                        }
                    } else {
                        changeWorkingDirectory(subDirectory,ftpClient);
                    }
    
                    paths = paths + "/" + subDirectory;
                    start = end + 1;
                    end = directory.indexOf("/", start);
                    // 检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            }
            return success;
        }
    
        /**
         * 改变目录路径
         * @param directory
         * @param ftpClient
         * @return
         */
        public boolean changeWorkingDirectory(String directory,FTPClient ftpClient) {
            boolean flag = true;
            try {
                flag = ftpClient.changeWorkingDirectory(directory);
                if (flag) {
                    System.out.println("进入文件夹" + directory + " 成功！");
    
                } else {
                    System.out.println("进入文件夹" + directory + " 失败！开始创建文件夹");
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return flag;
        }
    
        //判断ftp服务器文件是否存在
        public boolean existFile(String path,FTPClient ftpClient) throws IOException {
            boolean flag = false;
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            if (ftpFileArr.length > 0) {
                flag = true;
            }
            return flag;
        }
        //创建目录
        public boolean makeDirectory(String dir,FTPClient ftpClient) {
            boolean flag = true;
            try {
                flag = ftpClient.makeDirectory(dir);
                if (flag) {
                    log.info("创建文件夹" + dir + " 成功！");
    
                } else {
                    log.info("创建文件夹" + dir + " 失败！");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return flag;
        }
    }

# 6.在resource/WEB-INF创建spring.factories #

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.iot.ftp.config.FtpConfiguration

# 7.使用说明 #

## 7.1 包引入 ##

<dependency>
                <groupId>com.iot</groupId>
                <artifactId>iot-ftp-spring-boot-starter</artifactId>
                <version>最新版本</version>
            </dependency>

## 7.2 配置文件配置信息 ##

iot-ftp:
      isopen: true #是否开启
      host: 192.168.2.1 
      port: 21
      username: user
      password: pwd
      encoding: UTF-8

### 7.3 使用说明 ###

@Autowired
    private IotFtpService iotFtpService;
    
    @GetMapping("/ftp")
        public Object ftp() throws Exception{
            for (int i = 0; i < 10; i++) {
                boolean b = iotFtpService.uploadFile("ftp/testganinfo", "logstash-5.6.9.tar.gz", "f://logstash-5.6.9.tar.gz");
                System.out.println("上传文件==>"+b);
                boolean b1 = iotFtpService.downloadFile("ftp/testganinfo", "logstash-5.6.9.tar.gz", "c://");
                System.out.println("下载文件==>"+b1);
            }
            return iotFtpService.retrieveFileNames("ftp/testganinfo");
        }

# ***更多springboot相关知识关注博客\[持续更新\]*** #

[springboot教程目录][springboot]

[springboot_Starter]: https://blog.csdn.net/qq_31463999/article/details/81628891
[springboot]: https://blog.csdn.net/qq_31463999/article/details/81627799