Commons-net FTPClient上传下载的封装

        在项目中使用到FTP功能,于是采用类似Spring的各种回调机制公用各种代码,减少代码的开发量,简化开发人员的学习难度.本文仅供学习交流使用,如有比较好的意见希望可以一起交流,再次表示感谢.

package easyway.tbs.transfer.ftp;

import java.io.IOException;

import org.apache.commons.net.ftp.FTPClient;
/**
 * FTPCLient回调
 * @author longgangabai
 *
 * @param <T>
 */
public interface FTPClientCallback<T> {
	
	public T doTransfer(FTPClient ftp)throws IOException;

}

 

 

package easyway.tbs.transfer.ftp;

import java.io.IOException;
import java.util.Collection;

import org.apache.commons.net.ftp.FTPFile;

/**
 * FTP操作的客户端操作上传下载
 * @author longgangbai
 *
 */
public interface FTPClientOperations {
	/**
	 * 文件上传的方法
	 * @param remote
	 * @param local
	 * @return
	 * @throws IOException
	 */
	public UploadStatus upload(String remote, String local) throws IOException;
	

	 /**
	  * 
	  * 从远程服务器目录下载文件到本地服务器目录中
	  * @param localdir FTP服务器保存目录
	  * @param remotedir FTP下载服务器目录
	  * @param localTempFile临时下载记录文件
	  * @return 成功返回true，否则返回false
	  */
	public Collection<String> downloadList(final String localdir, final String remotedir,final String localTmpFile) throws IOException;

	/**
	 * 文件下载的方法
	 * @param remote
	 * @param local
	 * @return
	 * @throws IOException
	 */
	public DownloadStatus downloadFile( String local,String remote) throws IOException;
	
	/**
	 * 查看服务器上文件列表方法
	 * @param remotedir
	 * @return
	 * @throws IOException
	 */
	public FTPFile[] list(final String remotedir) throws IOException;
}

 

 

package easyway.tbs.transfer.ftp;

import java.io.File;
import java.io.IOException;
import java.net.ConnectException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.log4j.Logger;

import easyway.tbs.commons.FileOperateUtils;
/**
 * Ftp回调模板
 * 
 * @author longgangbai
 *
 */
public class FTPClientTemplate implements FTPClientOperations{
	private static final Logger logger = Logger.getLogger(FTPClientTemplate.class);

	private static String DEAFULT_REMOTE_CHARSET="UTF-8";
	private static int DEAFULT_REMOTE_PORT=21;
	private static String separator = File.separator;
	private FTPClientConfig ftpClientConfig;
	private String host;
	private String username;
	private String password;
	private String port;
	
	public FTPClientTemplate(String host,String user,String pwd,String port){
		this.host=host;
		this.username=user;
		this.password=pwd;
		this.port=port;
	}
	/**
	 * 查看服务器上文件列表方法
	 * @param remotedir
	 * @return
	 * @throws IOException
	 */
	public FTPFile[] list(final String remotedir) throws IOException{
	   return	execute(new FTPClientCallback<FTPFile[]>(){
		public FTPFile[] doTransfer(FTPClient ftp) throws IOException {
			 ftp.changeWorkingDirectory(remotedir);
			 FTPFile[] files= ftp.listFiles(remotedir);
			return files;
		}
		});
	}
	/**
	 * 文件上传的方法
	 * @param remote
	 * @param local
	 * @return
	 * @throws IOException
	 */
	public UploadStatus upload(final String local,final  String remote) throws IOException{
		return   execute(new FTPClientCallback<UploadStatus>(){
			public UploadStatus doTransfer(FTPClient ftpClient)throws IOException {
				return FtpHelper.getInstance().upload(ftpClient, local, remote);
			}
		});
	}
	
