1. 通过Java调用外部命令（推荐）：这是最可靠、最常用、功能最全的方法，Java代码本身不负责复杂的备份逻辑，而是像在命令行中一样，调用MySQL官方提供的mysqldump工具来完成备份。
2. 纯Java代码实现（不推荐用于生产环境）：通过JDBC连接数据库，逐表查询数据，然后将数据写入到一个SQL文件或文本文件中，这种方法逻辑复杂，难以处理存储过程、函数、触发器等复杂对象，且性能远不如mysqldump。

强烈推荐使用第一种方法。

通过Java调用 mysqldump 命令 (推荐)

这种方法的核心是使用Java的Runtime.exec()或ProcessBuilder来执行操作系统命令。

准备工作

1. 安装MySQL服务器：确保你的环境中已经安装了MySQL服务器。
2. 获取mysqldump路径：mysqldump通常位于MySQL的bin目录下，你需要知道它的完整路径。
   • Windows: C:\Program Files\MySQL\MySQL Server 8.0\bin\mysqldump.exe
   • Linux / macOS: /usr/bin/mysqldump 或 /usr/local/mysql/bin/mysqldump
3. 准备数据库连接信息：你需要知道主机名、端口、用户名、密码以及要备份的数据库名。

Java 实现代码

下面是一个完整的、健壮的Java类，它封装了调用mysqldump的逻辑。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
public class MySqlBackupUtil {
    /**
     * 备份MySQL数据库
     *
     * @param host        数据库地址
     * @param port        数据库端口
     * @param username    数据库用户名
     * @param password    数据库密码
     * @param databaseName 要备份的数据库名
     * @param outputPath   备份文件的输出路径 ( "C:/backups/mydb_backup.sql")
     * @return true 如果备份成功，false 如果失败
     */
    public static boolean backup(String host, int port, String username, String password, 
                                String databaseName, String outputPath) {
        // 检查mysqldump命令是否存在，这里以Linux/macOS为例，Windows需要修改
        String mysqldumpPath = "/usr/bin/mysqldump"; 
        if (!new File(mysqldumpPath).exists()) {
            System.err.println("错误: 找不到 mysqldump 工具，请检查路径是否正确: " + mysqldumpPath);
            return false;
        }
        // 使用 ProcessBuilder 来构建命令，它比 Runtime.exec() 更灵活
        ProcessBuilder pb = new ProcessBuilder(
                mysqldumpPath,
                "--host=" + host,
                "--port=" + port,
                "--user=" + username,
                "--password=" + password,
                "--databases", // 如果要备份所有数据库，使用 --all-databases
                databaseName,
                "--result-file=" + outputPath,
                "--default-character-set=utf8mb4", // 推荐使用utf8mb4
                "--routines", // 备储存储过程和函数
                "--triggers"  // 备份触发器
        );
        // 合并错误流和标准输出流，这样错误信息也能被读取到
        pb.redirectErrorStream(true);
        try {
            Process process = pb.start();
            // 读取命令的输出（包括错误信息）
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    // 可以选择打印日志或忽略
                    // System.out.println(line);
                }
            }
            // 等待命令执行完成
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                System.out.println("数据库备份成功！文件已保存至: " + outputPath);
                return true;
            } else {
                System.err.println("数据库备份失败！命令执行退出码: " + exitCode);
                return false;
            }
        } catch (IOException | InterruptedException e) {
            System.err.println("执行备份命令时发生异常: " + e.getMessage());
            if (e instanceof InterruptedException) {
                Thread.currentThread().interrupt(); // 恢复中断状态
            }
            return false;
        }
    }
    public static void main(String[] args) {
        // --- 配置信息 ---
        String host = "localhost";
        int port = 3306;
        String username = "root";
        String password = "your_password";
        String databaseName = "your_database";
        // Windows 示例: "C:\\data\\backups\\db_backup_20251027.sql"
        // Linux/macOS 示例: "/var/backups/db_backup_20251027.sql"
        String outputPath = "C:/data/backups/db_backup_20251027.sql"; 
        // 确保输出目录存在
        File outputFile = new File(outputPath);
        File outputDir = outputFile.getParentFile();
        if (outputDir != null && !outputDir.exists()) {
            boolean created = outputDir.mkdirs();
            if (!created) {
                System.err.println("无法创建备份目录: " + outputDir.getAbsolutePath());
                return;
            }
        }
        // 执行备份
        boolean success = backup(host, port, username, password, databaseName, outputPath);
        if (success) {
            System.out.println("备份任务完成。");
        } else {
            System.out.println("备份任务失败。");
        }
    }
}

代码解析

1. ProcessBuilder：这是执行外部命令的首选方式，它允许你更灵活地设置工作目录、环境变量等。
2. 命令参数：
   • --host, --port, --user, --password：标准的连接参数。
   • --databases：指定要备份的数据库，如果要备份所有数据库，请使用 --all-databases。
   • --result-file：指定备份文件的输出路径。这是关键参数，它告诉mysqldump直接将结果写入文件，而不是输出到控制台，避免了Java处理大流量的性能问题。
   • --default-character-set=utf8mb4：确保字符集正确，避免乱码。
   • --routines, --triggers：确保存储过程、函数和触发器也被备份。
