Ftp上传

public class FtpUtils {
    private static Logger logger = Logger.getLogger(FtpUtils.class);


    public static FTPClient getConnection(FtpConfig ftpConfig) {
        return getConnection(ftpConfig.getHost(), ftpConfig.getPort(), ftpConfig.getUserName(), ftpConfig.getPassword(), ftpConfig.getTimes());
    }

    /**
     * 带重试次数进行ftp连接的建立
     *
     * @param host     连接主机域名或IP
     * @param port     连接端口
     * @param userName ftp用户名
     * @param password ftp密码
     * @param times    重试次数
     * @return
     */
    public static FTPClient getConnection(String host, int port, String userName, String password, int times) {
        FTPClient ftp = new FTPClient();
        if (times <= 0) {
            times = 1;
        }
        while ((times--) > 0) {
            boolean isConnected = true;
            try {
                ftp.connect(host, port);
                ftp.login(userName, password);// 登录
                int reply = ftp.getReplyCode();
                //如果登录不成功(连接不上, 刚继续发起连接)
                if (!FTPReply.isPositiveCompletion(reply)) {
                    isConnected = false;
                    ftp.disconnect();
                    Thread.sleep(2000);
                    continue;
                }
                ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
                break;
            } catch (InterruptedException e) {
                isConnected = false;
                logger.error(String.format("ftp server:%s:%s 连接线程异常", host, port), e);
            } catch (Exception e) {
                isConnected = false;
                logger.error(String.format("ftp server:%s:%s 连接失败", host, port), e);
            }
            //连接不成功先释放连接后再重新连接
            if (!isConnected) {
                try {
                    ftp.disconnect();
                    Thread.sleep(2000); //等待2秒再进行重连
                } catch (IOException e) {
                    logger.error(String.format("释放ftp server失败:%s:%s 连接失败", host, port), e);
                } catch (Exception e) {
                    logger.error(String.format("ftp server:%s:%s 连接线程异常", host, port), e);
                }
            }
        }
        return ftp;
    }


    /**
     * 将inputStream 上传到服务器
     *
     * @param ftp
     * @param path
     * @param fileName
     * @param file
     * @return success 成功 fail失败
     */
    public static String upload2FtpServer(FTPClient ftp, String path, String fileName, File file) {
        String uploadResult = "success";
        try {
            InputStream is = new FileInputStream(file);
            uploadResult = upload2FtpServer(ftp, path, fileName, is);
        } catch (Exception e) {
            logger.error("上传文件失败", e);
            uploadResult = e.getMessage();
        }
        return uploadResult;
    }

