现在的位置: 首页 > 综合 > 正文

用Java实现将本机表数据转到Oracle表中

2013年10月11日 ⁄ 综合 ⁄ 共 11231字 ⁄ 字号 小 中 大 ⁄ 评论关闭

一、Oracle部分

1、在Oracle新建自定义类型，对应要传入oracle的字段，类型不一定一致，因为时间类型不好处理，为了处理方便将date/number类型均对应为varchar2类型

CREATE OR REPLACE TYPE alarm_content_type AS OBJECT
  (
  con_addr varchar2 (10) ,
  acq_no varchar2 (5) ,
  mea_no varchar2 (5) ,
   alarm_day varchar2 (20) ,  
  alarm_value varchar2 (5) ,
  data_type varchar2 (5) ,
  alarm_data varchar2 (15)
  )
其中acq_no对应为number，alarm_day对应为date类型

2、在Oracle新建对应的自定义类型数组

CREATE OR REPLACE TYPE alarm_content_array AS TABLE OF alarm_content_type

3、在Oracle建立package及 package bodies

CREATE OR REPLACE PACKAGE alarm_content_pck AS
  PROCEDURE insert_object(d alarm_content_array, tbname varchar2);
END alarm_content_pck;

 

CREATE OR REPLACE PACKAGE BODY alarm_content_pck AS
  PROCEDURE insert_object (d alarm_content_array, tbname varchar2) AS
  SqlText varchar2 (500);
  BEGIN
    FOR i IN d.FIRST..d.LAST
    LOOP
      SqlText := 'INSERT INTO ' || tbname 
      || ' VALUES(''' || d(i).con_addr
      || ''', ' || d(i).acq_no || ', ' || d(i).mea_no
      || ', decode(' || d(i).alarm_day || ', null , null, to_date(''' ||d(i).alarm_day || ''', ''yyyy-mm-dd''' || '))'
      || ', ''' || d(i).alarm_value  || ''', ''' || d(i).data_type  
      || ''', ' || d(i).alarm_data   
      || ')';  
      EXECUTE IMMEDIATE SqlText;  
    END LOOP;      
   END insert_object;
END alarm_content_pck;

其中参数d 为传入的数据, tbname 为插入Oracle的表名
二、Java部分

1、Oracle的链接、关闭等

  1. package com.techen.database;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement; 
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. import oracle.jdbc.OracleCallableStatement;
  12. import oracle.sql.ARRAY;
  13. import oracle.sql.ArrayDescriptor;
  14. import oracle.sql.STRUCT;
  15. import oracle.sql.StructDescriptor;
  16. import com.techen.database.DataDb;
  17. import com.techen.database.ProcedureParam;
  19. /**
  20.  * Oracle接口类
  21.  *
  22.  */
  23. public class OracleDb
  24. {
  25.     public static Connection connection = null; // 连接到数据库的对象
  26.     private static Statement state = null; // Statement对象
  27.     private static String URL = null;
  28.     private static String userName;
  29.     private static String passWord;
  30.     
  31.     /**
  32.      * 建立到内存数据库的连接
  33.      * 
  34.      * @return 成功与否
  35.      */
  36.     public OracleDb(String aURL, String aUserName, String aPassWord)
  37.     {
  38.         URL = aURL;
  39.         userName = aUserName;
  40.         passWord = aPassWord;
  41.     }
  42.     
  43.     /**
  44.      * 建立与Oracle数据库的连接
  45.      * 
  46.      * @return 成功与否
  47.      */
  48.     public boolean createConnection()
  49.     {
  50.         boolean bFlag = false;
  51.         if (connection != null)
  52.             closeConnection();
  53.         if (connection == null)
  54.         {
  55.             try
  56.             {
  57.                 // 加载Oracle数据库JDBC驱动
  58.                 Class.forName("oracle.jdbc.driver.OracleDriver");               
  59.                 connection = DriverManager.getConnection(
  60.                         URL, userName, passWord);
  61.                 state = connection.createStatement();
  62.                 bFlag = true;
  63.             } catch (SQLException e)
  64.             {
  65.                 e.printStackTrace();
  66.             } catch (ClassNotFoundException e)
  67.             {
  68.                 e.printStackTrace();
  69.             }
  70.         }
  71.         return bFlag;
  72.     }
  73.     
  74.     /**
  75.      * 释放到Oracle数据库的连接
  76.      */
  77.     public void closeConnection()
  78.     {
  79.         if (connection != null)
  80.             try
  81.             {
  82.                 connection.close();
  83.                 if (state != null)
  84.                 {
  85.                     try
  86.                     {
  87.                         state.close();
  88.                     } catch (SQLException e)
  89.                     {
  90.                         e.printStackTrace();
  91.                     }
  92.                     state = null;
  93.                 }
  94.             } catch (SQLException e)
  95.             {
  96.                 e.printStackTrace();
  97.             }
  98.         connection = null;
  99.     }
  100.     
  101.     
  102.     /**
  103.      * 查询
  104.      * @param sql 查询sql语句
  105.      * @return 数据集
  106.      */
  107.     public ResultSet executeQuery(String sql)
  108.     {
  109.         ResultSet rs = null;
  110.         try
  111.         {
  112.             rs = state.executeQuery(sql);
  113.         } catch (SQLException e)
  114.         {
  115.             e.printStackTrace();
  116.         }
  117.         return rs;
  118.     }
  119.     
  120.     /**
  121.      * 除查询外的其他Sql语句操作
  122.      * 
  123.      * @param sql 查询sql语句
  124.      * @return 成功与否
  125.      */
  126.     public boolean executeUpdate(String sql)
  127.     {
  128.         boolean bFlag = false;
  129.         try
  130.         {
  131.             state.executeUpdate(sql);
  132.             bFlag = true;
  133.         } catch (SQLException e)
  134.         {
  135.             e.printStackTrace();
  136.         }
  137.         return bFlag;
  138.     }

2、调用Oracle建立的package处理

 

    1.     /**
    2.      * 将内存数据库各表数据转到Oracle
    3.      * 
    4.      * @return 成功与否
    5.      */
    6.     @SuppressWarnings({ "unchecked", "unchecked" })
    7.     public boolean hsqlToOracle()
    8.     {
    9.         boolean bFlag = false;
    10.         if (connection != null)
    11.         {
    12.             try
    13.             {
    14.                 List lTb = new ArrayList();
    15.                 //获取内存中所有的主站数据表
    16.                 lTb = DataDb.getTable();
    17.                 if ((lTb != null) && (lTb.size() > 0))
    18.                 {
    19.                     //循环对各表操作
    20.                     for (int iTbCount = 0; iTbCount < lTb.size(); iTbCount++)   
    21.                     {
    22.                         //当前表名
    23.                         String curTb = (String)lTb.get(iTbCount);           
    24.                         //调用存储过程
    25.                         if (callProcedure(curTb, 1))
    26.                         {
    27.                             //如果添加成功则删除HSQLDB中对应的表数据
    28.                             String sqlText = "delete from " + curTb;
    29.                             DataDb.createConnection();
    30.                             DataDb.executeUpdate(sqlText);
    31.                             //DataDb.closeConnection();
    32.                         }
    33.                     }
    34.                     bFlag = true;
    35.                 }
    36.                 
    37.             } catch (Exception e)
    38.             {
    39.                 e.printStackTrace();
    40.             }
    41.         }
    42.         return bFlag;
    43.     }   

        /**

  2.      * 调用Oracle存储过程
  3.      * @param tbName 表名
  4.      * @param kind 类型: 1 取内存表数据；2 取XML数据
  5.      * @return 成功与否
  6.      */ 
  7.     @SuppressWarnings("unchecked")
  8.     public boolean callProcedure(String tbName, int kind)
  9.     {
  10.         boolean bFlag = false;
  11.         //获取当前表的记录集
  12.         List theTbDatas = null;
  13.         if (kind == 1)
  14.         {
  15.             theTbDatas = DataDb.GetRecsFromHsql(tbName);
  16.         }
  17.         else
  18.         {
  19.             theTbDatas = XmlFile.GetRecsFromXml(tbName);
  20.         }
  21.         if (theTbDatas.size() > 0)
  22.         {
  23.             StructDescriptor st;
  24.             //根据表名获取存储过程参数
  25.             ProcedureParam thePro = new ProcedureParam(tbName);
  26.             try
  27.             {
  28.                 st = new StructDescriptor(
  29.                         thePro.data_type, connection);
  30.                 STRUCT[] dataArray = new STRUCT[theTbDatas.size()];
  31.                 //将表中记录转换为Oracle中自定义类型
  32.                 for (int i = 0; i < theTbDatas.size(); i++)
  33.                 {
  34.                     STRUCT s = new STRUCT(st, connection,
  35.                             (Object[]) theTbDatas.get(i));
  36.                     dataArray[i] = s;
  37.                 }   
  38.                 //转换为数组形式
  39.                 ArrayDescriptor arrayData = ArrayDescriptor
  40.                         .createDescriptor(thePro.type_array, connection);
  41.                 ARRAY dataArrayObject = new ARRAY(arrayData,
  42.                         connection, dataArray);
  43.                 //调用Oracle包中存储过程
  44.                 OracleCallableStatement callStatement = null;
  45.                 callStatement = (OracleCallableStatement) connection
  46.                         .prepareCall(thePro.call_Statement);
  47.                 //参数1：数据
  48.                 ((OracleCallableStatement) callStatement).setArray(
  49.                         1, dataArrayObject);
  50.                 //参数2：表名
  51.                 ((OracleCallableStatement) callStatement)
  52.                         .setString(2, tbName);
  53.                 callStatement.executeUpdate();
  54.                 connection.commit();
  55.                 callStatement.close();  
  56.                 bFlag = true;
  57.             } catch (SQLException e)
  58.             {
  59.                 // TODO Auto-generated catch block
  60.                 e.printStackTrace();
  61.             }
  63.         }
  64.         return bFlag;
  65.     }       
  66.     

  1. /**
  2.  * Oracle存储过程各类型表所对应的参数
  3.  * 
  4.  * @author GavinPan
  5.  * 
  6.  */
  7. public class ProcedureParam
  8. {
  9.     public String data_type; // 数据类型
  10.     public String type_array; // 相应类型的数组
  11.     public String call_Statement; // 调用包内过程的字符串
  13.     /**
  14.      * 构造函数 根据表名初始化各成员
  15.      * 
  16.      * @param tableName 表名
  17.      */
  18.     public ProcedureParam(String tableName)
  19.     {
  20.         int iTb = OracleDb.getTableType(tableName);
  21.         switch (iTb)
  22.         {
  23.         case 1:
  24.         {
  25.             data_type = "MSTDATA_TYPE";
  26.             type_array = "MSTDATA_ARRAY";
  27.             call_Statement = "{call mst_pck.INSERT_OBJECT(?,?)}";
  28.             break;
  29.         }
  30.         case 2:
  31.         {
  32.             data_type = "MAXNEED_TYPE";
  33.             type_array = "MAXNEED_ARRAY";
  34.             call_Statement = "{call maxneed_pck.INSERT_OBJECT(?,?)}";
  35.             break;
  36.         }
  37.         case 3:
  38.         {
  39.             data_type = "ENERGY_TYPE";
  40.             type_array = "ENERGY_ARRAY";
  41.             call_Statement = "{call energy_pck.INSERT_OBJECT(?,?)}";
  42.             break;
  43.         }
  44.         case 4:
  45.         {
  46.             data_type = "VOLTAGE_ELIGIBILITY_TYPE";
  47.             type_array = "VOLTAGE_ELIGIBILITY_ARRAY";
  48.             call_Statement = "{call voltage_eligibility_pck.INSERT_OBJECT(?,?)}";
  49.             break;
  50.         }
  51.         case 5:
  52.         {
  53.             data_type = "ALARM_DATA_TYPE";
  54.             type_array = "ALARM_DATA_ARRAY";
  55.             call_Statement = "{call alarm_data_pck.INSERT_OBJECT(?,?)}";
  56.             break;
  57.         }
  58.         case 6:
  59.         {
  60.             data_type = "ALARM_CONTENT_TYPE";
  61.             type_array = "ALARM_CONTENT_ARRAY";
  62.             call_Statement = "{call alarm_content_pck.INSERT_OBJECT(?,?)}";
  63.             break;
  64.         }   
  65.         }
  66.     }
  67. }
  1.     /**
  2.      * 将内存中的相应表的电表数据记录读出
  3.      * @param tableName 表名 
  4.      * @return 记录的List列表
  5.      */
  6.     @SuppressWarnings("unchecked")
  7.     public static List GetRecsFromHsql(String tableName)
  8.     {
  9.         List rtndata = new ArrayList();
  10.         try
  11.         {
  12.             // 加载HSQLDB数据库JDBC驱动
  13.             Class.forName("org.hsqldb.jdbcDriver");
  14.             // 在内存中建立临时数据库score，用户名为sa，密码为空
  15.             @SuppressWarnings("unused")
  16.             Connection connect = DriverManager.getConnection(
  17.                     "jdbc:hsqldb:mem:MstDataDb", "sa", "");
  18.             Statement state = connect.createStatement();
  19.             String ssqltext = "select * from " + tableName;         
  20.             ResultSet rs = state.executeQuery(ssqltext);            
  21.             while (rs.next())
  22.             {               
  23.                 ResultSetMetaData rsmd = rs.getMetaData(); // 获取字段名
  24.                 Object[] tmpl = new Object[rsmd.getColumnCount()];  
  25.                 for (int i = 1; i <= rsmd.getColumnCount(); i++)
  26.                 {   
  27.                     tmpl[i-1] = rs.getString(i); //获取数据赋值
  28.                     if (tmpl[i-1] == null)
  29.                         tmpl[i-1] = "null";
  30.                 }
  31.                 rtndata.add(tmpl);
  32.             }
  34.         } catch (SQLException e1)
  35.         {
  36.             e1.printStackTrace();
  37.         } catch (Exception e2)
  38.         {
  39.             e2.printStackTrace();
  40.         }
  42.         return rtndata;
  43.     }       
  44.     

3、测试

  1.                 OracleDb TechenDb = new OracleDb(
  2.                         "jdbc:oracle:thin:@192.168.1.200:1521:techen",
  3.                         "techen", "techen");
  4.                 if (TechenDb.createConnection())
  5.                 {       
  6.                     if (TechenDb.hsqlToOracle())
  7.                         MessageDialog.openInformation(null, "title", "OK!");
  8.                 }

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