因为个人原因，不在csdn上更新了，欢迎各位来到我的个人博客：

https://tdsgpo.top

java代码参考的Java 实现ftp文件上传 - 简书大佬的代码，场景是原项目测试时期是存储文件到本地的，但是部署服务器之后有FTP文件服务器存在，需要将原本的代码更改为上传到ftp的代码。

1、是有多个pom文件的项目需要把maven放在最外面一层的pom文件里面，不然会出现依赖循环问题。

2、不能在ftp上创建文件夹的问题，可能存在已经创建好的根目录的文件所属用户不是ftp的使用者用户。需要 chown 用户 目录或文件名，更改文件夹拥有者。

接下来是使用到的代码部分：

3、有可能在切换目录的时候会出现550 Fial to change directoty 的报错，这个时候可能hi应为ftp服务器配置的问题，需要设置以下选项：

首先 vi /etc/vsftpd/vsftpd.conf

然后观察以下选项，是否一致

chroot_list_enable=YES（NO）
设置是否启用chroot_list_file配置项指定的用户列表文件。默认值为NO。
chroot_list_file=/etc/vsftpd.chroot_list
用于指定用户列表文件，该文件用于控制哪些用户可以切换到用户家目录的上级目录。
chroot_local_user=YES（NO）
用于指定用户列表文件中的用户是否允许切换到上级目录。默认值为NO。

最后service vsftpd restart 重启

1、pom依赖

<!--commons-net -->
<dependency>
    <groupId>commons-net</groupId>
    <artifactId>commons-net</artifactId>
    <version>3.5</version>
</dependency>

2、FTP工具类

package www.hrabbit.cn.util;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

import java.io.*;
import java.net.MalformedURLException;

/**
 * @Auther: hrabbit
 * @Date: 2018-04-21 下午12:35
 * @Description:
 */
public class FTPUtils {

    public static FTPClient ftpClient = null;

