FTP_socket_java主要要点

最新推荐文章于 2024-06-26 11:57:17 发布
最新推荐文章于 2024-06-26 11:57:17 发布
阅读量446 收藏 1
点赞数
分类专栏： java 文章标签： ftp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/znr1995/article/details/72892263
版权
FTP主要要点：

  1. 发送消息通过socket.getInputStream()/getOutputStream 的接口，比如发送USER数据

    java
    writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    writer.writer("USER "+user+"\r\n");

    注意\r\n，和USER后的空格

  2. ftp基于TCP的服务，使用2个端口，21->用于命令端口,20->用于数据端口但是数据端口并不总是20。这就是主动模式与被动模式的区别

  3. 主动FTP：客户端从非特定端口N向客户端21端口发送请求，客户端监听N+1 的端口，并发送“port N+1”到服务器，绑定自己的数据端口。

  4. N端口到FTP服务器21端口，客户端初始化

    1. 服务器21端口客户端N端口，服务器响应客户端
    2. 服务器20端口到客户机N+1端口，服务器初始数据到数据端口
    3. N+1端口到服务器20端口，客户端发送ACK到服务器数据端口

  5. 被动模式：在被动模式下，命令连接和数据连接都有客户端发起。服务端只响应客户端的请求即可。

    在被动模式下。客户端不会主动提交PORT命令来允许服务器回连它的数据端口，而是由服务器发送PORT P给客户端。

    xml
    227 Entering Passive Mode (127,0,0,1,212,237)

    这是进入PASV模式后的响应，127.0.0.1是本地主机，后面212，237是端口后，实际端口是212* 256 + 237 = 54509，这才是服务器分给我的数据端口后，每次上传，下载，获取服务文件列表，都需要通过这个端口，建立新的socket，获取数据。

    这样做的好处是避免服务器到客户端数据端口被防火墙过滤掉

    1. N端口到FTP服务器21端口，客户端初始化
    2. 服务器21端口客户端N端口，服务器响应客户端
    3. N+1端口到FTP服务器P（这里不是20端口了）端口，客户端初始化数据链路
    4. 服务器响应ACK给客户端

  6. 优缺点：主动模式对服务器有利，端口固定，对客户端来说，容易被客户端的防火墙柱塞数据端口。被动模式，对服务器不利，用到的高位数据端口可能被服务器的防火墙屏蔽。反正主动与否看数据端口是否由服务端发起，产生这个模式的锅防火墙背定了！

    本文章参考这篇文章

    http://jackiechen.blog.51cto.com/196075/193883

FTP数据传输：

  1. ftp的数据传输通过数据端口，进入被动模式，客户端主动连接数据端口，当通信端口21发送

    writeLine("LIST")后，在数据端口准备接受返回回来的数据，

    同理，上传和下载文件也是这么回事

  2. 其他的貌似我也没有研究了，反正作业要求就这么多，就到此位置了。

  3. 代码如下：

package ftpCient;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.LinkedList;
import java.util.StringTokenizer;

//trylock /lock 是我在类外为了获取这个类的信息的锁，读者可以忽略。
public class SimpleFTP {

    Socket socket = null;
    BufferedReader reader = null;
    BufferedWriter writer = null;
    private static boolean DEBUG = false;

    LinkedList<String> strlist = new LinkedList<String>();

    boolean lock = false;

    public SimpleFTP() throws IOException, InterruptedException {
    }

    public synchronized void connect(String host) throws IOException, InterruptedException {
        connect(host, 21);
    }

    public synchronized void connect(String host, int port) throws IOException, InterruptedException {
        connect(host, port, "anonymous", "anonymous");
    }

    public synchronized void connect(String host, int port, String user, String pass)
            throws IOException, InterruptedException {
        if (socket != null) {
            throw new IOException("FTP is already connected!");
        }
        socket = new Socket(host, port);
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        String response = readLine();
        if (!response.startsWith("220 ")) {
            trylock();
            strlist.add("SimpleFTP received an unknown response when connecting to the FTP server: " + response);
            unlock();
        }

        sendLine("USER " + user);
        response = readLine();
        if (!response.startsWith("331 ")) {
            trylock();
            strlist.add("SimpleFTP received an unknown response after sending the user: " + response);
            unlock();
        }

        sendLine("PASS " + pass);
        response = readLine();
        if (!response.startsWith("230 ")) {
            trylock();
            strlist.add("SimpleFTP was unable to log in with the supplied password: " + response);
            unlock();
        }
        // now logged in
    }

