java代码获取ftp java代码获取今天星期几

用java怎么获取ftp上的文件

public class FtpClientUtil {

为企业提供成都网站制作、成都网站设计、网站优化、营销型网站、竞价托管、品牌运营等营销获客服务。成都创新互联拥有网络营销运营团队，以丰富的互联网营销经验助力企业精准获客，真正落地解决中小企业营销获客难题，做到“让获客更简单”。自创立至今，成功用技术实力解决了企业“网站建设、网络品牌塑造、网络营销”三大难题，同时降低了营销成本，提高了有效客户转化率，获得了众多企业客户的高度认可！

FtpClient ftpClient;

private String server;

private int port;

private String userName;

private String userPassword;

public FtpClientUtil(String server,int port,String userName,String userPassword)

{

this.server=server;

this.port=port;

this.userName=userName;

this.userPassword=userPassword;

}

/**

* 链接到服务器

* @return

*/

public boolean open()

{

if(ftpClient!=nullftpClient.serverIsOpen())

return true;

try

{

ftpClient= new FtpClient();

ftpClient.openServer(server,port);

ftpClient.login(userName, userPassword);

ftpClient.binary();

return true;

}

catch(Exception e)

{

e.printStackTrace();

ftpClient=null;

return false;

}

}

public boolean cd(String dir){

boolean f = false;

try {

ftpClient.cd(dir);

} catch (IOException e) {

Logs.error(e.toString());

return f;

}

return true;

}

/**

* 上传文件到FTP服务器

* @param localPathAndFileName 本地文件目录和文件名

* @param ftpFileName 上传后的文件名

* @param ftpDirectory FTP目录如:/path1/pathb2/,如果目录不存在回自动创建目录

* @throws Exception

*/

public boolean upload(String localDirectoryAndFileName,String ftpFileName,String ftpDirectory)throws Exception {

if(!open())

return false;

FileInputStream is=null;

TelnetOutputStream os=null;

try

{

char ch = ' ';

if (ftpDirectory.length() 0)

ch = ftpDirectory.charAt(ftpDirectory.length() - 1);

for (; ch == '/' || ch == '\\'; ch = ftpDirectory.charAt(ftpDirectory.length() - 1))

ftpDirectory = ftpDirectory.substring(0, ftpDirectory.length() - 1);

int slashIndex = ftpDirectory.indexOf(47);

int backslashIndex = ftpDirectory.indexOf(92);

int index = slashIndex;

String dirall = ftpDirectory;

if (backslashIndex != -1 (index == -1 || index backslashIndex))

index = backslashIndex;

String directory = "";

while (index != -1) {

if (index 0) {

String dir = dirall.substring(0, index);

directory = directory + "/" + dir;

ftpClient.sendServer("XMKD " + directory + "\r\n");

ftpClient.readServerResponse();

}

dirall = dirall.substring(index + 1);

slashIndex = dirall.indexOf(47);

backslashIndex = dirall.indexOf(92);

index = slashIndex;

if (backslashIndex != -1 (index == -1 || index backslashIndex))

index = backslashIndex;

}

ftpClient.sendServer("XMKD " + ftpDirectory + "\r\n");

ftpClient.readServerResponse();

os = ftpClient.put(ftpDirectory + "/"

+ ftpFileName);

File file_in = new File(localDirectoryAndFileName);

is = new FileInputStream(file_in);

byte bytes[] = new byte[1024];

int i;

while ((i = is.read(bytes)) != -1)

os.write(bytes, 0, i);

//清理垃圾

return true;

}

catch(Exception e)

{

e.printStackTrace();

return false;

}

finally

{

if (is != null)

is.close();

if (os != null)

os.close();

}

}

/**

* 从FTP服务器上下载文件并返回下载文件长度

* @param ftpDirectoryAndFileName

* @param localDirectoryAndFileName

* @return

* @throws Exception

*/

public long download(String ftpDirectoryAndFileName,String localDirectoryAndFileName)throws Exception

{

long result = 0;

if(!open())

return result;

TelnetInputStream is = null;

FileOutputStream os = null;

try

{

is = ftpClient.get(ftpDirectoryAndFileName);

java.io.File outfile = new java.io.File(localDirectoryAndFileName);

os = new FileOutputStream(outfile);

byte[] bytes = new byte[1024];

int c;

while ((c = is.read(bytes)) != -1)

{

os.write(bytes, 0, c);

result = result + c;

}

}

catch (Exception e)

{

throw e;

}

finally

{

if (is != null)

is.close();

if (os != null)

os.close();

}

return result;

}

/**

* 返回FTP目录下的文件列表

* @param ftpDirectory

* @return

*/

public ListString getFileNameList(String ftpDirectory)

{

ListString list = new ArrayListString();

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;

}

/**

* 删除FTP上的文件

* @param ftpDirAndFileName

*/

public boolean deleteFile(String ftpDirAndFileName)

{

if(!open())

return false;

ftpClient.sendServer("DELE "+ftpDirAndFileName+"\r\n");

return true;

}

/**

* 删除FTP目录

* @param ftpDirectory

*/

public boolean deleteDirectory(String ftpDirectory)

{

if(!open())

return false;

ftpClient.sendServer("XRMD "+ftpDirectory+"\r\n");

return true;

}

/**

* 关闭链接

*/

public void close()

{

try

{

if(ftpClient!=nullftpClient.serverIsOpen())

ftpClient.closeServer();

}catch(Exception e)

{

}

}

}望采纳，谢谢。

