本文详细介绍使用Java实现数据库备份与恢复的过程，包括生成SQL语句、执行备份、恢复数据库及错误处理。通过具体代码示例，展示了如何在不同操作系统上执行备份与恢复操作。
Java代码备份与恢复数据库
数据库备份与恢复
生成SQL语句
备份SQL
/**
* 备份数据库语句
*
* @param hostIP
* @param userName
* @param password
* @param databaseName
* @return
*/
private static String[] getBackUpCommand(String hostIP, String userName, String password, String databaseName, String url) {
String[] cmd = new String[3];
String os = System.getProperties().getProperty("os.name");
if (os.startsWith("Win")) {
cmd[0] = "cmd.exe";
cmd[1] = "/c";
} else {
cmd[0] = "/bin/sh";
cmd[1] = "-c";
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("mysqldump").append(" -h").append(hostIP);
stringBuilder.append(" -u ").append(userName).append(" -p").append(password);
stringBuilder.append(" --databases ").append(databaseName);
stringBuilder.append(" > ").append(url);
cmd[2] = stringBuilder.toString();
return cmd;
}
恢复SQL
/**
* 恢复数据库语句
*
* @return
*/
private static String[] getCommand(String userName, String psw, String ip, String db, String url) {
String[] cmd = new String[3];
String os = System.getProperties().getProperty("os.name");
if (os.startsWith("Win")) {
cmd[0] = "cmd.exe";
cmd[1] = "/c";
} else {
cmd[0] = "/bin/sh";
cmd[1] = "-c";
}
StringBuilder arg = new StringBuilder();
arg.append("mysql ");
arg.append("-h" + ip + " ");
arg.append("-u" + userName + " ");
arg.append("-p" + psw + " ");
arg.append(db + " < ");
arg.append(url);
cmd[2] = arg.toString();
return cmd;
}
执行
备份
/**
* 数据库的备份
*
* @param hostIP mysql所在服务器的ip
* @param userName 用户名
* @param password 密码
* @param savePath 保存到服务器的路径
* @param databaseName 需要备份的数据库名
* @return
* @throws InterruptedException
*/
public static boolean backup(String hostIP, String userName, String password,
String savePath, String databaseName, String sdfFmt) throws IOException {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
// 创建文件保存的路径
File saveFile = new File(savePath);
if (!saveFile.exists()) {// 如果目录不存在
saveFile.mkdirs();// 创建文件夹
}
// 判断保存路径中是否添加了斜杠，如果没有就加上斜杠
if (!savePath.endsWith(File.separator)) {
savePath = savePath + File.separator;
}
String url = savePath + databaseName + "_" + sdfFmt + ".sql";
File file = new File(url);
if (databases.indexOf(databaseName) < 0) {
return false;
}
String[] command = getBackUpCommand(hostIP, userName, password, databaseName, url);
boolean flag = backup(file, command);
// 如果处理失败，清除之前所产生的sql文件
if (!flag) {
deleteFiles(file);
logger.info("备份失败，删除文件：" + file.getPath());
}
return flag;
}
上面的方法中有个backup(file, command)方法，第一个参数为生成SQL后，文件的全路径，第二个参数是生成SQL语句时，返回的备份语句，接下来看看backup(file, command)方法中的代码：
/**
* 备份方法
*
* @param file
* @param command
* @throws IOException
*/
public static boolean backup(File file, String[] command) {
logger.info("备份文件地址：" + file.getPath());
for (int i = 0; i < command.length; i++) {
logger.info("备份命令：" + command[i]);
}
final Process process;
try {
/**
* ##############特别关注的点#############
*
* 创建一个线程用户获取错误流，并且这个错误流是有返回结果的，所以用的是Callable来实现
*/
//-u后面是用户名，-p是密码-p后面最好不要有空格，-test是数据库的名字
Runtime runtime = Runtime.getRuntime();
logger.info("开始备份数据库中... command: " + JSON.toJSONString(command));
process = runtime.exec(command);
logger.info("数据库备份结束...");
// 新增一个线程用于处理错误流,如果有错误就返回true，没有就返回false
ErrorStreamUtil errThread = new ErrorStreamUtil(process);
FutureTask<Boolean> result = new FutureTask<Boolean>(errThread);
new Thread(result).start();
if (result.get()) {
return false;
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
执行backup(file, command)方法时，创建了一个实现Callable接口的对象，这个对象用于处理执行数据库备份时产生的信息，如果备份失败，会把失败的文件删除掉，代码如下：
package com.zom.cms.tools;
import com.zom.common.log.ZLoggerFactory;
import org.slf4j.Logger;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.concurrent.Callable;
public class ErrorStreamUtil implements Callable<Boolean> {
private final static Logger logger = ZLoggerFactory.getLogger(ErrorStreamUtil.class);
private Process process;
public ErrorStreamUtil (Process inputStream) {
this.process = inputStream;
}
@Override
public Boolean call() throws Exception {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getErrorStream(), "utf-8"));
String s = null;
StringBuffer errorSb = new StringBuffer();
boolean flag = true;
// 备份过程中出现错误就直接返回
while ((s = bufferedReader.readLine()) != null) {
logger.error("数据库备份错误流信息：" + s);
// mysql由于对明文展示密码来执行备份会写出warning警告，我们用flag做标识来排除第一行内容
if (flag) {
flag = false;
} else {
errorSb.append(s);
}
}
int ret = process.waitFor();
if (ret == 0) {
if (errorSb.length() > 0) {
String error = errorSb.toString();
logger.error("cmd命令出现错误，请仔细核对语句: " + error);
bufferedReader.close();
return true;
}
bufferedReader.close();
return false;
}
return true;
}
}
删除备份失败的文件调用的是：
/**
* 删除文件
*
* @param file
*/
public static void deleteFiles(File file) {
// 判断文件是否存在
if (file.exists()) {
if (file.isFile()) {
file.delete();
} else {
File[] files = file.listFiles();
for (File f : files) {
deleteFiles(f);
}
}
} else {
}
}
至此，数据库备份的操作完成了。
恢复
在前面我们备份好了SQL文件，现在恢复，只需要把文件路径、账号、密码、数据库作为参数传递到下面的方法中即可：
/**
* 数据库恢复
*
* @param path sql文件保存的路径（文件夹）
* @param db 恢复到此数据库中
* @param username 用户名
* @param psw 密码
* @throws Exception
*/
public static boolean recover(String path, String sql, String db, String username, String psw, String ip) throws Exception {
// 判断库是否存在，我们的业务中需要备份的库有两个，所以在这里直接写死了
if (databases.indexOf(db) < 0) {
return false;
}
// 判断保存路径中是否添加了斜杠，如果没有就加上斜杠
if (!path.endsWith(File.separator)) {
path = path + File.separator;
}
String cmdPath = path + sql;
File file = new File(cmdPath);
if (!file.exists()) {
return false;
}
// cmd 命令
String[] command = getCommand(username, psw, ip, db, cmdPath);
return recover(command, cmdPath);
}
这里调用了生产恢复数据库的SQL的方法，这个方法在前面已经说过，然后执行recover(command, cmdPath)方法，该方法代码如下：
/**
* mysql的还原方法
*
* @param command 命令行
* @param savePath 还原路径
* @return
*/
public static boolean recover(String[] command, String savePath) {
logger.info("文件所在位置：" + savePath);
logger.info("cmd命令：" + command[2]);
Runtime runtime = Runtime.getRuntime();
try {
logger.info("开始恢复数据库中... command: " + JSON.toJSONString(command));
Process process = runtime.exec(command);
logger.info("数据库恢复结束...");
// 新增一个线程用于处理错误流,如果有错误就返回true，没有就返回false
ErrorStreamUtil errThread = new ErrorStreamUtil(process);
FutureTask<Boolean> result = new FutureTask<Boolean>(errThread);
new Thread(result).start();
/*// 执行sql文件
InputStreamRestoreUtil restoreUtil = new InputStreamRestoreUtil(process, new File(savePath));
Thread thread = new Thread(restoreUtil);
thread.start();
thread.join();*/
if (result.get()) {
return false;
}
return true;
} catch (Exception e) {
e.printStackTrace();
logger.error("Mysql恢复出错: {}", e);
return false;
}
}
recover(command, cmdPath)方法中同样使用了ErrorStreamUtil类来进行错误信息的处理，可以通过判断是否有错误信息来验证此次恢复是否成功，方便响应给前端做展示。
在实现上述代码之前，我使用过通过缓存流的方式来实现数据库备份，但缓存流有个致命的问题，如果数据库过大，会导致OOM的发生，所以建议用上述代码来实现备份，经过充分验证，是可以实现数据库备份与恢复。
有什么不足之处，欢迎指正。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
