远程共享目录上传下载 WINDOWS

最新推荐文章于 2024-08-03 13:00:59 发布

dbeautifulLife

最新推荐文章于 2024-08-03 13:00:59 发布

阅读量1k

点赞数

分类专栏： javaWeb开发

javaWeb开发专栏收录该内容

57 篇文章 0 订阅

订阅专栏

转自 http://developer.51cto.com/art/201112/308235.htm

我在这里加了下载方法

RemoteFileUtil.Java为主要方法

RemoteConfigUtil.Java为连接共享目录的配置可以省略

RemoteFileUtil.Java:

[java]view plaincopy 
   
 package com.remote;  
   
 import java.io.BufferedInputStream;  
 import java.io.BufferedOutputStream;  
 import java.io.BufferedReader;  
 import java.io.File;  
 import java.io.FileInputStream;  
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 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:操作远程共享文件夹类 
  ***********************************************/  
 public class RemoteFileUtil {  
   
     private String remoteHostIp; // 远程主机IP  
     private String account; // 登陆账户  
     private String password; // 登陆密码  
     private String shareDocName; // 共享文件夹名称  
   
     /** 
      * 默认构造函数 
      */  
     public RemoteFileUtil() {  
         RemoteConfigUtil rc = new RemoteConfigUtil();  
         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 = null;  
         try {  
             buffer = new byte[is.available() + 1024];  
         } catch (IOException e1) {  
             e1.printStackTrace();  
         }  
         // 构建连接字符串,并取得文件连接  
         String conStr = null;  
         conStr = "smb://" + account + ":" + password + "@" + remoteHostIp + "/"  
                 + shareDocName + "/" + remoteFileName;  
         try {  
             smbFile = new SmbFile(conStr);  
         } catch (MalformedURLException e) {  
             e.printStackTrace();  
             return false;  
         }  
   
         // 获取远程文件输出流并写文件到远程共享文件夹  
   
         try {  
   
             int byteread = 0;  
             SmbFileOutputStream smbFileOutputStream = new SmbFileOutputStream(smbFile);  
 //          os = new FileOutputStream();  
 //          while ((byteread = is.read(buffer)) != -1) {  
 //              os.write(buffer, 0, byteread);  
 //          }  
             while ((byteread = is.read(buffer)) != -1) {  
                 smbFileOutputStream.write(buffer, 0, byteread);  
             }  
             /* 
              * if (oldfile.exists()) { //文件存在时 InputStream inStream = new 
              * FileInputStream(oldPath); //读入原文件 FileOutputStream fs = new 
              * FileOutputStream(newPath); byte[] buffer = new 
              * byte[inStream.available()]; while ( (byteread = 
              * inStream.read(buffer)) != -1) { bytesum += byteread; //字节数 文件大小 
              * System.out.println(bytesum); fs.write(buffer, 0, byteread); } 
              * inStream.close(); } 
              */  
   
         } 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;  
         List<string> resultLines = new ArrayList<string>();  
         // 构建连接字符串,并取得文件连接  
         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);  
             e.printStackTrace();  
         }  
     }  
   
     /** 
      * 复制文件到远程计算机，如果目标路径不存在则创建，反之不创建 
      *  
      * @param localFileFullName 
      *            本地指定文件路径 
      * @param targetDir 
      *            目标路径 
      */  
     public void copyFileToRemoteDir(String localFileFullName, String targetDir) {  
         targetDir = targetDir.replace("\\", "/");  
         System.err.println(localFileFullName + "--" + targetDir);  
         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(conStr);  
             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) {  
             e.printStackTrace();  
             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) {  
                 writeFile(sourceFile, "/" + targetDir + "/" + name); // 复制文件  
             } else if (targetFile != null) {  
                 writeFile(sourceFile, name); // 复制文件  
             }  
         }  
     }  
   
     /** 
      * 循环获取文件夹内所有匹配的文件 
      *  
      * @param strPath 
      *            路径 
      * @param subStr 
      *            匹配字符 
      * @return 
      */  
     public ArrayList<string> refreshFileList(String strPath, String subStr) {  
         ArrayList<string> filelist = new ArrayList<string>();  
         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;  
     }  
   
     /** 
      * 从共享目录拷贝文件到本地 
      *  
      * @param remoteUrl 
      *            共享目录内的文件路径 
      * @param localDir 
      *            本地目录 文件名不会改变 
      */  
     public void downLoadFile(String remoteUrlFile, String localDir) {  
         remoteUrlFile = remoteUrlFile.replace("\\", "/");  
         String conStr = "smb://" + account + ":" + password + "@"  
                 + remoteHostIp + "/" + shareDocName + "/" + remoteUrlFile;  
         InputStream in = null;  
         OutputStream out = null;  
         try {  
             SmbFile remoteFile = new SmbFile(conStr);  
   
             String fileName = remoteFile.getName();  
             // fileName.endsWith("")  
             File localFile = new File(localDir + "/" + fileName);  
             (new File(localDir)).mkdirs(); // 如果文件夹不存在 则建立新文件夹  
             in = new BufferedInputStream(new SmbFileInputStream(remoteFile));  
             out = new FileOutputStream(localFile);  
             byte[] buffer = new byte[20480];  
             int len = 0;  
             while ((len = in.read(buffer)) != -1) {  
                 out.write(buffer, 0, len);  
             }  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             try {  
                 if (out != null) {  
                     out.close();  
                     out = null;  
                 }  
                 if (in != null) {  
                     in.close();  
                     in = null;  
                 }  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
   
     /** 
      * 复制远程共享文件夹内容 
      *  
      * @param remoteUrlDirectory 
      *            String 原文件路径 共离目录下的子目录 如：dir/game 
      * @param localDir 
      *            String 复制后路径 如：f:/fqf/ff 
      */  
     public void downLoadDirectory(String remoteUrlDirectory, String localDir) {  
         remoteUrlDirectory = remoteUrlDirectory.replace("\\", "/");  
         String conStr = "smb://" + account + ":" + password + "@"  
                 + remoteHostIp + "/" + shareDocName + "/";  
         InputStream in = null;  
         OutputStream out = null;  
         try {  
             (new File(localDir)).mkdirs(); // 如果文件夹不存在 则建立新文件夹  
             SmbFile remoteFile = new SmbFile(conStr + remoteUrlDirectory + "/");  
             String[] fileNameList = remoteFile.list();  
             SmbFile tempSmb = null;  
             for (int i = 0; i < fileNameList.length; i++) {  
                 String _fileName = fileNameList[i];  
                 _fileName = _fileName.replace("\\", "/");  
                 // 将路径  
                 if (remoteUrlDirectory.endsWith("/")) {  
                     tempSmb = new SmbFile(conStr + remoteUrlDirectory  
                             + _fileName);  
                 } else {  
                     tempSmb = new SmbFile(conStr + remoteUrlDirectory + "/"  
                             + _fileName);  
                 }  
                 if (tempSmb.isFile()) {  
                     in = new BufferedInputStream(new SmbFileInputStream(  
                             remoteFile + "/" + _fileName));  
                     out = new FileOutputStream(localDir + "/" + _fileName);  
                     byte[] buffer = new byte[20480];  
                     int len = 0;  
                     while ((len = in.read(buffer)) != -1) {  
                         out.write(buffer, 0, len);  
                     }  
                     out.flush();  
                 }  
   
                 if (tempSmb.isDirectory()) {  
                     downLoadDirectory(remoteUrlDirectory + "/" + _fileName,  
                             localDir + "/" + _fileName);  
                 }  
             }  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             try {  
                 if (out != null) {  
                     out.close();  
                     out = null;  
                 }  
                 if (in != null) {  
                     in.close();  
                     in = null;  
                 }  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
   
     // 测试从本地复制文件到远程目标目录，测试已通过  
     public static void main(String[] args) {  
         long startTime = System.currentTimeMillis(); // 获取开始时间  
   
     //  远程连接配置  
     //  RemoteConfigUtil rc = new RemoteConfigUtil("192.168.3.200","administrator","harmony123;","autoUpdate","C:\\logs","qwe");  
         RemoteFileUtil util = new RemoteFileUtil("192.168.3.200","administrator", "harmony123;", "autoUpdate");  
 //      RemoteFileUtil util = new RemoteFileUtil("172.16.160.67","administrator", "admin", "testTemp");  
 //      util.copyFileToRemoteDir("D:\\新建文本文档.txt","");  
         util.copyFolder("c:\\down", "qwe");  
           
           
         //下载共享目录下的JDK文件到 c:\\down  
 //      util.downLoadFile("jdk-6u10-rc2-bin-b32-windows-i586-p-12_sep_2008.exe","c:\\down\\");  
   
         // 将共享目录下的qw文件夹里的内容下载到目录 c:\\dow  
 //      util.downLoadDirectory("qw", "c:\\down");  
   
         long endTime = System.currentTimeMillis(); // 获取结束时间  
         System.out.println("程序运行时间： " + (endTime - startTime) + "ms");  
   
     }  
 }</string></string></string></string></string></string></string></string></string>  

=================================================

RemoteConfigUtil.Java

[java]view plaincopy 
   
 package com.remote;  
   
 import java.io.IOException;  
 import java.util.Properties;  
   
 /** 
  * 读取配置文件中key对应的value 
  *  
  * @author JunjieQin 
  */  
 public class RemoteConfigUtil {  
     /* 
      * asd 
      */  
     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 RemoteConfigUtil(String REMOTE_HOST_IP, String LOGIN_ACCOUNT,  
             String LOGIN_PASSWORD, String SHARE_DOC_NAME, String sourcePath,  
             String targetPath) {  
         // 根据 key 获取 value  
         this.REMOTE_HOST_IP = REMOTE_HOST_IP;  
         this.LOGIN_ACCOUNT = LOGIN_ACCOUNT;  
         this.LOGIN_PASSWORD = LOGIN_PASSWORD;  
         this.SHARE_DOC_NAME = SHARE_DOC_NAME;  
         this.sourcePath = sourcePath;  
         this.targetPath = targetPath;  
     }  
   
     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;  
     }  
   
 }  