java在浏览器上获取FTP读文件路径

问一下，你是想做ftp上传下载么？

首先你需要安装一个ftp服务端程序，启动起来，然后下载一个ftp客户端程序，测试能不能连接，首先这一块儿需要测试通过。

代码ftp上传下载

2.1 上传代码：

import java.io.File;

import java.io.FileInputStream;

import org.apache.commons.net.;

import org.apache.commons.net.;

public class test {

private FTPClient ftp;

/**

*

* @param path 上传到ftp服务器哪个路径下

* @param addr 地址

* @param port 端口号

* @param username 用户名

* @param password 密码

* @return

* @throws Exception

*/

private boolean connect(String path,String addr,int port,String username,String password) throws Exception {

boolean result = false;

ftp = new FTPClient();

int reply;

;

;

;

reply = ;

if (!FTPReply.isPositiveCompletion(reply)) {

;

return result;

}

;

result = true;

return result;

}

/**

*

* @param file 上传的文件或文件夹

* @throws Exception

*/

private void upload(File file) throws Exception{

if(file.isDirectory()){

(file.getName());

(file.getName());

String[] files = file.list();

for (int i = 0; i files.length; i++) {

File file1 = new File(file.getPath()+"\\"+files[i] );

if(file1.isDirectory()){

upload(file1);

;

}else{

File file2 = new File(file.getPath()+"\\"+files[i]);

FileInputStream input = new FileInputStream(file2);

(file2.getName(), input);

input.close();

}

}

}else{

File file2 = new File(file.getPath());

FileInputStream input = new FileInputStream(file2);

(file2.getName(), input);

input.close();

}

}

public static void main(String[] args) throws Exception{

test t = new test();

t.connect("", "localhost", 21, "yhh", "yhhazr");

File file = new File("e:\\uploadify");

t.upload(file);

}

}

2.2 下载代码

这里没有用到filter，如果用filter就可以过滤想要的文件。

public class Ftp {

/**

* @param args

*/

public static void main(String[] args) {

   // TODO Auto-generated method stub

   Ftp ftp = new Ftp();

   String hostname = "";

   Integer port = 21;

   String username = "username";

   String password = "password";

   String remote = "/c.txt";

   String local = "/home/tin/LeonChen/FTP/";

   try {

       (hostname, port, username, password);

       System.out.println("接收状态："+(remote, local));

       ;

   } catch (IOException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

   }

}

private FTPClient ftpClient = new FTPClient();

/*

* * 连接到FTP服务器  

* * @param hostname 主机名  

* * @param port 端口  

* * @param username 用户名  

* * @param password 密码  

* * @return 是否连接成功

* * @throws IOException

*/

private boolean connect(String hostname, int port, String username,

       String password) throws IOException {

   ftpClient.connect(hostname, port);

   ftpClient.setControlEncoding("UTF-8");

   if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {

       if (ftpClient.login(username, password)) {

           return true;

       }

   }

   disconnect();

   return false;

}

/*

* 从FTP服务器上下载文件,支持断点续传，上传百分比汇报

*

* @param remote 远程文件路径

*

* @param local 本地文件路径

*

* @return 上传的状态

*

* @throws IOException

*/

public DownloadStatus download(String remote, String local)

