Golang实现FTP客户端协议(RFC 959)及插件库使用

标准库net/ftp使用

Go标准库中的net/ftp包实现了FTP客户端协议(RFC 959)，以下是基本使用方法：

package main

import (
	"fmt"
	"log"
	"net/ftp"
	"os"
	"time"
)

func main() {
	// 连接到FTP服务器
	conn, err := ftp.Dial("ftp.example.com:21", ftp.DialWithTimeout(5*time.Second))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Quit()

	// 登录
	err = conn.Login("username", "password")
	if err != nil {
		log.Fatal(err)
	}

	// 列出当前目录文件
	entries, err := conn.List("")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Directory listing:")
	for _, entry := range entries {
		fmt.Println(entry.Name)
	}

	// 下载文件
	downloadFile(conn, "remote_file.txt", "local_file.txt")

	// 上传文件
	uploadFile(conn, "local_file.txt", "remote_file.txt")

	// 创建目录
	err = conn.MakeDir("new_directory")
	if err != nil {
		log.Println("Create directory failed:", err)
	}

	// 删除文件
	err = conn.Delete("file_to_delete.txt")
	if err != nil {
		log.Println("Delete file failed:", err)
	}
}

func downloadFile(conn *ftp.ServerConn, remotePath, localPath string) {
	// 打开远程文件
	r, err := conn.Retr(remotePath)
	if err != nil {
		log.Fatal(err)
	}
	defer r.Close()

	// 创建本地文件
	localFile, err := os.Create(localPath)
	if err != nil {
		log.Fatal(err)
	}
	defer localFile.Close()

	// 复制内容
	_, err = localFile.ReadFrom(r)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Downloaded %s to %s\n", remotePath, localPath)
}

func uploadFile(conn *ftp.ServerConn, localPath, remotePath string) {
	// 打开本地文件
	localFile, err := os.Open(localPath)
	if err != nil {
		log.Fatal(err)
	}
	defer localFile.Close()

	// 上传文件
	err = conn.Stor(remotePath, localFile)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Uploaded %s to %s\n", localPath, remotePath)
}

第三方库github.com/jlaffaye/ftp使用

标准库的net/ftp功能有限，推荐使用更强大的第三方库github.com/jlaffaye/ftp：

package main

import (
	"fmt"
	"log"
	"os"
	"time"

	"github.com/jlaffaye/ftp"
)

func main() {
	// 连接到FTP服务器
	conn, err := ftp.Dial("ftp.example.com:21", ftp.DialWithTimeout(5*time.Second))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Quit()

	// 登录
	err = conn.Login("username", "password")
	if err != nil {
		log.Fatal(err)
	}

	// 获取当前工作目录
	currentDir, err := conn.CurrentDir()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Current directory:", currentDir)

	// 改变目录
	err = conn.ChangeDir("subdir")
	if err != nil {
		log.Fatal(err)
	}

	// 递归列出目录内容
	walker := conn.Walk(".")
	for walker.Next() {
		fmt.Println(walker.Path())
	}

	// 下载大文件(流式处理)
	downloadLargeFile(conn, "large_file.zip", "local_large_file.zip")

	// 上传大文件(流式处理)
	uploadLargeFile(conn, "local_large_file.zip", "remote_large_file.zip")
}

func downloadLargeFile(conn *ftp.ServerConn, remotePath, localPath string) {
	r, err := conn.Retr(remotePath)
	if err != nil {
		log.Fatal(err)
	}
	defer r.Close()

	file, err := os.Create(localPath)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	buf := make([]byte, 1024*1024) // 1MB buffer
	for {
		n, err := r.Read(buf)
		if n > 0 {
			_, writeErr := file.Write(buf[:n])
			if writeErr != nil {
				log.Fatal(writeErr)
			}
		}
		if err != nil {
			break
		}
	}
	fmt.Printf("Downloaded large file %s to %s\n", remotePath, localPath)
}

func uploadLargeFile(conn *ftp.ServerConn, localPath, remotePath string) {
	file, err := os.Open(localPath)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	err = conn.Stor(remotePath, file)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Uploaded large file %s to %s\n", localPath, remotePath)
}

高级功能实现

1. 断点续传

func resumeDownload(conn *ftp.ServerConn, remotePath, localPath string) {
	// 获取本地文件大小(如果存在)
	var localSize int64
	if info, err := os.Stat(localPath); err == nil {
		localSize = info.Size()
	}

	// 以追加模式打开本地文件
	file, err := os.OpenFile(localPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 设置偏移量进行断点续传
	r, err := conn.RetrFrom(remotePath, uint64(localSize))
	if err != nil {
		log.Fatal(err)
	}
	defer r.Close()

	_, err = file.ReadFrom(r)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Resumed download of %s to %s\n", remotePath, localPath)
}

2. 支持TLS/SSL加密

func connectWithTLS() {
	// 使用显式TLS(FTPS)
	conn, err := ftp.Dial("ftp.example.com:21", 
		ftp.DialWithTimeout(5*time.Second),
		ftp.DialWithExplicitTLS(&tls.Config{
			InsecureSkipVerify: true, // 仅测试使用，生产环境应验证证书
		}))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Quit()

	// 登录等操作与普通FTP相同
	err = conn.Login("username", "password")
	if err != nil {
		log.Fatal(err)
	}
}

3. 连接池管理

type FTPPool struct {
	pool chan *ftp.ServerConn
}

func NewFTPPool(addr string, max int) (*FTPPool, error) {
	pool := make(chan *ftp.ServerConn, max)
	for i := 0; i < max; i++ {
		conn, err := ftp.Dial(addr)
		if err != nil {
			return nil, err
		}
		pool <- conn
	}
	return &FTPPool{pool: pool}, nil
}

func (p *FTPPool) Get() *ftp.ServerConn {
	return <-p.pool
}

func (p *FTPPool) Put(conn *ftp.ServerConn) {
	p.pool <- conn
}

func (p *FTPPool) Close() {
	close(p.pool)
	for conn := range p.pool {
		conn.Quit()
	}
}

注意事项

1. FTP协议默认使用明文传输密码，建议使用FTPS或SFTP
2. 大文件传输时使用流式处理，避免内存问题
3. 网络操作应设置合理的超时时间
4. 生产环境应考虑连接池和错误重试机制
5. 被动模式(PASV)通常能更好地通过防火墙

以上代码展示了Go语言中实现FTP客户端的基本方法和高级技巧，可以根据实际需求进行调整和扩展。