java备份以及还原mysql数据库

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

[java]  view plain  copy

 

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. }