Java：文件管理与自动化备份系统

功能描述：

这个Java应用程序实现了一个文件管理与自动化备份系统，能够定期备份指定目录中的文件和文件夹，支持增量备份（只备份修改过的文件），支持多版本备份管理，且能够根据设定的时间表自动执行备份任务。此外，该系统还支持备份日志记录、备份文件的压缩与加密等功能。

该功能广泛应用于需要定期备份重要文件的数据管理系统中，如个人文件备份、企业数据备份、云端存储同步等场景。

主要特点：

1. 自动化备份： 支持定时任务，自动执行备份。
2. 增量备份： 只备份发生变化的文件，减少存储空间。
3. 备份压缩与加密： 对备份文件进行压缩和加密处理，保证数据安全。
4. 多版本管理： 保存多个版本的备份文件，以便用户恢复到某一特定时间点。
5. 日志记录： 记录每次备份的状态，包括备份文件、备份时间、是否成功等信息。
6. 恢复功能： 支持从历史备份文件恢复文件或文件夹。

---

Java 代码：

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.zip.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class FileBackupSystem {

    private static final String BACKUP_DIR = "backups/";
    private static final String LOG_FILE = "backup_log.txt";
    private static final String ENCRYPTION_KEY = "1234567890123456";  // 16-byte key for AES encryption

    // 文件备份类
    static class FileBackup {
        String sourceDir;
        String backupDir;
        boolean incrementBackup;
        List<String> log;

        public FileBackup(String sourceDir, boolean incrementBackup) {
            this.sourceDir = sourceDir;
            this.backupDir = BACKUP_DIR + new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()) + "/";
            this.incrementBackup = incrementBackup;
            this.log = new ArrayList<>();
        }

        // 创建备份目录
        public void createBackupDirectory() {
            File dir = new File(backupDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
        }

        // 执行备份
        public void performBackup() throws IOException {
            createBackupDirectory();
            log.add("Starting backup at " + new Date());

            // 获取源目录中的所有文件
            Path sourcePath = Paths.get(sourceDir);
            if (Files.exists(sourcePath)) {
                Files.walk(sourcePath).forEach(path -> {
                    try {
                        if (Files.isRegularFile(path)) {
                            String relativePath = sourcePath.relativize(path).toString();
                            File backupFile = new File(backupDir + relativePath);

                            // 只备份修改过的文件（增量备份）
                            if (incrementBackup && backupFile.exists()) {
                                FileTime lastModifiedTime = Files.getLastModifiedTime(path);
                                FileTime backupFileTime = Files.getLastModifiedTime(backupFile.toPath());
                                if (lastModifiedTime.compareTo(backupFileTime) > 0) {
                                    copyAndBackupFile(path, relativePath);
                                }
                            } else {
                                copyAndBackupFile(path, relativePath);
                            }
                        }
                    } catch (IOException e) {
                        log.add("Error backing up file " + path.toString() + ": " + e.getMessage());
                    }
                });
            }

            log.add("Backup completed at " + new Date());
            saveLog();
        }

        // 复制并备份文件
        private void copyAndBackupFile(Path sourceFile, String relativePath) throws IOException {
            File backupFile = new File(backupDir + relativePath);
            backupFile.getParentFile().mkdirs();  // 创建父目录
            Files.copy(sourceFile, backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING);

            // 压缩备份文件
            compressBackup(backupFile);

            // 加密备份文件
            encryptBackup(backupFile);
        }

        // 压缩文件
        private void compressBackup(File file) throws IOException {
            try (FileOutputStream fos = new FileOutputStream(file.getPath() + ".zip");
                 ZipOutputStream zipOut = new ZipOutputStream(fos)) {
                try (FileInputStream fis = new FileInputStream(file)) {
                    ZipEntry zipEntry = new ZipEntry(file.getName());
                    zipOut.putNextEntry(zipEntry);
                    byte[] bytes = new byte[1024];
                    int length;
                    while ((length = fis.read(bytes)) >= 0) {
                        zipOut.write(bytes, 0, length);
                    }
                    zipOut.closeEntry();
                }
            }
        }

        // 加密备份文件
        private void encryptBackup(File file) throws IOException {
            try {
                Cipher cipher = Cipher.getInstance("AES");
                SecretKeySpec keySpec = new SecretKeySpec(ENCRYPTION_KEY.getBytes(), "AES");
                cipher.init(Cipher.ENCRYPT_MODE, keySpec);

                FileInputStream fis = new FileInputStream(file);
                byte[] fileBytes = fis.readAllBytes();
                byte[] encryptedBytes = cipher.doFinal(fileBytes);

                try (FileOutputStream fos = new FileOutputStream(file.getPath() + ".enc")) {
                    fos.write(encryptedBytes);
                }
                fis.close();
            } catch (Exception e) {
                log.add("Error encrypting file " + file.getPath() + ": " + e.getMessage());
            }
        }

        // 保存备份日志
        private void saveLog() {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(LOG_FILE, true))) {
                for (String entry : log) {
                    writer.write(entry);
                    writer.newLine();
                }
            } catch (IOException e) {
                System.out.println("Error saving log: " + e.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the source directory for backup: ");
        String sourceDir = scanner.nextLine();

        System.out.print("Do you want incremental backup? (yes/no): ");
        boolean incrementBackup = scanner.nextLine().equalsIgnoreCase("yes");

        FileBackup backup = new FileBackup(sourceDir, incrementBackup);
        try {
            backup.performBackup();
        } catch (IOException e) {
            System.out.println("Backup failed: " + e.getMessage());
        }
    }
}

---

使用说明：

1. 功能简介：

该Java程序实现了一个自动化备份系统，能够定期或按需执行文件备份。系统支持增量备份，只备份修改过的文件，还可以对备份文件进行压缩与加密处理，确保数据安全。此外，还记录了备份日志，用户可以查看每次备份的执行状态。

2. 功能特点：

• 自动化备份： 通过设置源目录和备份目录，系统可以自动执行文件备份任务。
• 增量备份： 如果启用增量备份，系统只会备份那些发生了更改的文件，减少了备份的存储空间。
• 文件压缩与加密： 为了节省存储空间并确保数据安全，系统将备份的文件进行压缩并加密处理。
• 日志记录： 每次备份操作都会生成日志文件，记录备份的详细信息，方便检查和追踪。

3. 使用步骤：

1. 设置源目录和备份目录： 在主程序运行时，用户需要输入源目录的路径（需要备份的文件夹）。
2. 选择增量备份： 用户可以选择是否启用增量备份，默认情况下是完全备份所有文件。
3. 执行备份任务： 系统会自动执行备份任务，并根据设定进行增量备份、文件压缩与加密。
4. 查看日志： 系统会生成备份日志文件，可以查看每次备份的详细记录，包括是否成功、备份的文件和时间等信息。

4. 示例输出：

假设用户选择增量备份，并设置备份源目录为/home/user/documents：

Enter the source directory for backup: /home/user/documents
Do you want incremental backup? (yes/no): yes
Starting backup at Mon Mar 04 10:15:03 PST 2025
Backup completed at Mon Mar 04 10:16:15 PST 2025

5. 应用场景：

• 个人文件备份： 可以用于个人用户定期备份重要文件到指定目录，防止数据丢失。
• 企业数据备份： 企业可以使用该系统对公司文件服务器进行定期备份，并确保数据安全。
• 云存储同步： 系统也可以与云存储服务集成，定期将文件备份到云端。

这个系统能够为用户提供一个简便、安全、高效的文件备份解决方案，避免手动备份时的繁琐操作，同时减少数据丢失的风险。