PostgreSQL备份文件的位置

该程序主要完成不同数据库间数据的备份。此程序仅针对两个数据库间表中字段名相同的情况下使用，可支持两个表中字段不等的情况，如果老数据库中表的字段数少于或等于新数据库表中字段，就把老数据库表中有的字段的值拷贝到新数据库表相应的字段中；反之则把新数据库中有的字段的值从老数据库中拷贝到新数据库中。
在运行改程序的时候首先确保你的数据库可以连接上，然后再数据库中建立对应的数据库，
并在数据库中创建数据库表，确保表名和表中的字段名称一致，这样数据才能拷贝成功。

1、数据库信息实体类 

package com.test.jdbc; 


public class DB { 


 // 数据库驱动 

 private String driver; 

 // 数据库url 

 private String url; 


 // 数据库用户名 

 private String username; 


 // 数据库密码 

 private String password; 


 // 数据库名称 

 private String Name; 


 // 数据库类型，old,new 

 private String Type; 


 public String getDriver() { 

 return driver; 

 } 

 public void setDriver(String driver) { 

 this.driver = driver; 

 } 

 public String getUrl() { 

 return url; 

 } 

 public void setUrl(String url) { 

 this.url = url; 

 } 

 public String getUsername() { 

 return username; 

 } 

 public void setUsername(String username) { 

 this.username = username; 

 } 

 public String getPassword() { 

 return password; 

 } 

 public void setPassword(String password) { 

 this.password = password; 

 } 

 public String getName() { 

 return Name; 

 } 

 public void setName(String name) { 

 Name = name; 

 } 

 public String getType() { 

 return Type; 

 } 

 public void setType(String type) { 

 Type = type; 

 } 


} 


2、连接数据库文件 

package com.test.jdbc; 


import java.sql.Connection; 

import java.sql.DriverManager; 

import java.sql.SQLException; 


public class DBConnection { 


 private static Connection conn = null; 


 /** 

 * 连接数据库 

 * @param driver 数据库驱动 

 * @param url 连接数据库的url 

 * @param username 用户名 

 * @param password 密码 

 * @return Connecton 连接对象 

 */ 

 public static Connection getConnection(String driver, String dbUrl, 

 String userName, String passWord) { 

 try { 

 Class.forName(driver); 

 conn = DriverManager.getConnection(dbUrl,userName,passWord); 

 } catch (ClassNotFoundException e) { 

 e.printStackTrace(); 

 System.out.println("未找到数据库驱动......"); 

 } catch (SQLException e) { 

 e.printStackTrace(); 

 System.out.println("连接数据库发生异常......"); 

 } 

 return conn; 

 } 


 /** 

 * 关闭数据库 

 */ 

 public static void closeConnection() 

 { 

 if(conn != null) 

 { 

 try { 

 conn.close(); 

 } catch (SQLException e) { 

 System.out.println("关闭数据库发生异常......"); 

 e.printStackTrace(); 

 } 

 } 

 } 

} 



3、拷贝数据库数据类 

package com.test.jdbc; 


import java.sql.Connection; 

import java.sql.ResultSet; 

import java.sql.ResultSetMetaData; 

import java.sql.SQLException; 

import java.sql.Statement; 

import java.util.ArrayList; 

import java.util.List; 


/** 

 * 该程序主要完成不同数据库间数据的备份。 

 * 此程序仅针对两个数据库间表中字段名相同的情况下使用， 

 * 可支持两个表中字段不等的情况，如果老数据库中表的字段数少于或等于新数据库表中字段， 

 * 就把老数据库表中有的字段的值拷贝到新数据库表相应的字段中；反之则把新数据库中有的字段 

 * 的值从老数据库中拷贝到新数据库中。 

 * @author gaoht 

 * @date : 2010-11-12 

 */ 

public class DBBak { 


 // 老数据库的数据库用户名 (dbo) 

 private static String oldDbOwner = ""; 


 // 新数据库的数据库用户名 

 private static String newDbOwner = ""; 


 // 老数据库的连接对象 

 private static Connection oldDbConn = null; 


 // 新数据库的连接对象 

 private static Connection newDbConn = null; 


 /** 

 * 获取数据库所有表的集合 

 * @param driver 数据库驱动 

 * @param dbUrl 连接数据库的url 

 * @param userName 连接数据库用户名 

 * @param passWord 连接数据库密码 

 * @param dbName 数据库名 

 * @param dbType 数据库类型: old new 

 * @return 

 */ 