	/**
	 * 上传文件到服务器,新上传和断点续传
	 * @param remoteFile  远程文件名，在上传之前已经将服务器工作目录做了改变
	 * @param localFile   本地文件File句柄，绝对路径
	 * @param processStep  需要显示的处理进度步进值
	 * @param ftpClient  FTPClient引用
	 * @return
	 * @throws IOException
	 */
	public UploadStatus uploadFile(String remoteFile, File localFile,
	FTPClient ftpClient, long remoteSize) throws IOException {
		 return FtpHelper.getInstance().uploadFile(remoteFile, localFile, ftpClient, remoteSize);
	}

	
	 /**
	  * 从远程服务器目录下载文件到本地服务器目录中
	  * @param localdir FTP服务器保存目录
	  * @param remotedir FTP下载服务器目录
	  * @param localTempFile临时下载记录文件
	  * @return  成功下载记录
	  */
	public Collection<String> downloadList(final String localdir, final String remotedir,final String localTmpFile) throws IOException {
		return execute(new FTPClientCallback<Collection<String>>(){
			public Collection<String> doTransfer(final FTPClient ftp) throws IOException {
				//切换到下载目录的中
				ftp.changeWorkingDirectory(remotedir);
				//获取目录中所有的文件信息
				FTPFile[] ftpfiles=ftp.listFiles();
				Collection<String> fileNamesCol=new ArrayList<String>();
				//判断文件目录是否为空
				if(!ArrayUtils.isEmpty(ftpfiles)){
					for (FTPFile ftpfile : ftpfiles) {
						String remoteFilePath=remotedir+separator+ftpfile.getName();
						String localFilePath=localdir+separator+ftpfile.getName();
						System.out.println("remoteFilePath ="+remoteFilePath +" localFilePath="+localFilePath);
						//单个文件下载状态
						DownloadStatus downStatus=downloadFile(remoteFilePath, localFilePath);
						if(downStatus==DownloadStatus.Download_New_Success){
							//临时目录中添加记录信息
							fileNamesCol.add(remoteFilePath);
						}
					}
				}
				if(CollectionUtils.isNotEmpty(fileNamesCol)){
					FileOperateUtils.writeLinesToFile(fileNamesCol, localTmpFile);
				}
				return  fileNamesCol;
			}
		});
	}
	
	/**
	 * 从FTP服务器上下载文件,支持断点续传，上传百分比汇报
	 * @param remote  远程文件路径
	 * @param local 本地文件路径
	 * @return 上传的状态
	 * @throws IOException
	 * 
	 */
	public DownloadStatus downloadFile(final String remote, final String local) throws IOException{
		return   execute(new FTPClientCallback<DownloadStatus>(){
			public DownloadStatus doTransfer(FTPClient ftpClient) throws IOException {
				DownloadStatus result=FtpHelper.getInstance().download(ftpClient, remote, local);
				return result;
			}
		});
	}
	/**
	 * 执行FTP回调操作的方法
	 * @param callback   回调的函数
	 * @throws IOException
	 */
	public <T> T  execute(FTPClientCallback<T> callback) throws IOException{
		FTPClient ftp=new FTPClient();
		try {
				
			/*if(getFtpClientConfig()!=null){
				 ftp.configure(getFtpClientConfig());
				 ftpClientConfig.setServerTimeZoneId(TimeZone.getDefault().getID());
			}*/
			//登录FTP服务器
		    try {
                //设置超时时间  
		    	ftp.setDataTimeout(7200);
		    	//设置默认编码
		    	 ftp.setControlEncoding(DEAFULT_REMOTE_CHARSET);
		    	//设置默认端口
		    	ftp.setDefaultPort(DEAFULT_REMOTE_PORT);
		    	//设置是否显示隐藏文件
		    	ftp.setListHiddenFiles(false);
		    	//连接ftp服务器
		    	if(StringUtils.isNotEmpty(port)&&NumberUtils.isDigits(port)){
		    			ftp.connect(host, Integer.valueOf(port));
		    	}else{
		    		ftp.connect(host);
		    	}
	        } catch(ConnectException e) {
	        	logger.error("连接FTP服务器失败："+ftp.getReplyString()+ftp.getReplyCode());
	            throw new IOException("Problem connecting the FTP-server fail",e);
	        }
	        //得到连接的返回编码
			int reply=ftp.getReplyCode();
			
			if(!FTPReply.isPositiveCompletion(reply)){
				ftp.disconnect();
			}
			//登录失败权限验证失败
	        if(!ftp.login(getUsername(), getPassword())) {
	            ftp.quit();
	            ftp.disconnect();
	        	logger.error("连接FTP服务器用户或者密码失败：："+ftp.getReplyString());
	            throw new IOException("Cant Authentificate to FTP-Server");
	        }
	        if(logger.isDebugEnabled()){
	        	logger.info("成功登录FTP服务器："+host+" 端口："+port);
	        }
	        ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			//回调FTP的操作
			return callback.doTransfer(ftp);
		}finally{
			//FTP退出
			ftp.logout();
			//断开FTP连接
			if(ftp.isConnected()){
				ftp.disconnect();
			}
		}
	}
	
