精华内容
下载资源
问答
  • 通过java读取远程nfs服务器文件
    万次阅读 热门讨论
    2017-08-15 17:23:53

    1.什么是NFS

    NFSNetwork File System)即网络文件系统,是FreeBSD支持的文件系统中的一种,它允许网络中的计算机之间通过TCP/IP网络共享资源。在NFS的应用中,本地NFS的客户端应用可以透明地读写位于远端NFS服务器上的文件,就像访问本地文件一样。

    2.NFS适合哪种操作系统

    NFS是运行在应用层的协议。随着NFS多年的发展和改进,NFS既可以用于局域网也可以用于广域网,且与操作系统和硬件无关,可以在不同的计算机或系统上运行。

    3.一个简单的NFS使用(局域网使用)

    服务端:安装软件

    客户端:http://jingyan.baidu.com/article/0a52e3f4dc3f4abf63ed7259.html

    注意:win7非企业版本没有nfs功能选项

    4.编写java代码读出远程客户端的文件内容

    使用的包有 jftp.jar  

    这是包下载路径   http://download.csdn.net/download/kunfd/9935005


    import java.io.File;
    import java.io.FileFilter;
    import java.io.IOException;
    
    import com.sun.nfs.XFileExtensionAccessor;
    import com.sun.xfile.*;
    import net.sf.jftp.system.logging.Log;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by fd on 2017/8/14.
     */
    public class NFS {
        String url;
        XFile xfile;
        public void NFSconnection(String ip,String dir)
        {
            url = "nfs://" + ip + "/" + dir;//创建连接
             xfile = new XFile(url);
            //调用exists()判断是否连接成功
            if (xfile.exists()) {
                System.out.println("URL is OK!");
            } else {
                System.out.println("URL is Bad!");
                return;
            }
    
        }
        public void coming(String pathname) throws IOException {
            String path[] = pathname.split("/");//切割,如果服务器是unix系统,更改为"\"
            String[] fileList = new String[1024];//设置接收目录扫描的长度,暂时设置为1024
            fileList = xfile.list();//缺少这一句的话,会出现找不到文件的错误
            XFile temp;
            XFileInputStream in = null;
            for(String splittext:path){
                url = url+"/"+splittext;
                temp = new XFile(url);
                  in = new XFileInputStream(temp);
                fileList = temp.list();
            }
            BufferedReader reader = new BufferedReader(new InputStreamReader(in,"GBK"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    
        public static void main(String[] args) throws IOException {
            String ip ="172.19.152.32";
            String dir = "nfs";
            NFS nfs = new NFS();
            nfs.NFSconnection(ip,dir);
            nfs.coming("com/gdin/edu/test1.txt");
        }
    }
    
    
    


    5.附加

    ①我测试的时候服务端是在Windows系统,连接的时候无需登录(这样不安全,不过可以在服务端设置连接用户的权限,具体的自己去尝试)

    Linux上的还没有测试,按道理应该也是可以的,而且如果换到Linux系统,有些东西需要更改,比如文件路径等

    ③这些测试都是在局域网上测试的

    更多相关内容
  • java远程文件复制

    千次阅读 2014-06-11 16:19:16
    1、配置文件:copyRemoteFile.properties # src/dao.properties  # 这里保存的都是键值对信息  # interface name(no packgage) = implementation class # 注意:  # A:【路径符号】【必须】是【/】...
    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 模型的第四层, ...然而, 用户并不真正登录到自己想要存取的计算机上面而成为完

    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);
        }
    
    
    展开全文
  • JAVA: 读写文件的几种方法

    千次阅读 2021-03-19 09:43:28
    如果您使用java8,可以也参考这篇文章:JAVA: Java8流逐行读取文件import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException...

    如果您使用java8,可以也参考这篇文章:JAVA: Java8流逐行读取文件

    import java.io.BufferedReader;

    import java.io.BufferedWriter;

    import java.io.FileReader;

    import java.io.FileWriter;

    import java.io.IOException;

    import java.text.SimpleDateFormat;

    import java.util.Date;

    public class MainClass

    {

    public static void main(String[] args)

    {

    }

    /**

    * 使用FileWriter类写文本文件

    */

    public static void writeMethod1()

    {

    String fileName="C:\\kuka.txt";

    try

    {

    //使用这个构造函数时,如果存在kuka.txt文件,

    //则先把这个文件给删除掉,然后创建新的kuka.txt

    FileWriter writer=new FileWriter(fileName);

    writer.write("Hello Kuka:\n");

    writer.write(" My name is coolszy!\n");

    writer.write(" I like you and miss you。");

    writer.close();

    } catch (IOException e)

    {

    e.printStackTrace();

    }

    }

    /**

    * 使用FileWriter类往文本文件中追加信息

    */

    public static void writeMethod2()

    {

    String fileName="C:\\kuka.txt";

    try

    {

    //使用这个构造函数时,如果存在kuka.txt文件,

    //则直接往kuka.txt中追加字符串

    FileWriter writer=new FileWriter(fileName,true);

    SimpleDateFormat format=new SimpleDateFormat();

    String time=format.format(new Date());

    writer.write("\n\t"+time);

    writer.close();

    } catch (IOException e)

    {

    e.printStackTrace();

    }

    }

    //注意:上面的例子由于写入的文本很少,使用FileWrite类就可以了。但如果需要写入的

    //内容很多,就应该使用更为高效的缓冲器流类BufferedWriter。

    /**

    * 使用BufferedWriter类写文本文件

    */

    public static void writeMethod3()

    {

    String fileName="C:/kuka.txt";

    try

    {

    BufferedWriter out=new BufferedWriter(new FileWriter(fileName));

    out.write("Hello Kuka:");

    out.newLine(); //注意\n不一定在各种计算机上都能产生换行的效果

    out.write(" My name is coolszy!\n");

    out.write(" I like you and miss you。");

    out.close();

    } catch (IOException e)

    {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    /**

    * 使用FileReader类读文本文件

    */

    public static void readMethod1()

    {

    String fileName="C:/kuka.txt";

    int c=0;

    try

    {

    FileReader reader=new FileReader(fileName);

    c=reader.read();

    while(c!=-1)

    {

    System.out.print((char)c);

    c=reader.read();

    }

    reader.close();

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    /**

    * 使用BufferedReader类读文本文件

    */

    public static void readMethod2()

    {

    String fileName="c:/kuka.txt";

    String line="";

    try

    {

    BufferedReader in=new BufferedReader(new FileReader(fileName));

    line=in.readLine();

    while (line!=null)

    {

    System.out.println(line);

    line=in.readLine();

    }

    in.close();

    } catch (IOException e)

    {

    e.printStackTrace();

    }

    }

    }

    或者

    1、按字节读取文件内容

    2、按字符读取文件内容

    3、按行读取文件内容

    4、随机读取文件内容

    public class ReadFromFile {

    /**

    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。

    */

    public static void readFileByBytes(String fileName) {

    File file = new File(fileName);

    InputStream in = null;

    try {

    System.out.println("以字节为单位读取文件内容,一次读一个字节:");

    // 一次读一个字节

    in = new FileInputStream(file);

    int tempbyte;

    while ((tempbyte = in.read()) != -1) {

    System.out.write(tempbyte);

    }

    in.close();

    } catch (IOException e) {

    e.printStackTrace();

    return;

    }

    try {

    System.out.println("以字节为单位读取文件内容,一次读多个字节:");

    // 一次读多个字节

    byte[] tempbytes = new byte[100];

    int byteread = 0;

    in = new FileInputStream(fileName);

    ReadFromFile.showAvailableBytes(in);

    // 读入多个字节到字节数组中,byteread为一次读入的字节数

    while ((byteread = in.read(tempbytes)) != -1) {

    System.out.write(tempbytes, 0, byteread);

    }

    } catch (Exception e1) {

    e1.printStackTrace();

    } finally {

    if (in != null) {

    try {

    in.close();

    } catch (IOException e1) {

    }

    }

    }

    }

    /**

    * 以字符为单位读取文件,常用于读文本,数字等类型的文件

    */

    public static void readFileByChars(String fileName) {

    File file = new File(fileName);

    Reader reader = null;

    try {

    System.out.println("以字符为单位读取文件内容,一次读一个字节:");

    // 一次读一个字符

    reader = new InputStreamReader(new FileInputStream(file));

    int tempchar;

    while ((tempchar = reader.read()) != -1) {

    // 对于windows下,\r\n这两个字符在一起时,表示一个换行。

    // 但如果这两个字符分开显示时,会换两次行。

    // 因此,屏蔽掉\r,或者屏蔽\n。否则,将会多出很多空行。

    if (((char) tempchar) != '\r') {

    System.out.print((char) tempchar);

    }

    }

    reader.close();

    } catch (Exception e) {

    e.printStackTrace();

    }

    try {

    System.out.println("以字符为单位读取文件内容,一次读多个字节:");

    // 一次读多个字符

    char[] tempchars = new char[30];

    int charread = 0;

    reader = new InputStreamReader(new FileInputStream(fileName));

    // 读入多个字符到字符数组中,charread为一次读取字符数

    while ((charread = reader.read(tempchars)) != -1) {

    // 同样屏蔽掉\r不显示

    if ((charread == tempchars.length)

    && (tempchars[tempchars.length - 1] != '\r')) {

    System.out.print(tempchars);

    } else {

    for (int i = 0; i < charread; i++) {

    if (tempchars[i] == '\r') {

    continue;

    } else {

    System.out.print(tempchars[i]);

    }

    }

    }

    }

    } catch (Exception e1) {

    e1.printStackTrace();

    } finally {

    if (reader != null) {

    try {

    reader.close();

    } catch (IOException e1) {

    }

    }

    }

    }

    /**

    * 以行为单位读取文件,常用于读面向行的格式化文件

    */

    public static void readFileByLines(String fileName) {

    File file = new File(fileName);

    BufferedReader reader = null;

    try {

    System.out.println("以行为单位读取文件内容,一次读一整行:");

    reader = new BufferedReader(new FileReader(file));

    String tempString = null;

    int line = 1;

    // 一次读入一行,直到读入null为文件结束

    while ((tempString = reader.readLine()) != null) {

    // 显示行号

    System.out.println("line " + line + ": " + tempString);

    line++;

    }

    reader.close();

    } catch (IOException e) {

    e.printStackTrace();

    } finally {

    if (reader != null) {

    try {

    reader.close();

    } catch (IOException e1) {

    }

    }

    }

    }

    /**

    * 随机读取文件内容

    */

    public static void readFileByRandomAccess(String fileName) {

    RandomAccessFile randomFile = null;

    try {

    System.out.println("随机读取一段文件内容:");

    // 打开一个随机访问文件流,按只读方式

    randomFile = new RandomAccessFile(fileName, "r");

    // 文件长度,字节数

    long fileLength = randomFile.length();

    // 读文件的起始位置

    int beginIndex = (fileLength > 4) ? 4 : 0;

    // 将读文件的开始位置移到beginIndex位置。

    randomFile.seek(beginIndex);

    byte[] bytes = new byte[10];

    int byteread = 0;

    // 一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。

    // 将一次读取的字节数赋给byteread

    while ((byteread = randomFile.read(bytes)) != -1) {

    System.out.write(bytes, 0, byteread);

    }

    } catch (IOException e) {

    e.printStackTrace();

    } finally {

    if (randomFile != null) {

    try {

    randomFile.close();

    } catch (IOException e1) {

    }

    }

    }

    }

    /**

    * 显示输入流中还剩的字节数

    */

    private static void showAvailableBytes(InputStream in) {

    try {

    System.out.println("当前字节输入流中的字节数为:" + in.available());

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    public static void main(String[] args) {

    String fileName = "C:/temp/newTemp.txt";

    ReadFromFile.readFileByBytes(fileName);

    ReadFromFile.readFileByChars(fileName);

    ReadFromFile.readFileByLines(fileName);

    ReadFromFile.readFileByRandomAccess(fileName);

    }

    }

    5、将内容追加到文件尾部

    public class AppendToFile {

    /**

    * A方法追加文件:使用RandomAccessFile

    */

    public static void appendMethodA(String fileName, String content) {

    try {

    // 打开一个随机访问文件流,按读写方式

    RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");

    // 文件长度,字节数

    long fileLength = randomFile.length();

    //将写文件指针移到文件尾。

    randomFile.seek(fileLength);

    randomFile.writeBytes(content);

    randomFile.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    /**

    * B方法追加文件:使用FileWriter

    */

    public static void appendMethodB(String fileName, String content) {

    try {

    //打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件

    FileWriter writer = new FileWriter(fileName, true);

    writer.write(content);

    writer.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    public static void main(String[] args) {

    String fileName = "C:/temp/newTemp.txt";

    String content = "new append!";

    //按方法A追加文件

    AppendToFile.appendMethodA(fileName, content);

    AppendToFile.appendMethodA(fileName, "append end. \n");

    //显示文件内容

    ReadFromFile.readFileByLines(fileName);

    //按方法B追加文件

    AppendToFile.appendMethodB(fileName, content);

    AppendToFile.appendMethodB(fileName, "append end. \n");

    //显示文件内容

    ReadFromFile.readFileByLines(fileName);

    }

    }

    如果您使用java8,可以也参考这篇文章:JAVA: Java8流逐行读取文件

    cbd5a61765aed016a56103b68dcc8d51.gif

    相关

    Related Posts

    JAVA: Socket(套接字)讲解

    什么是 Socket Socket(套接字):是在网络上运行两个程序之间的双向通信链路的一个端点。socket绑定到一个端口号,使得 TCP 层可以标识数据最终要被发送到哪个应用程序。 正常情况下,一台服务器在特定计算机上运行,​​并具有被绑定到特定端口号的 socket。服务器只是等待,并监听用于客户发起的连接请求的 socket 。 在客户端:客户端知道服务器所运行的主机名称以及服务器正在侦听的端口号。建立连接请求时,客户端尝试与主机服务器和端口会合。客户端也需要在连接中将自己绑定到本地端口以便于给服务器做识别。本地端口号通常是由系统分配的。 如果一切顺利的话,服务器接受连接。一旦接受,服务器获取绑定到相同的本地端口的新 socket ,并且还具有其远程端点设定为客户端的地址和端口。它需要一个新的socket,以便它可以继续监听原来用于客户端连接请求的 socket…

    JAVA: 深入理解java异常处理机制

    1. 引子 try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。不信?那你看看下面的代码,“猜猜”它执行后的结果会是什么?不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确,那么这篇文章你就不用浪费时间看啦。 package Test; public class TestException { public TestException() { } boolean…

    JAVA: Java8流逐行读取文件

    在Java8中,可以使用Files.lines读取文件的流。 c://lines.txt – 用于测试的简单文本文件 line1 line2 line3 line4 line5 核心代码: Write to file using…

    展开全文
  • Java访问权限控制源代码 1个目标文件 摘要:Java源码,文件操作,权限控制 Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流...
  • java方法远程连接Windows Server

    千次阅读 2019-08-23 10:01:36
    项目环境说明 1.本地环境:Windows10、jdk1.8、Maven 3.6.0 ...需要开启Telnet服务和FTP服务(Telnet本身没有文件传输功能,要想实体文件传输只能借助其它服务如FTP服务),并进行一些设置;以下是配置图解:(...
  • java远程通讯的几种方法

    千次阅读 2018-08-15 14:51:45
    RMI介绍 RMI(Remote Method Invocation)为远程方法调用,是允许运行在一个Java虚拟机的对象调用运行在另一个Java虚拟机上的对象的方法。...Java RMI:Java远程方法调用,即Java RMI(Java Remote Met...
  • Java的SSH连接远程服务器

    千次阅读 2021-01-03 21:13:52
    Java的SSH连接远程服务器 1.简介 2. JSch 2.1 实践 3. Apache MINA SSHD 3.1 实践 4. 结论 Java的SSH连接远程服务器 1.简介 SSH,也称为安全外壳或安全套接字外壳,是一种网络协议,允许一台计算机通过不安全的网络...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
  • 文章目录Viper——Go语言写的配置文件读取写入工具神器1. 资料搜集2. 新建viper-demo项目3. 读取 yaml 文件server.yamlmain.go3. 写入配置文件main.go探索一下上面的程序使用 `SafeWriteConfigAs` 方法会怎样4. 建立...
  • Windows搭建FTP服务器目录博主介绍开启FTP功能放行端口重启计算机添加FTP访问用户添加FTP站点本地访问测试修改FTP设置Java整合FTP代码实现????作者相关的文章、资源分享????????点击直接资料领取???? 目录 博主介绍 ...
  • java开源包101

    2016-07-13 10:11:08
    FindDup 是一个简单易用的工具,用来检查计算机上重复的文件。 OpenID的Java客户端 JOpenID JOpenID是一个轻量级的OpenID 2.0 Java客户端,仅50KB+(含源代码),允许任何Web网站通过OpenID支持用户直接登录而无需...
  • Java访问权限控制源代码 1个目标文件 摘要:Java源码,文件操作,权限控制 Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流...
  • 使用ssh公共密钥身份验证连接到...将私钥保密并将其存储在用来连接远程系统的计算机上。公钥保存在需要远程登陆的服务器上,~/.ssh/authorized_keys文件里 ssh-keygen (选项) 选项 -b:指定密钥长度; -e:读取o...
  • Java访问权限控制源代码 1个目标文件 摘要:Java源码,文件操作,权限控制 Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流...
  • Java资源包01

    2016-08-31 09:16:25
    FindDup 是一个简单易用的工具,用来检查计算机上重复的文件。 OpenID的Java客户端 JOpenID JOpenID是一个轻量级的OpenID 2.0 Java客户端,仅50KB+(含源代码),允许任何Web网站通过OpenID支持用户直接登录而无需...
  • Java读写Windows共享文件夹的方法实例

    千次阅读 2021-02-12 18:25:18
    项目常常需要有访问共享文件夹的需求,例如共享文件夹存储照片、文件等。那么如何使用Java读写Windows共享文件夹呢?Java可以使用JCIFS框架对Windows共享文件夹进行读写,就这个框架可以让我们像访问本地文件夹一下...
  • 2021最新Java面经整理 | 计算机网络篇

    千次阅读 2020-11-12 10:49:32
    2021最新Java面经整理 | 计算机网络篇 一、网络层次划分 1、OSI 七层 二、TCP/IP协议(重点) 1、介绍 TCP/IP协议是Internet最基本的协议、Internet国际互联网络的基础,由网络层的IP协议和传输层的...
  • 10万字208道Java经典面试题总结(附答案)

    万次阅读 多人点赞 2021-08-01 16:05:55
    JDK(Java Development Kit),Java开发工具包 JRE(Java Runtime Environment),Java运行环境 JDK中包含JRE,JDK中有一个名为jre的目录,里面包含两个文件夹bin和lib,bin就是JVM,lib就是JVM工作所需要的类库。...
  • Java全国计算机等级考试二级笔记---java部分

    千次阅读 多人点赞 2018-09-16 17:34:06
    Java全国计算机二级笔记 ———java部分 作者 :arsoooo 本内容供要参加java全国二级计算机等级考试的参考 这是我初学java时做题总结的,会有自己乱总结出来的不普遍的结论或者错误的地方,或是...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
  • Java中的序列化到底是什么

    千次阅读 多人点赞 2020-06-29 14:07:46
    序列化的目的是为了方便数据的传递以及存储到磁盘上(把一个Java对象写入到硬盘或者传输到网路上面的其它计算机,这时我们就需要将对象转换成字节流才能进行网络传输。对于这种通用的操作,就出现了序列化
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
  • Java 远程通讯技术及原理分析

    千次阅读 2017-04-09 12:11:53
    摘要: 在分布式服务框架中,一个最基础的问题就是远程服务是怎么通讯的,在Java领域中有很多可实现远程通讯的技术,例如:RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等,这些名词之间到底是些什么关系呢,...
  • 这样一来,就可以实现用户在任意位置进行访问和下载这些文件了——相比于远程登录到程序运行的计算机内再进行拷贝而言,如此设计当然要高效得多(只要用户有浏览器即可),操作过程也会更简单。 那么...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
  • ”新兵蛋子小二头顶很凉快的老王抱怨道,“你瞧,我就按照传输方式对 IO 进行了一个简单的分类,就能搞出来这么多的玩意!” PS:为了能够帮助更多的 Java 初学者,已将《Java 程序员进阶之路》开源到了 GitHub...
  • SMB协议的共享文件读写

    千次阅读 2020-09-03 11:06:09
    服务器信息块(SMB)协议是一种IBM协议,用于在计算机间共享文件、打印机、串口等。SMB 协议可以用在因特网的TCP/IP协议之上,也可以用在其它网络协议如IPX和NetBEUI 之上。  SMB 一种客户机/服务器、请求/响应协议...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,597
精华内容 9,438
关键字:

java向远程计算机写入文件

java 订阅