    /**
     * 将inputStream 上传到服务器
     *
     * @param ftpClient
     * @param ftpPath
     * @param fileName
     * @param is
     * @return 1 表示成功 0表示失败 2表示ftp断开连接
     */
    public static String upload2FtpServer(FTPClient ftpClient, String ftpPath, String fileName, InputStream is) {
        if (null == is || StringUtils.isEmpty(ftpPath) || StringUtils.isEmpty(fileName)) {
            logger.warn("上传信息不完整");
            return "fail";
        }

        String uploadResult = "success";
        try {
            if (!ftpClient.isConnected()) { //ftp 连接已断开
                return "fail";
            }

            if (!ftpPath.contains("/")) {
                if (!ftpClient.changeWorkingDirectory(ftpPath)) {
                    ftpClient.makeDirectory(ftpPath);
                    ftpClient.changeWorkingDirectory(ftpPath);
                }
            } else {
                for (String path : ftpPath.split("/")) {
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        ftpClient.makeDirectory(path);
                        ftpClient.changeWorkingDirectory(path);
                    }
                }
                ;
            }
            //设置成被动模式
            ftpClient.enterLocalPassiveMode();
            if (ftpClient.storeFile(fileName, is)) {
                uploadResult = "success";
            } else {
                uploadResult = "fail";
            }
            is.close();
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
            uploadResult = e.getMessage();
        }
        return uploadResult;
    }

    public static void deleteFile(FTPClient ftpClient, String ftpPath, String fileName) throws Exception {
        if (StringUtils.isEmpty(ftpPath) || StringUtils.isEmpty(fileName)) {
            return;
        }
        if (!ftpClient.isConnected()) { //ftp 连接已断开
            return;
        }

        if (!ftpPath.contains("/")) {
            if (ftpClient.changeWorkingDirectory(ftpPath)) {
                ftpClient.deleteFile(fileName);
            }
        } else {
            for (String path : ftpPath.split("/")) {
                if (!ftpClient.changeWorkingDirectory(path)) {
                    return;
                }
            }
            ;
            ftpClient.deleteFile(fileName);
        }
    }

    public static void moveFile(FTPClient ftpClient, String from, String to) {
        if (StringUtils.isEmpty(from) || StringUtils.isEmpty(to) || null == ftpClient) {
            return;
        }
        if (!ftpClient.isConnected()) { //ftp 连接已断开
            return;
        }
        try {
            ftpClient.rename(from, to);
        } catch (IOException e) {
            e.printStackTrace();
            logger.error("FTP移动文件出错", e);
        }
    }


    /**
     * 释放ftp连接
     *
     * @param ftpClient
     */
    public static void releaseConnect(FTPClient ftpClient) {
        if (null != ftpClient) {
            try {
                ftpClient.quit();
                ftpClient.disconnect();
            } catch (IOException e) {
                logger.error("释放ftp连接失败", e);
            }
        }
    }

    public static boolean deleteFiles(String... paths) {
        boolean res = false;
        try {
            FTPClient ftpClient = conFTPClient();
            String ftpPath = PropertiesUtil.getProperties().getProperty("ftp.file.path2");
            if (!ftpClient.isConnected()) { //ftp 连接已断开
                return false;
            }

            for (String path : paths) {
                String dirStr = new String(path.getBytes("UTF-8"), "iso-8859-1");
                res = ftpClient.deleteFile(ftpPath+dirStr);
                if (!res) {
                    break;
                }
            }
            releaseConnect(ftpClient);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return res;
    }

    public static boolean makeDir(String... paths) {
        boolean res = false;
        try {
            FTPClient ftpClient = conFTPClient();
            String ftpPath = PropertiesUtil.getProperties().getProperty("ftp.file.path2");
            for (String path : paths) {
                String dirStr = new String(path.getBytes("UTF-8"), "iso-8859-1");
                res = ftpClient.makeDirectory(ftpPath + dirStr);
                if (!res) {
                    for (String delPath : paths) {
                        String delDirStr = new String(delPath.getBytes("UTF-8"), "iso-8859-1");
                        deleteDir(ftpPath + delDirStr);
                    }
                    break;
                }
            }
            releaseConnect(ftpClient);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return res;
    }

    public static void deleteDir(String... paths) {
        try {
            FTPClient ftpClient = conFTPClient();
            String ftpPath = PropertiesUtil.getProperties().getProperty("ftp.file.path2");
            for (String path : paths) {
                String dirStr = new String(path.getBytes("UTF-8"), "iso-8859-1");
                ftpClient.removeDirectory(ftpPath + dirStr);
            }
            releaseConnect(ftpClient);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static FTPClient conFTPClient() throws IOException {
        FTPClient ftpClient = new FTPClient();
        String ftpIp = PropertiesUtil.getProperties().getProperty("ftp.ip2");
        String ftpPort = PropertiesUtil.getProperties().getProperty("ftp.port2");
        String ftpUser = PropertiesUtil.getProperties().getProperty("ftp.user2");
        String ftpPwd = PropertiesUtil.getProperties().getProperty("ftp.pwd2");
        ftpClient.connect(ftpIp, Integer.parseInt(ftpPort));
        ftpClient.login(ftpUser, ftpPwd);
        ftpClient.enterLocalPassiveMode();
        ftpClient.setControlEncoding("UTF-8");
        return ftpClient;
    }

    /**
     * 上传
     *
     * @param file
     * @param dir
     * @param newName
     * @return
     */
    public static boolean upload(MultipartFile file, String dir, String newName) {

        boolean res = false;
        FTPClient ftpClient = null;
        try {
            ftpClient = conFTPClient();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            String ftpPath = PropertiesUtil.getProperties().getProperty("ftp.file.path2");
            FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
            conf.setServerLanguageCode("zh");
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            String dirStr = new String(dir.getBytes("UTF-8"), "iso-8859-1");
            String path = ftpPath + dirStr;
            // 如果不存在就创建，如果存在则返回false
            ftpClient.makeDirectory(path);
            // 设置上传目录
            ftpClient.changeWorkingDirectory(path);
            System.out.println(path);
            FTPFile[] fs = ftpClient.listFiles();
            if (fs != null && fs.length > 0) {
                for (FTPFile f : fs) {
                    if (f.getName().equals(newName)) {
                        ftpClient.deleteFile(f.getName());
                        break;
                    }
                }
            }
            OutputStream os = ftpClient.appendFileStream(newName);
            byte[] bytes = new byte[1024];
            InputStream is = file.getInputStream();
            int c;
            // 暂未考虑中途终止的情况
            while ((c = is.read(bytes)) != -1) {
                os.write(bytes, 0, c);
            }
            os.flush();
            is.close();
            os.close();
            res = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                ftpClient.disconnect();
            } catch (IOException e) {
                //e.printStackTrace();
                System.out.println(e.getStackTrace());
                res = false;
            }
        }
        return res;
    }

    public static boolean uploadFile(String dir, String newName, File file) {
        boolean res = false;
        try {
            FTPClient ftpClient = conFTPClient();
            String ftpPath = PropertiesUtil.getProperties().getProperty("ftp.file.path2");
            FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
            conf.setServerLanguageCode("zh");
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            String dirStr = new String(dir.getBytes("UTF-8"), "iso-8859-1");
            String newName2 = new String(newName.getBytes("UTF-8"), "iso-8859-1");
            String path = ftpPath + dirStr;
            // 如果不存在就创建，如果存在则返回false
            ftpClient.makeDirectory(path);
            // 设置上传目录
            ftpClient.changeWorkingDirectory(path);
            FTPFile[] fs = ftpClient.listFiles();
            if (fs != null && fs.length > 0) {
                for (FTPFile f : fs) {
                    if (f.getName().equals(newName)) {
                        ftpClient.deleteFile(f.getName());
                        break;
                    }
                }
            }
            System.out.println(path);
            OutputStream os = ftpClient.appendFileStream(newName2);
            byte[] bytes = new byte[1024];
            InputStream is = new FileInputStream(file);
            int c;
            // 暂未考虑中途终止的情况
            while ((c = is.read(bytes)) != -1) {
                os.write(bytes, 0, c);
            }
            os.flush();
            is.close();
            os.close();
            res = true;
            releaseConnect(ftpClient);
        } catch (Exception e) {
            logger.error("上传文件失败", e);
            e.printStackTrace();
        }
        return res;
    }
}

<div class="iteye-blog-content-contain" style="font-size: 20px"></div>

public class FtpConfig{

	private String host;
	private int port;
	private String userName;
	private String password;
	private int times;

	public String getHost() {
		return host;
	}
	public void setHost(String host) {
		this.host = host;
	}
	public int getPort() {
		return port;
	}
	public void setPort(int port) {
		this.port = port;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getTimes() {
		return times;
	}
	public void setTimes(int times) {
		this.times = times;
	}

}