	  protected String resolveFile(String file)
	  {
		  return null;
	    //return file.replace(System.getProperty("file.separator").charAt(0), this.remoteFileSep.charAt(0));
	  }
	
	/**
	 * 获取FTP的配置操作系统
	 * @return
	 */
	public FTPClientConfig getFtpClientConfig() {
		 //获得系统属性集  
		Properties props=System.getProperties();
		//操作系统名称
		String osname=props.getProperty("os.name");  
		//针对window系统
		if(osname.equalsIgnoreCase("Windows XP")){
			ftpClientConfig=new FTPClientConfig(FTPClientConfig.SYST_NT);
		//针对linux系统
		}else if(osname.equalsIgnoreCase("Linux")){
			ftpClientConfig=new FTPClientConfig(FTPClientConfig.SYST_UNIX);
		}
		if(logger.isDebugEnabled()){
			logger.info("the ftp client system os Name "+osname);
		}
		return ftpClientConfig;
	}
    
	

	public String getHost() {
		return host;
	}

	public void setHost(String host) {
		this.host = host;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	
	

}

 

 

package easyway.tbs.transfer.ftp;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.StringTokenizer;

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;
/**
 * FTP下载工具类
 * @author longgangbai
 *
 */
public class FtpHelper {
	private static String DEAFULT_REMOTE_CHARSET="GBK";
	private static String DEAFULT_LOCAL_CHARSET="iso-8859-1";


	
	private static FtpHelper instance=new FtpHelper();
	
	public static FtpHelper getInstance(){
		 return instance;
	}
	/**
	 * 连接到FTP服务器
	 * @param hostname主机名
	 * @param port 端口
	 * @param username 用户名
	 * @param password 密码
	 * @return 是否连接成功
	 * @throws IOException
	 */
	public  boolean connect(FTPClient ftpClient,String hostname, int port, String username,String password) throws IOException {
		ftpClient.connect(hostname, port);
		ftpClient.setControlEncoding(DEAFULT_REMOTE_CHARSET);
		if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
			if (ftpClient.login(username, password)) {
				return true;
			}
		}
		disconnect(ftpClient);
		return false;
	}

