Java文件夹操作的那点事, 嵌套,shell,bat,FTP

Java进行文件操作比较容易,但是进行文件夹操作,例如文件夹复制删除操作就比较麻烦,没有直接的操作符和API接口,需要自己进行递推嵌套完成相应的工作,下面是利用java进行文件夹的复制和删除操作:

  1.     public static void delete(File file) {    
  2.         if (!file.exists()) return;    
  3.         if (file.isFile()) {    
  4.             file.delete();    
  5.         } else {    
  6.             for (File f : file.listFiles()) {    
  7.                 delete(f);    
  8.             }    
  9.             file.delete();    
  10.         }    
  11.     }    
  12.   
  13.     /** 
  14.      * 复制文件(夹)到一个目标文件夹   
  15.      * @param resFile  源文件(夹)   
  16.      * @param objFolderFile 目标文件夹   
  17.      * @throws IOException 异常时抛出   
  18.      */    
  19.     public static void copy(File resFile, File objFolderFile) throws IOException {    
  20.         if (!resFile.exists()) return;    
  21.         if (!objFolderFile.exists()) objFolderFile.mkdirs();    
  22.         if (resFile.isFile()) {    
  23.             File objFile = new File(objFolderFile.getPath() + File.separator + resFile.getName());    
  24.             //复制文件到目标地    
  25.             InputStream ins = new FileInputStream(resFile);    
  26.             FileOutputStream outs = new FileOutputStream(objFile);    
  27.             byte[] buffer = new byte[1024 * 512];    
  28.             int length;    
  29.             while ((length = ins.read(buffer)) != -1) {    
  30.                 outs.write(buffer, 0, length);    
  31.             }    
  32.             ins.close();    
  33.             outs.flush();    
  34.             outs.close();    
  35.         } else {    
  36. //            String objFolder = objFolderFile.getPath();    
  37. //            File _objFolderFile = new File(objFolder);    
  38. //            _objFolderFile.mkdirs();    
  39.             for (File sf : resFile.listFiles()) {    
  40.                 copy(sf, objFolderFile, true);   
  41.             }    
  42.         }    
  43.     }   
  44.     public static void copy(File resFile, File objFolderFile, boolean subFolder) throws IOException {    
  45.         if (!resFile.exists()) return;    
  46.         if (!objFolderFile.exists()) objFolderFile.mkdirs();    
  47.         if (resFile.isFile()) {    
  48.             File objFile = new File(objFolderFile.getPath() + File.separator + resFile.getName());    
  49.             //复制文件到目标地    
  50.             InputStream ins = new FileInputStream(resFile);    
  51.             FileOutputStream outs = new FileOutputStream(objFile);    
  52.             byte[] buffer = new byte[1024 * 512];    
  53.             int length;    
  54.             while ((length = ins.read(buffer)) != -1) {    
  55.                 outs.write(buffer, 0, length);    
  56.             }    
  57.             ins.close();    
  58.             outs.flush();    
  59.             outs.close();    
  60.         } else {    
  61.             String objFolder = objFolderFile.getPath() + File.separator + resFile.getName();    
  62.             File _objFolderFile = new File(objFolder);    
  63.             _objFolderFile.mkdirs();    
  64.             for (File sf : resFile.listFiles()) {    
  65.                 copy(sf, new File(objFolder), true);    
  66.             }    
  67.         }    
  68.     }   

