1、配置文件：copyRemoteFile.properties


#  src/dao.properties 
#      这里保存的都是键值对信息 
#  interface name(no packgage) = implementation class
# 注意： 
#　　A：【路径符号】【必须】是【/】【如：D:/home/publish】 
#　　B：【键key=值value】对【后面】【绝不允许有空格】【如：REMOTE_HOST_IP=172.77.9.77】
# REMOTE_HOST_IP  远程机器IP 
# LOGIN_ACCOUNT   远程机器登录名 
# LOGIN_PASSWORD  远程机器登录密码 
# SHARE_DOC_NAME  远程机器共享文件夹名（设置共享后必须授予读写权限）
# sourcePath      本地路径 
# targetPath      目标路径（真实路径=共享文件夹路径+目标路径）
REMOTE_HOST_IP=172.77.9.77
LOGIN_ACCOUNT=77
LOGIN_PASSWORD=77
SHARE_DOC_NAME=vfs_home 
sourcePath=D:/home/publish
targetPath=publish
　　

2、导入jar包：jcifs-1.3.16.jar

3、读取配置文件中key对应的value类：RemoteConfigUtil.java

package com.remote;
 
import java.io.IOException;
import java.util.Properties;
 
/**
 * 读取配置文件中key对应的value
 * 
 */
public class RemoteConfigUtil {
    private String REMOTE_HOST_IP;
    private String LOGIN_ACCOUNT;
    private String LOGIN_PASSWORD;
    private String SHARE_DOC_NAME;
    private String sourcePath;
    private String targetPath;
 