	/**
	 * 从FTP服务器上下载文件,支持断点续传，上传百分比汇报
	 * @param remoteFilePath  远程文件路径
	 * @param localFilePath 本地文件路径
	 * @return 上传的状态
	 * @throws IOException
	 */
	public DownloadStatus download(FTPClient ftpClient,String remoteFilePath, String localFilePath)
	throws IOException {
		// 设置被动模式
		ftpClient.enterLocalPassiveMode();
		// 设置以二进制方式传输
		ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
		DownloadStatus result;
		// 检查远程文件是否存在
		FTPFile[] files = ftpClient.listFiles(new String(
		remoteFilePath.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET));
		if (files.length != 1) {
			System.out.println("远程文件不存在");
			return DownloadStatus.Remote_File_Noexist;
		}
		long lRemoteSize = files[0].getSize();
		File f = new File(localFilePath);
		// 本地存在文件，进行断点下载
		if (f.exists()) {
			long localSize = f.length();
			// 判断本地文件大小是否大于远程文件大小
			if (localSize >= lRemoteSize) {
				System.out.println("本地文件大于远程文件，下载中止");
				return DownloadStatus.Local_Bigger_Remote;
			}
			// 进行断点续传，并记录状态
			FileOutputStream out = new FileOutputStream(f, true);
			ftpClient.setRestartOffset(localSize);
			InputStream in = ftpClient.retrieveFileStream(new String(remoteFilePath
			.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET));
			byte[] bytes = new byte[1024];
			long step = lRemoteSize / 100;
			long process = localSize / step;
			int c;
			while ((c = in.read(bytes)) != -1) {
				out.write(bytes, 0, c);
				localSize += c;
				long nowProcess = localSize / step;
				if (nowProcess > process) {
					process = nowProcess;
					if (process % 10 == 0){
						System.out.println("下载进度：" + process);
					}
					// TODO 更新文件下载进度,值存放在process变量中
				}
			}
			in.close();
			out.close();
			boolean isDo = ftpClient.completePendingCommand();
			if (isDo) {
				result = DownloadStatus.Download_From_Break_Success;
			} else {
				result = DownloadStatus.Download_From_Break_Failed;
			}
		} else {
			OutputStream out = new FileOutputStream(f);
			InputStream in = ftpClient.retrieveFileStream(new String(remoteFilePath
			.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET));
			byte[] bytes = new byte[1024];
			long step = lRemoteSize / 100;
			long process = 0;
			long localSize = 0L;
			int c;
			while ((c = in.read(bytes)) != -1) {
				out.write(bytes, 0, c);
				localSize += c;
				long nowProcess = localSize / step;
				if (nowProcess > process) {
					process = nowProcess;
					if (process % 10 == 0){
						System.out.println("下载进度：" + process);
					}
					// TODO 更新文件下载进度,值存放在process变量中
				}
			}
			in.close();
			out.close();
			boolean upNewStatus = ftpClient.completePendingCommand();
			if (upNewStatus) {
				result = DownloadStatus.Download_New_Success;
			} else {
				result = DownloadStatus.Download_New_Failed;
			}
		}
		return result;
	}
	/**
	 * 
	 * 上传文件到FTP服务器，支持断点续传
	 * @param localFilePath  本地文件名称，绝对路径
	 * @param remoteFilePath   远程文件路径，使用/home/directory1/subdirectory/file.ext
	 * 按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
	 * @return 上传结果
	 * @throws IOException
	 */
	public UploadStatus upload(FTPClient ftpClient,String localFilePath, String remoteFilePath) throws IOException {
		// 设置PassiveMode传输
		ftpClient.enterLocalPassiveMode();
		// 设置以二进制流的方式传输
		ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
		ftpClient.setControlEncoding(DEAFULT_REMOTE_CHARSET);
		UploadStatus result;
		// 对远程目录的处理
		String remoteFileName = remoteFilePath;
		if (remoteFilePath.contains("/")) {
			remoteFileName = remoteFilePath.substring(remoteFilePath.lastIndexOf("/") + 1);
			// 创建服务器远程目录结构，创建失败直接返回
			if (createDirecroty(remoteFilePath, ftpClient) == UploadStatus.Create_Directory_Fail) {
				return UploadStatus.Create_Directory_Fail;
			}
		}
		// ftpClient.feat();
		// System.out.println( ftpClient.getReply());
		// System.out.println( ftpClient.acct(null));
		// System.out.println(ftpClient.getReplyCode());
		// System.out.println(ftpClient.getReplyString());
		// 检查远程是否存在文件
		FTPFile[] files = ftpClient.listFiles(new String(remoteFileName
		.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET));
		if (files.length == 1) {
			long remoteSize = files[0].getSize();
			File f = new File(localFilePath);
			long localSize = f.length();
			if (remoteSize == localSize) { // 文件存在
				return UploadStatus.File_Exits;
			} else if (remoteSize > localSize) {
				return UploadStatus.Remote_Bigger_Local;
			}
			// 尝试移动文件内读取指针,实现断点续传
			result = uploadFile(remoteFileName, f, ftpClient, remoteSize);
			// 如果断点续传没有成功，则删除服务器上文件，重新上传
			if (result == UploadStatus.Upload_From_Break_Failed) {
				if (!ftpClient.deleteFile(remoteFileName)) {
					return UploadStatus.Delete_Remote_Faild;
				}
				result = uploadFile(remoteFileName, f, ftpClient, 0);
			}
		} else {
			result = uploadFile(remoteFileName, new File(localFilePath), ftpClient, 0);
		}
		return result;
	}
	/**
	 * 
	 * 断开与远程服务器的连接
	 * @throws IOException
	 */
	public void disconnect(FTPClient ftpClient) throws IOException {
		if (ftpClient.isConnected()) {
			ftpClient.disconnect();
		}
	}
	/**
	 * 递归创建远程服务器目录
	 * @param remote 远程服务器文件绝对路径
	 * @param ftpClient  FTPClient对象
	 * @return 目录创建是否成功
	 * @throws IOException
	 */
	public UploadStatus createDirecroty(String remote, FTPClient ftpClient)
	throws IOException {
		UploadStatus status = UploadStatus.Create_Directory_Success;
		String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
		if (!directory.equalsIgnoreCase("/")
		&& !ftpClient.changeWorkingDirectory(new String(directory
		.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET))) {
			// 如果远程目录不存在，则递归创建远程服务器目录
			int start = 0;
			int end = 0;
			if (directory.startsWith("/")) {
				start = 1;
			} else {
				start = 0;
			}
			end = directory.indexOf("/", start);
			while (true) {
				String subDirectory = new String(remote.substring(start, end)
				.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET);
				if (!ftpClient.changeWorkingDirectory(subDirectory)) {
					if (ftpClient.makeDirectory(subDirectory)) {
						ftpClient.changeWorkingDirectory(subDirectory);
					} else {
						System.out.println("创建目录失败");
						return UploadStatus.Create_Directory_Fail;
					}
				}
				start = end + 1;
				end = directory.indexOf("/", start);
				// 检查所有目录是否创建完毕
				if (end <= start) {
					break;
				}
			}
		}
		return status;
	}