delete(File file)函数通过递归完成了文件夹的删除工作,copy(File resFile, File objFolderFile) 为顶层的文件夹复制函数,里面嵌套了下层的递归函数完成复制工作,如此函数递推可以完成自己需求的个性化操作。 常常使用linux的同学一定都习惯了shell脚本操作,文件夹的复制和删除,只需要简单的一行指令,cp 或 rm即可完成操作,那么如果能把脚本指令嵌入到Java代码中的话就会方便很多,其实这样的操作并不难,而且我们完全可以把shell脚本和bat脚本同时写入java中,并根据当前操作系统自行适应,下面是一个简单的例子来完成文件夹的复制和删除操作:

  1. public static boolean rmFolder(String targetPath){   
  2.     if (SmsBase.osName==“windows”) {   
  3.         String[] cmd = {   
  4.             “cmd”,   
  5.             “/c”,    
  6.             “rd ” +  targetPath +“/s/q”     
  7.         };   
  8.         try {   
  9.              Runtime rt = Runtime.getRuntime();     
  10.              Process proc = rt.exec(cmd);     
  11.              proc.waitFor();   
  12.         } catch (IOException e) {   
  13.             e.printStackTrace();   
  14.         } catch (InterruptedException e) {   
  15.             e.printStackTrace();   
  16.         }   
  17.     }else {   
  18.         String[] cmd = {   
  19.             “/bin/sh”,     
  20.             “-c”,     
  21.             “rm -rf ” +  targetPath     
  22.         };   
  23.         try {   
  24.              Runtime rt = Runtime.getRuntime();     
  25.              Process proc = rt.exec(cmd);     
  26.              proc.waitFor();   
  27.         } catch (IOException e) {   
  28.             e.printStackTrace();   
  29.         } catch (InterruptedException e) {   
  30.             e.printStackTrace();   
  31.         }   
  32.     }   
  33.     return false;   
  34. }   
  35. public static boolean cpFolder(String sourcePath, String targetPath){   
  36.     if (SmsBase.osName==“windows”) {   
  37.         String[] cmd = {   
  38.             “cmd”,   
  39.             “/c”,    
  40.             “md ” +  targetPath     
  41.         };   
  42.         String[] cmd2 = {   
  43.                 “cmd”,   
  44.                 “/c”,   
  45.                 “xcopy ” + sourcePath +“ ”+ targetPath +“/e”  
  46.             };   
  47.         try {   
  48.              Runtime rt = Runtime.getRuntime();     
  49.              Process proc = rt.exec(cmd);     
  50.              proc.waitFor();   
  51.              proc = rt.exec(cmd2);   
  52.         } catch (IOException e) {   
  53.             e.printStackTrace();   
  54.         } catch (InterruptedException e) {   
  55.             e.printStackTrace();   
  56.         }   
  57.     }else {   
  58.         String[] cmd = {   
  59.             “/bin/sh”,   
  60.             “-c”,   
  61.             “cp -rf ” + sourcePath +“ ”+ targetPath     
  62.         };   
  63.         try {   
  64.             Runtime.getRuntime().exec(cmd);   
  65.         } catch (IOException e) {   
  66.             e.printStackTrace();   
  67.         }   
  68.     }   
  69.     return false;   
  70. }  

关于操作系统的判断可以如下判断:

  1. if(System.getProperties().getProperty(“os.name”).toLowerCase().contains(“windows”))   
  2.             osName = “windows”;   
  3.         else  
  4.             osName = “linux”;   

在实际应用中,发现cmd下的xcopy命令并没有那么好使,只有退出JVM后才能全部复制成功,最后一个File总是被暂留在内存中。不过利用脚本嵌入的这种方式倒是可以完成很多java比较难办的操作。
这里用到了System.getProperties()属性,那么顺便提及一下System类可以拿到那些属性,
public static Properties getProperties()
将 getProperty(String) 方法使用的当前系统属性集合作为 Properties 对象返回

键 相关值的描述
java.version Java 运行时环境版本
java.vendor Java 运行时环境供应商
java.vendor.url Java 供应商的 URL
java.home Java 安装目录
java.vm.specification.version Java 虚拟机规范版本
java.vm.specification.vendor Java 虚拟机规范供应商
java.vm.specification.name Java 虚拟机规范名称
java.vm.version Java 虚拟机实现版本
java.vm.vendor Java 虚拟机实现供应商
java.vm.name Java 虚拟机实现名称
java.specification.version Java 运行时环境规范版本
java.specification.vendor Java 运行时环境规范供应商
java.specification.name Java 运行时环境规范名称
java.class.version Java 类格式版本号
java.class.path Java 类路径
java.library.path 加载库时搜索的路径列表
java.io.tmpdir 默认的临时文件路径
java.compiler 要使用的 JIT 编译器的名称
java.ext.dirs 一个或多个扩展目录的路径
os.name 操作系统的名称
os.arch 操作系统的架构
os.version 操作系统的版本
file.separator 文件分隔符(在 UNIX 系统中是“/”)
path.separator 路径分隔符(在 UNIX 系统中是“:”)
line.separator 行分隔符(在 UNIX 系统中是“/n”)
user.name 用户的账户名称
user.home 用户的主目录
user.dir 用户的当前工作目录

