java备份以及还原mysql数据库

时间：2022-06-12 03:17:57

参考：http://xp84012493.iteye.com/blog/199290

[java]  view plain  copy   java备份以及还原mysql数据库 java备份以及还原mysql数据库
  1. java.io.BufferedReader;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.InputStream;  
  6. import java.io.InputStreamReader;  
  7. import java.io.OutputStream;  
  8. import java.io.OutputStreamWriter;  
  9. import java.text.SimpleDateFormat;  
  10. import java.util.Date;  
  11.   
  12. /** 
  13.  * 功能：备份以及还原mysql数据库 
  14.  * 需要将mysql安装的bin目录C:\Program Files\MySQL\MySQL Server 5.5\bin设置到环境变量，否则不知道怎么调用mysqldump[⊙﹏⊙b汗] 
  15.  * 用java备份的话，不能使用">"了，所以调用cmd命令时，需要更改里面的参数 
  16.  * mysqldump -h127.0.0.1 -uroot -proot erp > backupfile.sql 
  17.  * mysqldump  -h 127.0.0.1 -u root -proot erp  --default-character-set=utf8  --result-file=D:backupfile.sql 
  18.  * @author Administrator 
  19.  * 
  20.  */  
  21. public class BackupsDB {  
  22.   
  23.     /** 
  24.      * 备份mysql数据库 
  25.      * @param root  mysql登录名 
  26.      * @param rootPass  登录密码 
  27.      * @param dbName  要备份的数据库名称 
  28.      * @param backupsPath  备份的路径 
  29.      * @param backupsSqlFileName  备份文件的名字 
  30.      * @return 
  31.      */  
  32.     public static String dbBackUp(String root,String rootPass,String dbName,String backupsPath,String backupsSqlFileName)  
  33.     {  
  34.         //生成临时备份文件  
  35. //      SimpleDateFormat sd=new SimpleDateFordckupsSqlFileName;  
  36.         String pathSql = backupsPath+backupsSqlFileName;  
  37.         try {  
  38.             File fileSql = new File(pathSql);  
  39.             if(!fileSql.exists()){  
  40.                 fileSql.createNewFile();  
  41.             }  
  42.             StringBuffer sbs = new StringBuffer();  
  43.             sbs.append("mysqldump ");  
  44.             sbs.append(" -h 127.0.0.1 ");  
  45.             sbs.append(" -u ");  
  46.             sbs.append(root+" ");  
  47.             sbs.append("-p"+rootPass+" ");  
  48.             sbs.append(dbName);  
  49.             sbs.append(" --default-character-set=utf8 ");  
  50. //          sbs.append(">"+pathSql);  
  51.             sbs.append(" --result-file="+pathSql);  
  52.             System.out.println("cmd命令为：——>>>"+sbs.toString());  
  53.             Runtime runtime = Runtime.getRuntime();  
  54.             Process child = runtime.exec(sbs.toString());  
  55.               
  56.             //读取备份数据并生成临时文件  
  57.             InputStream in = child.getInputStream();  
  58.             OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(pathSql), "utf8");  
  59.             BufferedReader reader = new BufferedReader(new InputStreamReader(in, "utf8"));  
  60.             String line=reader.readLine();  
  61.             while (line != null) {  
  62.                 writer.write(line+"\n");  
  63.                 line=reader.readLine();  
  64.              }  
  65.              writer.flush();  
  66.              System.out.println("数据库已备份到——>>"+pathSql);  
  67.         } catch (Exception e) {  
  68.               
  69.         }  
  70.         return pathSql;  
  71.     }  
  72.       
  73.     /** 
  74.      * @param args 
  75.      */  
  76.     public static void main(String[] args) {  
  77.         // TODO Auto-generated method stub  
  78. //      mysqldump -h 192.168.110.10 --user=root --password=fortune123 --lock-all-tables=true --result-file=D:tt.sql\ --default-character-set=utf8 ERP  
  79.         SimpleDateFormat sd=new SimpleDateFormat("yyyyMMddHHmmss");  
  80.         String root = "root";  
  81.         String rootPass = "root";  
  82.         String dbName = "erp";  
  83.         String backupsPath = "D:";  
  84.         String backupsSqlFileName = "erpDB_"+sd.format(new Date())+".sql";  
  85.         dbBackUp(root, rootPass, dbName, backupsPath, backupsSqlFileName);  
  86.         backup();  
  87.         load();  
  88.     }  
  89.   
  90.     /** 
  91.      * 备份erp数据库到D:db.sql 
  92.      * @return 
  93.      */  
  94.     public static boolean backup() {//备份  
  95.         try {  
  96.             Runtime rt = Runtime.getRuntime();    
  97.             String mysql = "mysqldump -uroot -proot erp --default-character-set=utf8 ";    
  98. //          mysql ="C:\\Program Files\\MySQL\\MySQL Server 5.5\\bin\\"+mysql;  
  99.               
  100.             System.out.println("mysql=============>>>>"+mysql);  
  101.             // 调用 mysql 的 cmd:    
  102.             Process child = rt    
  103.             .exec("cmd /c "+mysql);// 设置导出编码为utf8。这里必须是utf8    
  104.         
  105.             // 把进程执行中的控制台输出信息写入.sql文件，即生成了备份文件。注：如果不对控制台信息进行读出，则会导致进程堵塞无法运行    
  106.             InputStream in = child.getInputStream();// 控制台的输出信息作为输入流    
  107.         
  108.             InputStreamReader xx = new InputStreamReader(in, "utf8");// 设置输出流编码为utf8。这里必须是utf8，否则从流中读入的是乱码    
  109.         
  110.             String inStr;    
  111.             StringBuffer sb = new StringBuffer("");    
  112.             String outStr;    
  113.             // 组合控制台输出信息字符串    
  114.             BufferedReader br = new BufferedReader(xx);    
  115.             while ((inStr = br.readLine()) != null) {    
  116.                 sb.append(inStr + "\r\n");    
  117.             }    
  118.             outStr = sb.toString();    
  119.         
  120.             // 要用来做导入用的sql目标文件：    
  121.             FileOutputStream fout = new FileOutputStream(    
  122.                     "D:/db.sql");    
  123.             OutputStreamWriter writer = new OutputStreamWriter(fout, "utf8");    
  124.             writer.write(outStr);    
  125.             // 注：这里如果用缓冲方式写入文件的话，会导致中文乱码，用flush()方法则可以避免    
  126.             writer.flush();    
  127.         
  128.             // 别忘记关闭输入输出流    
  129.             in.close();    
  130.             xx.close();    
  131.             br.close();    
  132.             writer.close();    
  133.             fout.close();    
  134.         
  135.             System.out.println("/* Output OK! */");    
  136.                             
  137.             String error="备份成功!";    
  138.         
  139.         } catch (Exception e) {    
  140.             e.printStackTrace();    
  141.         }    
  142.         
  143.         return true;    
  144.     }    
  145.       
  146.     /** 
  147.      * 还原D:db.sql到erp数据库 
  148.      * @return 
  149.      */  
  150.     public static boolean load() {//还原    
  151.         try {  
  152.             String fPath = "D:/db.sql";    
  153.             Runtime rt = Runtime.getRuntime();    
  154.         
  155.             // 调用 mysql 的 cmd:    
  156.             Process child = rt.exec("mysql -uroot -proot erp ");    
  157.             OutputStream out = child.getOutputStream();//控制台的输入信息作为输出流    
  158.             String inStr;    
  159.             StringBuffer sb = new StringBuffer("");    
  160.             String outStr;    
  161.             BufferedReader br = new BufferedReader(new InputStreamReader(    
  162.                     new FileInputStream(fPath), "utf8"));    
  163.             while ((inStr = br.readLine()) != null) {    
  164.                 sb.append(inStr + "\r\n");    
  165.             }    
  166.             outStr = sb.toString();    
  167.         
  168.             OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");    
  169.             writer.write(outStr);    
  170.             // 注：这里如果用缓冲方式写入文件的话，会导致中文乱码，用flush()方法则可以避免    
  171.             writer.flush();    
  172.             // 别忘记关闭输入输出流    
  173.             out.close();    
  174.             br.close();    
  175.             writer.close();    
  176.                 
  177.             System.out.println("/* Load OK! */");    
  178.         } catch (Exception e) {    
  179.             e.printStackTrace();    
  180.         }    
  181.         return true;    
  182.     }     
  183. }  
java备份以及还原mysql数据库

标签：

相关文章