	/**
	 * 上传文件到服务器,新上传和断点续传
	 * @param remoteFile  远程文件名，在上传之前已经将服务器工作目录做了改变
	 * @param localFile   本地文件File句柄，绝对路径
	 * @param processStep  需要显示的处理进度步进值
	 * @param ftpClient  FTPClient引用
	 * @return
	 * @throws IOException
	 */
	public UploadStatus uploadFile(String remoteFile, File localFile,
	FTPClient ftpClient, long remoteSize) throws IOException {
		UploadStatus status;
		// 显示进度的上传
		long step = localFile.length() / 100;
		long process = 0;
		long localreadbytes = 0L;
		RandomAccessFile raf = new RandomAccessFile(localFile, "r");
		String remote = new String(remoteFile.getBytes(DEAFULT_REMOTE_CHARSET), DEAFULT_LOCAL_CHARSET);
		OutputStream out = ftpClient.appendFileStream(remote);
		if (out == null)
		{
			String message = ftpClient.getReplyString();
			throw new RuntimeException(message);
		}
		// 断点续传
		if (remoteSize > 0) {
			ftpClient.setRestartOffset(remoteSize);
			process = remoteSize / step;
			raf.seek(remoteSize);
			localreadbytes = remoteSize;
		}
		byte[] bytes = new byte[1024];
		int c;
		while ((c = raf.read(bytes)) != -1) {
			out.write(bytes, 0, c);
			localreadbytes += c;
			if (localreadbytes / step != process) {
				process = localreadbytes / step;
				System.out.println("上传进度:" + process);
				// TODO 汇报上传状态
			}
		}
		out.flush();
		raf.close();
		out.close();
		boolean result = ftpClient.completePendingCommand();
		if (remoteSize > 0) {
			status = result ? UploadStatus.Upload_From_Break_Success
			: UploadStatus.Upload_From_Break_Failed;
		} else {
			status = result ? UploadStatus.Upload_New_File_Success
			: UploadStatus.Upload_New_File_Failed;
		}
		return status;
	}
	
	
	 protected void makeRemoteDir(FTPClient ftp, String dir)
	    throws IOException
	  {
	    String workingDirectory = ftp.printWorkingDirectory();
	    if (dir.indexOf("/") == 0) {
	      ftp.changeWorkingDirectory("/");
	    }
	    String subdir = new String();
	    StringTokenizer st = new StringTokenizer(dir, "/");
	    while (st.hasMoreTokens()) {
	      subdir = st.nextToken();
	      if (!(ftp.changeWorkingDirectory(subdir))) {
	        if (!(ftp.makeDirectory(subdir)))
	        {
	          int rc = ftp.getReplyCode();
	          if (((rc != 550) && (rc != 553) && (rc != 521)))
	          {
	            throw new IOException("could not create directory: " + ftp.getReplyString());
	          }
	        }
	        else {
	          ftp.changeWorkingDirectory(subdir);
	        }
	      }
	    }
	    if (workingDirectory != null){
	      ftp.changeWorkingDirectory(workingDirectory);
	    }
	  }

	
	
	
	
	
	
	
	
