FileDetector-基于java开发的照片整理工具

1. 项目背景

开发这个功能的主要原因如下：
1. 大学期间拍摄了约50G的照片，照片很多
2. 存放不规范，导致同一张照片出现在不同的文件夹内，可读性差，无法形成记忆线。
3. 重复存放过多，很多照片都有冗余备份，导致磁盘空间越来越不够用。

2. 解决思路

1. 根据照片拍摄时间对照片文件重命名，并移动到统一文件夹内。
2. 重复文件只移动一份，结果是除了目标文件夹内的照片以外，其他照片都是冗余照片。

注意：并非所有照片都有拍摄时间，只有数码相机与手机拍摄的才有。部分网上下载的图片也有原始拍摄时间。没有拍摄时间的照片不作处理。

3. 项目概述

3.1 项目依赖

这里的依赖都比较普通，只有一个比较特殊：metadata-extractor是用来提取照片中的拍摄时间的。joda-time用来规范日期格式。

3.2 项目结构

功能实现比较简单，根据业务分了biz/service/util/ui包。其中ui开发的比较粗糙，因为java开发基本上已经转入了后端，swing已经很少用到了，能跑起来就行。

3.3 项目流程图

1.重复文件删除

Created with Raphaël 2.1.0开始用户输入目录获取目录下所有文件对所有文件进行hash得到MultiMap根据hashcode删除重复的文件结束

2.按拍摄时间重命名照片

Created with Raphaël 2.1.0开始用户输入目录与后缀获取目录下所有后缀匹配文件通过metadata获得拍摄时间并重命名结束

3.移动文件到目标文件夹

Created with Raphaël 2.1.0开始用户输入目录与后缀获取目录下所有后缀匹配文件移动文件到目标文件夹结束

3.4 项目下载

代码地址：github地址
可执行应用地址:应用地址

关键代码

1.重复文件检测

package cuishining.bizz;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.HashMultimap;
import com.google.common.hash.Hashing;
import com.google.common.io.Files;

import cuishining.util.FileUtil;

/**
 * Created by shining.cui on 2016/7/20.
 */
public class DuplicateFileDetector {
    private static final Logger logger = LoggerFactory.getLogger(DuplicateFileDetector.class);

    public HashMultimap<Long, String> detect(String path, String nameSuffix) {
        List<File> fileList = FileUtil.getAllFilesUnderPath(path, nameSuffix);
        HashMultimap<Long, String> md5AndFilePathMultiMap = analyzeMd5OfAllFiles(fileList);
        return analyzeDuplicateFiles(md5AndFilePathMultiMap);
    }

    private HashMultimap<Long, String> analyzeMd5OfAllFiles(List<File> fileList) {
        HashMultimap<Long, String> md5FileNameMultiMap = HashMultimap.create();
        for (File file : fileList) {
            logger.info("文件{}，正在分析中……",file);
            try {
                long md5 = Files.hash(file, Hashing.md5()).asLong();
                String path = file.getCanonicalPath();
                md5FileNameMultiMap.put(md5, path);
            } catch (IOException e) {
                logger.error("文件hash出错，请检查文件是否可读。",e);
            }

        }
        return md5FileNameMultiMap;
    }

    private HashMultimap<Long, String> analyzeDuplicateFiles(HashMultimap<Long, String> multimap) {
        Set<Long> md5s = multimap.keySet();
        HashMultimap<Long, String> duplicateFilesMap = HashMultimap.create();
        for (Long md5 : md5s) {
            Set<String> fileNames = multimap.get(md5);
            // 如果对应md5的value多于1个，证明是重复的文件，放入新的map中返回
            if (fileNames.size() > 1) {
                for (String name : fileNames) {
                    duplicateFilesMap.put(md5, name);
                }
            }
        }
        return duplicateFilesMap;
    }
}

2.重命名策略

package cuishining.service.impl;

import java.io.File;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cuishining.service.RenamePolicy;
import cuishining.util.JpgFileUtil;

/**
 * Created by shining.cui on 2016/7/23.
 */
public class RenameByTimePolicy implements RenamePolicy {
    private static final Logger logger = LoggerFactory.getLogger(RenameByTimePolicy.class);

    @Override
    public boolean rename(List<File> fileList) {
        logger.info("接受参数fileList为:{}", fileList);
        for (File file : fileList) {
            String photoTimeStr = JpgFileUtil.getPhotoTimeStr(file);
            if (StringUtils.isEmpty(photoTimeStr)) {
                logger.error("文件{}不存在拍摄日期，无法重命名",file);
            }
            String path = file.getParentFile().getAbsolutePath();
            if (StringUtils.isNotEmpty(photoTimeStr)) {
                renameFile(file, photoTimeStr, path);
            }
        }
        return true;
    }

    private void renameFile(File file, String photoTimeStr, String path) {
        logger.info("文件{}正在重命名中……",file);
        File renamedFile = new File(path + File.separator + photoTimeStr + ".jpg");
        if (renamedFile.exists()) {
            logger.error("{}文件已经存在，无法重命名。", renamedFile);
        } else {
            boolean renameSuccess = file.renameTo(renamedFile);
            if (renameSuccess) {
                logger.info("{}文件命名为{}", file.getName(), renamedFile.getName());
            }
        }
    }
}

