A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 kelin410 于 2016-4-13 11:44 编辑

测试类中的代码:
  1. package com.heima.Demo;

  2. import java.io.File;
  3. import java.io.IOException;

  4. import com.heima.EncryptFile.EncryptFile;


  5. public class Demo1_Encrypt{
  6.         public static void main(String[] args) throws IOException {
  7.                 //创建加密类,制定文件夹路径。并设置可以加密子文件夹中的文件,和制定后缀名的文件。
  8.                 EncryptFile ef = new EncryptFile(new File("E:\\黑马"), true, ".txt|.jpg");
  9.                 //为制定的文件夹中的文件加密。
  10.                 ef.encrypt();
  11.         }
  12. }
复制代码

具体类中的代码:
  1. package com.heima.EncryptFile;

  2. import java.io.BufferedInputStream;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.FilenameFilter;
  9. import java.io.IOException;

  10. /*
  11. * 需求:根据指定的文件夹路径或文件夹File对象将数据加密。
  12. *                 注:可以设置是否加密子文件夹、可以通过文件过滤器加密某种类型的文件。
  13. *
  14. * 公共字段:
  15. *                         无公共字段
  16. *
  17. * 构造方法:
  18. *                         1.public EncryptFile(File aimFile)
  19. *                         2.public EncryptFile(String path)
  20. *                         3.public EncryptFile(File aimFile, boolean encryptSublevelFolder)
  21. *                         4.public EncryptFile(File aimFile, String filter)
  22. *                         5.public EncryptFile(File aimFile, boolean encryptSublevelFolder, String filter)
  23. *                 构造方法参数说明:
  24. *                                 1.aimFile 一个有效的文件夹对象
  25. *                                 2.path        一个有效的文件夹路径
  26. *                                 3.encryptSublevelFolder        是否要对子文件夹中的文件进行加密
  27. *                                 4.filter        过滤器条件,如过给出了条件就表示启用文件过滤器。可以设置多个后缀名,中间用“|”分开。例如:".jpg|.bmp|.txt"
  28. *
  29. * 公共方法:
  30. *                         1.public void encrypt ()  执行加密
  31. *                         2.public File getAimFolder()        过去当前对象中封装的文件夹路径
  32. *                         3.public boolean setAimFolder(String aimFolderString)        重新设置当前对象中封装的文件夹路径
  33. *                         4.public boolean setAimFolder(File aimFolder)                        重新设置当前对象中封装的文件夹路径
  34. *
  35. */
  36. public class EncryptFile {
  37.         private boolean useFilter = false;                                        //是否使用文件过滤器
  38.         private boolean encryptSublevelFolder = false;                //是否加密子文件夹
  39.         private String[] filter;                                                                //当用户传入多个过滤器条件时,此数组用来存放每个条件。
  40.         private File aimFolder;                                                                //创建File对象用来存放用户给定的文件路径。
  41.        
  42.         /**
  43.          * 有参构造,用户必须在创建本类对象时给定一个有效的文件夹对象       
  44.          * @param aimFile
  45.          * @throws FileNotFoundException
  46.          */
  47.         public EncryptFile(File aimFile) throws FileNotFoundException {
  48.                 super();
  49.                 this.aimFolder = aimFile;
  50.                 if (!this.aimFolder.isDirectory() || !this.aimFolder.exists())                        //如果用户给定的不是一个有效文件夹路径,就抛出异常。
  51.                         throw new FileNotFoundException(aimFile.getAbsolutePath());
  52.         }

  53.         /**
  54.          * 有参构造,用户必须在创建本类对象时给定一个有效的文件夹路径
  55.          * @param path
  56.          * @throws FileNotFoundException
  57.          */
  58.         public EncryptFile(String path) throws FileNotFoundException {
  59.                 this(new File(path));
  60.         }
  61.        
  62.         /**
  63.          * 有参构造,用户可以设置是否加密子文件夹
  64.          * @param aimFile
  65.          * @param encryptDirectory
  66.          * @throws FileNotFoundException
  67.          */
  68.         public EncryptFile(File aimFile, boolean encryptSublevelFolder) throws FileNotFoundException {
  69.                 this(aimFile);
  70.                 this.encryptSublevelFolder = encryptSublevelFolder;
  71.         }
  72.        
  73.         /**
  74.          * 有参构造,用户可以设置是否加密子文件夹和是否使用过滤器
  75.          * @param aimFile
  76.          * @param filter
  77.          * @throws FileNotFoundException
  78.          */
  79.         public EncryptFile(File aimFile, String filter) throws FileNotFoundException {
  80.                 this(aimFile);
  81.                 if (!filter.matches("\\.[a-z]{2,}"))
  82.                         new FileNotFoundException("没有找到合法的过滤器格式");
  83.                
  84.                 this.filter = filter.split("\\|");
  85.                 if (this.filter.length == 0)
  86.                         new FileNotFoundException("没有找到合法的过滤器格式");
  87.                 this.useFilter = true;
  88.         }
  89.        
  90.         /**
  91.          * 有参构造,用户可以设置是否即加密子文件夹,又使用过滤器
  92.          * @param aimFile
  93.          * @param encryptDirectory
  94.          * @param filter
  95.          * @throws FileNotFoundException
  96.          */
  97.         public EncryptFile(File aimFile, boolean encryptSublevelFolder, String filter) throws FileNotFoundException {
  98.                 this(aimFile, filter);
  99.                 this.encryptSublevelFolder = encryptSublevelFolder;
  100.         }
  101.        
  102.         /**
  103.          * 获取当前EncryptFile对象中封装的File对象
  104.          * @return
  105.          */
  106.         public File getAimFolder() {
  107.                 return aimFolder;
  108.         }

  109.         /**
  110.          * 改变当前EncryptFile对象中所封装的文件夹对象
  111.          * @param aimFolder
  112.          */
  113.         public boolean setAimFolder(File aimFolder) {
  114.                 return folderValidity(aimFolder);
  115.         }
  116.        
  117.         /**
  118.          * 改变当前EncryptFile对象中所封装的文件夹对象,成功返回true,失败返回false.
  119.          * @param aimFolderString
  120.          * @return
  121.          */
  122.         public boolean setAimFolder(String aimFolderString) {
  123.                 return folderValidity(new File(aimFolderString));
  124.         }

  125.         //此方法是检验一个文件夹是否符合要求,如果符合要求就赋值给成员属性aimFolder
  126.         private boolean folderValidity(File newAimFile) {
  127.                 if (!newAimFile.isDirectory() || !newAimFile.exists())                        //如果用户给定的不是一个有效文件夹路径,返回false
  128.                         return false;
  129.                 this.aimFolder = newAimFile;
  130.                 return true;
  131.         }
  132.        
  133.         /**
  134.          * 加密文件,将EncryptFile对象中封装的路径中所有的符合指定过滤器的文件进行加密。
  135.          */
  136.         public void encrypt () {
  137.                 analyse (aimFolder);
  138.         }

  139.         //分析文件
  140.         private void analyse (File aimFolder) {
  141.                 //定义File数组,存放给定文件夹中的所有符合过滤器的对象。
  142.                 File[] fiArr = aimFolder.listFiles(new FilenameFilter() {
  143.                        
  144.                         //重写过滤器中的抽象方法
  145.                         @Override
  146.                         public boolean accept (File dir, String name) {
  147.                                 File fi = new File(dir, name);
  148.                                 if (useFilter == false && encryptSublevelFolder == true)                                //如果不启用过滤器,且要对子文件夹加密,如果是直接返回true。
  149.                                         return true;
  150.                                
  151.                                 if (useFilter == true && encryptSublevelFolder == true)                                //如果既要启用过滤器又要加密子文件夹就判断是否满足过滤器,不满足就返回是否是文件夹
  152.                                         return isFilter(name) ? true : fi.isDirectory();
  153.                                        
  154.                                 if (useFilter == true && encryptSublevelFolder == false)                                //如果只使用过滤器不加密子文件夹,就返回是否不是文件夹,如果不是就返回是否满足过滤器。
  155.                                         return fi.isDirectory() ? false : isFilter(name);
  156.                                
  157.                                 return fi.isFile();                                                                                                //如果不满足前面三条,就直接返回是否是文件。因为是文件就肯定不是文件夹。
  158.                         }
  159.                        
  160.                        
  161.                         //判断指定的文件名是否包含在过滤器中
  162.                         private boolean isFilter(String name) {
  163.                                 for (String s : filter) {
  164.                                         if (name.endsWith(s))
  165.                                                 return true;
  166.                                 }
  167.                                 return false;
  168.                         }
  169.                        
  170.                 });       
  171.                 File tempFile = new File("temp");                                                                                                                //定义临时文件,用来将要加密的文件先剪切的当前目录,然后再加密写出到原目录。
  172.                 for (File f : fiArr) {                                                                                                                                        //遍历获取到的每个文件对象。
  173.                         if (f.isDirectory())                                                                                                                                //如果当前对象是文件夹,就递归调用本方法。
  174.                                 analyse(f);
  175.                         else {                                                                                                                                                                //如果不是文件夹就进行加密操作。
  176.                                 f.renameTo(tempFile);
  177.                                 startEncrypt(tempFile, f);
  178.                         }
  179.                 }
  180.         }

  181.         //开始加密文件,tempFile是一个临时文件        ,加密后将会删除。srcFile是源文件。
  182.         private void startEncrypt (File tempFile, File srcFile) {
  183.                 System.out.println(Thread.currentThread().getName() + " : " + tempFile + " 到 " + srcFile);
  184.                 synchronized (this) {
  185.                         BufferedInputStream bufi = null;
  186.                         BufferedOutputStream bufo = null;
  187.                         try {
  188.                                 bufi = new BufferedInputStream(new FileInputStream(tempFile));                                                //创建高效字节输入流
  189.                                 bufo = new BufferedOutputStream(new FileOutputStream(srcFile));                                                //创建高效字节输出流
  190.                                 byte[] by = new byte[8192];                                                                                                                //创建字节数组,用于接收bufi读取到的数据。
  191.                                 int len;                                                                                       
  192.                                 while ((len = bufi.read(by)) != -1) {
  193.                                         for (int x = 0; x < len; x++)                                                                                                        //遍历读取到的数据,将他们加密。
  194.                                                 by[x] = (byte) (by[x] ^ 13);
  195.                                        
  196.                                         bufo.write(by, 0, len);                                                                                                                        //加密完成后,一次性写入到原文件的原目录中。
  197.                                 }
  198.                         } catch (IOException e) {
  199.                                 e.printStackTrace();
  200.                         } finally {
  201.                                 //关闭流
  202.                                 try {
  203.                                         if (bufi != null)
  204.                                         bufi.close();
  205.                                 } catch (IOException e) {
  206.                                         e.printStackTrace();
  207.                                 } finally {
  208.                                         try {
  209.                                                 if (bufo != null)
  210.                                                         bufo.close();
  211.                                         } catch (IOException e) {
  212.                                                 e.printStackTrace();
  213.                                         } finally {
  214.                                                 //删除临时文件
  215.                                                 tempFile.delete();
  216.                                         }
  217.                                 }
  218.                         }
  219.                 }
  220.         }
  221. }
复制代码





0 个回复

您需要登录后才可以回帖 登录 | 加入黑马