 public static List<String> getTableList(DB db) 

 { 


 // 创建对数据库的链接对象 

 Connection conn = DBConnection.getConnection(db.getDriver(), db.getUrl(), db.getUsername(), db.getPassword()); 


 List<String> tableList = new ArrayList<String>(); 

 ResultSet rs = null; 

 try { 

 // 获取该数据库中所有表的结果集 

 rs = conn.getMetaData().getTables(db.getName(), null, null, new String[]{"TABLE"}); 

 while(rs.next()) 

 { 

 if(db.getType().equals("old")) 

 { 

 oldDbOwner = rs.getObject(2).toString(); 

 oldDbConn = conn; 

 }else 

 { 

 newDbOwner = rs.getObject(2).toString(); 

 newDbConn = conn; 

 } 

 // 此处是因为在sql server2000中这个系统表一直删除不掉，而却取出来拷贝的时候会发生错误此处在程序处理。 

 if(!rs.getObject(3).toString().equals("dtproperties")) 

 { 

 tableList.add(rs.getObject(3).toString()); 

 } 

 } 

 } catch (SQLException e) { 

 e.printStackTrace(); 

 } 


 //System.out.println(oldDbOwner+"*老数据库*"+oldDbName); 

 //System.out.println(newDbOwner+"*新数据库*"+newDbName); 

 System.out.println("获取"+db.getType()+"数据库表集合"); 

 return tableList; 

 } 


 /** 

 * 将给定的老的数据库中的数据备份到新的数据库中 

 * @param oldDb 老数据库 

 * @param newDb 新数据库 

 */ 

 public static void dataBak(DB oldDb, DB newDb) 

 { 

 List<String> oldDbTables = new ArrayList<String>(); 

 List<String> newDbTables = new ArrayList<String>(); 


 oldDbTables = getTableList(oldDb); 

 newDbTables = getTableList(newDb); 


 //System.out.println(oldDbTables.size()+"老数据库中表的数量"); 

 //System.out.println(newDbTables.size()+"新数据库中表的数量"); 


 for(int i=0; i<oldDbTables.size(); i++) 

 { 

 for(int j=0; j<newDbTables.size(); j++) 

 { 

 String oldTableName = oldDbTables.get(i).toString(); 

 String newTableName = newDbTables.get(j).toString(); 


 // 获取相应数据库中指定表的所有属性列表 

 List<String> oldTableFields = getTableFieldList(oldDb.getName()+"."+oldDbOwner+"."+oldTableName, oldDbConn); 

 List<String> newTableFields = getTableFieldList(newDb.getName()+"."+newDbOwner+"."+newTableName, newDbConn); 


 //System.out.println(oldDb.getName()+"."+oldDbOwner+"."+oldTableName+"老数据库表名"); 

 //System.out.println(newDb.getName()+"."+newDbOwner+"."+newTableName+"新数据库表名"); 


 if(oldTableName.equals(newTableName)) 

 { 

 // 获取表中字段的个数 

 int oldTableColNum = oldTableFields.size(); 

 int newTableColNum = newTableFields.size(); 


 /** 

 * 此处判如果断老数据库中表中字段的个数少于或者等于新数据库中表地段的个数， 

 * 此时就根据字段名插入 

 */ 

 if(oldTableColNum <= newTableColNum) 

 { 

 // 用StringBuffer类拼接sql语句 

 System.out.println("老数据库中表的字段数小于新数据库中表的字段数"); 

 StringBuffer sqlBuff = new StringBuffer("insert into "); 

 sqlBuff.append(newDb.getName()).append(".").append(newDbOwner).append(".").append(newTableName).append("("); 


 for(int k=0; k<oldTableFields.size(); k++) 

 { 

 sqlBuff.append(oldTableFields.get(k)); 

 if(k < oldTableFields.size()-1) 

 { 

 sqlBuff.append(", "); 

 } 

 } 

 sqlBuff.append(") select "); 

 for(int k=0; k<oldTableFields.size(); k++) 

 { 

 sqlBuff.append(oldTableFields.get(k)); 

 if(k < oldTableFields.size()-1) 

 { 

 sqlBuff.append(", "); 

 } 

 } 

 sqlBuff.append(" from ").append(oldDb.getName()).append(".").append(oldDbOwner).append(".").append(oldTableName).append(";"); 

 String sql = new String(sqlBuff); 

 System.out.println(sqlBuff); 

 Statement stmt = null; 


 try { 

 stmt = newDbConn.createStatement(); 

 stmt.executeUpdate(sql); 

 continue; 


 } catch (SQLException e) { 

 e.printStackTrace(); 

 System.out.println("备份数据发生异常......"); 

 } 

 }else { 

 /** 

 * 新数据库中表中字段的个数少于旧数据库中表地段的个数， 

 * 此时只需要把旧数据库表中存在的字段值插入到新表中即可； 

 */ 

 System.out.println("新数据库中表的字段数小于老数据库中表的字段数"); 

 // 用StringBuffer类拼接sql语句 

 StringBuffer sqlBuff = new StringBuffer("insert into "); 

 sqlBuff.append(newDb.getName()).append(".").append(newDbOwner).append(".").append(newTableName).append("("); 


 for(int k=0; k<newTableFields.size(); k++) 

 { 

 sqlBuff.append(newTableFields.get(k)); 

 if(k < newTableFields.size()-1) 

 { 

 sqlBuff.append(", "); 

 } 

 } 

 sqlBuff.append(") select "); 

 for(int k=0; k<newTableFields.size(); k++) 

 { 

 sqlBuff.append(newTableFields.get(k)); 

 if(k < newTableFields.size()-1) 

 { 

 sqlBuff.append(", "); 

 } 

 } 

 sqlBuff.append(" from ").append(oldDb.getName()).append(".").append(oldDbOwner).append(".").append(oldTableName).append(";"); 

 String sql = new String(sqlBuff); 

 System.out.println(sqlBuff); 

 Statement stmt = null; 


 try { 

 stmt = newDbConn.createStatement(); 

 stmt.executeUpdate(sql); 

 continue; 


 } catch (SQLException e) { 

 e.printStackTrace(); 

 System.out.println("备份数据发生异常......"); 

 } 

 } 

 } 

 } 

 } 

 } 


