编写一个diff工具，用于判断两个目录下所有的改动 --1.0版本

需求说明:

编写一个diff工具，用于判断两个目录下所有的改动

详细介绍：

1. 有A和B两个目录，目录所在位置及层级均不确定
2. 需要以B为基准找出两个目录中所有有改动的文件（文件或内容增加、修改、删除），将有改动的文件放入第三个目录中，层级结构与原目录相同
3. 将所有新增与更新信息记录到更新日志文件中
4. 将删除信息单独记录到删除日志文件中
5. 每次执行diff工具需要生成一个新的以日期命名的目录存放文件

使用场景：

本工具用于软件版本升级时找出两个版本间所有修改过的文件，便于增量替换。

提示：

1. 使用CRC判断文件是否改动
2. 控制台日志记录使用slf4j，增删日志可以使用其他方式记录
3. 部分jar包已提供，如需使用到新的jar包可自行添加

package comcollection.test;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.CRC32;
import org.apache.commons.io.FileUtils;

/**
 * @author MJC 2018年4月24日 上午23:53:45
 */
public class DiffUtils {

    private static void writeToFile(File file, String content, String charbyte) {
        try {
            FileUtils.write(file, content + "
", "UTF-8", true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("resource")
    public static void judgeFileChange(String oldUrl, String newUrl, String diffUrl) {

        FileChannel inputChannel = null;
        FileChannel outputChannel = null;
        HashMap<String, File> filesMap = getFilesUpdateAndAddMap(oldUrl, newUrl);

        // 创建diffUrl对应的根目录
        File fileDir = new File(diffUrl);
        fileDir.mkdirs();

        Date now = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日HH点mm分ss秒");
        String nowTime = dateFormat.format(now);
        diffUrl = diffUrl + "\" + nowTime + "\";
        File fileDire = new File(diffUrl);
        fileDire.mkdirs();

        // 创建delete.log、updateAndAdd.log日志文件
        String deleteLog = diffUrl + "delete.log";
        String updateAndAddLog = diffUrl + "updateAndAdd.log";
        File deleteLogFile = null;
        File updateAndAddLogFile = null;
        deleteLogFile = new File(deleteLog);
        updateAndAddLogFile = new File(updateAndAddLog);

        // 遍历删除文件、并且将信息写入日志文件
        String timeUrl = "-------- Diff时间：" + nowTime + " --------";
        writeToFile(deleteLogFile, timeUrl, "UTF-8");
        List<String> oldUrlFilePaths = getAllFilePaths(oldUrl);
        List<String> newUrlFilePaths = getAllFilePaths(newUrl);
        int count = 0;
        long start = System.currentTimeMillis(); // 获取开始时间
        for (String filePath : oldUrlFilePaths) {
            if (!newUrlFilePaths.contains(filePath)) {
                count++;
                writeToFile(deleteLogFile, filePath, "UTF-8");
            }
        }
        long end = System.currentTimeMillis(); // 获取结束时间
        String fileCount = "-------- 共删除文件" + count + "--------";
        writeToFile(deleteLogFile, fileCount + "
", "UTF-8");
        String endContent = "-------- 运行完毕，耗时：" + (end - start) + "ms";
        writeToFile(deleteLogFile, endContent + "
", "UTF-8");

        // 遍历新增/更改文件、并且将信息写入日志文件
        Date now2 = new Date();
        SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy年MM月dd日HH点mm分ss秒");
        String nowTime2 = dateFormat2.format(now2);
        String timeUrl2 = "-------- Diff时间：" + nowTime2 + " --------";
        writeToFile(updateAndAddLogFile, timeUrl2, "UTF-8");
        HashMap<String, Long> oldUrlMap = getAllFileMap(oldUrl);
        HashMap<String, Long> newUrlMap = getAllFileMap(newUrl);

        for (Map.Entry<String, Long> newUrlMapEntry : newUrlMap.entrySet()) {
            // 如果元素存在原来的目录下，并且crc相同，就是更新操作
            if (oldUrlMap.containsKey(newUrlMapEntry.getKey())) {
                try {
                    long oldUrlCrc = oldUrlMap.get(newUrlMapEntry.getKey());
                    long newUrlCrc = newUrlMapEntry.getValue();
                    if (oldUrlCrc != newUrlCrc) {
                        writeToFile(updateAndAddLogFile, "更新：" + newUrlMapEntry.getKey(), "UTF-8");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            } else {// 如果元素不存在A目录下，就是新增的元素
                writeToFile(updateAndAddLogFile, "新增：" + newUrlMapEntry.getKey(), "UTF-8");
            }
        }
        /**
         * 将新增、更新的文件copy到diffUrl目录下
         */
        for (Map.Entry<String, File> addAndUpdate : filesMap.entrySet()) {
            // 创建每个文件对应的目录
            File file = addAndUpdate.getValue();
            String filePath = diffUrl + addAndUpdate.getKey();
            String fileDirs = filePath.replace(file.getName(), "");
            File creFileDir = new File(fileDirs);
            creFileDir.mkdirs();

            try {
                inputChannel = new FileInputStream(file).getChannel();
                outputChannel = new FileOutputStream(new File(filePath)).getChannel();
                outputChannel.transferFrom(inputChannel, 0, inputChannel.size());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    inputChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    outputChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 获取新增/更新文件-用于遍历出file文件，以便复制操作引用此方法
     * 
     * @param oldUrl
     * @param newUrl
     * @return
     */
    private static HashMap<String, File> getFilesUpdateAndAddMap(String oldUrl, String newUrl) {
        HashMap<String, File> oldUrlMap = getAllFileMaps(oldUrl);
        HashMap<String, File> newUrlMap = getAllFileMaps(newUrl);
        HashMap<String, File> addAndUpdateMap = new HashMap<String, File>();
        for (Map.Entry<String, File> newUrlEntry : newUrlMap.entrySet()) {
            // 如果元素存在A目录下，且crc相同，就是更新
            if (oldUrlMap.containsKey(newUrlEntry.getKey())) {
                try {
                    long oldFileCrc = getFileCRC(oldUrlMap.get(newUrlEntry.getKey()));
                    long newFileCrc = getFileCRC(newUrlEntry.getValue());
                    if (oldFileCrc != newFileCrc) {
                        addAndUpdateMap.put(newUrlEntry.getKey(), newUrlEntry.getValue());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            } else {// 如果元素不存在A目录下，就是新增的元素
                addAndUpdateMap.put(newUrlEntry.getKey(), newUrlEntry.getValue());
            }
        }
        return addAndUpdateMap;
    }

    /**
     * 遍历所有文件-- map的value类型为File形式
     * 
     * @param path
     * @return
     */
    private static HashMap<String, File> getAllFileMaps(String path) {

        List<File> allFileList = new ArrayList<File>();
        HashMap<String, File> resMap = new HashMap<String, File>();

        allFileList = getAllFile(new File(path), allFileList);
        for (File file : allFileList) {
            resMap.put(file.getAbsolutePath().replace(path, ""), file);
        }
        return resMap;
    }

    /**
     * 遍历所有文件-- map的value类型为long形式的CRC 该路径去掉url前缀
     * 
     * @param path
     * @return
     */
    private static HashMap<String, Long> getAllFileMap(String url) {

        List<File> allFileList = new ArrayList<File>();
        HashMap<String, Long> resMap = new HashMap<String, Long>();

        allFileList = getAllFile(new File(url), allFileList);
        for (File file : allFileList) {
            resMap.put(file.getAbsolutePath().replace(url, ""), getFileCRC(file));
        }
        return resMap;
    }

    /**
     * 遍历该目录下的所有文件对应的路径(截取 path之后的路径)
     * 
     * @param path
     * @return
     */
    private static List<String> getAllFilePaths(String path) {

        List<File> allFileList = new ArrayList<File>();
        List<String> allFilePaths = new ArrayList<String>();

        allFileList = getAllFile(new File(path), allFileList);
        for (File file : allFileList) {
            allFilePaths.add(file.getAbsolutePath().replace(path, ""));
        }

        return allFilePaths;
    }

    /**
     * 遍历该目录下的所有文件
     * 
     * @param file
     * @param allFileList
     * @return
     */
    private static List<File> getAllFile(File file, List<File> allFileList) {
        if (file.exists()) {
            // 如果当前对象是文件夹，递归调用此方法，获取目录下的所有文件
            if (file.isDirectory()) {
                File f[] = file.listFiles();
                for (File tempFile : f) {
                    getAllFile(tempFile, allFileList);
                }
            } else {
                // 如果当前对象是个文件，将文件存到list中
                allFileList.add(file);
            }
        }
        return allFileList;
    }

    /**
     * 获取文件的CRC
     * 
     * @param file
     * @return
     * @throws IOException
     */
    private static long getFileCRC(File file) {
        BufferedInputStream bsrc = null;
        CRC32 crc = new CRC32();
        try {
            bsrc = new BufferedInputStream(new FileInputStream(file));
            byte[] bytes = new byte[1024];
            int i;
            while ((i = bsrc.read(bytes)) != -1) {
                crc.update(bytes, 0, i);
            }
        } catch (Exception e) {

        } finally {
            if (bsrc != null) {
                try {
                    bsrc.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return crc.getValue();
    }
}

package comcollection.test;


import org.junit.Test;

/**
 * @author MJC 2018年4月24日 上午23:53:45
 */
public class DiffUtilsTest {
    private static final String oldUrl = "C:\Users\jljd\Desktop\diff工具需求说明及示例\diff工具需求说明及示例\A";
    private static final String newUrl = "C:\Users\jljd\Desktop\diff工具需求说明及示例\diff工具需求说明及示例\B";
    private static final String diffUrl = "C:\Users\jljd\Desktop\diff工具需求说明及示例\diff工具需求说明及示例\change";
    
    @Test
    public void testjudgeFileChange(){
        DiffUtils7.judgeFileChange(oldUrl, newUrl, diffUrl);
    }

}