如何用java实现ftp客户端程序

Posted 2023-04-01

FTP 的主要操作都是基于各种命令基础之上的。常用的命令有： 　　· 设置传输模式，它包括ASCⅡ(文本) 和BINARY 二进制模式; 　　· 目录操作，改变或显示远程计算机的当前目录(cd、dir/ls 命令); 　　· 连接操作，open命令用于建立同远程计算机的连接；close命令用于关闭连接; 　　· 发送操作，put命令用于传送文件到远程计算机；mput 命令用于传送多个文件到远程计算机; 　　· 获取操作，get命令用于接收一个文件；mget命令用于接收多个文件。 　　编程思路 　　根据FTP 的工作原理，在主函数中建立一个服务器套接字端口，等待客户端请求，一旦客户端请求被接受，服务器程序就建立一个服务器分线程，处理客户端的命令。如果客户端需要和服务器端进行文件的传输，则建立一个新的套接字连接来完成文件的操作。 　　编程技巧说明 http://www.jacken.com.cn/Programming/Java/2008-10-24/Java-Articlea7b870512fe2bce0ffefc95c6800ca5d.html 参考技术A 楼上的答案不够严谨。忽略了FTP的协议的内容。
实际上真正的FTP server都要实现FTP协议约定的内容。所以建议你找开源的代码结合FTP协议仔细学习。 参考技术B 1.主函数设计

在主函数中，完成服务器端口的侦听和服务线程的创建。我们利用一个静态字符串变量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)
参考技术C 去这里参考一下 http://tech.techweb.com.cn/thread-224066-1-1.html

如何用Java Socket实现一个简单的Redis客户端工具

Redis是最常见的缓存服务中间件，在java开发中，一般使用 jredis 来实现。

如果不想依赖第三方组件，自己实现一个简单的redis客户端工具，该如何实现呢？本文就是介绍这样一种方法。

 

Redis的协议非常简单，而且输入数据和输出数据都遵循统一的协议，具体规则参考这里：

http://redisdoc.com/topic/protocol.html

 

最重要的规则有如下几点：

状态回复（status reply）的第一个字节是 "+"
错误回复（error reply）的第一个字节是 "-"
整数回复（integer reply）的第一个字节是 ":"
批量回复（bulk reply）的第一个字节是 "$"
多条批量回复（multi bulk reply）的第一个字节是 "*"

 

针对上述规则，我们用两个类来实现：

1、SimpleRedisClient类，主要用于发送请求，并读取响应结果（字符串）；

2、SimpleRedisData类，用于解析响应结果，把redis统一协议的字符串，解析为具体的对象。

package tebon.kjcrm;

import java.io.Closeable;
import java.io.IOException;
import java.net.Socket;
import java.util.List;

public class SimpleRedisClient implements Closeable {

    private String host;
    private int port;
    private String auth;
    private Socket socket = null;

    public SimpleRedisClient(String host, int port, String auth) {
        this.host = host;
        this.port = port;
        this.auth = auth;

        try {
            socket = new Socket(this.host, this.port);
            socket.setSoTimeout(60 * 1000);
            socket.setSendBufferSize(102400);
            socket.setReceiveBufferSize(102400);
        } catch (Exception ex) {
            socket = null;
            ex.printStackTrace();
        }
    }

    public boolean connect() throws IOException {
        if (socket == null || auth == null || auth.length() <= 0) {
            return false;
        }
        String response = execute("AUTH", auth);
        if (response == null || response.length() <= 0) {
            return false;
        }
        Object data = new SimpleRedisData(response).getObject();
        String res = data != null ? data.toString() : null;
        return "OK".compareTo(res) == 0;
    }

