java FTP传文件 .
sun.net.ftp.FtpClient.，该类库主要提供了用于建立FTP连接的类。利用这些类的方法，编程人员可以远程登录到FTP服务器，列举该服务器上的目录，设置传输协议，以及传送文件。FtpClient类涵盖了几乎所有FTP的功能，FtpClient的实例变量保存了有关建立"代理"的各种信息。下面给出了这些实例变量。
public static boolean useFtpProxy
这个变量用于表明FTP传输过程中是否使用了一个代理，因此，它实际上是一个标记，此标记若为TRUE，表明使用了一个代理主机。
public static String ftpProxyHost
此变量只有在变量useFtpProxy为TRUE时才有效，用于保存代理主机名。
public static int ftpProxyPort
此变量只有在变量useFtpProxy为TRUE时才有效，用于保存代理主机的端口地址。
FtpClient有三种不同形式的构造函数，如下所示：
1、public FtpClient(String hostname,int port)
此构造函数利用给出的主机名和端口号建立一条FTP连接。
2、public FtpClient(String hostname)
此构造函数利用给出的主机名建立一条FTP连接，使用默认端口号。
3、FtpClient()
此构造函数将创建一FtpClient类，但不建立FTP连接。这时，FTP连接可以用openServer方法建立。
一旦建立了类FtpClient，就可以用这个类的方法来打开与FTP服务器的连接。类FtpClient提供了如下两个可用于打开与FTP服务器之间的连接的方法。
public void openServer(String hostname)
这个方法用于建立一条与指定主机上的FTP服务器的连接，使用默认端口号。
public void openServer(String host,int port)
这个方法用于建立一条与指定主机、指定端口上的FTP服务器的连接。
打开连接之后，接下来的工作是注册到FTP服务器。这时需要利用下面的方法。
public void login(String username，String password)
此方法利用参数username和password登录到FTP服务器。使用过Intemet的用户应该知道，匿名FTP服务器的登录用户名为anonymous，密码一般用自己的电子邮件地址。
下面是FtpClient类所提供的一些控制命令。
public void cd(String remoteDirectory)
该命令用于把远程系统上的目录切换到参数remoteDirectory所指定的目录。
public void cdUp()：该命令用于把远程系统上的目录切换到上一级目录。
public String pwd()：该命令可显示远程系统上的目录状态。
public void binary()：该命令可把传输格式设置为二进制格式。
public void ascii()：该命令可把传输协议设置为ASCII码格式。
public void rename(String string，String string1)
该命令可对远程系统上的目录或者文件进行重命名操作。
除了上述方法外，类FtpClient还提供了可用于传递并检索目录清单和文件的若干方法。这些方法返回的是可供读或写的输入、输出流。下面是其中一些主要的方法。
public TelnetInputStream list()
返回与远程机器上当前目录相对应的输入流。
public TelnetInputStream get(String filename)
获取远程机器上的文件filename，借助TelnetInputStream把该文件传送到本地。
public TelnetOutputStream put(String filename)
以写方式打开一输出流，通过这一输出流把文件filename传送到远程计算机。
再来Ftp的实际操作类:
package org.javawo.components.ftp;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
/**
*
* FTP消费类,提供一系列的FTP操作方法
*
* @author 杨涛
*
*/
public class FtpUtil {
/** 登录用户名,密码,IP等参数*/
private String name,password,ip;
/** 登录端口*/
private int port;
/** FTP操作对象*/
private FTPClient ftpClient = null;
/** 构造方法,初始化传入要连接的FTP参数信息*/
public FtpUtil(FtpInfo ftpInfo) throws Exception {
if(ftpInfo==null) {
/** 判断如果为null 就抛出初始化异常*/
throw new Exception("传递的FTP连接参数对象是null");
} else {
this.init(ftpInfo);
}
}
/**
* 下载文件到本地
*
* @param remoteFileName
* @param localFileName
*/
public void loadFile(String remoteFileName, String localFileName) {
BufferedOutputStream buffOut = null;
try {
buffOut = new BufferedOutputStream(new FileOutputStream(localFileName));
/** 写入本地文件*/
ftpClient.retrieveFile(remoteFileName, buffOut);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (buffOut != null)
buffOut.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 上传文件到FTP服务器上
*
* @param localFileStream
* @param fileName
* @return
* @throws IOException
*/
public boolean uploadFile(InputStream localFileStream, String fileName) throws IOException {
/** 返回参数*/
boolean fla = false;
try{
/** 设置文件类型*/
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
/** 上传之前先给文件命明为.TMP*/
String tempName = fileName+".tmp";
/** 开始上传文件*/
ftpClient.storeFile(tempName, localFileStream);
/** 上传完毕之后再该为原名*/
renameFile(tempName,fileName);
fla = true;
}catch(Exception ex){
ex.printStackTrace();
}finally {
localFileStream.close();
}
return fla;
}
/**
* 下载文件流
*
* @param remoteFileName
* @param output
* @return
*/
public boolean downloadFile(String remoteFileName, OutputStream output) throws IOException{
try {
if ((remoteFileName!=null)&&(output!=null)) {
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
boolean ret = ftpClient.retrieveFile(remoteFileName, output);
return ret;
} else {
return false;
}
}catch (IOException e) {
if (e.getMessage()=="IOException caught while copying." || output==null) {
ftpClient.disconnect();
}
return false;
}
}
/**
* 重命名FTP上的文件
*
* @param oldName
* @param newName
*/
public void renameFile(String oldName,String newName) {
try{
/** 重命名*/
ftpClient.rename(oldName, newName);
}catch(Exception ex){
ex.printStackTrace();
}
}
/**
* 获取服务器上的文件大小
*
* @param fileName
* @return
*/
public long getFileSize(String fileName) {
try {
StringBuffer command = new StringBuffer("size ");
command.append(fileName);
ftpClient.sendCommand(command.toString());
if (ftpClient.getReplyCode()==213)
{
String replyText=ftpClient.getReplyString().substring(4).trim();
return Long.parseLong(replyText);
}else{
return 0;
}
} catch (Throwable e) {
e.printStackTrace();
return 0;
}
}
/**
* 初始化FTP连接参数
*
* @param ftpInfo
*/
public void init(FtpInfo ftpInfo) {
this.name = ftpInfo.getName();
this.password = ftpInfo.getPassword();
this.ip = ftpInfo.getIp();
this.port = ftpInfo.getPort();
}
/**
* 连接到FTP服务器
*
*/
public void connectServer() {
/** 如果当前ftpClient对象是null且没有连接就连接到FTP服务器*/
if(this.ftpClient==null && !this.ftpClient.isConnected()) {
try {
/** 如果ftpClient对象为null就实例化一个新的*/
this.ftpClient = new FTPClient();
this.ftpClient.setDefaultPort(this.port); /** 设置默认的IP地址*/
this.ftpClient.connect(this.ip);/** 连接到FTP服务器*/
/** 登录到这台FTP服务器*/
if(ftpClient.login(this.name, this.password)){
System.out.println("在类FtpUtil中: 服务器"+this.ip+"的用户"+this.name+"登录成功!");
}
}catch(Exception ex){
ex.printStackTrace();
}
}
}
/**
* 销毁FTP服务器连接
*
*/
public void closeConnect() {
/** 判断当前ftpClient对象不为null和FTP已经被连接就关闭*/
if (this.ftpClient != null && this.ftpClient.isConnected()) {
try{
this.ftpClient.disconnect();/** 销毁FTP连接*/
}catch(Exception ex){
ex.printStackTrace();
}
}
}
}
在来Ftp的Map连接池
package org.javawo.components.ftp;
import java.util.HashMap;
/**
* 定义一个HashMap,装载FTP连接的实例化对象,这里做FTP的连接池使用
*
* @author 杨涛
*
*/
public class FtpConnectMap {
/** K-V对应的连接池*/
@SuppressWarnings("unchecked")
private static HashMap connectMap = new HashMap();
private static FtpConnectMap ftpMap = null;
/**
* 获得FtpConnectMap的实例化对象
*
* @return
*/
public static FtpConnectMap getInstance() {
if(ftpMap==null){
ftpMap = new FtpConnectMap();
}
return ftpMap;
}
/**
* 通过Name获取存在HashMap中的FTP连接对象
*
* @param name
* @return
*/
public FtpUtil getFtpUtil(String name) {
FtpUtil ftpUtil = (FtpUtil)connectMap.get(name);
return ftpUtil;
}
/**
* 给HashMap添加一个新的FTP连接对象
*
* @param name
* @param ftpUtil
*/
@SuppressWarnings("unchecked")
public void addFtpUtil(String name,FtpUtil ftpUtil) {
connectMap.put(name, ftpUtil);
}
}
最后再来一个是Ftp的创建工厂
package org.javawo.components.ftp;
/**
* FTP操作工厂类,负责FTP的实例创建和其他
*
* @author 杨涛
*
*/
public class FtpFactory {
/**
* 创建一个FtpUtil的实例化对象
*
* @param ftpInfo
* @return
*/
public FtpUtil createFtpUtil(FtpInfo ftpInfo){
/** 获取存储对象的实例*/
FtpConnectMap ftpMap = FtpConnectMap.getInstance();
/** 从HashMap中获取一个连接的实例化对象*/
FtpUtil ftpUtil = ftpMap.getFtpUtil(ftpInfo.getName());
if(ftpUtil==null) {
try{
/** 该连接不存在于HashMap中,实例化一个连接将此连接添加到HashMap中*/
ftpUtil = new FtpUtil(ftpInfo);/** 实例化一个FTP连接*/
ftpUtil.connectServer();
ftpMap.addFtpUtil(ftpInfo.getName(),ftpUtil);
}catch(Exception ex){
ex.printStackTrace();
}
}
return ftpUtil;
}
}
例子：
import sun.net.ftp. * ;
import sun.net. * ;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;
/** */ /**
FTP远程命令列表<br>
USER PORT RETR ALLO DELE SITE XMKD CDUP FEAT<br>
PASS PASV STOR REST CWD STAT RMD XCUP OPTS<br>
ACCT TYPE APPE RNFR XCWD HELP XRMD STOU AUTH<br>
REIN STRU SMNT RNTO LIST NOOP PWD SIZE PBSZ<br>
QUIT MODE SYST ABOR NLST MKD XPWD MDTM PROT<br>
在服务器上执行命令,如果用sendServer来执行远程命令(不能执行本地FTP命令)的话，所有FTP命令都要加上 <br>
ftpclient.sendServer("XMKD /test/bb "); //执行服务器上的FTP命令<br>
ftpclient.readServerResponse一定要在sendServer后调用<br>
nameList("/test")获取指目录下的文件列表<br>
XMKD建立目录，当目录存在的情况下再次创建目录时报错<br>
XRMD删除目录<br>
DELE删除文件<br>
* <p>Title: 使用JAVA操作FTP服务器(FTP客户端)</p>
* <p>Description: 上传文件的类型及文件大小都放到调用此类的方法中去检测，比如放到前台JAVASCRIPT中去检测等
* 针对FTP中的所有调用使用到文件名的地方请使用完整的路径名（绝对路径开始）。
* </p>
* <p>Copyright: Copyright (c) 2005</p>
* <p>Company: 静靖工作室</p>
* @author 欧朝敬 13873195792
* @version 1.0
*/
public class FTPConnectorBK {
private FtpClient ftpclient;
private String ipAddress;
private int ipPort;
private String userName;
private String PassWord;
/** */ /**
* 构造函数
* @param ip String 机器IP
* @param port String 机器FTP端口号
* @param username String FTP用户名
* @param password String FTP密码
* @throws Exception
*/
public FTPConnectorBK(String ip, int port, String username, String password) throws
Exception {
ipAddress = new String(ip);
ipPort = port;
// System.out.println("1......"+ftpclient.serverIsOpen());
ftpclient = new FtpClient(ipAddress, ipPort);
// ftpclient = new FtpClient();
System.out.println( " 2...... " + ftpclient.serverIsOpen());
// ftpclient = new FtpClient(ipAddress);
userName = new String(username);
PassWord = new String(password);
}
/** */ /**
* 构造函数
* @param ip String 机器IP，默认端口为21
* @param username String FTP用户名
* @param password String FTP密码
* @throws Exception
*/
public FTPConnectorBK(String ip, String username, String password) throws
Exception {
ipAddress = new String(ip);
ipPort = 21 ;
ftpclient = new FtpClient(ipAddress, ipPort);
// ftpclient = new FtpClient(ipAddress);
userName = new String(username);
PassWord = new String(password);
}
/** */
/**
* 登录FTP服务器
*
* @throws Exception
*/
public void login() throws Exception {
System.out.println( " b...... " + ftpclient.welcomeMsg);
ftpclient.login(userName, PassWord);
ftpclient.setConnectTimeout( 30 );
System.out.println( " getReadTimeout... " + ftpclient.getReadTimeout());
System.out.println( " getConnectTimeout... " + ftpclient.getConnectTimeout());
System.out.println( " e...... " + ftpclient.welcomeMsg);
}
/** */ /**
* 退出FTP服务器
*
* @throws Exception
*/
public void logout() throws Exception {
// 用ftpclient.closeServer()断开FTP出错时用下更语句退出
System.out.println( " 10...... " + ftpclient.serverIsOpen());
ftpclient.sendServer( " QUIT " );
int reply = ftpclient.readServerResponse(); // 取得服务器的返回信息
System.out.println( " reply.... " + reply);
System.out.println( " 11...... " + ftpclient.serverIsOpen());
ftpclient.closeServer();
System.out.println( " 12...... " + ftpclient.serverIsOpen());
}
/** */ /**
* 在FTP服务器上建立指定的目录,当目录已经存在的情下不会影响目录下的文件,这样用以判断FTP
* 上传文件时保证目录的存在目录格式必须以"/"根目录开头
* @param pathList String
* @throws Exception
*/
public void buildList(String pathList) throws Exception {
ftpclient.ascii();
StringTokenizer s = new StringTokenizer(pathList, " / " ); // sign
int count = s.countTokens();
String pathName = "" ;
while (s.hasMoreElements()) {
pathName = pathName + " / " + (String) s.nextElement();
try {
ftpclient.sendServer( " XMKD " + pathName + " " );
} catch (Exception e) {
e = null ;
}
int reply = ftpclient.readServerResponse();
System.out.println(reply);
}
ftpclient.binary();
}
/** */ /**
* 取得指定目录下的所有文件名，不包括目录名称
* 分析nameList得到的输入流中的数，得到指定目录下的所有文件名
* @param fullPath String
* @return ArrayList
* @throws Exception
*/
public ArrayList fileNames(String fullPath) throws Exception {
ftpclient.ascii(); // 注意，使用字符模式
ftpclient.cd( " /freep " );
// ftpclient.cdUp();
// TelnetInputStream list = ftpclient.nameList(fullPath);
TelnetInputStream list = ftpclient.list();
byte [] names = new byte [ 2048 ];
int bufsize = 0 ;
bufsize = list.read(names, 0 , names.length); // 从流中读取
list.close();
ArrayList namesList = new ArrayList();
int i = 0 ;
int j = 0 ;
while (i < bufsize /** / /* names.length */ ) {
// System.out.println(i);
// char bc = (char) names;
// System.out.println(i + " " + bc + " : " + (int) names);
// i = i + 1;
if (names[i] == 10 ) { // 字符模式为10，二进制模式为13
System.out.println( " j.... " + j);
// 文件名在数据中开始下标为j,i-j为文件名的长度,文件名在数据中的结束下标为i-1
// System.out.write(names, j, i - j);
// System.out.println(j + " " + i + " " + (i - j));
String tempName = new String(names, j, i - j);
namesList.add(tempName);
System.out.println(tempName);
// 处理代码处
// j = i + 2; // 上一次位置二进制模式
j = i + 1 ; // 上一次位置字符模式
}
i = i + 1 ;
}
return namesList;
}
/** */ /**
* 上传文件到FTP服务器,destination路径以FTP服务器的"/"开始，带文件名、
* 上传文件只能使用二进制模式，当文件存在时再次上传则会覆盖
* @param source String
* @param destination String
* @throws Exception
*/
public void upFile(String source, String destination) throws Exception {
buildList(destination.substring( 0 , destination.lastIndexOf( " / " )));
ftpclient.binary(); // 此行代码必须放在buildList之后
TelnetOutputStream ftpOut = ftpclient.put(destination);
TelnetInputStream ftpIn = new TelnetInputStream( new
FileInputStream(source), true );
byte [] buf = new byte [ 204800 ];
int bufsize = 0 ;
while ((bufsize = ftpIn.read(buf, 0 , buf.length)) != - 1 ) {
ftpOut.write(buf, 0 , bufsize);
}
ftpIn.close();
ftpOut.close();
}
/** */ /**
* JSP中的流上传到FTP服务器,
* 上传文件只能使用二进制模式，当文件存在时再次上传则会覆盖
* 字节数组做为文件的输入流,此方法适用于JSP中通过
* request输入流来直接上传文件在RequestUpload类中调用了此方法，
* destination路径以FTP服务器的"/"开始，带文件名
* @param sourceData byte[]
* @param destination String
* @throws Exception
*/
public void upFile( byte [] sourceData, String destination) throws Exception {
buildList(destination.substring( 0 , destination.lastIndexOf( " / " )));
ftpclient.binary(); // 此行代码必须放在buildList之后
TelnetOutputStream ftpOut = ftpclient.put(destination);
ftpOut.write(sourceData, 0 , sourceData.length);
// ftpOut.flush();
ftpOut.close();
}
/** */ /**
* 从FTP文件服务器上下载文件SourceFileName，到本地destinationFileName
* 所有的文件名中都要求包括完整的路径名在内
* @param SourceFileName String
* @param destinationFileName String
* @throws Exception
*/
public void downFile(String SourceFileName, String destinationFileName) throws
Exception {
ftpclient.binary(); // 一定要使用二进制模式
TelnetInputStream ftpIn = ftpclient.get(SourceFileName);
byte [] buf = new byte [ 204800 ];
int bufsize = 0 ;
FileOutputStream ftpOut = new FileOutputStream(destinationFileName);
while ((bufsize = ftpIn.read(buf, 0 , buf.length)) != - 1 ) {
ftpOut.write(buf, 0 , bufsize);
}
ftpOut.close();
ftpIn.close();
}
/** */ /**
*从FTP文件服务器上下载文件，输出到字节数组中
* @param SourceFileName String
* @return byte[]
* @throws Exception
*/
public byte [] downFile(String SourceFileName) throws
Exception {
ftpclient.binary(); // 一定要使用二进制模式
TelnetInputStream ftpIn = ftpclient.get(SourceFileName);
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
byte [] buf = new byte [ 204800 ];
int bufsize = 0 ;
while ((bufsize = ftpIn.read(buf, 0 , buf.length)) != - 1 ) {
byteOut.write(buf, 0 , bufsize);
}
byte [] return_arraybyte = byteOut.toByteArray();
byteOut.close();
ftpIn.close();
return return_arraybyte;
}
/** */ /** 调用示例
* FtpUpfile fUp = new FtpUpfile("192.150.189.22", 21, "admin", "admin");
* fUp.login();
* fUp.buildList("/adfadsg/sfsdfd/cc");
* String destination = "/test.zip";
* fUp.upFile("C:/Documents and Settings/Administrator/My Documents/sample.zip",destination);
* ArrayList filename = fUp.fileNames("/");
* for (int i = 0; i < filename.size(); i++) {
* System.out.println(filename.get(i).toString());
* }
* fUp.logout();
* @param args String[]
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// FTPConnectorBK fUp = new FTPConnectorBK( "192.168.1.230" , 21 , "admin" , "sanco_freep" );
FTPConnectorBK fUp = new FTPConnectorBK( " 192.168.1.160 " , 21 , " ftptest " , " ftptest " );
System.out.println( " fUp...... " + fUp.ftpclient.serverIsOpen());
fUp.login();
System.out.println( " login()...... " + fUp.ftpclient.serverIsOpen());
// fUp.fileNames("/freep");
System.out.println( " 1......begin " );
fUp.upFile( " f:/小游戏.rar " , " /1.rar " );
System.out.println( " 1......end " );
System.out.println( " 2......begin " );
fUp.upFile( " f:/小游戏.rar " , " /2.rar " );
System.out.println( " 2......end " );
System.out.println( " 3......begin " );
fUp.upFile( " f:/小游戏.rar " , " /小游戏.rar " );
System.out.println( " 3......end " );
String ss = fUp.ftpclient.pwd();
System.out.println( " ss...... " + ss);
System.out.println( " option...... " + fUp.ftpclient.serverIsOpen());
// fUp.deleteFile();
// 建立文件目录
// fUp.buildList("/adfadsg/sfsdfd/cc");
// String destination = "/test/SetupDJ.rar";
// fUp.upFile(
// "C:/Documents and Settings/Administrator/My Documents/SetupDJ.rar",
// destination);
// ArrayList filename = fUp.fileNames("/");
// for (int i = 0; i < filename.size(); i++) {
// System.out.println(filename.get(i).toString());
// }
//
// fUp.downFile("/sample.zip", "d:/sample.zip");
// 文件上传
// FileInputStream fin = new FileInputStream(
// "d: // 37.jpg" );
// byte [] data = new byte [ 20480000 ];
// fin.read(data, 0 , data.length);
fUp.logout();
System.out.println( " fUp.logout()...... " + fUp.ftpclient.serverIsOpen());
System.out.println( " 程序运行完成！ " );
/** / /* FTP远程命令列表
USER PORT RETR ALLO DELE SITE XMKD CDUP FEAT
PASS PASV STOR REST CWD STAT RMD XCUP OPTS
ACCT TYPE APPE RNFR XCWD HELP XRMD STOU AUTH
REIN STRU SMNT RNTO LIST NOOP PWD SIZE PBSZ
QUIT MODE SYST ABOR NLST MKD XPWD MDTM PROT
*/
/** / /* 在服务器上执行命令,如果用sendServer来执行远程命令(不能执行本地FTP命令)的话，所有FTP命令都要加上
ftpclient.sendServer("XMKD /test/bb "); //执行服务器上的FTP命令
ftpclient.readServerResponse一定要在sendServer后调用
nameList("/test")获取指目录下的文件列表
XMKD建立目录，当目录存在的情况下再次创建目录时报错
XRMD删除目录
DELE删除文件
*/
}
public void deleteFile() throws Exception {
ftpclient.ascii();
ftpclient.sendServer( " DELE " + " /freep/jpg/37.jpg " + " " );
int reply = ftpclient.readServerResponse();
System.out.println(reply);
}
}
以上的代码是我在网上搜索到的，我也有2个疑问：
1、ftpclient.setConnectTimeout(int arg); 里面的参数应该是时间吧，但是这个时间的单位是什么呢？秒？还是毫秒？还是其他的什么？怎么我将arg的值分别设为 2 60 5000 然后每次都等了10分钟都没什么效果啊？
2、除非调用了 ftpclient.closeServer()方法 否则ftpclient.serverIsOpen() 恒为true，那么我怎么才能判断链接状态呢？
后来我发现链接超时是由服务器端设定的，FTP服务器会在设定的时间以外自动将链接断开，这样我的程序就不好控制了。在实际项目当中，如果这个FTP上传使用的很频繁的话，要不停的打开连接和关闭连接，如果使用的不是很平凡的话，可能服务器端已经因为连接超时而把连接断开了而程序也无法判断（当然也要注意线程安全问题）。
后来我的做法是在第一次链接服务器的时候设置一个"连接超时的时间点"（即当前时间＋FTP服务器端设置的连接超时时间＝与FTP服务器断开连接的时间），然后在每次上传的时候根据"连接超时的时间点" 判断是否已经和FTP服务器端断开连接，如果是则重新连接后在上传，否则直接上传，最后重新设置“连接超时的时间点”。