一直用的系统是 Oracle的数据库，现在一个客户比较小，不想投入钱购买数据库软件，所以只能使用Mysql，需要将框架中的一些表结构、记录从Oracle导入到Mysql中去。网上没找到好用的软件，所以决定自己弄一个小程序实现异构库备份：
思路比较简单， 先生成建表语句并在mysql库中执行，在生成insert语句在mysql中执行。
一： 生成建表语句重点是需要获取表的字段，默认值，是否为空， 字段类型、字段长度等， 万幸的是这些jdbc都有实现，通过Connect获取数据库的DatabaseMetaData--dmd，
System.out.println("加载Oracle链接0...");
connect = connect(0);
System.out.println("加载Mysql链接1...");
insertConnect = connect(1);
System.out.println("获取dmd...");
dmd = connect.getMetaData();
再通过DatabaseMetaData--dmd查询表单字段信息,
ResultSet colrs = dmd.getColumns("%", dmd.getUserName(),table.toUpperCase(), "%");
然后解析获取到的ResultSet信息后即可获取到字段的全部信息，生成建表语句：
二：取生成insert语句类似，需要适用select语句查询表的信息，然后循环解析每一行的记录，生成insert插入，此处执行sql的是PreparedStatement，可以循环适用insert语句，仅需要改变每一次动态设置的值属性即可。
全部代码比较简单，直接上代码：
有两个类：jdbc工具类：JDBCUtil.java
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class JDBCUtil {
public static Connection connect(int type) {
Connection conn;
if (type == 0) {//oracle
conn = connectOracle();
} else { //Mysql
conn = connectMysql();
}
return conn;
}
/**
* 连接Oracle
*
* @return
*/
public static Connection connectMysql() {
// 连接MySql数据库，用户名和密码
String username = "111212";
String password = "2121";
String url = "jdbc:mysql://192.168.1.1/training?user=" + username+ "&password=" + password + "";
Connection conn = null;
try {
// 加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(url);
} catch (ClassNotFoundException e) {
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace();
} catch (SQLException se) {
System.out.println("数据库连接失败！");
se.printStackTrace();
}
return conn;
}
/**
* 连接Oracle
*
* @return
*/
public static Connection connectOracle() {
String url = "jdbc:oracle:thin:@192.168.1.1:1521:orcl";
// 连接MySql数据库，用户名和密码都是root
String username = "abcaf";
String password = "syjgagagac";
Connection conn = null;
try {
// 加载MySql的驱动类
Class.forName("oracle.jdbc.OracleDriver");
conn = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace();
} catch (SQLException se) {
System.out.println("数据库连接失败！");
se.printStackTrace();
}
return conn;
}
public static List getColumnNames(ResultSetMetaData meta) throws SQLException{
List list = new ArrayList();
for (int i = 1; i <= meta.getColumnCount(); i++) {
list.add(meta.getColumnName(i));
}
return list;
}
// ResultSetMetaData 使用示例
// 此方法参考 http://blog.csdn.net/yirentianran/article/details/2950321
public static void demoResultSetMetaData(ResultSetMetaData data)
throws SQLException {
for (int i = 1; i <= data.getColumnCount(); i++) {
// 获得所有列的数目及实际列数
int columnCount = data.getColumnCount();
// 获得指定列的列名
String columnName = data.getColumnName(i);
// 获得指定列的列值
// String columnValue = rs.getString(i);
// 获得指定列的数据类型
int columnType = data.getColumnType(i);
// 获得指定列的数据类型名
String columnTypeName = data.getColumnTypeName(i);
// 所在的Catalog名字
String catalogName = data.getCatalogName(i);
// 对应数据类型的类
String columnClassName = data.getColumnClassName(i);
// 在数据库中类型的最大字符个数
int columnDisplaySize = data.getColumnDisplaySize(i);
// 默认的列的标题
String columnLabel = data.getColumnLabel(i);
// 获得列的模式
String schemaName = data.getSchemaName(i);
// 某列类型的精确度(类型的长度)
int precision = data.getPrecision(i);
// 小数点后的位数
int scale = data.getScale(i);
// 获取某列对应的表名
String tableName = data.getTableName(i);
// 是否自动递增
boolean isAutoInctement = data.isAutoIncrement(i);
// 在数据库中是否为货币型
boolean isCurrency = data.isCurrency(i);
// 是否为空
int isNullable = data.isNullable(i);
// 是否为只读
boolean isReadOnly = data.isReadOnly(i);
// 能否出现在where中
boolean isSearchable = data.isSearchable(i);
System.out.println(columnCount);
System.out.println("获得列" + i + "的字段名称:" + columnName);
// System.out.println("获得列" + i + "的字段值:" + columnValue);
System.out.println("获得列" + i + "的类型,返回SqlType中的编号:" + columnType);
System.out.println("获得列" + i + "的数据类型名:" + columnTypeName);
System.out.println("获得列" + i + "所在的Catalog名字:" + catalogName);
System.out.println("获得列" + i + "对应数据类型的类:" + columnClassName);
System.out.println("获得列" + i + "在数据库中类型的最大字符个数:"
+ columnDisplaySize);
System.out.println("获得列" + i + "的默认的列的标题:" + columnLabel);
System.out.println("获得列" + i + "的模式:" + schemaName);
System.out.println("获得列" + i + "类型的精确度(类型的长度):" + precision);
System.out.println("获得列" + i + "小数点后的位数:" + scale);
System.out.println("获得列" + i + "对应的表名:" + tableName);
System.out.println("获得列" + i + "是否自动递增:" + isAutoInctement);
System.out.println("获得列" + i + "在数据库中是否为货币型:" + isCurrency);
System.out.println("获得列" + i + "是否为空:" + isNullable);
System.out.println("获得列" + i + "是否为只读:" + isReadOnly);
System.out.println("获得列" + i + "能否出现在where中:" + isSearchable);
}
}
// 演示 DatabaseMetaData
public static void demoDatabaseMetaData() {
try {
Connection con = connect(0);
//
DatabaseMetaData dmd = con.getMetaData();
System.out.println("当前数据库是：" + dmd.getDatabaseProductName());
System.out.println("当前数据库版本：" + dmd.getDatabaseProductVersion());
System.out.println("当前数据库驱动：" + dmd.getDriverVersion());
System.out.println("当前数据库URL：" + dmd.getURL());
System.out.println("当前数据库是否是只读模式？：" + dmd.isReadOnly());
System.out.println("当前数据库是否支持批量更新？：" + dmd.supportsBatchUpdates());
System.out .println("当前数据库是否支持结果集的双向移动（数据库数据变动不在ResultSet体现）？：" + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
System.out .println("当前数据库是否支持结果集的双向移动（数据库数据变动会影响到ResultSet的内容）？：" + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
System.out.println("========================================");
// ResultSet rs = dmd.getTables(null, null, "%", null);
// System.out.println("表名" + "," + "表类型");
/*
* while (rs.next()) { String tname =
* rs.getString("TABLE_NAME").toLowerCase();
* if(!tname.startsWith("t_")){ continue; }
* System.out.println(rs.getString("TABLE_NAME") + ","+
* rs.getString("TABLE_TYPE")); }
*/
System.out.println("========================================");
ResultSet rs = dmd.getPrimaryKeys(null, "SYJC", "t_mz_djlr".toUpperCase());
while (rs.next()) {
System.out .println(rs.getString(3) + "表的主键是：" + rs.getString(4));
}
System.out.println("========================================");
rs = dmd.getColumns("%", "SYJC", "t_mz_djlr", "%");
System.out.println("t_student表包含的字段:");
while (rs.next()) {
System.out.println(rs.getString(4) + " " + rs.getString(6) + "(" + rs.getString(7) + ");");
}
System.out.println("========================================");
} catch (Exception e) {
System.out.println("数据库操作出现异常");
}
}
}
还有一个实现 解析字段信息生成建表语句、解析结果生成insert语句的类DBBackUtil.java
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DBBackUtil extends JDBCUtil{
public static Connection connect;
public static Connection insertConnect;
public static DatabaseMetaData dmd;
public static Map dataTypesMap = new HashMap();
public static List<String> types = new ArrayList();
public static Map<String,Boolean> unneedLength = new HashMap();
static{
/**
* 此处对象的是 jdbcType 将要转换到mysql的数据类型
*/
dataTypesMap.put(12+"","VARCHAR");
dataTypesMap.put(3+"","DECIMAL");
dataTypesMap.put(93+"","TIMESTAMP");
dataTypesMap.put(1+"","CHAR");
dataTypesMap.put(6+"","DECIMAL");
dataTypesMap.put(2005+"","LONGTEXT");
dataTypesMap.put(1111+"","VARCHAR");
/***不需要长度的字段， clob（longtext）、TIMESTAMP*/
unneedLength.put(93+"",true);
unneedLength.put(2005+"",true);
types.add("VARCHAR2");
types.add("NUMBER");
types.add("DATE");
types.add("CHAR");
types.add("FLOAT");
types.add("CLOB");
types.add("NCHAR");
}
public static void main(String[] args) throws SQLException {
System.out.println("加载Oracle链接0...");
connect = connect(0);
System.out.println("加载Mysql链接1...");
insertConnect = connect(1);
System.out.println("获取dmd...");
dmd = connect.getMetaData();
String[] tables = { "t_base_zg" };
String table = null;
for (int j = 0; j < tables.length; j++) {
table = tables[j];
System.out.println("===========================================================");
createCreateSQL(table);
System.out.println("===========================================================");
System.out.println("插入开始表："+table);
createInsertSQL(table);
System.out.println("插入表结束："+table);
System.out.println("===========================================================");
}
// System.out.println("*******************************************");
// for (String ty : types) {
// System.out.println(ty);
// }
// System.out.println("*******************************************");
connect.close();
}
private static void createInsertSQL(String table) throws SQLException {
Statement stmt = createStmt(connect);
String sql = "select * from "+table;
System.out.println("查询表数据 "+table);
ResultSet rs = stmt.executeQuery(sql);
System.out.println("获取表字段。。。。"+table);
List<String> columns = getColumnNames(rs.getMetaData());
StringBuffer insertSql = new StringBuffer("INSERT INTO "+table+"(");
for (String col : columns) {
insertSql.append(col+",");
}
insertSql.delete(insertSql.length()-1, insertSql.length());
insertSql.append(") \n values(");
for (String col : columns) {
insertSql.append("?,");
}
insertSql.delete(insertSql.length()-1, insertSql.length());
insertSql.append(")");
System.out.println(insertSql.toString());
System.out.println("循环插入数据......");
PreparedStatement preStmt = null;
while(rs.next()){
preStmt = createPreStmt(insertConnect, insertSql.toString());
//循环结果集 执行插入操作
for (int i = 0; i < columns.size(); i++) {
Object obj = rs.getObject(columns.get(i));
//System.out.println(obj+"\t"+(obj!=null?obj.getClass():""));
preStmt.setObject(i+1, obj);
}
int count = preStmt.executeUpdate();
System.out.println("插入 "+count+"条");
preStmt.clearBatch();
preStmt.clearParameters();
preStmt.close();
}
rs.close();
}
/**
* 生成建表语句
* @param table
* @return
* @throws SQLException
*/
public static String createCreateSQL(String table) throws SQLException{
ResultSet colrs = dmd.getColumns("%", dmd.getUserName(),table.toUpperCase(), "%");
StringBuffer sb = new StringBuffer("create table " + table + "(\n");
System.out.println("获取表 【"+table+"】的字段创建按create语句");
while (colrs.next()) {
String columnName = colrs.getString("COLUMN_NAME"); //字段名
int dataType = colrs.getInt("DATA_TYPE"); //数据类型 数字表示
String dataTypeName = (String) dataTypesMap.get(dataType+"");
String typeName = colrs.getString("TYPE_NAME"); //类型名 varchar2等，数据库的实际字段类型
if(!types.contains(typeName)){
types.add(typeName);
}
int columnSize = colrs.getInt("COLUMN_SIZE");
String remarks = colrs.getString("REMARKS");
int nullable = colrs.getInt("NULLABLE");
String columnDef = colrs.getString("COLUMN_DEF");
sb.append("\t"+columnName.toLowerCase()+"\t");//字段名
if( columnSize == 4000 && "VARCHAR".equals(dataTypeName)){
sb.append("Text");//daatype
}else{
sb.append(dataTypeName);//daatype
}
Boolean unNeedLength = unneedLength.get(dataType+"");
if(!(unNeedLength!=null && unNeedLength.booleanValue())){
if("DECIMAL".equals(dataTypeName)){
sb.append("("+(columnSize>10?10:columnSize)); //字段长度
}else{
sb.append("("+columnSize); //字段长度
}
sb.append(")");
}
sb.append("\t");
//sb.append("typeName:"+typeName+"\t");
//sb.append("dataType:"+dataType+"\t");
if(columnDef!=null && !"".equals(columnDef.trim())){
sb.append("default "+columnDef+" \t"); //默认值
}
//sb.append("remarks:"+remarks+"\t");
sb.append((nullable == 0 ? " not null " : "")+","); //是否为空
sb.append("\n");
}
//去掉最后的逗号
sb.replace(sb.length()-3, sb.length(), "");
System.out.println("获取表 【"+table+"】的主键....");
/**
* 生成主键
*/
String keySql = createKeySqlByTableName(table);
if(keySql!=null && keySql.length()>0){
sb.append(",\n");
sb.append("\t"+keySql+"\n");
}
sb.append(") ENGINE=INNODB ;");
System.out.println(sb.toString());
Statement stmt = createStmt(insertConnect);
System.out.println("执行表 【"+table+"】的建表语句 ....");
boolean runRs = stmt.execute(sb.toString());
System.out.println("上述建表语句 执行完成");
return sb.toString();
}
/**
* 获取表主键集合
* @return
* @throws SQLException
*/
private static List getTableKeys(String tableName) throws SQLException{
ResultSet rs = dmd.getPrimaryKeys(null, "SYJC", tableName.toUpperCase());//此处旭要将表名设置成大写 oracle 只认大写
List list = new ArrayList();
while (rs.next()) {
list.add(rs.getString(4).toLowerCase());
}
rs.close();
return list;
}
/**
* 将表名拼接成Key sql
* @param tableName
* @return
* @throws SQLException
*/
public static String createKeySqlByTableName(String tableName) throws SQLException{
List list = getTableKeys(tableName);
return createKeySql(list);
}
/**
* 将字段拼接成Key sql
* @param list
* @return
*/
public static String createKeySql(List<String> list){
if(list==null || list.size()<=0){
return null;
}
StringBuffer keySql = new StringBuffer();
keySql.append("primary key (");
for (int i = 0; i < list.size(); i++) {
if(i!=0 ){
keySql.append(",");
}
keySql.append(list.get(i));
}
keySql.append(")");
return keySql.toString();
}
public static PreparedStatement createPreStmt(Connection conn, String sql) {
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement(sql);
} catch (SQLException e) {
System.out.println("生成预处理stmt失败");
e.printStackTrace();
}
return pstmt;
}
public static Statement createStmt(Connection conn) {
Statement pstmt = null;
try {
pstmt = conn.createStatement();
} catch (SQLException e) {
System.out.println("生成预处理stmt失败");
e.printStackTrace();
}
return pstmt;
}
/**
* 解析ResultSet的单条记录,不进行 ResultSet 的next移动处理
*
* @param rs
* @return
*/
private static Map<String, Object> parseResultSetToMap(ResultSet rs) {
//
if (null == rs) {
return null;
}
//
Map<String, Object> map = new HashMap<String, Object>();
//
try {
ResultSetMetaData meta = rs.getMetaData();
//
int colNum = meta.getColumnCount();
//
for (int i = 1; i <= colNum; i++) {
// 列名
String name = meta.getColumnLabel(i); // i+1
Object value = rs.getObject(i);
// 加入属性
map.put(name, value);
}
} catch (SQLException e) {
e.printStackTrace();
}
//
return map;
}
// /**
// * varchar2 number date char clob nchar
// *
// * @return
// */
// public static Map createMappingRelation() {
// Map map = new HashMap();
// map.put("varchar2", "varchar");
// map.put("number", "varchar");
// map.put("date", "datetime");
// map.put("char", "charo");
// map.put("clob", "mediumtext");
// map.put("nchar", "varchar");
// return map;
// }
}
通过dmd 获取字段信息 请参考：http://blog.sina.com.cn/s/blog_707a9f0601014y1y.html
转载请注明出处：http://314649444.iteye.com/admin/blogs/2307007
相关推荐
在Java中，使用JDBC连接MySQL数据库的过程与Oracle类似，但需要加载对应的MySQL JDBC驱动，如mysql-connector-java.jar。MySQL的JDBC驱动支持最新的JDBC 4.2规范，提供更高效的批处理和连接池管理。 JDBC的核心组件...
在进行MySQL到Oracle的数据迁移之前，首先需要做好一系列的准备工作。 ##### 1.1 导入机 - **安装Oracle 11g数据库**：确保安装过程中正确配置数据库的各项参数，包括数据库实例名、管理端口等。 - **安装MySQL...
1. **依赖引入**：在`pom.xml`中添加MySQL和Oracle的JDBC驱动依赖，同时确保引入SpringBoot的数据源相关依赖，例如`spring-boot-starter-jdbc`。 2. **配置文件**：在`application.properties`或`application.yml`...
DbVisualizer是一款强大的...无论你是处理MySQL的数据备份，还是Oracle的复杂查询，或是SQL Server的表结构设计，DbVisualizer都能提供一个统一且高效的平台。因此，掌握其安装与配置对于日常的数据库工作至关重要。
1. **类型1（JDBC-ODBC桥接驱动）**：这是最早的JDBC驱动类型，通过Java到ODBC（Open Database Connectivity）的桥接实现Java与数据库的连接。这种方法灵活性较差，因为需要安装ODBC驱动。 2. **类型2（部分Java...
本压缩包中的"Oracle MySQL SQLite JDBC学习知识点练习源代码"提供了一套全面的实践教程，帮助你深入理解和掌握这些数据库的相关知识。 首先，Oracle是企业级数据库的代表，以其强大的性能和丰富的功能著称。在源...
本压缩包内含有MSSQL数据库备份文件，以及基于JDBC连接MsSQL/MYSQL/Oracle/Access等常用数据库的示例代码，比较经典的低级问题，笔者也曾遇到过当初学JSp的时候，曾经因为不会连接数据库而很苦恼，这次你可参考...
- 如果工具类提供了Oracle的支持，它可能通过JDBC连接到数据库，并执行自定义的SQL查询或PL/SQL存储过程来实现数据的导出和导入。 3. **JAVA编程接口**： - `DatabaseBackup.java` 文件很可能是这个工具类的实现...
在本主题中，我们主要关注两种常用的数据库系统：MySQL和Oracle，以及它们对应的Java数据库连接（JDBC）驱动。 **MySQL数据库驱动** MySQL是一种开源、关系型数据库管理系统，广泛应用于Web应用、小型到大型企业...
Java Swing+JDBC+MySQL实现的毕业设计选题管理系统是一个基于桌面应用的软件项目，它利用Java的Swing库构建用户界面，通过JDBC（Java Database Connectivity）与MySQL数据库进行数据交互，实现了对毕业设计选题的...
它涵盖了JSP的动态网页生成、Oracle和MySQL的数据库管理，以及通过JDBC实现数据访问的实践。通过深入研究提供的源码和thesis文档，开发者可以提升自己的Web开发技能，特别是在数据库驱动的Java应用方面。
- **备份与恢复**：介绍Oracle备份策略、备份工具以及恢复流程。 #### 二、MySQL数据库基础 ##### 2.1 MySQL概述 - **简介**：MySQL是一款开源的关系型数据库管理系统，广泛应用于Web应用。 - **优势**：易于使用...
- **配置管理**：Nacos 提供了一种集中式的方式，可以在 Oracle 中存储和管理微服务的配置，这些配置可以实时推送到各个服务实例，实现配置的动态更新。 - **健康检查**：Nacos 可以监控注册在 Oracle 中的服务实例...
如果需要备份其他类型的数据库（如MySQL、Oracle等），则需要对源码进行相应的修改。 在实际操作中，通常会创建一个批处理文件（.bat文件），这是一种Windows操作系统下的文本脚本文件，用户可以通过双击运行来执行...
1. 连接数据库：使用Java的JDBC（Java Database Connectivity）API，可以连接到MySQL或Oracle数据库，获取数据库的连接。 2. 执行SQL查询：通过执行`SHOW CREATE TABLE`（MySQL）或`DESCRIBE TABLE`（Oracle）等...
此版本的JDBC驱动兼容MySQL 5.6，可以实现数据的增删改查，执行复杂SQL语句，以及事务处理等功能。 在安装过程中，首先解压下载的压缩包，然后按照MySQL的安装指南安装MySQL 5.6。安装完成后，配置数据库的服务器...
3. **Oracle备份** - Oracle提供RMAN（Recovery Manager）进行物理备份，而Java可以通过`Runtime.exec()`调用RMAN命令行工具。 - 逻辑备份通常涉及PL/SQL包DBMS_METADATA，Java可以通过JDBC接口执行相应的PL/SQL...
`MySQLUploader.java`文件可能包含处理MySQL数据库中图片或二进制数据的Java代码，使用JDBC连接，加载MySQL驱动，通过PreparedStatement执行SQL语句将二进制数据存入数据库。读取时，可以使用ResultSet的...
本压缩包"常用数据库JDBC驱动程序打包下载"提供了三种主流数据库的JDBC驱动，包括Oracle、MySQL和MSSQL，方便开发者一次性获取所需资源，避免了逐个寻找和安装的繁琐过程。 首先，Oracle JDBC驱动，也称为Oracle ...