如果需要跨服务器操作,第一种方式显然是行不通的,第二中方式可以在完全信任的服务器上使用scp服务,但是scp只能方便的跨服务器复制,不能删除。那么ftp就闪亮登场了。通过在服务器上搭建ftp服务,然后就可以通过ftp进行跨服务器的文件操作了,同样地,文件夹的操作也需要进行嵌套和递归:

  1. import java.io.File;     
  2. import java.io.FileInputStream;     
  3. import java.io.FileOutputStream;     
  4. import java.io.IOException;     
  5. import java.io.InputStream;     
  6. import java.io.OutputStream;     
  7. import java.net.SocketException;     
  8. import java.util.ArrayList;     
  9. import java.util.Date;     
  10. import java.util.List;     
  11. import org.apache.commons.net.ftp.FTP;     
  12. import org.apache.commons.net.ftp.FTPClient;     
  13. import org.apache.commons.net.ftp.FTPFile;     
  14. import org.apache.commons.net.ftp.FTPReply;   
  15. import org.cbrain.sms.config.SmsBase;   
  16.      
  17. public class FtpUtil {     
  18.     private FTPClient ftpClient;     
  19.     public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;     
  20.     public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;     
  21.          
  22.     // path should not the path from root index     
  23.     // or some FTP server would go to root as ’/’.     
  24.     public void connectServer() throws SocketException,     
  25.             IOException {     
  26.         String server = SmsBase.ftpHostname;   
  27.         int port = SmsBase.ftpPort;   
  28.         String user = SmsBase.ftpUsername;   
  29.         String password = SmsBase.ftpPassword;   
  30.         String location = SmsBase.solrIndexPath;   
  31.         connectServer(server, port, user, password, location);     
  32.     }   
  33.          
  34.     public void connectServer(String server, int port, String user,     
  35.             String password, String path) throws SocketException, IOException {     
  36.        try {   
  37.            ftpClient = new FTPClient();     
  38.            ftpClient.connect(server, port);     
  39.            System.out.println(“Connected to ” + server + “.”);     
  40.            System.out.println(ftpClient.getReplyCode());     
  41.            ftpClient.login(user, password);    
  42.            // 文件类型,默认是ASCII     
  43.            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);   
  44.            // Path is the sub-path of the FTP path     
  45.            if (path.length() != 0) {     
  46.                ftpClient.changeWorkingDirectory(path);     
  47.            }     
  48.            // 设置被动模式     
  49.            ftpClient.enterLocalPassiveMode();     
  50.   
  51.            ftpClient.setConnectTimeout(10000);      
  52.            // 响应信息     
  53.            int replyCode = ftpClient.getReplyCode();     
  54.            if ((!FTPReply.isPositiveCompletion(replyCode))) {     
  55.                // 关闭Ftp连接     
  56.             closeServer();     
  57.                // 释放空间     
  58.             ftpClient = null;   
  59.                throw new Exception(“error: failur login FTP server, please check![Server:" + server + ", "     
  60.                        + "User:" + user + ", " + "Password:" + password);     
  61.            }    
  62.        }catch (Exception e) {   
  63.            ftpClient.disconnect();     
  64.            ftpClient = null;   
  65.            e.printStackTrace();   
  66.        }   
  67.     }    
  68.     //FTP.BINARY_FILE_TYPE | FTP.ASCII_FILE_TYPE     
  69.     // Set transform type     
  70.     public void setFileType(int fileType) throws IOException {     
  71.         ftpClient.setFileType(fileType);     
  72.     }     
  73.      
  74.     public void closeServer() throws IOException {     
  75.         if (ftpClient.isConnected()) {     
  76.             ftpClient.disconnect();     
  77.         }     
  78.     }     
  79.     //=======================================================================     
  80.     //==         About directory       =====     
  81.     // The following method using relative path better.     
  82.     //=======================================================================     
  83.          
  84.     public boolean changeDirectory(String path) throws IOException {     
  85.         return ftpClient.changeWorkingDirectory(path);     
  86.     }     
  87.     public boolean createDirectory(String pathName) throws IOException {     
  88.         return ftpClient.makeDirectory(pathName);     
  89.     }     
  90.     public boolean removeDirectory(String path) throws IOException {     
  91.         return ftpClient.removeDirectory(path);     
  92.     }     
  93.          
  94.     // delete all subDirectory and files.     
  95.     public boolean removeDirectory(String path, boolean isAll)     
  96.             throws IOException {     
  97.         if (!isAll) {     
  98.             return removeDirectory(path);     
  99.         }     
  100.         FTPFile[] ftpFileArr = ftpClient.listFiles(path);   
  101.         if (ftpFileArr == null || ftpFileArr.length == 0) {     
  102.             return removeDirectory(path);     
  103.         }     
  104.         //      
  105.         for (FTPFile ftpFile : ftpFileArr) {     
  106.             String name = ftpFile.getName();     
  107.             if (ftpFile.isDirectory()) {   
  108.                 if(!ftpFile.getName().equals(“.”)&&(!ftpFile.getName().equals(“..”))){   
  109. //                  System.out.println(“* [sD]Delete subPath ["+path + "/" + name+"]“);                  
  110.                     removeDirectory(path + “/” + name, true);     
  111.                 }   
  112.             } else if (ftpFile.isFile()) {     
  113. //              System.out.println(“* [sF]Delete file ["+path + "/" + name+"]“);                             
  114.                 deleteFile(path + “/” + name);     
  115.             } else if (ftpFile.isSymbolicLink()) {     
  116.      
  117.             } else if (ftpFile.isUnknown()) {     
  118.      
  119.             }     
  120.         }     
  121.         return ftpClient.removeDirectory(path);     
  122.     }     
  123.     public boolean uploadDirectory(File resFile, String objFolderFile) throws IOException{   
  124.         if (!resFile.exists()){   
  125.             System.out.println(“error: the source folder is not exist, please check the path:”+resFile.getAbsolutePath());   
  126.             return false;   
  127.         }   
  128.         if (!existDirectory(objFolderFile)) createDirectory(objFolderFile);   
  129.   
  130.         if (resFile.isFile()) {   
  131.             changeDirectory(objFolderFile);   
  132.             //复制文件到目标地    
  133.             uploadFile(resFile);   
  134.         } else {   
  135.             for (File sf : resFile.listFiles()) {    
  136.                 uploadDirectory(sf, objFolderFile, true);   
  137.             }    
  138.         }   
  139.         return true;   
  140.     }   
  141.     public boolean uploadDirectory(File resFile, String objFolderFile, boolean subFolder) throws IOException{     
  142.         if (!resFile.exists()){   
  143.             System.out.println(“error: the source folder is not exist, please check the path:”+resFile.getAbsolutePath());   
  144.             return false;   
  145.         }   
  146.         if (!existDirectory(objFolderFile)) createDirectory(objFolderFile);   
  147.            
  148.         if (resFile.isFile()) {   
  149.             changeDirectory(objFolderFile);   
  150.             //复制文件到目标地    
  151.             uploadFile(resFile);   
  152.         } else {   
  153.             String objFolder = objFolderFile + File.separator + resFile.getName();   
  154.             createDirectory(objFolder);   
  155.             for (File sf : resFile.listFiles()) {   
  156.                 uploadDirectory(sf, objFolder, true);   
  157.             }    
  158.         }   
  159.         return true;   
  160.     }   
  161.     // Check the path is exist; exist return true, else false.     
  162.     public boolean existDirectory(String path) throws IOException {    
  163.         boolean flag = false;     
  164.         FTPFile[] ftpFileArr = ftpClient.listFiles(path);     
  165.         for (FTPFile ftpFile : ftpFileArr) {     
  166.             if (ftpFile.isDirectory()     
  167.                     && ftpFile.getName().equalsIgnoreCase(path)) {     
  168.                 flag = true;     
  169.                 break;     
  170.             }     
  171.         }     
  172.         return flag;     
  173.     }     
  174.     // Check the path is exist; exist return true, else false.     
  175.     public boolean existDirectory(String path,String folderName) throws IOException {    
  176.         boolean flag = false;     
  177.         FTPFile[] ftpFileArr = ftpClient.listFiles(path);     
  178.         for (FTPFile ftpFile : ftpFileArr) {     
  179.             if (ftpFile.isDirectory()     
  180.                     && ftpFile.getName().equalsIgnoreCase(folderName)) {     
  181.                 flag = true;     
  182.                 break;     
  183.             }     
  184.         }     
  185.         return flag;     
  186.     }    
  187.      
  188.     //=======================================================================     
  189.     //==         About file        =====     
  190.     // Download and Upload file using     
  191.     // ftpUtil.setFileType(FtpUtil.BINARY_FILE_TYPE) better!     
  192.     //=======================================================================     
  193.      
  194.     // #1. list & delete operation     
  195.     // Not contains directory     
  196.     public List<String> getFileList(String path) throws IOException {     
  197.         // listFiles return contains directory and file, it’s FTPFile instance     
  198.         // listNames() contains directory, so using following to filer directory.     
  199.         //String[] fileNameArr = ftpClient.listNames(path);     
  200.         FTPFile[] ftpFiles= ftpClient.listFiles(path);     
  201.              
  202.         List<String> retList = new ArrayList<String>();     
  203.         if (ftpFiles == null || ftpFiles.length == 0) {     
  204.             return retList;     
  205.         }     
  206.         for (FTPFile ftpFile : ftpFiles) {     
  207.             if (ftpFile.isFile()) {     
  208.                 retList.add(ftpFile.getName());     
  209.             }     
  210.         }     
  211.         return retList;     
  212.     }     
  213.      
  214.     public boolean deleteFile(String pathName) throws IOException {     
  215.         return ftpClient.deleteFile(pathName);     
  216.     }     
  217.      
  218.     // #2. upload to ftp server     
  219.     // InputStream <——> byte[]  simple and See API     
  220.      
  221.     public boolean uploadFile(File resFile, String newName)     
  222.             throws IOException {     
  223.         boolean flag = false;     
  224.         InputStream iStream = null;   
  225.         try {     
  226.             iStream = new FileInputStream(resFile);     
  227.             flag = ftpClient.storeFile(newName, iStream);     
  228.         } catch (IOException e) {     
  229.             flag = false;     
  230.             return flag;     
  231.         } finally {     
  232.             if (iStream != null) {     
  233.                 iStream.close();     
  234.             }     
  235.         }     
  236.         return flag;     
  237.     }     
  238.      
  239.     public boolean uploadFile(File resFile) throws IOException {     
  240.         return uploadFile(resFile, resFile.getName());     
  241.     }     
  242.      
  243.     public boolean uploadFile(InputStream iStream, String newName)     
  244.             throws IOException {     
  245.         boolean flag = false;     
  246.         try {     
  247.             // can execute [OutputStream storeFileStream(String remote)]     
  248.             // Above method return’s value is the local file stream.     
  249.             flag = ftpClient.storeFile(newName, iStream);     
  250.         } catch (IOException e) {     
  251.             flag = false;     
  252.             return flag;     
  253.         } finally {     
  254.             if (iStream != null) {     
  255.                 iStream.close();     
  256.             }     
  257.         }     
  258.         return flag;     
  259.     }     
  260.      
  261.     // #3. Down load      
  262.      
  263.     public boolean download(String remoteFileName, String localFileName)     
  264.             throws IOException {     
  265.         boolean flag = false;     
  266.         File outfile = new File(localFileName);     
  267.         OutputStream oStream = null;     
  268.         try {     
  269.             oStream = new FileOutputStream(outfile);     
  270.             flag = ftpClient.retrieveFile(remoteFileName, oStream);     
  271.         } catch (IOException e) {     
  272.             flag = false;     
  273.             return flag;     
  274.         } finally {     
  275.             oStream.close();     
  276.         }     
  277.         return flag;     
  278.     }     
  279.          
  280.     public InputStream downFile(String sourceFileName) throws IOException {     
  281.         return ftpClient.retrieveFileStream(sourceFileName);     
  282.     }     
  283. }  

原文出自: http://jacoxu.com/?p=589

发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>