       throws IOException {

   // 设置被动模式

   ftpClient.enterLocalPassiveMode();

   // 设置以二进制方式传输

   ftpClient.setFileType();

   DownloadStatus result;

   // 检查远程文件是否存在

   FTPFile[] files = ftpClient.listFiles(new String(remote

           .getBytes("UTF-8"), "iso-8859-1"));

   if (files.length != 1) {

       System.out.println("远程文件不存在");

       return DownloadStatus.Remote_File_Noexist;

   }

   long lRemoteSize = files[0].getSize();

   String fildName = files[0].getName();

   // 本地存在文件，进行断点下载

   File f = new File(local+fildName);

   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(remote.getBytes("UTF-8"), "iso-8859-1"));

       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(remote.getBytes("UTF-8"), "iso-8859-1"));

       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;

}

private void disconnect() throws IOException {

   if (ftpClient.isConnected()) {

       ftpClient.disconnect();

   }

}

}

java获取ftp文件路径怎么写

package com.weixin.util;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.RandomAccessFile;

import org.apache.commons.net.PrintCommandListener;

import org.apache.commons.net.;

import org.apache.commons.net.;

import org.apache.commons.net.;

import org.apache.commons.net.;

import com.weixin.constant.DownloadStatus;

import com.weixin.constant.UploadStatus;

/**

* 支持断点续传的FTP实用类

* @version 0.1 实现基本断点上传下载

* @version 0.2 实现上传下载进度汇报

* @version 0.3 实现中文目录创建及中文文件创建，添加对于中文的支持

*/

public class ContinueFTP {

public FTPClient ftpClient = new FTPClient();

public ContinueFTP(){

//设置将过程中使用到的命令输出到控制台

this.ftpClient.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out)));

}

/**

* 连接到FTP服务器

* @param hostname 主机名

* @param port 端口

* @param username 用户名

* @param password 密码

* @return 是否连接成功

* @throws IOException

*/

public boolean connect(String hostname,int port,String username,String password) throws IOException{

ftpClient.connect(hostname, port);

ftpClient.setControlEncoding("GBK");

if(FTPReply.isPositiveCompletion(ftpClient.getReplyCode())){

if(ftpClient.login(username, password)){

return true;

}

}

disconnect();

return false;

}

/**

* 从FTP服务器上下载文件,支持断点续传，上传百分比汇报

* @param remote 远程文件路径

* @param local 本地文件路径

* @return 上传的状态

* @throws IOException

*/

public DownloadStatus download(String remote,String local) throws IOException{

//设置被动模式

ftpClient.enterLocalPassiveMode();

//设置以二进制方式传输

ftpClient.setFileType();

DownloadStatus result;

//检查远程文件是否存在

FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("GBK"),"iso-8859-1"));

if(files.length != 1){

System.out.println("远程文件不存在");

return DownloadStatus.Remote_File_Noexist;

}

long lRemoteSize = files[0].getSize();

File f = new File(local);

//本地存在文件，进行断点下载

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(remote.getBytes("GBK"),"iso-8859-1"));

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(remote.getBytes("GBK"),"iso-8859-1"));

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 local 本地文件名称，绝对路径

* @param remote 远程文件路径，使用/home/directory1/subdirectory/file.ext 按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构

* @return 上传结果

* @throws IOException

*/

public UploadStatus upload(String local,String remote) throws IOException{

//设置PassiveMode传输

ftpClient.enterLocalPassiveMode();

//设置以二进制流的方式传输

ftpClient.setFileType();

ftpClient.setControlEncoding("GBK");

UploadStatus result;

//对远程目录的处理

String remoteFileName = remote;

if(remote.contains("/")){

remoteFileName = remote.substring(remote.lastIndexOf("/")+1);

//创建服务器远程目录结构，创建失败直接返回

if(CreateDirecroty(remote, ftpClient)==UploadStatus.Create_Directory_Fail){

return UploadStatus.Create_Directory_Fail;

}

}

//检查远程是否存在文件

FTPFile[] files = ftpClient.listFiles(new String(remoteFileName.getBytes("GBK"),"iso-8859-1"));

if(files.length == 1){

long remoteSize = files[0].getSize();

File f = new File(local);

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(local), ftpClient, 0);

}

return result;

}

/**

* 断开与远程服务器的连接

* @throws IOException

*/

public void disconnect() 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("GBK"),"iso-8859-1"))){

//如果远程目录不存在，则递归创建远程服务器目录

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("GBK"),"iso-8859-1");

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");

OutputStream out = ftpClient.appendFileStream(new String(remoteFile.getBytes("GBK"),"iso-8859-1"));

//断点续传

if(remoteSize0){

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;

}