    /**
     * 初始化ftp服务器
     */
    public static void initFtpClient(String hostname,String username,String password,Integer port) {
        ftpClient = new FTPClient();
        ftpClient.setControlEncoding("utf-8");
        try {
            //连接ftp服务器
            ftpClient.connect(hostname, port);
            //登录ftp服务器
            ftpClient.login(username, password);
            //是否成功登录服务器
            int replyCode = ftpClient.getReplyCode();
            if(!FTPReply.isPositiveCompletion(replyCode)){
                System.out.println("ftp服务器登录成功");
            }
        }catch (MalformedURLException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 上传文件
     * @param pathname ftp服务保存地址
     * @param fileName 上传到ftp的文件名
     * @param inputStream 输入文件流
     * @return
     */
    public static boolean uploadFile(String hostname,String username,String password,Integer port, String pathname, String fileName,InputStream inputStream){
        boolean flag = false;
        try{
            System.out.println("开始上传文件");
            initFtpClient(hostname,username,password,port);
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ftpClient.enterLocalPassiveMode();
            CreateDirecroty(pathname);
            ftpClient.makeDirectory(pathname);
            ftpClient.setControlEncoding("utf-8");
            ftpClient.storeFile(fileName, inputStream);
            System.out.println("上传结束");
            inputStream.close();
            ftpClient.logout();
            flag = true;
            System.out.println("上传文件成功");

        }catch (Exception e) {
            System.out.println("上传文件失败");
            e.printStackTrace();
        }finally{
            if(ftpClient.isConnected()){
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }
    //改变目录路径
    public static boolean changeWorkingDirectory(String directory) {
        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 static boolean CreateDirecroty(String remote) throws IOException {
        boolean success = true;
        String directory = remote + "/";
        // 如果远程目录不存在，则递归创建远程服务器目录
        if (!directory.equalsIgnoreCase("/") && !changeWorkingDirectory(new String(directory))) {
            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("UTF-8"), "iso-8859-1");
                path = path + "/" + subDirectory;
                if (!existFile(path)) {
                    if (makeDirectory(subDirectory)) {
                        changeWorkingDirectory(subDirectory);
                    } else {
                        System.out.println("创建目录[" + subDirectory + "]失败");
                        changeWorkingDirectory(subDirectory);
                    }
                } else {
                    changeWorkingDirectory(subDirectory);
                }

                paths = paths + "/" + subDirectory;
                start = end + 1;
                end = directory.indexOf("/", start);
                // 检查所有目录是否创建完毕
                if (end <= start) {
                    break;
                }
            }
        }
        return success;
    }

    //判断ftp服务器文件是否存在
    public static boolean existFile(String path) throws IOException {
        boolean flag = false;
        FTPFile[] ftpFileArr = ftpClient.listFiles(path);
        if (ftpFileArr.length > 0) {
            flag = true;
        }
        return flag;
    }
    //创建目录
    public static boolean makeDirectory(String dir) {
        boolean flag = true;
        try {
            flag = ftpClient.makeDirectory(dir);
            if (flag) {
                System.out.println("创建文件夹" + dir + " 成功！");

            } else {
                System.out.println("创建文件夹" + dir + " 失败！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /** * 下载文件 *
     * @param pathname FTP服务器文件目录 *
     * @param filename 文件名称 *
     * @param localpath 下载后的文件路径 *
     * @return */
    public static  boolean downloadFile(String hostname,String username,String password,Integer port,String pathname, String filename, String localpath){
        boolean flag = false;
        OutputStream os=null;
        try {
            System.out.println("开始下载文件");
            initFtpClient(hostname,username,password,port);
            //切换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();
                }
            }
            ftpClient.logout();
            flag = true;
            System.out.println("下载文件成功");
        } catch (Exception e) {
            System.out.println("下载文件失败");
            e.printStackTrace();
        } finally{
            if(ftpClient.isConnected()){
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(null != os){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }

    /** * 删除文件 *
     * @param pathname FTP服务器保存目录 *
     * @param filename 要删除的文件名称 *
     * @return */
    public static boolean deleteFile(String hostname,String username,String password,Integer port,String pathname, String filename){
        boolean flag = false;
        try {
            System.out.println("开始删除文件");
            initFtpClient(hostname,username,password,port);
            //切换FTP目录
            ftpClient.changeWorkingDirectory(pathname);
            ftpClient.dele(filename);
            ftpClient.logout();
            flag = true;
            System.out.println("删除文件成功");
        } catch (Exception e) {
            System.out.println("删除文件失败");
            e.printStackTrace();
        } finally {
            if(ftpClient.isConnected()){
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
        return flag;
    }
}

欢迎大家光临我的个人博客，里面还有更多的好东西

Hexohttps://tdsgpo.top/

欢迎来到小生的博客，各种工具类，常用知识点、技巧持续更新中。。。。。。。
感谢大家点赞关注，希望大家能够给小生更多的支持。
祝您阅读愉快！
有任何疑问可以加小生QQ群咨询：107680366

前段时间，项目中使用到了上传文件到FTP服务器，再此略作整理，形成一个util工具,方便日后使用。
项目代码已上传至github:https://github.com/hack-feng/ftpdemo.git
点击直接前往

其中部分生成规则可以根据实际业务进行修改，删除

首先定义一个FTP服务器和上传文件的基础信息
封装一个FtpBean.java实体类

public class FtpBean {
	/**
	 * 部分信息如果传空的话，默认赋值，根据业务需求修改
	 */
	//FTP服务器地址
	private String address;
	//FTP服务器端口号
	private String port;
    //FTP服务器用户名
	private String username;
	//FTP服务器密码
	private String password;
	//上传文件名称
	private String fileName;
	//基本路径
	private String basepath;
	//文件输入流
	private InputStream inputStream;
	//保存文件方式  默认：1-覆盖；2-文件名称后面+(递增数据) 
	private Integer saveFileType;
	//省略get,set方法，详情可查询github上的源码

创建FTP上传工具类 FtpUtil.java：

public class FtpUtil {
	
	public static boolean uploadFile(FtpBean ftpBean) {
		
		boolean result = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(ftpBean.getAddress(), Integer.valueOf(ftpBean.getPort()));// 连接FTP服务器
			// 如果采用默认端口，可以使用ftp.connect(host)的方式直接连接FTP服务器
			ftp.login(ftpBean.getUsername(), ftpBean.getPassword());// 登录
			reply = ftp.getReplyCode();
			
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return result;
			}
			
			String tempPath = ftpBean.getBasepath();
			String fileName = ftpBean.getFileName();
			if (!ftp.changeWorkingDirectory(ftpBean.getBasepath())) {
				//判断目录是否存在，如果目录不存在创建目录，目录存在则跳转到此目录下
				String []tempPathList = tempPath.split("/");
				for (String dir : tempPathList) {
					if(dir != null && dir != ""){
						if (!ftp.changeWorkingDirectory(dir)) {
							if (!ftp.makeDirectory(dir)) {
								return result;
							} else {
								ftp.changeWorkingDirectory(dir);
							}
						}
					}
				}
			}
			
			//保存文件方式  默认：1-覆盖；2-文件名称后面+(递增数据) 
			if(ftpBean.getSaveFileType() == 2){
				FTPFile[]file = ftp.listFiles();
				Integer i = 1;
				//采用递归，文件名重复自动加(i)
				fileName = aaa(file, i, fileName, fileName);
			}
			//设置上传文件的类型为二进制类型
			ftp.setFileType(FTP.BINARY_FILE_TYPE);
			//设置模式很重要
			ftp.enterLocalActiveMode();
			//上传文件
			result = ftp.storeFile(fileName, ftpBean.getInputStream());
			if(!result){
				return result;
			}

			ftpBean.getInputStream().close();
			ftp.logout();
			result = true;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return result;
	}
	
	
	//递归重命名去重复
	public static String aaa(FTPFile[] file, int i, String fileName, String nameFlag){
		boolean isOk = true;
		for (FTPFile file2 : file) {
			String flag = file2.getName();
			if(nameFlag.equals(flag)){
				String []fileNames = fileName.split("\\.");
				if(fileNames.length > 0){
					nameFlag = "";
				}
				for (int j = 0; j < fileNames.length; j++) {
					if(j == fileNames.length-1){
						nameFlag = nameFlag+"("+i+")."+fileNames[j];
					}else if(j == fileNames.length-2){
						nameFlag = nameFlag + fileNames[j];
					}else{
						nameFlag = nameFlag + fileNames[j] + ".";
					}
				}
				i += 1;
				isOk = false;
			}else{
				isOk = true;
			}
		}
		
		if(isOk == false){
			nameFlag = aaa(file, i, fileName, nameFlag);
		}
		return nameFlag;
	}
}

生成上传路径规则工具类 GenerateDirUtil.java：

public class GenerateDirUtil {
	
	public static enum Type{
		DEFAULT,
		FILETYPE
	}

	/**
	 *  <p>
	 *  type为DEFAULT或者type为null时：获取原文件所在路径，直接在FTP创建此路径保存
	 *  type为FILETYPE时：则根据文件类型创建目录
	 *  </p>
	 *  @method_Name    : fileDirectory
	 *  @author         : Maple
	 *  @creation       : 2019年3月15日 下午1:59:31 
	 *  @param file
	 *  @return
	 */
	public static String fileDirectory(File file, Type type){
		if(Type.FILETYPE.equals(type)){
			String resDir = "/";
			resDir = new MimetypesFileTypeMap().getContentType(file);
			resDir.replace('\\', '/');
			return "/"+resDir;
		}else{
			String resDir = "/";
			resDir = file.getParent();
			return resDir;
		}
	}
}

创建测试用例FtpDemo.java:

public class FtpDemo {
	
	public static void main(String[] args){
		
		//获取本地需要上传的文件，此处只用作测试
		File file = new File("D:\\test\\ftp.txt");
		
		if(file.isFile() && file.exists()){
			
			//设置FTP上传的基本信息，可直接初始化数据
			FtpBean ftp = new FtpBean();
			
			//自动生成路径，默认取源文件路径，为FILETYPE时，取文件类型做路径
			//如使用自己的路径，直接ftp.setBasepath赋值即可
			String basepath = GenerateDirUtil.fileDirectory(file, GenerateDirUtil.Type.FILETYPE);
			ftp.setBasepath(basepath);
			
			/**
			 * 文件名生成方式
			 * 1、自己命名			ftp.setBasepath("aaaa.txt");
			 * 2、取文件原名字		ftp.setBasepath(file.getName());
			 * 3、根据时间戳自动生成	
			 */
			SimpleDateFormat sdfms = new SimpleDateFormat("yyyyMMddHHmmssSSS");
			String date = sdfms.format(System.currentTimeMillis());
			//添加三位自动生成的数字，防止重复
			int i=(int)(Math.random()*900)+100; 
			String fileName = date + i +".txt";
			ftp.setFileName(fileName);
			
			//测试命名重复递增
			fileName = "aaa.txt";
			
			try{
				//将文件转换成一个输入流
				InputStream in = new FileInputStream(file);
				ftp.setInputStream(in);
				//传入文件名称，和文件输入流，上传至FTP服务器
				boolean isOk = FtpUtil.uploadFile(ftp);
				if(isOk){
					System.out.println("文件上传成功");
				}else{
					System.out.println("文件上传失败");
				}
				in.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}else{
			System.out.println("文件不存在");
		}
	}
}

待上传的文件截图：

上传至FTP服务器后的截图，分别用按时间戳命名和固定不重复命名两种方法实现：

package com.company.project.utils;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Map;

/**
 * ftp 上传文件
 * FTPClient commons.net 3.0.1版本
 * 上传文件至指定ftp路径
 * @author Lenovo
 * oracle每天更新工参三次。抽取一次。上传至ftp目录
 */
public class FtpClientUpFile {

    private static final String hostname = "10.*.*.4";//FTP IP

    private static final int port = 21;//FTP 端口号

    private static final String username = "ftpuser";//FTP 登录账号

    private static final String password = "123456"; //FTP 登录密码

    private static final String pathname = "/data/ftp/";//FTP 工作路径

    private static final SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd"); //FTP服务器上文件


    /**
     * 上传文件（可供Action/Controller层使用）
     *
     * @param fileName    上传到FTP服务器后的文件名称
     * @param inputStream 输入文件流
     * @return
     */
    public static boolean uploadFile(String fileName, FileInputStream inputStream) {

        boolean flag = false;
        FTPClient ftpClient = new FTPClient();
        //设置超时
        ftpClient.setConnectTimeout(60 * 60 * 1000);
        //设置编码
        ftpClient.setControlEncoding("UTF-8");
        try {
            //连接FTP服务器
            ftpClient.connect(hostname, port);
            //登录FTP服务器
            ftpClient.login(username, password);
            //是否成功登录FTP服务器
            int replyCode = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                return flag;
            }
            System.out.println("===========登录FTP成功了==========");
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //切换路径 创建路径
            ftpClient.makeDirectory(pathname);
            ftpClient.changeWorkingDirectory(pathname);
            ftpClient.enterLocalPassiveMode();
            
            String pathDir1 = pathname+df.format(new Date());
            boolean pathIsExis = ftpClient.changeWorkingDirectory(pathDir1);
            System.out.println("查看文件夹是否存在");
            if(!pathIsExis){//不存在文件夹则创建并且进入文件夹
                ftpClient.makeDirectory(pathDir1);
                ftpClient.changeWorkingDirectory(pathDir1);
            }

            //设置缓冲
            ftpClient.setBufferSize(1024 * 1024 * 20);
            //保持连接
            ftpClient.setKeepAlive(true);
            boolean a = ftpClient.storeFile(new String(fileName.getBytes("utf-8"), "iso-8859-1"), inputStream);
            if (a) {
                flag = true;
                System.out.println("===========创建文件成功==============" + a);
                String fileName2 = fileName;  //这里可以将名字更改
                boolean status = ftpClient.rename(fileName, fileName2);
                if (status)
                    System.out.println("===========修改文件名称成功==============" + status);
            }else{
                flag = false;
            }
            inputStream.close();
            ftpClient.logout();
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return flag;

    }


    public static void main(String[] args) {
        String fileName = "tousu.xlsx.gz";
        String originfilename = "E:\\data\\"+fileName;
        FileInputStream inputStream;
        try {
            inputStream = new FileInputStream(originfilename);
            boolean a = uploadFile(fileName, inputStream);
            System.out.println("上传文件结果============" + a);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }


    /**
     * 测试上传
     *
     * @param map 从数据库获取到的文件信息 （包含文件路径FILE_PATH 文件类型FILE_TYPE等信息）
     */
    public void testUpdFtpFile(Map<String, Object> map) {
        /*上传附件到FTP*/
        FileInputStream inputStream = null;
        try {
            //找到要上传的文件
            String originfilename = "E:\\work\\files\\" + map.get("FILE_PATH").toString();
            //转成流
            inputStream = new FileInputStream(originfilename);
            //上传后的文件名+文件类型
            String ftpName = "上传到FTP后的文件名." + map.get("FILE_TYPE");
            boolean updFtpFile = FtpClientUpFile.uploadFile(ftpName, inputStream);
            if (updFtpFile) {
                //打印下日志
                System.out.println(("=======文件已上传到FTP========"));
            }
        } catch (Exception e) {
            System.out.println("上传异常");
            e.printStackTrace();
        }
    }


}