	/**
	 * 获取指定目录下的文件名称列表
	 * @param currentDir
	 *            需要获取其子目录的当前目录名称
	 * @return 返回子目录字符串数组
	 */
	public String[] GetFileNames(FTPClient ftpClient,String currentDir) {
		String[] dirs = null;
		try {
			if (currentDir == null)
				dirs = ftpClient.listNames();
			else
				dirs = ftpClient.listNames(currentDir);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return dirs;
	}

	/**
	 * 获取指定目录下的文件与目录信息集合
	 * @param currentDir
	 *            指定的当前目录
	 * @return 返回的文件集合
	 */
	public FTPFile[] GetDirAndFilesInfo(FTPClient ftpClient,String currentDir)
	{
		FTPFile[] files = null;
		try
		{
			if (currentDir == null)
				files = ftpClient.listFiles();
			else
				files = ftpClient.listFiles(currentDir);
		}
		catch (IOException ex)
		{
			ex.printStackTrace();
		}
		return files;
	}
}

 

 

 

package easyway.tbs.transfer.ftp;

import easyway.tbs.commons.EnumUtils;

/**
 * 文件下载状态
 * @author longgangbai
 *
 */
public enum DownloadStatus {
	   
		Remote_File_Noexist(0,"远程文件不存在"), // 远程文件不存在 
	    //用于单个下载
		Download_New_Success(1,"下载文件成功"), // 下载文件成功
		Download_New_Failed(2,"下载文件失败"), // 下载文件失败
		Local_Bigger_Remote(3,"本地文件大于远程文件"), // 本地文件大于远程文件
		Download_From_Break_Success(4,"文件断点续传成功"), // 断点续传成功
		Download_From_Break_Failed(5,"文件断点续传失败"), // 断点续传失败
		//用于批量下载
		Download_Batch_Success(6,"文件批量下载成功"),
		Download_Batch_Failure(7,"文件批量下载失败"),
		Download_Batch_Failure_SUCCESS(8,"文件批量下载不完全成功");
	
	 	private int code;
	    
	    private String description;
	    
	    
	    private DownloadStatus(int code , String description) {
	    	this.code = code;
	    	this.description = description;
	    }

		public int getCode() {
			return code;
		}

		public void setCode(int code) {
			this.code = code;
		}

		public String getDescription() {
			return description;
		}

		public void setDescription(String description) {
			this.description = description;
		}
	    
	    /**
	     * 下载状态中中使用的code
	     * @param code
	     * @return
	     */
		public static DownloadStatus fromCode(int code) {
			return EnumUtils.fromEnumProperty(DownloadStatus.class, "code", code);
		}
	}

 

 

 

package easyway.tbs.transfer.ftp;

import easyway.tbs.commons.EnumUtils;

/**
 * 文件上传状态
 * @author longgangbai
 *
 */
public enum UploadStatus {
	Create_Directory_Fail(0,"远程服务器相应目录创建失败"), // 远程服务器相应目录创建失败
	Create_Directory_Success(1,"远程服务器闯将目录成功"), // 远程服务器闯将目录成功
	Upload_New_File_Success(2,"上传新文件成功"), // 上传新文件成功
	Upload_New_File_Failed(3,"上传新文件失败"), // 上传新文件失败
	File_Exits(4,"文件已经存在"), // 文件已经存在
	Remote_Bigger_Local(5,"远程文件大于本地文件"), // 远程文件大于本地文件
	Upload_From_Break_Success(6," 断点续传成功"), // 断点续传成功
	Upload_From_Break_Failed(7,"断点续传失败"), // 断点续传失败
	Delete_Remote_Faild(8,"删除远程文件失败"); // 删除远程文件失败
	
	private int code;
    
    private String description;
    
    
    private UploadStatus(int code , String description) {
    	this.code = code;
    	this.description = description;
    }

	public int getCode() {
		return code;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}
    
