Java 实现 FTP 服务

逃离我推掉我的手 2022-02-14 06:51 270阅读 0赞

1、FTP简介  
FTP 是File Transfer Protocol（文件传输协议）的英文简称，而中文简称为“文传协议”。用于Internet上的控制文件的双向传输。同时，它也是一个应用程序（Application）。基于不同的操作系统有不同的FTP应用程序，而所有这些应用程序都遵守同一种协议以传输文件。在FTP的使用当中，用户经常遇到两个概念：“下载”（Download）和"上传"（Upload）。"下载"文件就是从远程主机拷贝文件至自己的计算机上；"上传"文件就是将文件从自己的计算机中拷贝至远程主机上。用Internet语言来说，用户可通过客户机程序向（从）远程主机上传（下载）文件。

实现FTP文件上传与下载的两种方式：

*  1、通过JDK自带的API实现
 *  2、通过Apache提供的API实现

**代码如下：**

package com.cloudpower.util;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import sun.net.TelnetInputStream;
    import sun.net.TelnetOutputStream;
    import sun.net.ftp.FtpClient;
    
    /** * Java自带的API对FTP的操作 * * @Title:Ftp.java * @author: 周玲斌 */
    public class Ftp { 
    	/** * 本地文件名 */
    	private String localfilename;
    	/** * 远程文件名 */
    	private String remotefilename;
    	/** * FTP客户端 */
    	private FtpClient ftpClient;
    
    	/** * 服务器连接 * * @param ip * 服务器IP * @param port * 服务器端口 * @param user * 用户名 * @param password * 密码 * @param path * 服务器路径 * @author 周玲斌 * @date 2012-7-11 */
    	public void connectServer(String ip, int port, String user,
    			String password, String path) { 
    		try { 
    			/* ******连接服务器的两种方法****** */
    			// 第一种方法
    			// ftpClient = new FtpClient();
    			// ftpClient.openServer(ip, port);
    			// 第二种方法
    			ftpClient = new FtpClient(ip);
    
    			ftpClient.login(user, password);
    			// 设置成2进制传输
    			ftpClient.binary();
    			System.out.println("login success!");
    			if (path.length() != 0) { 
    				// 把远程系统上的目录切换到参数path所指定的目录
    				ftpClient.cd(path);
    			}
    			ftpClient.binary();
    		} catch (IOException ex) { 
    			ex.printStackTrace();
    			throw new RuntimeException(ex);
    		}
    	}
    
    	/** * 关闭连接 * * @author 周玲斌 * @date 2012-7-11 */
    	public void closeConnect() { 
    		try { 
    			ftpClient.closeServer();
    			System.out.println("disconnect success");
    		} catch (IOException ex) { 
    			System.out.println("not disconnect");
    			ex.printStackTrace();
    			throw new RuntimeException(ex);
    		}
    	}
    
    	/** * 上传文件 * * @param localFile * 本地文件 * @param remoteFile * 远程文件 * @author 周玲斌 * @date 2012-7-11 */
    	public void upload(String localFile, String remoteFile) { 
    		this.localfilename = localFile;
    		this.remotefilename = remoteFile;
    		TelnetOutputStream os = null;
    		FileInputStream is = null;
    		try { 
    			// 将远程文件加入输出流中
    			os = ftpClient.put(this.remotefilename);
    			// 获取本地文件的输入流
    			File file_in = new File(this.localfilename);
    			is = new FileInputStream(file_in);
    			// 创建一个缓冲区
    			byte[] bytes = new byte[1024];
    			int c;
    			while ((c = is.read(bytes)) != -1) { 
    				os.write(bytes, 0, c);
    			}
    			System.out.println("upload success");
    		} catch (IOException ex) { 
    			System.out.println("not upload");
    			ex.printStackTrace();
    			throw new RuntimeException(ex);
    		} finally { 
    			try { 
    				if (is != null) { 
    					is.close();
    				}
    			} catch (IOException e) { 
    				e.printStackTrace();
    			} finally { 
    				try { 
    					if (os != null) { 
    						os.close();
    					}
    				} catch (IOException e) { 
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	/** * 下载文件 * * @param remoteFile * 远程文件路径(服务器端) * @param localFile * 本地文件路径(客户端) * @author 周玲斌 * @date 2012-7-11 */
    	public void download(String remoteFile, String localFile) { 
    		TelnetInputStream is = null;
    		FileOutputStream os = null;
    		try { 
    			// 获取远程机器上的文件filename，借助TelnetInputStream把该文件传送到本地。
    			is = ftpClient.get(remoteFile);
    			File file_in = new File(localFile);
    			os = new FileOutputStream(file_in);
    			byte[] bytes = new byte[1024];
    			int c;
    			while ((c = is.read(bytes)) != -1) { 
    				os.write(bytes, 0, c);
    			}
    			System.out.println("download success");
    		} catch (IOException ex) { 
    			System.out.println("not download");
    			ex.printStackTrace();
    			throw new RuntimeException(ex);
    		} finally { 
    			try { 
    				if (is != null) { 
    					is.close();
    				}
    			} catch (IOException e) { 
    				e.printStackTrace();
    			} finally { 
    				try { 
    					if (os != null) { 
    						os.close();
    					}
    				} catch (IOException e) { 
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	public static void main(String agrs[]) { 
    
    		String filepath[] = {  "/temp/aa.txt", "/temp/regist.log" };
    		String localfilepath[] = {  "C:\\tmp\\1.txt", "C:\\tmp\\2.log" };
    
    		Ftp fu = new Ftp();
    		/* * 使用默认的端口号、用户名、密码以及根目录连接FTP服务器 */
    		fu.connectServer("127.0.0.1", 22, "anonymous", "IEUser@", "/temp");
    
    		// 下载
    		for (int i = 0; i < filepath.length; i++) { 
    			fu.download(filepath[i], localfilepath[i]);
    		}
    
    		String localfile = "E:\\号码.txt";
    		String remotefile = "/temp/哈哈.txt";
    		// 上传
    		fu.upload(localfile, remotefile);
    		fu.closeConnect();
    	}
    }
    
    // 这种方式没啥可说的，比较简单，也不存在中文乱码的问题。貌似有个缺陷，不能操作大文件，有兴趣的朋友可以试试。
    
    // 第二种方式
    public class FtpApche { 
    	private static FTPClient ftpClient = new FTPClient();
    	private static String encoding = System.getProperty("file.encoding");
    
    	/** * Description: 向FTP服务器上传文件 * * @Version1.0 * @param url * FTP服务器hostname * @param port * FTP服务器端口 * @param username * FTP登录账号 * @param password * FTP登录密码 * @param path * FTP服务器保存目录,如果是根目录则为“/” * @param filename * 上传到FTP服务器上的文件名 * @param input * 本地文件输入流 * @return 成功返回true，否则返回false */
    	public static boolean uploadFile(String url, int port, String username,
    			String password, String path, String filename, InputStream input) { 
    		boolean result = false;
    
    		try { 
    			int reply;
    			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
    			ftpClient.connect(url);
    			// ftp.connect(url, port);// 连接FTP服务器
    			// 登录
    			ftpClient.login(username, password);
    			ftpClient.setControlEncoding(encoding);
    			// 检验是否连接成功
    			reply = ftpClient.getReplyCode();
    			if (!FTPReply.isPositiveCompletion(reply)) { 
    				System.out.println("连接失败");
    				ftpClient.disconnect();
    				return result;
    			}
    
    			// 转移工作目录至指定目录下
    			boolean change = ftpClient.changeWorkingDirectory(path);
    			ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    			if (change) { 
    				result = ftpClient.storeFile(
    						new String(filename.getBytes(encoding), "iso-8859-1"),
    						input);
    				if (result) { 
    					System.out.println("上传成功!");
    				}
    			}
    			input.close();
    			ftpClient.logout();
    		} catch (IOException e) { 
    			e.printStackTrace();
    		} finally { 
    			if (ftpClient.isConnected()) { 
    				try { 
    					ftpClient.disconnect();
    				} catch (IOException ioe) { 
    				}
    			}
    		}
    		return result;
    	}
    
    	/** * 将本地文件上传到FTP服务器上 * */
    	public void testUpLoadFromDisk() { 
    		try { 
    			FileInputStream in = new FileInputStream(new File("E:/号码.txt"));
    			boolean flag = uploadFile("127.0.0.1", 21, "zlb", "123", "/",
    					"哈哈.txt", in);
    			System.out.println(flag);
    		} catch (FileNotFoundException e) { 
    			e.printStackTrace();
    		}
    	}
    
    	/** * Description: 从FTP服务器下载文件 * * @Version1.0 * @param url * FTP服务器hostname * @param port * FTP服务器端口 * @param username * FTP登录账号 * @param password * FTP登录密码 * @param remotePath * FTP服务器上的相对路径 * @param fileName * 要下载的文件名 * @param localPath * 下载后保存到本地的路径 * @return */
    	public static boolean downFile(String url, int port, String username,
    			String password, String remotePath, String fileName,
    			String localPath) { 
    		boolean result = false;
    		try { 
    			int reply;
    			ftpClient.setControlEncoding(encoding);
    
    			/* * 为了上传和下载中文文件，有些地方建议使用以下两句代替 new * String(remotePath.getBytes(encoding),"iso-8859-1")转码。 经过测试，通不过。 */
    			// FTPClientConfig conf = new
    			// FTPClientConfig(FTPClientConfig.SYST_NT);
    			// conf.setServerLanguageCode("zh");
    
    			ftpClient.connect(url, port);
    			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
    			ftpClient.login(username, password);// 登录
    			// 设置文件传输类型为二进制
    			ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    			// 获取ftp登录应答代码
    			reply = ftpClient.getReplyCode();
    			// 验证是否登陆成功
    			if (!FTPReply.isPositiveCompletion(reply)) { 
    				ftpClient.disconnect();
    				System.err.println("FTP server refused connection.");
    				return result;
    			}
    			// 转移到FTP服务器目录至指定的目录下
    			ftpClient.changeWorkingDirectory(new String(remotePath
    					.getBytes(encoding), "iso-8859-1"));
    			// 获取文件列表
    			FTPFile[] fs = ftpClient.listFiles();
    			for (FTPFile ff : fs) { 
    				if (ff.getName().equals(fileName)) { 
    					File localFile = new File(localPath + "/" + ff.getName());
    					OutputStream is = new FileOutputStream(localFile);
    					ftpClient.retrieveFile(ff.getName(), is);
    					is.close();
    				}
    			}
    
    			ftpClient.logout();
    			result = true;
    		} catch (IOException e) { 
    			e.printStackTrace();
    		} finally { 
    			if (ftpClient.isConnected()) { 
    				try { 
    					ftpClient.disconnect();
    				} catch (IOException ioe) { 
    				}
    			}
    		}
    		return result;
    	}
    
    	/** * 将FTP服务器上文件下载到本地 * */
    	public void testDownFile() { 
    		try { 
    			boolean flag = downFile("127.0.0.1", 21, "zlb", "123", "/",
    					"哈哈.txt", "D:/");
    			System.out.println(flag);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    
    	public static void main(String[] args) { 
    		FtpApche fa = new FtpApche();
    		fa.testDownFile();
    	}
    }

使用Apache的FTP Client，实现：

package com.zhangjun.ftp;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.apache.commons.net.ftp.FTPReply;
    
    /** * ftp连接管理(使用apache commons-net-1.4.1 lib) * * @author 张军 * @version 1.0 20120912 */
    public class FTPClientUtil { 
        private FTPClient ftpClient = null;
        private String server;
        private int port;
        private String userName;
        private String userPassword;
    
        public static void main(String[] args) { 
            FtpClientUtil f = new FtpClientUtil("10.3.12.17", 21, "was", "was");
            try { 
                if (f.open()) { 
                    // 远程路径为相对路径
                    f.get("/opt/IBM/WebSphere/AppServer/profiles/AppSrv01/qunarlog.txt", "E:/zhangjun.txt");
                    f.close();
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        public FtpClientUtil(String server, int port, String userName, String userPassword) { 
            this.server = server;
            this.port = port;
            this.userName = userName;
            this.userPassword = userPassword;
        }
    
        /** * 链接到服务器 * * @return * @throws Exception */
        public boolean open() { 
            if (ftpClient != null && ftpClient.isConnected()) { 
                return true;
            }
            try { 
                ftpClient = new FTPClient();
                // 连接
                ftpClient.connect(this.server, this.port);
                ftpClient.login(this.userName, this.userPassword);
                // 检测连接是否成功
                int reply = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) { 
                    this.close();
                    System.exit(1);
                }
                // 设置上传模式binally or ascii
                ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
    
                return true;
            } catch (Exception ex) { 
                // 关闭
                this.close();
                return false;
            }
    
        }
    
        private boolean cd(String dir) throws IOException { 
            if (ftpClient.changeWorkingDirectory(dir)) { 
                return true;
            } else { 
                return false;
            }
        }
    
        /** * 获取目录下所有的文件名称 * * @param filePath * @return * @throws IOException */
    
        private FTPFile[] getFileList(String filePath) throws IOException { 
            FTPFile[] list = ftpClient.listFiles();
            return list;
        }
    
        /** * 循环将设置工作目录 */
        public boolean changeDir(String ftpPath) { 
            if (!ftpClient.isConnected()) { 
                return false;
            }
            try { 
    
                // 将路径中的斜杠统一
                char[] chars = ftpPath.toCharArray();
                StringBuffer sbStr = new StringBuffer(256);
                for (int i = 0; i < chars.length; i++) { 
    
                    if ('\\' == chars[i]) { 
                        sbStr.append('/');
                    } else { 
                        sbStr.append(chars[i]);
                    }
                }
                ftpPath = sbStr.toString();
    
                if (ftpPath.indexOf('/') == -1) { 
                    // 只有一层目录
                    ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
                } else { 
                    // 多层目录循环创建
                    String[] paths = ftpPath.split("/");
                    for (int i = 0; i < paths.length; i++) { 
                        ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
                    }
                }
    
                return true;
            } catch (Exception e) { 
                return false;
            }
        }
    
        /** * 循环创建目录，并且创建完目录后，设置工作目录为当前创建的目录下 */
        public boolean mkDir(String ftpPath) { 
            if (!ftpClient.isConnected()) { 
                return false;
            }
            try { 
                // 将路径中的斜杠统一
                char[] chars = ftpPath.toCharArray();
                StringBuffer sbStr = new StringBuffer(256);
                for (int i = 0; i < chars.length; i++) { 
    
                    if ('\\' == chars[i]) { 
                        sbStr.append('/');
                    } else { 
                        sbStr.append(chars[i]);
                    }
                }
                ftpPath = sbStr.toString();
    
                if (ftpPath.indexOf('/') == -1) { 
                    // 只有一层目录
                    ftpClient.makeDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
                    ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
                } else { 
                    // 多层目录循环创建
                    String[] paths = ftpPath.split("/");
                    for (int i = 0; i < paths.length; i++) { 
                        ftpClient.makeDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
                        ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
                    }
                }
    
                return true;
            } catch (Exception e) { 
                return false;
            }
        }
    
        /** * 上传文件到FTP服务器 * * @param localPathAndFileName * 本地文件目录和文件名 * @param ftpFileName * 上传后的文件名 * @param ftpDirectory * FTP目录如:/path1/pathb2/,如果目录不存在回自动创建目录 * @throws Exception */
        public boolean put(String localDirectoryAndFileName, String ftpFileName, String ftpDirectory) { 
            if (!ftpClient.isConnected()) { 
                return false;
            }
            boolean flag = false;
            if (ftpClient != null) { 
                File srcFile = new File(localDirectoryAndFileName);
                FileInputStream fis = null;
                try { 
                    fis = new FileInputStream(srcFile);
    
                    // 创建目录
                    this.mkDir(ftpDirectory);
    
                    ftpClient.setBufferSize(1024);
                    ftpClient.setControlEncoding("UTF-8");
    
                    // 设置文件类型（二进制）
                    ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    
                    // 上传
                    flag = ftpClient.storeFile(new String(ftpFileName.getBytes(), "iso-8859-1"), fis);
                } catch (Exception e) { 
                    this.close();
                    return false;
                } finally { 
                    IOUtils.closeQuietly(fis);s
                }
            }
            return flag;
        }
    
        /** * 从FTP服务器上下载文件并返回下载文件长度 * * @param ftpDirectoryAndFileName * @param localDirectoryAndFileName * @return * @throws Exception */
        public long get(String ftpDirectoryAndFileName, String localDirectoryAndFileName) { 
            long result = 0;
            if (!ftpClient.isConnected()) { 
                return 0;
            }
            ftpClient.enterLocalPassiveMode();
            try { 
                // 将路径中的斜杠统一
                char[] chars = ftpDirectoryAndFileName.toCharArray();
                StringBuffer sbStr = new StringBuffer(256);
                for (int i = 0; i < chars.length; i++) { 
    
                    if ('\\' == chars[i]) { 
                        sbStr.append('/');
                    } else { 
                        sbStr.append(chars[i]);
                    }
                }
                ftpDirectoryAndFileName = sbStr.toString();
                String filePath = ftpDirectoryAndFileName.substring(0, ftpDirectoryAndFileName.lastIndexOf("/"));
                String fileName = ftpDirectoryAndFileName.substring(ftpDirectoryAndFileName.lastIndexOf("/") + 1);
                this.changeDir(filePath);
                ftpClient.retrieveFile(new String(fileName.getBytes(), "iso-8859-1"),
                        new FileOutputStream(localDirectoryAndFileName)); // download
                System.out.print(ftpClient.getReplyString()); // check result
    
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 返回FTP目录下的文件列表 * * @param ftpDirectory * @return */
        public List getFileNameList(String ftpDirectory) { 
            List list = new ArrayList();
            if (!open())
                return list;
            try { 
                DataInputStream dis = new DataInputStream(ftpClient.nameList(ftpDirectory));
                String filename = "";
                while ((filename = dis.readLine()) != null) { 
                    list.add(filename);
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return list;
            return list;
        }
    
        /** * 删除FTP上的文件 * * @param ftpDirAndFileName */
        public boolean deleteFile(String ftpDirAndFileName) { 
            if (!ftpClient.isConnected()) { 
                return false;
            }
            return true;
        }
    
        /** * 删除FTP目录 * * @param ftpDirectory */
        public boolean deleteDirectory(String ftpDirectory) { 
            if (!ftpClient.isConnected()) { 
                return false;
            }
            return true;
        }
    
        /** * 关闭链接 */
        public void close() { 
            try { 
                if (ftpClient != null && ftpClient.isConnected())
                    ftpClient.disconnect();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        public FTPClient getFtpClient() { 
            return ftpClient;
        }
    
        public void setFtpClient(FTPClient ftpClient) { 
    
            this.ftpClient = ftpClient;
        }
    }