public static void main(String[] args) {

ContinueFTP myFtp = new ContinueFTP();

try {

System.err.println(my("10.10.6.236", 21, "5", "jieyan"));

// my(new String("歌曲".getBytes("GBK"),"iso-8859-1"));

// my(new String("歌曲".getBytes("GBK"),"iso-8859-1"));

// my(new String("爱你等于爱自己".getBytes("GBK"),"iso-8859-1"));

// System.out.println(my("E:\\yw.flv", "/yw.flv",5));

// System.out.println(my("E:\\爱你等于爱自己.mp4","/爱你等于爱自己.mp4"));

//System.out.println(my("/爱你等于爱自己.mp4", "E:\\爱你等于爱自己.mp4"));

my;

} catch (IOException e) {

System.out.println("连接FTP出错："+e.getMessage());

}

}

}

如何用JAVA实现FTP访问

在主函数中，完成服务器端口的侦听和服务线程的创建。我们利用一个静态字符串变量initDir 来保存服务器线程运行时所在的工作目录。服务器的初始工作目录是由程序运行时用户输入的，缺省为C盘的根目录。

具体的代码如下：

public class ftpServer extends Thread{

private Socket socketClient;

private int counter;

private static String initDir;

public static void main(String[] args){

if(args.length != 0) {

initDir = args[0];

}else{ initDir = "c:";}

int i = 1;

try{

System.out.println("ftp server started!");

//监听21号端口

ServerSocket s = new ServerSocket(21);

for(;;){

//接受客户端请求

Socket incoming = s.accept();

//创建服务线程

new ftpServer(incoming,i).start();

i++;

}

}catch(Exception e){}

}

java 获取ftp文件的最后修改时间比实际时间少8小时,该怎么处理

org.apache.commons.net.;

java 获取ftp文件的最后修改时间比实际时间少了8小时代码如下:FTPFile[] files = ftpClient.listFiles();

for (FTPFile file : files){

System.out.println(file.getName());

Date date = file.getTimestamp().getTime();

System.out.println(文件修改 + dateFormat.format(date));

Date date1 = new Date();

System.out.println(now + dateFormat.format(date1));

long f = date1.getTime() -date.getTime();

System.out.println(时间差 + f/60000+分);}------解决方案--------------------------------------------------------

FTPFile.getTimestamp().getTime()

java.io.File.lastModified()

java中怎么实现ftp服务器

学习了计算机网络之后，利用java写了一个ftp服务器。

一、实现的ftp命令

实现了基本的user,pass,list,port,quit,retr,cwd,stor等命令

二、以上命令所对应的功能

对应的功能是：下载，上传，获取服务器目录，切换目录等

三、用于测试的ftp客户端：windows自带的ftp客户端

四、实现的思想

1、使用ServerSocket进行监听，每个控制连接的请求到来之后，开启一个线程进行处理（这里使用的java bio,效率较差，对于控制连接最好使用NIO处理，之后会再写个

nio的实现）

2、 对于命令使用工厂方法模式进行设计，当需要添加新的命令的时候，只需要添加一个新的命令类，实现相应接口，修改工厂产生逻辑，而不用修改其他的程序代码。可

扩展性较好，同时符合开闭原则。

五、实现过程中碰到的问题

1、对于tcp与socket的关系理解错误，以为所有的数据的输入都是要经过serverSocket().accept（）方法。其实，ServerSocket.accept（）所对应的是tcp里面的三次握手建

立连接的阶段，之后的tcp的连接由客户端和服务器端的一对socket来维护，是属于establish阶段，在这个阶段，通信是全双工的，任何一方都能够发送数据。

socket.close（）对应的阶段是断开连接（四次挥手）的阶段。

2、刚开始对于ftp协议不是很理解，不知道他的工作方式是怎样的，后来在看了tcp协议卷里面的ftp的内容之后，才知道ftp命令和应答码是关键。eg:刚开始测试时，在

输入用户名之后，不会提示输入密码的。原因：没有返回对应的应答码：331. 另外要注意的是：返回的数据要以换行回车作为结束--\r\n.

六、代码列表

简单说明：

ftpServer:是服务器的主程序，入口，同时负责监听本地的21号端口。

ControllerThread.java：用于处理控制连接的线程（每一个控制连接请求对应一个线程）ps:实在很浪费（流量小，连接多）。

Share：一些全局性数据的维护。

Command:是命令接口，定义了一个所有命令都要实现的方法。

CommandFactory:命令工厂，通过传人的参数，决定生成的命令对象。

UserCommand,PortCommand等：是具体ftp命令的实现