    /**
     * 下载状态中中使用的code
     * @param code
     * @return
     */
	public static UploadStatus fromCode(int code) {
		return EnumUtils.fromEnumProperty(UploadStatus.class, "code", code);
	}
}

 

package easyway.tbs.commons;

import org.apache.commons.lang.ObjectUtils;
import org.apache.log4j.Logger;

/**
 * 枚举的工具类
 * @author longgangbai
 *
 */
public abstract class EnumUtils {
	private static final Logger logger = Logger.getLogger(EnumUtils.class);

		/**
	 * 从指定的枚举类中根据property搜寻匹配指定值的枚举实例
	 * @param <T>
	 * @param enumClass
	 * @param property
	 * @param propValue
	 * @return
	 */
	public static <T extends Enum<T>> T fromEnumProperty(Class<T> enumClass, String property, Object propValue) {
		T[] enumConstants = enumClass.getEnumConstants();
		for (T t : enumConstants) {
			Object constantPropValue;
			try {
				constantPropValue = BeanUtils.getDeclaredFieldValue(t, property);
				if (ObjectUtils.equals(constantPropValue, propValue)) {
					return t;
				}
			} catch (Exception e) {
				logger.error(e.getMessage());
				throw new RuntimeException(e);
			}
		}
		return null;
	}

	/**
	 * 从指定的枚举类中根据名称匹配指定值
	 * @param <T>
	 * @param enumClass
	 * @param constantName
	 * @return
	 */
    public static <T extends Enum<T>> T fromEnumConstantName(Class<T> enumClass, String constantName) {
        T[] enumConstants = enumClass.getEnumConstants();
        for (T t : enumConstants) {
            if (((Enum<?>) t).name().equals(constantName)) {
                return t;
            }
        }
        return null;
    }
	
}

 

 

package easyway.tbs.commons;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Collection;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.filefilter.FalseFileFilter;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.log4j.Logger;
/**
 * 文件操作工具类
 * 
 * @author longgangbai
 * 
 */
public class FileOperateUtils {
	
	private static final Logger logger = Logger.getLogger(FileOperateUtils.class);	
    /**
     * 查找需要合并文件的临时文件信息 
     * 
     * @param directory
     * 			临时文件所在的目录
     * @param prefix
     * 			临时文件的前缀
     * @param caseSensitivity
     * 			临时文件的大小写敏感
     * @return
     */
	public static Collection<File> searchPrefixFile(File directory,String prefix,boolean caseSensitivity){
		IOCase iocase=IOCase.INSENSITIVE;
		if(caseSensitivity){
			 iocase=IOCase.SENSITIVE;
		}
		//创建相关的过滤器
		IOFileFilter fileFilter=FileFilterUtils.prefixFileFilter(prefix, iocase);
		//检查相关的过滤信息
		return FileUtils.listFiles(directory, fileFilter, FalseFileFilter.INSTANCE);
	}
	
	/**
	 *  查找目录下特定后缀的文件
	 * @param directory    
	 * 		 特定的目录
	 * @param extensions
	 * 		临时文件的后缀扩展
	 * @param recursive
	 * 		是否查询临时文件所在的目录下的子目录
	 * @return
	 */
	public static Collection<File> searchExtensionFile(File directory,String[] extensions,boolean recursive){
		return FileUtils.listFiles(directory, extensions, recursive);
	}
	/**
	 * 文件追加功能
	 * @param lines
	 * @param tmpFilePath
	 */
	public static void writeLinesToFile(Collection<String> lines,String tmpFilePath){
		OutputStream output=null;
		try {
			output = new FileOutputStream(tmpFilePath,true);
			IOUtils.writeLines(lines, "UTF-8", output);
		} catch (Exception e) {
			logger.error(tmpFilePath+"追加文件失败"+e.getMessage());
		}
		
	}
}

 

评论

5 楼 fym548 2014-11-14  

下载乱码需要怎么做？

4 楼 fym548 2014-11-14  

上传中文乱码怎么处理？

3 楼 yuaihui 2013-11-08  

FileOperateUtils、EnumUtils求同

2 楼 longgangbai 2012-11-19  

FileOperateUtils、EnumUtils怎么都没有？这两个类自己封装的两个工具类.已经在下边代码中添加,请知悉!

1 楼 yangkai 2012-11-16  

FileOperateUtils、EnumUtils怎么都没有？
能否提供一份打包的源代码呀，谢谢！！！
[e-mail]