    public synchronized void disconnect() throws IOException {
        try {
            sendLine("QUIT");
            readLine();
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            socket = null;
        }
    }

    public synchronized String pwd() throws IOException, InterruptedException {
        sendLine("PWD");
        String dir = null;
        Thread.sleep(100);
        String respone = readLine();
        if (respone.startsWith("257 ")) {
            int firstQuote = respone.indexOf('\"');
            int secondQuote = respone.indexOf('\"', firstQuote + 1);
            if (secondQuote > 0) {
                dir = respone.substring(firstQuote + 1, secondQuote);
            }
        }
        return dir;
    }

    public String list() throws IOException, InterruptedException {
        sendLine("PASV");
        String respone = readLine();
        sendLine("LIST");
        respone = readLine();
        String ip = null;
        int port = -1;
        int opening = respone.indexOf('(');
        int closing = respone.indexOf(')', opening + 1);
        if (closing > 0) {
            String dataLink = respone.substring(opening + 1, closing);
            StringTokenizer tokenizer = new StringTokenizer(dataLink, ",");
            try {
                ip = tokenizer.nextToken() + "." + tokenizer.nextToken() + "." + tokenizer.nextToken() + "."
                        + tokenizer.nextToken();
                port = Integer.parseInt(tokenizer.nextToken()) * 256 + Integer.parseInt(tokenizer.nextToken());
            } catch (Exception e) {
                trylock();
                strlist.add("data link information:" + respone);
                unlock();
            }

        }
        Socket dataSocket = new Socket(ip, port);
        respone = readLine();
        BufferedInputStream input = new BufferedInputStream(dataSocket.getInputStream());
        // maybe out limit ,but I just want easy
        byte[] buffer = new byte[10240];
        int byteRead = 0;
        byteRead = input.read(buffer);
        String string = new String(buffer, 0, byteRead);
        return string;
    }

    public synchronized boolean cwd(String dir) throws IOException, InterruptedException {
        sendLine("CMD " + dir);
        String respone = readLine();
        return (respone.startsWith("250 "));
    }

    public synchronized boolean stor(File file) throws IOException, InterruptedException {
        if (file.isDirectory()) {
            trylock();
            strlist.add("FTP canot upload dir");
            unlock();
        }
        String filename = file.getName();
        return stor(filename, filename);

    }

    public synchronized boolean stor(String uploadFilename, String filename) throws IOException, InterruptedException {
        BufferedInputStream input = new BufferedInputStream(new FileInputStream(uploadFilename));
        sendLine("PASV");
        String respone = readLine();
        if (!respone.startsWith("227 ")) {
            trylock();
            strlist.addLast("SimpleFTP could not request passive mode: " + respone);
            unlock();
        }
        String ip = null;
        int port = -1;
        int opening = respone.indexOf('(');
        int closing = respone.indexOf(')', opening + 1);
        if (closing > 0) {
            String dataLink = respone.substring(opening + 1, closing);
            StringTokenizer tokenizer = new StringTokenizer(dataLink, ",");
            ip = tokenizer.nextToken() + "." + tokenizer.nextToken() + "." + tokenizer.nextToken() + "."
                    + tokenizer.nextToken();
            port = Integer.parseInt(tokenizer.nextToken()) * 256 + Integer.parseInt(tokenizer.nextToken());
        }
        trylock();
        sendLine("STOR " + filename);
        Socket dataSocket = new Socket(ip, port);
        String response = readLine();
        unlock();
        if (!response.startsWith("125 ")) {
            if (!response.startsWith("150 ")) {
                trylock();
                strlist.add("SimpleFTP was not allowed to send the file: " + response);
                unlock();
            }
        }

        BufferedOutputStream outputStream = new BufferedOutputStream(dataSocket.getOutputStream());
        byte[] buffer = new byte[4096];
        int byteRead = 0;
        while ((byteRead = input.read(buffer)) != -1) {
            outputStream.write(buffer, 0, byteRead);

        }

        outputStream.flush();
        outputStream.close();
        input.close();
        return true;
    }

    public synchronized boolean pasv() throws IOException, InterruptedException {
        sendLine("PASV");
        return true;
    }

    public synchronized boolean bin() throws IOException, InterruptedException {
        sendLine("TYPE I");
        String response = readLine();
        return (response.startsWith("200 "));
    }