    //无参构造方法
    public RemoteConfigUtil() {
        try {
            // 读取配置文件
            Properties prop = new Properties();
            prop.load(this.getClass().getClassLoader().getResourceAsStream("copyRemoteFile.properties"));
            // 根据 key 获取 value
            REMOTE_HOST_IP = prop.getProperty("REMOTE_HOST_IP");
            LOGIN_ACCOUNT = prop.getProperty("LOGIN_ACCOUNT");
            LOGIN_PASSWORD = prop.getProperty("LOGIN_PASSWORD");
            SHARE_DOC_NAME = prop.getProperty("SHARE_DOC_NAME");
            sourcePath = prop.getProperty("sourcePath");
            targetPath = prop.getProperty("targetPath");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public String getLOGIN_ACCOUNT() {
        return LOGIN_ACCOUNT;
    }
 
    public void setLOGIN_ACCOUNT(String login_account) {
        LOGIN_ACCOUNT = login_account;
    }
 
    public String getLOGIN_PASSWORD() {
        return LOGIN_PASSWORD;
    }
 
    public void setLOGIN_PASSWORD(String login_password) {
        LOGIN_PASSWORD = login_password;
    }
 
    public String getREMOTE_HOST_IP() {
        return REMOTE_HOST_IP;
    }
 
    public void setREMOTE_HOST_IP(String remote_host_ip) {
        REMOTE_HOST_IP = remote_host_ip;
    }
 
    public String getSHARE_DOC_NAME() {
        return SHARE_DOC_NAME;
    }
 
    public void setSHARE_DOC_NAME(String share_doc_name) {
        SHARE_DOC_NAME = share_doc_name;
    }
 
    public String getSourcePath() {
        return sourcePath;
    }
 
    public void setSourcePath(String sourcePath) {
        this.sourcePath = sourcePath;
    }
 
    public String getTargetPath() {
        return targetPath;
    }
 
    public void setTargetPath(String targetPath) {
        this.targetPath = targetPath;
    }
}

4、操作远程共享文件夹类： RemoteFileUtil.java

     根据需求选择相应的 Method

package com.remote;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
 
import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFileInputStream;
import jcifs.smb.SmbFileOutputStream;
 
/***********************************************
 *  File Name: RemoteFileUtil.java             
 *  
 *  Description:操作远程共享文件夹类
 *  Change Description：From local copy files to remote directory
 *
 ***********************************************/
public class RemoteFileUtil {   
     
    private ArrayList filelist = new ArrayList();
    RemoteConfigUtil rc = new RemoteConfigUtil();
 
    private String remoteHostIp;  //远程主机IP   
    private String account;       //登陆账户   
    private String password;      //登陆密码   
    private String shareDocName;  //共享文件夹名称   
        
    /**  
     * 默认构造函数  
     */ 
    public RemoteFileUtil(){  
        this.remoteHostIp = rc.getREMOTE_HOST_IP();   
        this.account = rc.getLOGIN_ACCOUNT();   
        this.password = rc.getLOGIN_PASSWORD();   
        this.shareDocName = rc.getSHARE_DOC_NAME();   
    }   
        
    /**  
     * 构造函数  
     * @param remoteHostIp  远程主机Ip  
     * @param account       登陆账户  
     * @param password      登陆密码  
     * @param sharePath     共享文件夹路径  
     */ 
    public RemoteFileUtil(String remoteHostIp, String account, String password,String shareDocName) {   
        this.remoteHostIp = remoteHostIp;   
        this.account = account;   
        this.password = password;   
        this.shareDocName = shareDocName;   
    }      
        
    /**  
     * 对远程共享文件进行读取所有行  
     * @param remoteFileName  文件名  说明：参数为共享目录下的相对路径  
     *  若远程文件的路径为：shareDoc\test.txt,则参数为test.txt(其中shareDoc为共享目录名称);  
     *  若远程文件的路径为：shareDoc\doc\text.txt,则参数为doc\text.txt;  
     * @return  文件的所有行  
     */ 
    public List<String> readFile(String remoteFileName){   
        SmbFile smbFile = null;   
        BufferedReader reader = null;   
        List<String> resultLines = null;   
        //构建连接字符串,并取得文件连接   
        String conStr = null;   
        conStr = "smb://"+account+":"+password+"@"+remoteHostIp+"/"+shareDocName+"/"+remoteFileName;   
        try {   
            smbFile = new SmbFile(conStr);   
        } catch (MalformedURLException e) {   
            e.printStackTrace();   
        }   
        //创建reader   
        try {   
            reader = new BufferedReader(new InputStreamReader(new SmbFileInputStream(smbFile)));   
        } catch (SmbException e) {   
            e.printStackTrace();   
        } catch (MalformedURLException e) {   
            e.printStackTrace();   
        } catch (UnknownHostException e) {   
            e.printStackTrace();   
        }          
        //循环对文件进行读取   
        String line;   
        try {   
            line = reader.readLine();   
            if(line != null && line.length()>0){   
                resultLines = new ArrayList<String>();   
            }   
            while (line != null) {   
                resultLines.add(line);   
                line = reader.readLine();   
            }   
        } catch (IOException e) {   
            e.printStackTrace();   
        }   
        //返回   
        return resultLines;   
    }   
        
    /**  
     * 对远程共享文件进行写入  
     * @param is                本地文件的输入流  
     * @param remoteFileName    远程文件名    说明：参数为共享目录下的相对路径  
     *  若远程文件的路径为：shareDoc\test.txt,则参数为test.txt(其中shareDoc为共享目录名称);  
     *  若远程文件的路径为：shareDoc\doc\text.txt,则参数为doc\text.txt;  
     * @return    
     */ 
    public boolean writeFile(InputStream is,String remoteFileName){   
        SmbFile smbFile = null;   
        OutputStream os = null;   
        byte[] buffer = new byte[1024*8];   
        //构建连接字符串,并取得文件连接   
        String conStr = null;   
        conStr = "smb://"+account+":"+password+"@"+remoteHostIp+"/"+shareDocName+"/"+remoteFileName;   
        try {   
            smbFile = new SmbFile(conStr);   
        } catch (MalformedURLException e) {   
            e.printStackTrace();   
            return false;   
        }   
            
        //获取远程文件输出流并写文件到远程共享文件夹   
        try {   
            os = new BufferedOutputStream(new SmbFileOutputStream(smbFile));   
            while((is.read(buffer))!=-1){   
                os.write(buffer);          
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
            return false;   
        }    
            
        return true;   
    }   
        
        
    /**  
     * 对远程共享文件进行写入重载  
     * @param localFileName   要写入的本地文件全名  
     * @param remoteFileName  远程文件名    说明：参数为共享目录下的相对路径  
     *  若远程文件的路径为：shareDoc\test.txt,则参数为test.txt(其中shareDoc为共享目录名称);  
     *  若远程文件的路径为：shareDoc\doc\text.txt,则参数为doc\text.txt;  
     * @return  
     */ 
    public boolean writeFile(String localFileFullName ,String remoteFileName){   
        try {   
            return writeFile(new FileInputStream(new File(localFileFullName)),remoteFileName);   
        } catch (FileNotFoundException e) {   
            e.printStackTrace();   
            return false;   
        }   
    }   
        
    /**  
     * 对远程共享文件进行写入重载  
     * @param localFileName   要写入的本地文件  
     * @param remoteFileName  远程文件名    说明：参数为共享目录下的相对路径  
     *  若远程文件的路径为：shareDoc\test.txt,则参数为test.txt(其中shareDoc为共享目录名称);  
     *  若远程文件的路径为：shareDoc\doc\text.txt,则参数为doc\text.txt;  
     * @return  
     */ 
    public boolean writeFile(File localFile ,String remoteFileName){   
        try {   
            return writeFile(new FileInputStream(localFile),remoteFileName);   
        } catch (FileNotFoundException e) {   
            e.printStackTrace();   
            return false;   
        }   
    }   
 
        
    /**  
     * 对远程共享文件所有文件  
     * @return  所有文件 
     */ 
    public List<String> getFiles(){   
        SmbFile smbFile = null;   
        BufferedReader reader = null;   
        List<String> resultLines = new ArrayList();   
        //构建连接字符串,并取得文件连接   
        String conStr = null;   
        conStr = "smb://"+account+":"+password+"@"+remoteHostIp+"/"+shareDocName+"/";   
        try {   
            smbFile = new SmbFile(conStr);   
        } catch (MalformedURLException e) {   
            e.printStackTrace();   
        }   
        //创建reader   
        try {   
          String[] a = smbFile.list();
          for(int i=0;i<a.length;i++){
            resultLines.add(a[i]);
            System.out.println(a[i]);
          }
        } catch (SmbException e) {   
            e.printStackTrace();   
        } catch (Exception e) {   
            e.printStackTrace();   
        }          
        //返回   
        return resultLines;   
    }   
     
    /** 在本地为共享计算机创建文件夹 
     * @param remoteUrl 远程计算机路径 
     */ 
    public void smbMkDir(String name) {
        // 注意使用jcifs-1.3.15.jar的时候 操作远程计算机的时候所有类前面须要增加Smb
        // 创建一个远程文件对象
        String conStr = "smb://" + account + ":" + password + "@" + remoteHostIp + "/" + shareDocName;
        SmbFile remoteFile;
        try {
            remoteFile = new SmbFile(conStr + "/" + name);
            if (!remoteFile.exists()) {
                remoteFile.mkdir();// 创建远程文件夹
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (SmbException e) {
            e.printStackTrace();
        }
    }
     
    /**
     * 删除文件夹
     * @param folderPath 共享文件夹下一个文件夹名
     * @return
     */
    public void delFolder(String folderPath) {
        //String conStr = "smb://"+LOGIN_ACCOUNT+":"+LOGIN_PASSWORD+"@"+remoteHostIp+"/"+shareDocName; 
        try {
            delAllFile(folderPath); //删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
             
            SmbFile myFilePath = new SmbFile(filePath);
            myFilePath.delete(); //删除空文件夹
        }
        catch (Exception e) {
            String message = ("删除文件夹操作出错");
            System.out.println(message);
        }
    }
     
     
    /**
     * 删除共享文件夹下一个文件夹名
     * @param path 共享文件夹下一个文件夹名
     * @return
     * @return
     */
    public boolean delAllFile(String path) {
        boolean bea = false;
        try {
            SmbFile file = new SmbFile(path);
            if (!file.exists()) {
                return bea;
            }
            if (!file.isDirectory()) {
                return bea;
            }
            String[] tempList = file.list();
            SmbFile temp = null;
            for (int i = 0; i < tempList.length; i++) {
                if (path.endsWith("/")) {
                    temp = new SmbFile(path + tempList[i]);
                } else {
                    temp = new SmbFile(path + "/" + tempList[i]);
                }
                if (temp.isFile()) {
                    temp.delete();
                }
                if (temp.isDirectory()) {
                    delAllFile(path + "/" + tempList[i] + "/");// 先删除文件夹里面的文件
                    delFolder(path + "/" + tempList[i] + "/");// 再删除空文件夹
                    bea = true;
                }
            }
            return bea;
        } catch (Exception e) {
            return bea;
        }
    }
 
     
     
    /**
     * 复制整个文件夹的内容
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     * @return
     */
    public void copyFolder(String oldPath, String newPath) {
        String conStr = "smb://" + account + ":" + password + "@" + remoteHostIp + "/" + shareDocName;
        System.err.println(conStr);
        try {
            /**
             * 如果存在文件夹删除文件 
             * SmbFile exittemp = new SmbFile(conStr + "/"+newPath);
             * if(exittemp.exists()){
             *      delFolder(conStr+"/"+newPath+"/"); 
             * }
             */
            SmbFile exittemps = new SmbFile(conStr + "/" + newPath);
            if (!exittemps.exists()) {
                exittemps.mkdirs(); // 如果文件夹不存在 则建立新文件夹
            }
            File a = new File(oldPath);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                if (oldPath.endsWith("/")) {
                    temp = new File(oldPath + file[i]);
                } else {
                    temp = new File(oldPath + "/" + file[i]);
                }
                if (temp.isFile()) {
                    if (temp.exists()) {
                        writeFile(temp, newPath + "/" + file[i]);
                    }
                }
                if (temp.isDirectory()) {// 如果是子文件夹
                    copyFolder(oldPath + "/" + file[i], newPath + "/" + file[i]);
                }
            }
 
        } catch (Exception e) {
            String message = "复制整个文件夹内容操作出错";
            System.out.println(message);
        }
    }
     
    /**
     * 复制文件到远程计算机，如果目标路径不存在则创建，反之不创建
     * @param localFileFullName 本地指定文件路径
     * @param targetDir 目标路径
     */
    public void copyFileToRemoteDir(String localFileFullName, String targetDir) {
        System.err.println(localFileFullName + "--" + targetDir);
        RemoteFileUtil rf = new RemoteFileUtil();
        InputStream is = null;
        SmbFile smbFile = null;
        OutputStream os = null;
        byte[] buffer = new byte[1024 * 8];
        // 构建连接字符串,并取得文件连接
        String conStr = null;
        conStr = "smb://" + account + ":" + password + "@" + remoteHostIp + "/" + shareDocName + "/" + targetDir;
        System.err.println(conStr);
        SmbFile sf;
        try {
            sf = new SmbFile("smb://" + account + ":" + password + "@" + remoteHostIp + "/" + shareDocName + "/" + targetDir);
            if (!sf.exists()) {
                // 新建目标目录
                sf.mkdirs();
                is = new FileInputStream(new File(localFileFullName));
                // 获取远程文件输出流并写文件到远程共享文件夹
                os = new BufferedOutputStream(new SmbFileOutputStream(smbFile));
                while ((is.read(buffer)) != -1) {
                    os.write(buffer);
                }
            }
        } catch (Exception e) {
            System.err.println("提示：复制整个文件夹内容操作出错。");
        }
 
        File file = new File(localFileFullName);
        if (file.isFile()) {
            File sourceFile = file;     // 源文件
            File targetFile = new File(new File(targetDir).getAbsolutePath() + File.separator + file.getName());// 目标文件
            String name = file.getName();// 文件名
            if (targetDir != null && targetFile != null) {
                rf.writeFile(sourceFile, "/" + targetDir + "/" + name); // 复制文件
            } else if (targetFile != null) {
                rf.writeFile(sourceFile, name); // 复制文件
            }
        }
    }
     
    /**
     * 循环获取文件夹内所有匹配的文件
     * @param strPath 路径
     * @param subStr 匹配字符
     * @return
     */
    public ArrayList refreshFileList(String strPath, String subStr) {
        File dir = new File(strPath);
        File[] files = dir.listFiles();
        if (files == null)
            return null;
        for (int i = 0; i < files.length; i++) {
            if (!files[i].isDirectory()) {
                String strFileName = files[i].getAbsolutePath().toLowerCase();
                if (files[i].getName().indexOf(subStr) >= 0) {
                    filelist.add(files[i].getName());
                }
            }
        }
        return filelist;
    }
 
    // 测试从本地复制文件到远程目标目录，测试已通过
    public static void main(String[] args) {
        RemoteConfigUtil rc = new RemoteConfigUtil();
        RemoteFileUtil util = new RemoteFileUtil();
        util.copyFileToRemoteDir(rc.getSourcePath(), rc.getTargetPath());
    }
}  

1：ftp简介

文件传输协议（File Transfer Protocol，FTP）是用于在网络上进行文件传输的一套标准协议，它工作在 OSI 模型的第七层， TCP 模型的第四层， 即应用层， 使用 TCP 传输而不是 UDP， 客户在和服务器建立连接前要经过一个“三次握手”的过程， 保证客户与服务器之间的连接是可靠的， 而且是面向连接， 为数据传输提供可靠保证。
FTP允许用户以文件操作的方式（如文件的增、删、改、查、传送等）与另一主机相互通信。然而， 用户并不真正登录到自己想要存取的计算机上面而成为完全用户， 可用FTP程序访问远程资源， 实现用户往返传输文件、目录管理以及访问电子邮件等等， 即使双方计算机可能配有不同的操作系统和文件存储方式。

1.1：工作流程

在传输文件时，FTP 客户端程序先与服务器建立连接，然后向服务器发送命令。服务器收到命令后给予响应，并执行命令。FTP 协议与操作系统无关，任何操作系统上的程序只要符合 FTP 协议，就可以相互传输数据

1.2：工作模式

FTP支持两种模式：Standard （PORT方式，主动方式），Passive （PASV，被动方式）。

1.3：传输方式

FTP的传输有两种方式：ASCII、二进制。

2：windows开启ftp服务

在自己的电脑上可以开启一个ftp服务用于测试。
1：打开控制面板—》程序—》启动或关闭windows功能
找到互联网信息服务勾选✔其中的ftp服务器，web管理，万维网服务。
系统就会安装IIS服务管理器了，安装过程可能需要等待几分钟。

2：回到电脑桌面，右击“计算机”，点击 管理，进入计算机管理界面。在这里，我们就可以看到刚刚添加的IIS服务，接下来的操作就像我们在VPS主机上添加网站差不多的操作步骤了。选中IIS服务——》网站——》右键添加FTP站点

3：设置ftp基本信息。路径为远程连接的工作路径

选取本机的IP地址，SSL如果不涉密可以选无。

这里权限先这样设置之后再修改，点击完成即可。

保存后在此后即可看到添加的ftp服务。可以这样开启多个。

4：注意
要想通过java程序连接FTP在这里我新建了一个FTP的用户，新建一个用户ftptest，密码：123456，如下所示

这里注意一定要把√取消掉确定完成新建，之后修改FTP服务器设置，添加这个特定用户。

点击创建的ftp名称—》ftp身份验证—》修改身份认证，禁止匿名身份


返回最开始的页面，添加刚才创建的用户，如果创建用户对勾选着可能添加不成功。

输入刚才新建的用户名和密码，完成

如何测试刚才新建的用户是否有效嘞有好多种方法常用的是CMD命令行和下面介绍的这种
打开我的电脑在最上面输入
ftp:/+FTP之前设置的IP地址
我的是ftp:/169.254.187.243回车
输入用户和密码即可登录

3：用java开发连接ftp

org.apache.common.io提供了对FTP的开发，引入以下依赖

     <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.5</version>
    </dependency>

3.1：ftp工具类

连接ftp服务

public class FtpClient {
    private final static Logger LOGGER = LoggerFactory.getLogger(FtpClient.class);
    /**
     * FTP服务地址
     */
    private static String FTP_IP;
    /**
     * FTP端口号
     */
    private static Integer FTP_PORT;
    /**
     * FTP用户名
     */
    private static String FTP_USER;
    /**
     * FTP密码
     */
    private static String FTP_PASSWORD;
    /**
     * FTP根路径
     */
    private static String FTP_PATH;
    /**
     * 映射盘符
     */
    private static String FTP_DRIVELETTER;
    private static FTPClient ftpClient;

    static {
        try {
            Properties properties = new Properties();
            InputStream inputStream = FtpClient.class.getClassLoader().getResourceAsStream("ftp-config.properties");
            properties.load(inputStream);
            FTP_IP = properties.getProperty("FTP_IP");
            FTP_PORT = Integer.valueOf(properties.getProperty("FTP_PORT"));
            FTP_USER = properties.getProperty("FTP_USER");
            FTP_PASSWORD = properties.getProperty("FTP_PASSWORD");
            FTP_PATH = properties.getProperty("FTP_PATH");
            FTP_DRIVELETTER = properties.getProperty("FTP_DRIVELETTER");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static FTPClient getFTPConnection() {
        ftpClient = new FTPClient();
        try {
            //连接
            ftpClient.connect(FtpClient.FTP_IP, FtpClient.FTP_PORT);
            //设置编码
            ftpClient.setControlEncoding("UTF-8");
            //设置传输文件类型
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //登录
            ftpClient.login(FtpClient.FTP_USER, FtpClient.FTP_PASSWORD);
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                LOGGER.info("==============未连接到FTP，用户名或密码错误=================");
                //拒绝连接
                ftpClient.disconnect();
            } else {
                LOGGER.info("==============连接到FTP成功=================");
            }
        } catch (SocketException e) {
            e.printStackTrace();
            LOGGER.info("==============FTP的IP地址错误==============");
        } catch (IOException e) {
            e.printStackTrace();
            LOGGER.info("==============FTP的端口错误==============");
        }
        return ftpClient;
    }

    public static void closeConnect() {
        LOGGER.warn("关闭ftp服务器");
        try {
            if (ftpClient != null) {
                ftpClient.logout();
                ftpClient.disconnect();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ftp工具类，进行文件上传下载等操作

public class FTPUtils {
    /**
     * 上传单个文件到远程
     *
     * @param ftpPath        路径
     * @param uploadFileName 文件名
     * @param input          输入流
     * @return
     */
    public static boolean uploadFile(String ftpPath, String uploadFileName, InputStream input) {
        boolean issuccess = false;
        FTPClient ftpClient = null;
        try {
            ftpClient = FtpClient.getFTPConnection();

            //切换到工作目录

            if (!ftpClient.changeWorkingDirectory(ftpPath)) {
                ftpClient.changeWorkingDirectory("/");
                String[] dirs = ftpPath.split("/");
                for (String dir : dirs) {
                    ftpClient.makeDirectory(dir);
                    ftpClient.changeWorkingDirectory(dir);
                }
            }

            ftpClient.enterLocalPassiveMode();//工作模式被动
            //文件写入 远程文件名；输入流
            boolean storeFile = ftpClient.storeFile(uploadFileName, input);
            if (!storeFile) {
                return issuccess;
            }
            input.close();
            ftpClient.logout();
            issuccess = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect();
                } catch (IOException ioe) {
                }
            }
        }
        return issuccess;
    }

    private String inputStreamToString(InputStream inputStream) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        StringBuffer stringBuffer = new StringBuffer();
        String oneLine = "";
        try {
            while ((oneLine = bufferedReader.readLine()) != null) {
                stringBuffer.append(oneLine);
            }
            return stringBuffer.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

3.2：测试

数据写入成功

    public static void main(String[] args) {
        String str = "test";
        final ByteArrayInputStream inputStream = new ByteArrayInputStream(str.getBytes());
        FTPUtils.uploadFile("/remote", "test.txt", inputStream);
    }