3.文件处理工具

package cuishining.util;

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import com.google.common.collect.HashMultimap;
import com.google.common.io.Files;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.Lists;

/**
 *   文件处理工具
 * Created by shining.cui on 2016/7/12.
 */
public class FileUtil {
    public static Logger logger = LoggerFactory.getLogger(FileUtil.class);

    /**
     * 读取指定路径下的所有文件，使用队列实现
     * 
     * @param filePath 指定的文件夹目录
     * @param nameSuffix 指定后缀，若为null或者" "则匹配所有
     * @return 文件夹及其子文件夹内所有文件
     */
    public static List<File> getAllFilesUnderPath(String filePath, String nameSuffix) {
        logger.info("接受的文件夹路径为:{},文件名匹配后缀为:{}", filePath, nameSuffix);
        File basicfile = new File(filePath);
        List<File> fileLis = Lists.newArrayList();
        LinkedList<File> fileQueue = Lists.newLinkedList(Lists.newArrayList(basicfile));
        while (!fileQueue.isEmpty()) {
            File file = fileQueue.poll();
            if (file.isDirectory() && file.listFiles() != null) {
                fileQueue.addAll(Lists.newArrayList(file.listFiles()));
            } else {
                fileQueue = matchTheSuffix(file, nameSuffix, fileQueue, fileLis);
            }
        }
        logger.info("得到的文件列表的长度为:{}", fileLis.size());
        return fileLis;
    }

    private static LinkedList<File> matchTheSuffix(File file, String nameSuffix, LinkedList<File> fileQueue,
            List<File> fileList) {
        String fileName = file.getName();
        if (StringUtils.isNotEmpty(nameSuffix)
                && StringUtils.endsWith(fileName.toLowerCase(), nameSuffix.toLowerCase())) {
            // 当有后缀名时，匹配的放入队列
            fileList.add(file);
        } else if (StringUtils.isEmpty(nameSuffix)) {
            // 没有匹配名时，所有的都放入队列
            fileList.add(file);
        }
        return fileQueue;
    }

    public static String deleteFilesFromMultiMap(HashMultimap<Long, String> duplicateFileMultimap) {
        Set<Long> md5s = duplicateFileMultimap.keySet();
        StringBuilder sb = new StringBuilder();
        int count = 0;
        for (long md5 : md5s) {
            ArrayList<String> filenames = Lists.newArrayList(duplicateFileMultimap.get(md5));
            sb.append("以下重复文件：
");
            for (String filename : filenames) {
                    sb.append(filename).append("
");
            }
            String firstDupFile = filenames.get(0);
            File file = new File(firstDupFile);
            boolean delete = file.delete();
            if (delete) {
                logger.info("文件{}已被删除", firstDupFile);
                sb.append("文件").append(firstDupFile).append("已被删除");
                count++;
            } else {
                logger.error("文件{}删除失败", firstDupFile);
            }
        }
        sb.append("共删除").append(count).append("个文件");
        logger.info("共删除{}个文件",count);
        return sb.toString();
    }
}

4.照片拍摄时间提取工具

package cuishining.util;

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.drew.imaging.ImageMetadataReader;
import com.drew.imaging.ImageProcessingException;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.exif.ExifDirectoryBase;

/**
 * Created by shining.cui on 2016/7/23.
 */
public class JpgFileUtil {
    private static final Logger logger = LoggerFactory.getLogger(JpgFileUtil.class);

    public static String getPhotoTimeStr(File file) {
        Date date = null;
        try {
            Metadata metadata = ImageMetadataReader.readMetadata(file);
            for (Directory dr : metadata.getDirectories()) {
                if (dr.containsTag(ExifDirectoryBase.TAG_DATETIME_ORIGINAL)) {
                    date = dr.getDate(ExifDirectoryBase.TAG_DATETIME_ORIGINAL);
                }
                if (date != null) {
                    return TimeUtil.parseDateFromJpgFileDate(date);
                }
            }
        } catch (ImageProcessingException e) {
            logger.error("jpg文件读取错误", e);
        } catch (IOException e) {
            logger.error("发生io错误", e);
        }
        return null;
    }
}
5.时间工具

package cuishining.util;

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;

import java.util.Date;

/**
 * Created by shining.cui on 2016/7/25.
 */
public class TimeUtil {
    private static final String timeFormatStr = "yyyy-MM-dd HH-mm-ss";
    private static final String timeFormatStr1 = "yyyy-MM-dd HH:mm:ss";

    public static String parseDateFromSystemDate(Date date) {
       return new DateTime(date).toString(timeFormatStr1);
    }

    public static String parseDateFromJpgFileDate(Date date) {
        return new DateTime(date, DateTimeZone.UTC).toString(timeFormatStr);
    }
}

总结

项目总体思想是根据md5删除重复照片，然后根据拍摄时间重命名之后移动到统一文件夹内。可以在同一个文件夹内按照拍摄时间浏览照片，比较有历史感，容易唤起回忆。