 /** 

 * 获取表中列名属性的集合 

 * @param table 表名称 

 * @param stmt Statement对象 

 * @return List 表中列名称的集合 

 */ 

 public static List<String> getTableFieldList(String table, Connection conn) 

 { 

 List<String> fieldList = new ArrayList<String>(); 

 Statement stmt = null; 

 try { 

 stmt = conn.createStatement(); 

 ResultSet rs = stmt.executeQuery("select * from "+table); 

 ResultSetMetaData rsmd = rs.getMetaData(); 

 // 获取表的列数 

 int columnNum = rsmd.getColumnCount(); 


 for(int i=0; i<columnNum; i++) 

 { 

 fieldList.add(rsmd.getColumnName(i+1)); 

 //System.out.println(rsmd.getColumnName(i+1)); 

 } 

 } catch (SQLException e) { 

 e.printStackTrace(); 

 System.out.println("查询数据库表发生异常......"); 

 } 

 return fieldList; 

 } 



 public static void main(String[] args) { 


 String oldDBDriver = "com.microsoft.jdbc.sqlserver.SQLServerDriver"; 

 String oldDbUrl = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mytest"; 

 String oldDBName = "mytest"; 

 String oldDbUser = "sa"; 

 String oldDbPwd = "sa"; 

 String oldType = "old"; 


 String newDBDriver = "com.microsoft.jdbc.sqlserver.SQLServerDriver"; 

 String newDbUrl = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mytest3"; 

 String newDBName = "mytest3"; 

 String newDbUser = "sa"; 

 String newDbPwd = "sa"; 

 String newType = "new"; 


 DB oldDB = new DB(); 

 oldDB.setDriver(oldDBDriver); 

 oldDB.setUrl(oldDbUrl); 

 oldDB.setName(oldDBName); 

 oldDB.setUsername(oldDbUser); 

 oldDB.setPassword(oldDbPwd); 

 oldDB.setType(oldType); 


 DB newDB = new DB(); 

 newDB.setDriver(newDBDriver); 

 newDB.setUrl(newDbUrl); 

 newDB.setName(newDBName); 

 newDB.setUsername(newDbUser); 

 newDB.setPassword(newDbPwd); 

 newDB.setType(newType); 


 DBBak.dataBak(oldDB, newDB); 

 } 


}