用FTP4J jar包类上传文件

import it.sauronsoftware.ftp4j.FTPClient;
import it.sauronsoftware.ftp4j.FTPException;
import it.sauronsoftware.ftp4j.FTPFile;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Properties;
import java.util.logging.Logger;

import org.apache.commons.lang.StringUtils;


public class Ftp4jFtpClient
{

	
	private static Ftp4jFtpClient ftp;
	/**
	 * FTP服务地址
	 */
	private static String ADDRESS;
	/**
	 * FTP登录用户名
	 */
	private static String USERNAME;
	/**
	 * FTP登录密码
	 */
	private static String PASSWORD;
	
	static {
		
		Properties pro = new Properties();
		FileInputStream in;
		try
		{
			String filePath = Ftp4jFtpClient.class.getClassLoader().getResource("/").toURI().getPath() + "ftpserver.properties";
			in =  new FileInputStream(filePath);
			
			pro.load(in);
			
			ADDRESS = pro.getProperty("ftp_server_address");
			USERNAME = pro.getProperty("ftp_server_username");
			PASSWORD = pro.getProperty("ftp_server_password");
			
			in.close();
			
		}
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (URISyntaxException e)
		{
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 构造方法
	 */
	private Ftp4jFtpClient() {
	}
	
	/**
	 * 实例化对象
	 * 
	 * @return
	 */
	public static Ftp4jFtpClient getInstance() {
		if (ftp == null) {
			ftp = new Ftp4jFtpClient();
		}
		return ftp;
	}
	/**
	 * 获取FTP客户端对象
	 * 
	 * @return
	 * @throws Exception
	 */
	private FTPClient getClient() throws Exception {
		FTPClient client = new FTPClient();
		client.setCharset("utf-8");
		client.setType(FTPClient.TYPE_BINARY);
		URL url = new URL(Ftp4jFtpClient.ADDRESS);
		int port = url.getPort() < 1 ? 21 : url.getPort();
		
		client.connect(url.getHost(), port);
		client.login(Ftp4jFtpClient.USERNAME, Ftp4jFtpClient.PASSWORD);
		return client;
	}
	/**
	 * 注销客户端连接
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @throws Exception
	 */
	private void logout(FTPClient client) throws Exception {
		if (client != null) {
			try {
				// 有些FTP服务器未实现此功能，若未实现则会出错
				client.logout(); // 退出登录
			} catch (FTPException fe) {
			} catch (Exception e) {
				throw e;
			} finally {
				if (client.isConnected()) { // 断开连接
					client.disconnect(true);
				}
			}
		}
	}
	/**
	 * 创建目录
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param dir
	 *            目录
	 * @throws Exception
	 */
	private void mkdirs(FTPClient client, String dir) throws Exception {
		if (dir == null || dir=="") {
			return;
		}
		
		dir = dir.replace("//", "/");
		String[] dirs = dir.split("/");
		String path = "";
		for (int i = 0; i < dirs.length; i++) {
			path  +=  dirs[i] + "/";
			
			if (!isDirExist(client,path)) {
                client.createDirectory(path);// 创建目录
                client.changeDirectory(path);// 进入创建的目录
            }
		}
	}
	/**
	 * 获取FTP目录
	 * 
	 * @param url
	 *            原FTP目录
	 * @param dir
	 *            目录
	 * @return
	 * @throws Exception
	 */
	private URL getURL(URL url, String dir) throws Exception {
		String path = url.getPath();
		if (!path.endsWith("/") && !path.endsWith("//")) {
			path += "/";
		}
		dir = dir.replace("//", "/");
		if (dir.startsWith("/")) {
			dir = dir.substring(1);
		}
		path += dir;
		return new URL(url, path);
	}
	/**
	 * 获取FTP目录
	 * 
	 * @param dir
	 *            目录
	 * @return
	 * @throws Exception
	 */
	private URL getURL(String dir) throws Exception {
		return getURL(new URL(Ftp4jFtpClient.ADDRESS), dir);
	}
	/**
	 * 判断文件或目录是否存在
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param dir
	 *            文件或目录
	 * @return
	 * @throws Exception
	 */
	private boolean exists(FTPClient client, String dir) throws Exception {
		return getFileType(client, dir) != -1;
		
	}
	
	//检查目录是否存在
    private static boolean isDirExist(FTPClient client,String dir) {
        try {
            client.changeDirectory(dir);
        } catch (Exception e) {
            return false;
        }
        return true;
    }
	
	/**
	 * 判断当前为文件还是目录
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param dir
	 *            文件或目录
	 * @return -1、文件或目录不存在 0、文件 1、目录
	 * @throws Exception
	 */
	private int getFileType(FTPClient client, String dir) throws Exception {
		FTPFile[] files = null;
		try {
			files = client.list(dir);
			
		} catch (Exception e) {
			return -1;
		}
		if (files.length > 1) {
			return FTPFile.TYPE_DIRECTORY;
		} else if (files.length == 1) {
			FTPFile f = files[0];
			if (f.getType() == FTPFile.TYPE_DIRECTORY) {
				return FTPFile.TYPE_DIRECTORY;
			}
			String path = dir + "/" + f.getName();
			try {
				int len = client.list(path).length;
				if (len == 1) {
					return FTPFile.TYPE_DIRECTORY;
				} else {
					return FTPFile.TYPE_FILE;
				}
			} catch (Exception e) {
				return FTPFile.TYPE_FILE;
			}
		} else {
			try {
				client.changeDirectory(dir);
				client.changeDirectoryUp();
				return FTPFile.TYPE_DIRECTORY;
			} catch (Exception e) {
				return -1;
			}
		}
	}
	/**
	 * 上传文件或目录
	 * 
	 * @param dir
	 *            目标文件
	 * @param del
	 *            是否删除源文件，默认为false
	 * @param file
	 *            文件或目录对象数组
	 * @throws Exception
	 */
	public void upload(String dir, boolean del, File... files) throws Exception {
		if (StringUtils.isEmpty(dir) || files == null || files.length==0) {
			return;
		}
		FTPClient client = null;
		try {
			client = getClient();
			
			mkdirs(client, dir); // 创建文件夹
			
			for (File file : files) {
				if (file.isDirectory()) { // 上传目录
					uploadFolder(client, getURL(dir), file, del);
				} else {
					String current1 = client.currentDirectory();
					
					client.changeDirectory(dir);
					
					client.changeDirectory("/" + dir + "/");
					
					String current2 = client.currentDirectory();
					
					client.upload(file); // 上传文件
					if (del) { // 删除源文件
						file.delete();
					}
				}
			}
		} finally {
			logout(client);
		}
	}
	/**
	 * 上传文件或目录
	 * 
	 * @param dir
	 *            目标文件
	 * @param files
	 *            文件或目录对象数组
	 * @throws Exception
	 */
	public void upload(String dir, File... files) throws Exception {
		upload(dir, false, files);
	}
	/**
	 * 上传文件或目录
	 * 
	 * @param dir
	 *            目标文件
	 * @param del
	 *            是否删除源文件，默认为false
	 * @param path
	 *            文件或目录路径数组
	 * @throws Exception
	 */
	public void upload(String dir, boolean del, String... paths)
			throws Exception {
		if (dir==null || paths == null || paths.length ==0) {
			return;
		}
		File[] files = new File[paths.length];
		for (int i = 0; i < paths.length; i++) {
			files[i] = new File(paths[i]);
		}
		upload(dir, del, files);
	}
	/**
	 * 上传文件或目录
	 * 
	 * @param dir
	 *            目标文件
	 * @param paths
	 *            文件或目录路径数组
	 * @throws Exception
	 */
	public void upload(String dir, String... paths) throws Exception {
		upload(dir, false, paths);
	}
	/**
	 * 上传目录
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param parentUrl
	 *            父节点URL
	 * @param file
	 *            目录
	 * @throws Exception
	 */
	private void uploadFolder(FTPClient client, URL parentUrl, File file,
			boolean del) throws Exception {
		client.changeDirectory(parentUrl.getPath());
		String dir = file.getName(); // 当前目录名称
		URL url = getURL(parentUrl, dir);
		if (!exists(client, url.getPath())) { // 判断当前目录是否存在
			client.createDirectory(dir); // 创建目录
		}
		client.changeDirectory(dir);
		File[] files = file.listFiles(); // 获取当前文件夹所有文件及目录
		for (int i = 0; i < files.length; i++) {
			file = files[i];
			if (file.isDirectory()) { // 如果是目录，则递归上传
				uploadFolder(client, url, file, del);
			} else { // 如果是文件，直接上传
				client.changeDirectory(url.getPath());
				client.upload(file);
				if (del) { // 删除源文件
					file.delete();
				}
			}
		}
	}
	/**
	 * 删除文件或目录
	 * 
	 * @param dir
	 *            文件或目录数组
	 * @throws Exception
	 */
	public void delete(String... dirs) throws Exception {
		if (dirs == null || dirs.length ==0) {
			return;
		}
		FTPClient client = null;
		try {
			client = getClient();
			int type = -1;
			for (String dir : dirs) {
				client.changeDirectory("/"); // 切换至根目录
				type = getFileType(client, dir); // 获取当前类型
				if (type == 0) { // 删除文件
					client.deleteFile(dir);
				} else if (type == 1) { // 删除目录
					deleteFolder(client, getURL(dir));
				}
			}
		} finally {
			logout(client);
		}
	}
	/**
	 * 删除目录
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param url
	 *            FTP URL
	 * @throws Exception
	 */
	private void deleteFolder(FTPClient client, URL url) throws Exception {
		String path = url.getPath();
		client.changeDirectory(path);
		FTPFile[] files = client.list();
		String name = null;
		for (FTPFile file : files) {
			name = file.getName();
			// 排除隐藏目录
			if (".".equals(name) || "..".equals(name)) {
				continue;
			}
			if (file.getType() == FTPFile.TYPE_DIRECTORY) { // 递归删除子目录
				deleteFolder(client, getURL(url, file.getName()));
			} else if (file.getType() == FTPFile.TYPE_FILE) { // 删除文件
				client.deleteFile(file.getName());
			}
		}
		client.changeDirectoryUp();
		client.deleteDirectory(url.getPath()); // 删除当前目录
	}
	/**
	 * 下载文件或目录
	 * 
	 * @param localDir
	 *            本地存储目录
	 * @param dirs
	 *            文件或者目录
	 * @throws Exception
	 */
	public void download(String localDir, String... dirs) throws Exception {
		if (dirs==null ||dirs.length ==0) {
			return;
		}
		FTPClient client = null;
		try {
			client = getClient();
			File folder = new File(localDir);
			if (!folder.exists()) { // 如果本地文件夹不存在，则创建
				folder.mkdirs();
			}
			int type = -1;
			String localPath = null;
			for (String dir : dirs) {
				client.changeDirectory("/"); // 切换至根目录
				type = getFileType(client, dir); // 获取当前类型
				if (type == 0) { // 文件
					localPath = localDir + "/" + new File(dir).getName();
					client.download(dir, new File(localPath));
				} else if (type == 1) { // 目录
					downloadFolder(client, getURL(dir), localDir);
				}
			}
		} finally {
			logout(client);
		}
	}
	/**
	 * 下载文件夹
	 * 
	 * @param client
	 *            FTP客户端对象
	 * @param url
	 *            FTP URL
	 * @param localDir
	 *            本地存储目录
	 * @throws Exception
	 */
	private void downloadFolder(FTPClient client, URL url, String localDir)
			throws Exception {
		String path = url.getPath();
		client.changeDirectory(path);
		// 在本地创建当前下载的文件夹
		File folder = new File(localDir + "/" + new File(path).getName());
		if (!folder.exists()) {
			folder.mkdirs();
		}
		localDir = folder.getAbsolutePath();
		FTPFile[] files = client.list();
		String name = null;
		for (FTPFile file : files) {
			name = file.getName();
			// 排除隐藏目录
			if (".".equals(name) || "..".equals(name)) {
				continue;
			}
			if (file.getType() == FTPFile.TYPE_DIRECTORY) { // 递归下载子目录
				downloadFolder(client, getURL(url, file.getName()), localDir);
			} else if (file.getType() == FTPFile.TYPE_FILE) { // 下载文件
				client.download(name, new File(localDir + "/" + name));
			}
		}
		client.changeDirectoryUp();
	}
	/**
	 * 获取目录下所有文件
	 * 
	 * @param dir
	 *            目录
	 * @return
	 * @throws Exception
	 */
	public String[] list(String dir) throws Exception {
		FTPClient client = null;
		try {
			client = getClient();
			client.changeDirectory(dir);
			String[] values = client.listNames();
			if (values != null) {
				// 将文件排序(忽略大小写)
				Arrays.sort(values, new Comparator<String>(){
					public int compare(String val1, String val2) {
						return val1.compareToIgnoreCase(val2);
					}
				});
			}
			return values;
		} catch(FTPException fe) {
			// 忽略文件夹不存在的情况
			String mark = "code=550";
			if (fe.toString().indexOf(mark) == -1) {
				throw fe;
			}
		} finally {
			logout(client);
		}
		return new String[0];
	}
	
	
	
}