3. redirectErrorStream(true)：将标准错误流合并到标准输出流，这样，即使mysqldump报错，我们也能通过读取InputStream来获取错误信息。
4. process.waitFor()：等待外部进程执行完毕，并返回其退出码。0代表成功，非零代表失败。
5. 异常处理：必须捕获IOException和InterruptedException，如果线程在等待进程时被中断，需要恢复中断状态。

纯Java JDBC实现 (不推荐，仅作了解)

这种方法不依赖外部工具,完全在Java代码中实现，它适用于无法访问mysqldump的极端环境，但功能非常有限。

核心逻辑

1. 连接数据库：使用JDBC连接到目标数据库。
2. 获取所有表名：查询information_schema.tables获取数据库中所有的表。
3. 逐表导出：
   • 对于每个表,先执行SHOW CREATE TABLE语句，获取建表SQL语句并写入文件。
   • 然后执行SELECT * FROM table_name查询所有数据。
   • 遍历结果集,将每一行数据格式化为INSERT INTO ... VALUES (...);语句，并写入文件。
4. 处理特殊类型：需要对NULL值、字符串中的特殊字符（如单引号）进行转义处理。

代码示例（简化版）

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class JdbcBackupExample {
    public static void backupWithJdbc(String host, int port, String username, String password, 
                                     String databaseName, String outputPath) {
        String url = "jdbc:mysql://" + host + ":" + port + "/" + databaseName + "?useSSL=false&serverTimezone=UTC";
        try (Connection conn = DriverManager.getConnection(url, username, password);
             OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(outputPath), StandardCharsets.UTF_8)) {
            // 1. 写入文件头
            writer.write("-- JDBC Backup of Database: " + databaseName + "\n");
            writer.write("-- Backup Date: " + new java.util.Date() + "\n\n");
            // 2. 获取所有表名
            List<String> tables = getTableNames(conn, databaseName);
            // 3. 逐表备份
            for (String tableName : tables) {
                backupTable(conn, writer, tableName);
            }
            System.out.println("JDBC备份完成！文件已保存至: " + outputPath);
        } catch (SQLException | IOException e) {
            e.printStackTrace();
        }
    }
    private static List<String> getTableNames(Connection conn, String databaseName) throws SQLException {
        List<String> tables = new ArrayList<>();
        String sql = "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, databaseName);
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                tables.add(rs.getString("TABLE_NAME"));
            }
        }
        return tables;
    }
    private static void backupTable(Connection conn, OutputStreamWriter writer, String tableName) throws SQLException, IOException {
        // 写入建表语句
        String createTableSql = getCreateTableSql(conn, tableName);
        writer.write(createTableSql + ";\n\n");
        // 写入数据
        String selectSql = "SELECT * FROM " + tableName;
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(selectSql)) {
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();
            while (rs.next()) {
                writer.write("INSERT INTO " + tableName + " VALUES (");
                for (int i = 1; i <= columnCount; i++) {
                    Object value = rs.getObject(i);
                    if (value == null) {
                        writer.write("NULL");
                    } else {
                        // 简单的转义处理，实际应用中需要更复杂
                        String strValue = value.toString().replace("'", "''");
                        writer.write("'" + strValue + "'");
                    }
                    if (i < columnCount) {
                        writer.write(", ");
                    }
                }
                writer.write(");\n");
            }
            writer.write("\n");
        }
    }
    private static String getCreateTableSql(Connection conn, String tableName) throws SQLException {
        String sql = "SHOW CREATE TABLE " + tableName;
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            if (rs.next()) {
                return rs.getString(2); // 第二列是完整的建表SQL
            }
        }
        return "";
    }
    public static void main(String[] args) {
        String host = "localhost";
        int port = 3306;
        String username = "root";
        String password = "your_password";
        String databaseName = "your_database";
        String outputPath = "C:/data/backups/jdbc_backup.sql";
        backupWithJdbc(host, port, username, password, databaseName, outputPath);
    }
}

• 性能极差：逐行查询和写入，对于大数据量来说非常缓慢。
• 功能不完整：无法备份视图、存储过程、函数、触发器、事件、用户权限等数据库对象。
• 类型处理复杂：正确处理各种数据类型（如BLOB, JSON, DATE）和转义字符非常繁琐，容易出错。
• 事务问题：难以保证备份期间数据的一致性，而mysqldump支持--single-transaction选项，可以在不锁表的情况下完成备份。

总结与建议

对于任何严肃的数据库备份需求,都应该选择方法一，它是行业标准，经过时间和无数用户验证的可靠方案，方法二的价值仅在于理解备份的基本原理，或是在一些极其特殊、受限的环境中作为备选方案。