java代码实现在linux服务器上mysql数据库备份以及恢复

1、备份

public Object insertDataBase(DataBaseBean dataBaseBean) {

long count = System.currentTimeMillis();

int num = 1;

// 测试备份 /usr/bin/mysqldump为数据库的路径以及备份命令 -u用户名 -p密码  数据库名称database

String command1 = "/usr/bin/mysqldump -uroot -p123456 database";// 参数依次是IP、账号、密码、数据库名

 

String fileName = TimeUtils.getCurrentTime("yyyyMMddHHmmss") + NumberUtils.createRandom(true, 6) + ".sql";

#img_path linux服务器路径 

String savePath1 = img_path + "/database/" + fileName;

 

String b1 = DataBaseUtils.backup(command1, savePath1);

if ("1".equals(b1.substring(0, 1))) {

dataBaseBean.setSize(b1.substring(1));

dataBaseBean.setData_name(fileName);

dataBaseBean.setUrl(img_path + "/database/" + fileName);

dataBaseBean.setVersion("V"+count);

num = settingDaoC.insertDataBase(dataBaseBean);

if (num <= 0) {

throw new AppException("备份失败");

}

} else {

throw new AppException("备份失败");

}

 

return num;

}

 

2、恢复

public Object updateDataBase(DataBaseBean dataBaseBean) {

String command2 = "/usr/bin/mysql -uroot -p123456 --default-character-set=utf8 database";

String savePath2 = img_path + "/database/" + dataBaseBean.getData_name();

boolean b2 = DataBaseUtils.recover(command2, savePath2);

if (b2) {

return "1";

} else {

throw new AppException("还原失败");

}

 

}

 

 

 

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.nio.channels.FileChannel;

 

public class DataBaseUtils {

/**

* 数据库备份

* @param command

* @param savePath

* @return

*/

public static String backup(String command, String savePath) {

        String flag;

        long size = 0;

        // 获得与当前应用程序关联的Runtime对象

        Runtime r = Runtime.getRuntime();

        BufferedReader br = null;

        BufferedWriter bw = null;

        FileChannel fc = null;

 

        try {

            // 在单独的进程中执行指定的字符串命令

            Process p = r.exec(command);

            // 获得连接到进程正常输出的输入流，该输入流从该Process对象表示的进程的标准输出中获取数据

            InputStream is = p.getInputStream();

            // InputStreamReader是从字节流到字符流的桥梁：它读取字节，并使用指定的charset将其解码为字符

            InputStreamReader isr = new InputStreamReader(is, "utf-8");

            //BufferedReader从字符输入流读取文本，缓冲字符，提供字符，数组和行的高效读取

            br = new BufferedReader(isr);

            String s;

            StringBuffer sb = new StringBuffer("");

            // 组装字符串

            while ((s = br.readLine()) != null) {

                sb.append(s + System.lineSeparator());

            }

            s = sb.toString();

            // 创建文件输出流

            FileOutputStream fos = new FileOutputStream(savePath);

            // OutputStreamWriter是从字符流到字节流的桥梁，它使用指定的charset将写入的字符编码为字节

            OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");

            fc = fos.getChannel();

            // BufferedWriter将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入

            bw = new BufferedWriter(osw);

            bw.write(s);

            size =fc.size();

            bw.flush();

            flag = "1";

        } catch (IOException e) {

            flag = "0";

            e.printStackTrace();

        } finally {

            //由于输入输出流使用的是装饰器模式，所以在关闭流时只需要调用外层装饰类的close()方法即可，

            //它会自动调用内层流的close()方法

            try {

                if (null != bw) {

                    bw.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

 

            try {

                if (null != br) {

                    br.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return flag+size;

 

}

/**

* 数据库备份恢复

* @param command

* @param savePath

* @return

*/

public static boolean recover(String command, String savePath) {

        boolean flag;

        Runtime r = Runtime.getRuntime();

        BufferedReader br = null;

        BufferedWriter bw = null;

        try {

            Process p = r.exec(command);

            OutputStream os = p.getOutputStream();

            FileInputStream fis = new FileInputStream(savePath);

            InputStreamReader isr = new InputStreamReader(fis, "utf-8");

            br = new BufferedReader(isr);

            String s;

            StringBuffer sb = new StringBuffer("");

            while ((s = br.readLine()) != null) {

                sb.append(s + System.lineSeparator());

            }

            s = sb.toString();

            OutputStreamWriter osw = new OutputStreamWriter(os, "utf-8");

            bw = new BufferedWriter(osw);

            bw.write(s);

            bw.flush();

            flag = true;

        } catch (IOException e) {

            flag = false;

            e.printStackTrace();

        } finally {

            try {

                if (null != bw) {

                    bw.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

 

            try {

                if (null != br) {

                    br.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return flag;

}

 

}