    @Override
    public void close()  {
        try {
            if (socket != null) {
                socket.shutdownOutput();
                socket.close();
            }
            //System.out.println("closed");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public String getString(String key) {
        if (socket == null || key == null || key.isEmpty()) {
            return null;
        }
        try {
            String response = execute("GET", key);
            Object data = new SimpleRedisData(response).getObject();
            return data != null ? data.toString() : null;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    public String setString(String key, String value) {
        if (socket == null || key == null || key.isEmpty()) {
            return null;
        }
        try {
            String response = execute("SET", key, value);
            if (response == null || response.length() <= 0) {
                return null;
            }
            Object data = new SimpleRedisData(response).getObject();
            return data != null ? data.toString() : null;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    public String deleteKey(String key) throws IOException {
        if (socket == null || key == null || key.isEmpty()) {
            return null;
        }
        String response = execute("DEL", key);
        if (response == null || response.length() <= 0) {
            return null;
        }
        Object data = new SimpleRedisData(response).getObject();
        return data != null ? data.toString() : null;
    }

    public List<String> getKeys(String pattern) throws IOException {
        if (socket == null || pattern == null || pattern.isEmpty()) {
            return null;
        }

        String response = execute("KEYS", pattern);
        if (response == null || response.length() <= 0) {
            return null;
        }

        Object data = new SimpleRedisData(response).getObject();
        return data != null ? (List<String>)data : null;
    }

    public String execute(String... args) throws IOException {
        if (socket == null || args == null || args.length <= 0) {
            return null;
        }

        //System.out.println(StringUtil.join(args, " "));

        StringBuilder request = new StringBuilder();
        request.append("*" + args.length).append("\\r\\n");//参数的数量

        for (int i = 0; i < args.length; i++) {
            request.append("$" + args[i].getBytes("utf8").length).append("\\r\\n");//参数的长度
            request.append(args[i]).append("\\r\\n");//参数的内容
        }

        socket.getOutputStream().write(request.toString().getBytes());
        socket.getOutputStream().flush();

        StringBuilder reply = new StringBuilder();
        int bufSize = 1024;
        while (true) {
            byte[] buf = new byte[bufSize];
            int len = socket.getInputStream().read(buf);
            if (len < 0) {
                break;
            }
            String str = new String(buf, 0, len);
            reply.append(str);
            if (str.endsWith("\\r\\n")) {
                break;
            }
        }

        String response = reply.toString();
        //System.out.println("response: " + response);
        return response;
    }


}

 

package tebon.kjcrm;

import java.util.ArrayList;
import java.util.List;

public class SimpleRedisData {

    public SimpleRedisData(String rawData) {
        this.rawData = rawData;
        //System.out.println(rawData);
    }

    private int pos;
    private String rawData;

    public Object getObject() {
        if (rawData == null || rawData.length() <= 0) {
            return null;
        }
        char c = rawData.charAt(pos);
        if (c == \'+\') {
            return getSingleLineString();
        } else if (c == \'-\') {
            return getErrorString();
        } else if (c == \':\') {
            return getNumberString();
        } else if (c == \'$\') {
            return getBlukString();
        } else if (c == \'*\') {
            return getMultiBulkStringList();
        } else {
            return null;
        }
    }

    private String getSingleLineString() {
        int i = rawData.indexOf("\\r\\n", pos);
        if (i > 0) {
            int from = pos + 1;
            int to = i;
            String v = rawData.substring(from, to);
            pos = to + 2;
            return v;
        }
        return null;
    }

    private String getErrorString() {
        int i = rawData.indexOf("\\r\\n", pos);
        if (i > 0) {
            int from = pos + 1;
            int to = i;
            String v = rawData.substring(from, to);
            pos = to + 2;
            return v;
        }
        return null;
    }

    private String getNumberString() {
        int i = rawData.indexOf("\\r\\n", pos);
        if (i > 0) {
            int from = pos + 1;
            int to = i;
            String v = rawData.substring(from, to);
            pos = to + 2;
            return v;
        }
        return null;
    }

    private String getBlukString() {
        int i = rawData.indexOf("\\r\\n", pos);
        if (i > 0) {
            int from = pos + 1;
            int to = i;
            int bulkSize = Integer.parseInt(rawData.substring(from, to));
            pos = to + 2;

            from = pos;
            to = pos + bulkSize;
            try {
                //$符号后面的数值是指内容的字节长度，而不是字符数量，所以要转换为二进制字节数组，再取指定长度的数据
                byte[] buf = rawData.substring(from).getBytes("utf-8");
                String v = new String(buf, 0, bulkSize);
                pos = to + 2;
                return v;
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
        }
        return null;
    }

    private List<String> getMultiBulkStringList() {
        int i = rawData.indexOf("\\r\\n", pos);
        if (i > 0) {
            List<String> values = new ArrayList<>();
            int from = pos + 1;
            int to = i;
            int multSize = Integer.parseInt(rawData.substring(from, to));
            pos = to + 2;
            for (int index = 0; index < multSize; index++) {
                values.add(getBlukString());
            }
            return values;
        }
        return null;
    }

}

 

package tebon.kjcrm;

import org.junit.jupiter.api.Test;

import java.util.List;

public class RedisTest {

    @Test
    public void test() {
        SimpleRedisClient client = null;
        try {
            client = new SimpleRedisClient("172.16.101.43", 6379, "Tebon@2019");
            System.out.println("connected: " + client.connect());

            List<String> keyList = client.getKeys("api_*");

            for (int i = 0; i < keyList.size(); i++) {
                System.out.println((i + 1) + "\\t" + keyList.get(i));
            }

           System.out.println("keys: " + keyList != null ? keyList.size() : "null");

            System.out.println(client.getString("api_getCustomerName"));

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (client != null) {
                client.close();
            }
        }
    }

}

 

优点：

1、不依赖任何第三方组件，可以顺利编译通过；

2、代码及其简单。

 

不足之处：

1、未考虑并发访问；

2、未提供更多的数据类型，以及读写方法。