    public synchronized boolean ascii() throws IOException, InterruptedException {
        sendLine("TYPE A");
        String response = readLine();
        return (response.startsWith("200 "));
    }

    private void sendLine(String line) throws IOException {
        if (socket == null) {
            throw new IOException("FTP not connected");
        }
        try {
            writer.write(line + "\r\n");
            writer.flush();
            if (DEBUG)
                System.out.println(">" + line);
        } catch (IOException e) {
            socket = null;
            throw e;
        }

    }

    public String readLine() throws IOException, InterruptedException {
        String line = reader.readLine();
        trylock();
        strlist.add(line);
        System.out.println(line);
        unlock();
        return line;
    }

    public String[] getOutput() throws InterruptedException {
        if (strlist.isEmpty())
            return null;
        trylock();
        String[] tmp = new String[strlist.size()];
        for (int i = 0; i < strlist.size(); i++)
            tmp[i] = strlist.get(i);
        strlist.clear();
        unlock();
        return tmp;
    }

    private void trylock() throws InterruptedException {
        while (lock) {
            Thread.sleep(50);
        }
        lock = true;
    }

    private void unlock() {
        lock = false;
    }

    public boolean isLock() {
        return lock;
    }
}
znr1995
关注
专栏目录
socket实现FTP客户端
weixin_40976154的博客
06-23 1476
通过socket实现FTP客户端（MFC版） 使用socket我们可以自己编写一个FTP的客户端。开始之前先了解FTP的两种工作模式大致的过程。 被动模式的流程 被动模式下，FTP客户端使用一个非知名的随机端口N（>1024)去连接FTP服务器的21端口建立控制连接，然后通过控制通道发送PASV命令到服务器，服务器收到后会开启一个随机端口P（>1024）并开始监听，同时告诉客户端连接我...
java原始套接字,raw socket介绍(示例代码)
weixin_31304599的博客
03-15 1260
原文: http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=876233test1.原始套接字(raw socket)1.1 原始套接字工作原理与规则原始套接字是一个特殊的套接字类型,它的创建方式跟TCP/UDP创建方法几乎是一摸一样,例如,通过int sockfd;sockfd = socktet(AF_INET， SOCK_RAW...
FTP协议要点
02-01 460
FTP协议的大体流程分为如下3步： 1、登陆         客户端发送用户名，服务器要求密码；客户端发送密码，服务器验证返回结果       （可将匿名，非匿名的验证方式再详细点。。。。。。。。。。） 2、协商传输模式        传输模式分为主动模式和被动模式，这里的主被动是针对服务器而言。也就是说，在开始建立数据连接时，如果是服务器主动连客户端，就叫主动模式，服务器被动等待客
使用 Socket 通信实现 FTP 客户端程序
一杯茶品人生沉浮，平常心造万千世界
06-02 4891
FTP 概述文件传输协议（FTP）作为网络共享文件的传输协议，在网络应用软件中具有广泛的应用。FTP的目标是提高文件的共享性和可靠高效地传送数据。在传输文件时，FTP 客户端程序先与服务器建立连接，然后向服务器发送命令。服务器收到命令后给予响应，并执行命令。FTP 协议与操作系统无关，任何操作系统上的程序只要符合 FTP 协议，就可以相互传输数据。本文主要基于 LINUX 平台，对 FTP 客户端的实现原理进行详尽的解释并阐述如何使用 C 语言编写一个简单的 FTP 客户端。回页首FTP 协议相比其他协议，
Socket 实现 FTP Server
勇敢的心博客
01-03 1157
get  /tmp/1.txt  /tmp/1.txt ：把服务端 /tmp/1.txt 下载到客户端 /tmp/1.txt put  /tmp/1.txt  /tmp/1.txt ：把客户端 /tmp/1.txt 上传到服务端 /tmp/1.txt [root@localhost ~]# cat ftp_server.py #!/usr/bin/env python #-*- coding
Socket——向FTP服务器发送消息并获得响应
最新发布
计算机硕士的博客
06-26 993
Socket——向FTP服务器发送消息并获得响应。Socket（套接字）是网络编程中用于描述IP地址和端口的一个抽象概念，通过它可以实现不同主机间的通信。套接字可以分为几种不同的类型，每种类型对应不同的协议和传输模式。
视频传输（Java程序）.rar_Java 视频传输_java传输视频_视频上传 java_视频传输_视频传输 java
09-20
下面我们将详细探讨Java在视频传输中的应用，以及相关的技术要点。 首先，Java是一种跨平台的编程语言，其丰富的类库和强大的网络支持使其成为实现视频传输的理想选择。在Java中，我们可以利用Socket编程来建立...
毕设&课程作业_java原生Socket实现小区智能快递柜系统.zip
01-31
"毕设&课程作业_java原生Socket实现小区智能快递柜系统.zip" 这个标题表明这是一个基于Java编程语言的毕业设计或课程作业项目，专注于实现一个小区内的智能快递柜系统。该系统可能利用了Java的Socket编程技术来实现...
java scoket FTP
05-13
根据提供的文件信息，我们可以深入探讨如何使用Java Socket编程来实现FTP（文件传输协议）的功能。在下面的内容中，我们将详细解析这段代码所涉及的核心概念、技术细节以及其实现原理。 ### Java Socket编程基础 ...
Java写的一个FTP服务器下载程序
07-20
### Java实现的FTP服务器下载...综上所述，本程序不仅展示了如何使用Java实现FTP文件下载的基本流程，还涉及了异常处理、资源管理、文件路径处理等多个技术要点，对于学习Java网络编程和FTP协议有着重要的参考价值。
socket实现ftp客户端
05-31
用socket来fpt客户端
用Socket编程实现FTP
03-07
它的原理也相当的简单，客户端程序实现一个命令行或图形界面，将用户命令翻译成 FTP 命令，并发送给服务器端程序。服务器端程序响应 FTP 命令，并将操作成功与否的信息以 FTP 响应形式返回给客户端程序。双方遵守 FTP 协议，完成文件传输服务。 就是利用MFC提供的CSocket类和CAsyncsocket类实现一个客户/服务器模式的数据通信模式，使用CSocketFile类和CArchive类来读写数据。它很好的实现了所有的功能，提供了简洁实用的接口。
用Socket写的简易FTP服务器和客户端
12-31
FTP服务器支持简单的CD，GET，DIR等命令。 通信用UDP实现
VC++ Socket通信实现的FTP通信协议，实测下载速度比MFC封装的类快很多。
05-25
VC++ Socket通信实现的FTP通信协议，实测下载速度比MFC封装的类快很多。基于VS2015 MFC工程实现的测试程序，适合新手入门，简单易懂。
C实现FTP客户端 socket编程
12-18
我们的实验报告，C实现FTP客户端，有实验报告和源程序。 socket编程实例C实现FTP客户端 socket编程实例C实现FTP客户端 socket编程实例C实现FTP客户端 socket编程实例C实现FTP客户端 socket编程实例C实现FTP客户端 socket编程实例
Ftp协议Socket实现
diuku1661的博客
09-03 408
原来用WebRequest来传输文件，被人鄙视了。就弄个Socket版的，支持Active，Passive模式。 带事件日志，有时间的人可以拿去做C#版的flashfxp。 1 public class FtpClient 2 { 3 public class FtpLogEventArgs : EventArgs 4 ...
基于socket实现FTP服务器
yoke__的博客
10-24 3725
基于socket完成了一个FTP服务器，实现了其基本功能
FTP传输软件（基于socket网络编程）
举子人间
04-13 369
哈哈哈，这一次终于轮到我来总结啦！经过今天的不懈努力，在借鉴前辈的基础上，终于完成了这一阶段的goal！ 功能：通过客户端输入指令，“ls pwd cd get put”等等能实现客户端查看服务端文件，获取和发送文件功能。 ls列出服务端文件，lls列出客户端本地文件，get xxx表示从服务端获取一个文件，因而put xxx表示从客户端发送一个文件到服务端。cd和lcd功能大致差不多，最后quit退出软件。 大致思路 server.c client.c 代码区 这是文件的基础配置。将命令都宏定义，
Socket 及 FTP通讯
standhui的专栏
05-21 307
#pragma once // 头文件 #include "afxwin.h" #include <afxsock.h> #include <afxinet.h> class CRobotControl { public: CRobotControl(void); ~CRobotControl(void); public: BOOL RobotSocketConnect(CString m_RobotIP, int strport); BOOL RobotFTPCon
Java_TCPIP_Socket编程指南
Java_TCPIP_Socket编程 本资源摘要信息涵盖了Java_TCPIP_Socket编程的基础知识和高级话题，涵盖了计算机网络、套接字编程、TCP/IP协议、客户端和服务器、数据编码和解码、多任务处理、阻塞和超时、多接收者、控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值