springboot 实现ftp 文件上传、下载

迷南。 2022-05-10 23:24 1310阅读 0赞

1. 先添加pom文件
    使用gradle :
    compile group: 'commons-net', name: 'commons-net', version: "3.6"
    
    2. 在application.yml中配置参数：
    ftp.host: localhost
    ftp.port: 210
    ftp.username: ftp01
    ftp.password: abc
    ftp.filepath: /
    
    3. 实现代码：

import org.apache.commons.net.ftp.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Calendar;
    import java.util.Date;
    
    
    /**
     * 类说明：文件上传下载工具类
     * 
     */
    @Component
    public class FtpOperation{
    	public static final int imageCutSize=300;
        private static final Logger log= LoggerFactory.getLogger(FtpOperation.class);
    
        @Value("${ftp.username}")
        private String userName;
    
        @Value("${ftp.password}")
        private String passWord;
    
        @Value("${ftp.host}")
        private String ip;
    
        @Value("${ftp.port}")
        private int port;
    
        @Value("${ftp.filepath}")
        private String CURRENT_DIR;     // 文件存放的目录
    
        public static final String DIRSPLIT="/";
        
        public String getCURRENT_DIR() {
            return CURRENT_DIR;
        }
    
    
        public void setCURRENT_DIR(String cURRENTDIR) {
            CURRENT_DIR = cURRENTDIR;
        }
    
        // 下载的文件目录
        private String DOWNLOAD_DIR;
        
        // ftp客户端
        private FTPClient ftpClient = new FTPClient();
        
        /**
         * 
         * 功能：上传文件附件到文件服务器
         * @param buffIn:上传文件流
         * @param fileName：保存文件名称
         * @param needDelete：是否同时删除
         * @return
         * @throws IOException
         */
        public boolean uploadToFtp(InputStream buffIn, String fileName,boolean needDelete)
                throws FTPConnectionClosedException, IOException,Exception {
            boolean returnValue = false;
            // 上传文件
            try {
                
                    // 建立连接
                    connectToServer();
                    // 设置传输二进制文件
                    setFileType(FTP.BINARY_FILE_TYPE);
                    int reply = ftpClient.getReplyCode();   
                    if(!FTPReply.isPositiveCompletion(reply))    
                    {   
                        ftpClient.disconnect();   
                        throw new IOException("failed to connect to the FTP Server:"+ip);   
                    }
                    ftpClient.enterLocalPassiveMode();
                   /* if(StringUtils.checkStr(CURRENT_DIR)){
                    	if(!existDirectory(CURRENT_DIR)){
                    		this.createDirectory(CURRENT_DIR);
                    	}
                        ftpClient.changeWorkingDirectory(CURRENT_DIR);
                    }*/
                    // 上传文件到ftp
                    returnValue = ftpClient.storeFile(fileName, buffIn);
                    if(needDelete){
                        ftpClient.deleteFile(fileName);
                    }
                    // 输出操作结果信息
                    if (returnValue) {
                        log.info("uploadToFtp INFO: upload file  to ftp : succeed!");
                    } else {
                    	log.info("uploadToFtp INFO: upload file  to ftp : failed!");
                    }
                    buffIn.close();
                    // 关闭连接
                    closeConnect();
            } catch (FTPConnectionClosedException e) {
            	log.error("ftp连接被关闭！", e);
                throw e;
            } catch (Exception e) {
                returnValue = false;
                log.error("ERR : upload file  to ftp : failed! ", e);
                throw e;
            } finally {
                try {
                    if (buffIn != null) {
                        buffIn.close();
                    }
                } catch (Exception e) {
                	log.error("ftp关闭输入流时失败！", e);
                }
                if (ftpClient.isConnected()) {
                    closeConnect();
                }            
            }
            return returnValue;
        }
        
        
        /**
         * 
         * 功能：根据文件名称，下载文件流
         * @param filename
         * @return
         * @throws IOException
         */
        public InputStream  downloadFile(String filename)
                throws IOException {
            InputStream in=null;
            try {
                
                    // 建立连接
                    connectToServer();
                    ftpClient.enterLocalPassiveMode();
                    // 设置传输二进制文件
                    setFileType(FTP.BINARY_FILE_TYPE);
                    int reply = ftpClient.getReplyCode();   
                    if(!FTPReply.isPositiveCompletion(reply))    
                    {   
                        ftpClient.disconnect();
                        throw new IOException("failed to connect to the FTP Server:"+ip);   
                    }
                    ftpClient.changeWorkingDirectory(CURRENT_DIR);
    
                    // ftp文件获取文件
                    in=ftpClient.retrieveFileStream(filename);
    
            } catch (FTPConnectionClosedException e) {
            	log.error("ftp连接被关闭！", e);
                throw e;
            } catch (Exception e) {
                log.error("ERR : upload file "+ filename+ " from ftp : failed!", e);
            }
            return in;
        }
        
        /**
         * 转码[GBK -> ISO-8859-1] 不同的平台需要不同的转码
         * 
         * @param obj
         * @return
         */
    //    private String gbkToIso8859(Object obj) {
    //        try {
    //            if (obj == null)
    //                return "";
    //            else
    //                return new String(obj.toString().getBytes("GBK"), "iso-8859-1");
    //        } catch (Exception e) {
    //            return "";
    //        }
    //    }
        
        /**
         * 设置传输文件的类型[文本文件或者二进制文件]
         * 
         * @param fileType
         *            --BINARY_FILE_TYPE、ASCII_FILE_TYPE
         */
        private void setFileType(int fileType) {
            try {
                ftpClient.setFileType(fileType);
            } catch (Exception e) {
            	log.error("ftp设置传输文件的类型时失败！", e);
            }
        }
        
        /**
         * 
         * 功能：关闭连接
         */
        public void closeConnect() {
            try {
                if (ftpClient != null) {
                    ftpClient.logout();
                    ftpClient.disconnect();
                }
            } catch (Exception e) {
            	log.error("ftp连接关闭失败！", e);
            }
        }
        
        /** 
         * 连接到ftp服务器 
         */ 
        private void connectToServer() throws FTPConnectionClosedException,Exception { 
            if (!ftpClient.isConnected()) { 
                int reply; 
                try { 
                    ftpClient=new FTPClient();
                    ftpClient.connect(ip,port);
                    ftpClient.login(userName,passWord);
                    reply = ftpClient.getReplyCode(); 
    
                    if (!FTPReply.isPositiveCompletion(reply)) { 
                        ftpClient.disconnect(); 
                        log.info("connectToServer FTP server refused connection."); 
                    } 
                
                }catch(FTPConnectionClosedException ex){
                    log.error("服务器:IP："+ip+"没有连接数！there are too many connected users,please try later", ex);
                    throw ex;
                }catch (Exception e) { 
                    log.error("登录ftp服务器【"+ip+"】失败", e); 
                    throw e;
                } 
            } 
        } 
        // Check the path is exist; exist return true, else false.  
        public boolean existDirectory(String path) throws IOException {
            boolean flag = false;  
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);  
            for (FTPFile ftpFile : ftpFileArr) {  
                if (ftpFile.isDirectory()  
                        && ftpFile.getName().equalsIgnoreCase(path)) {  
                    flag = true;  
                    break;  
                }  
            }  
            return flag;  
        } 
        /**
         * 创建FTP文件夹目录
         * @param pathName
         * @return
         * @throws IOException
         */
        public boolean createDirectory(String pathName) throws IOException { 
        	boolean isSuccess=false;
        	try{
        		isSuccess=ftpClient.makeDirectory(pathName);
        	}catch(Exception e){
        		e.printStackTrace();
        	}
            return isSuccess;  
        }
        /**
         * 带点的
         * @param fileName
         * @return
         */
        public static String getExtention(String fileName) {
            int pos = fileName.lastIndexOf(".");
            return fileName.substring(pos);
        }
        /**
         * 不带点
         * @param fileName
         * @return
         */
        public static String getNoPointExtention(String fileName) {
            int pos = fileName.lastIndexOf(".");
            return fileName.substring(pos+1);
        }
        /**
         * 
         * 功能：根据当前时间获取文件目录
         * @return String
         */
        public static String getDateDir(Date dateParam){
            Calendar cal = Calendar.getInstance();
            if(null!=dateParam){
                cal.setTime(dateParam);
            }
            int currentYear = cal.get(Calendar.YEAR);
            int currentMouth = cal.get(Calendar.MONTH) + 1;
            int currentDay = cal.get(Calendar.DAY_OF_MONTH) ;
            //int currentHour = cal.get(Calendar.HOUR_OF_DAY);
            //return currentYear+FtpOperation.DIRSPLIT+currentMouth+FtpOperation.DIRSPLIT+currentDay+FtpOperation.DIRSPLIT+currentHour;
            return currentYear+FtpOperation.DIRSPLIT+currentMouth+FtpOperation.DIRSPLIT+currentDay;
        }
    
        
    }