一、Oracle中大数据处理

　　在Oracle中，LOB（Large Object，大型对象）类型的字段现在用得越来越多了。因为这种类型的字段，容量大（最多能容纳4GB的数据），且一个表中可以有多个这种类型的字段，很灵活，适用于数据 量非常大的业务领域（如图象、档案等）。

　　LOB类型分为BLOB和CLOB两种：BLOB即二进制大型对象（Binary Large Object），适用于存贮非文本的字节流数据（如程序、图象、影音等）。而CLOB，即字符型大型对象（Character Large Object），则与字符集相关，适于存贮文本型的数据（如历史档案、大部头著作等）。

二、搭建测试环境

2.1、建立两个测试用的数据库表

　　建表SQL语句为：

  1. 1 CREATE TABLE TEST_CLOB ( ID NUMBER(3), CLOBCOL CLOB)
  2. 2
  3. 3 CREATE TABLE TEST_BLOB ( ID NUMBER(3), BLOBCOL BLOB)

2.2、搭建测试项目架构

　　

2.3、编写db.properties配置文件

  1. 1 oracleDb_Driver=oracle.jdbc.driver.OracleDriver
  2. 2 oracleDb_Url=jdbc:oracle:thin:@localhost:1521:GACL
  3. 3 oracleDb_UserName=GACL_XDP
  4. 4 oracleDb_Password=P

2.4、编写JdbcUtils工具类

  1.  1 package me.gacl.utils;
  2.  2
  3.  3 import java.io.InputStream;
  4.  4 import java.sql.Connection;
  5.  5 import java.sql.DriverManager;
  6.  6 import java.sql.ResultSet;
  7.  7 import java.sql.SQLException;
  8.  8 import java.sql.Statement;
  9.  9 import java.util.Properties;
  10. 10
  11. 11 public class JdbcUtils {
  12. 12
  13. 13     private static String oracleDb_Driver = null;
  14. 14     private static String oracleDb_Url = null;
  15. 15     private static String oracleDb_UserName = null;
  16. 16     private static String oracleDb_Password = null;
  17. 17
  18. 18     static{
  19. 19         try{
  20. 20             //读取db.properties文件中的数据库连接信息
  21. 21             InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
  22. 22             Properties prop = new Properties();
  23. 23             prop.load(in);
  24. 24
  25. 25             //获取数据库连接驱动
  26. 26             oracleDb_Driver = prop.getProperty("oracleDb_Driver");
  27. 27             //获取数据库连接URL地址
  28. 28             oracleDb_Url = prop.getProperty("oracleDb_Url");
  29. 29             //获取数据库连接用户名
  30. 30             oracleDb_UserName = prop.getProperty("oracleDb_UserName");
  31. 31             //获取数据库连接密码
  32. 32             oracleDb_Password = prop.getProperty("oracleDb_Password");
  33. 33
  34. 34             //加载数据库驱动
  35. 35             Class.forName(oracleDb_Driver);
  36. 36
  37. 37         }catch (Exception e) {
  38. 38             throw new ExceptionInInitializerError(e);
  39. 39         }
  40. 40     }
  41. 41
  42. 42     /**
  43. 43     * @Method: getOracleConnection
  44. 44     * @Description: 获取Oracle数据库连接对象
  45. 45     * @Anthor:
  46. 46     *
  47. 47     * @return Connection数据库连接对象
  48. 48     * @throws SQLException
  49. 49     */
  50. 50     public static Connection getOracleConnection() throws SQLException{
  51. 51         return DriverManager.getConnection(oracleDb_Url, oracleDb_UserName,oracleDb_Password);
  52. 52     }
  53. 53
  54. 54     /**
  55. 55     * @Method: release
  56. 56     * @Description: 释放资源，
  57. 57     *     要释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
  58. 58     * @Anthor:
  59. 59     *
  60. 60     * @param conn
  61. 61     * @param st
  62. 62     * @param rs
  63. 63     */
  64. 64     public static void release(Connection conn,Statement st,ResultSet rs){
  65. 65         if(rs!=null){
  66. 66             try{
  67. 67                 //关闭存储查询结果的ResultSet对象
  68. 68                 rs.close();
  69. 69             }catch (Exception e) {
  70. 70                 e.printStackTrace();
  71. 71             }
  72. 72             rs = null;
  73. 73         }
  74. 74         if(st!=null){
  75. 75             try{
  76. 76                 //关闭负责执行SQL命令的Statement对象
  77. 77                 st.close();
  78. 78             }catch (Exception e) {
  79. 79                 e.printStackTrace();
  80. 80             }
  81. 81         }
  82. 82
  83. 83         if(conn!=null){
  84. 84             try{
  85. 85                 //关闭Connection数据库连接对象
  86. 86                 conn.close();
  87. 87             }catch (Exception e) {
  88. 88                 e.printStackTrace();
  89. 89             }
  90. 90         }
  91. 91     }
  92. 92 }

三、JDBC处理Oracle大数据

3.1、JDBC处理CLOB数据

  1.  
  1.   1 package me.gacl.demo;
  2.   2
  3.   3 import java.io.BufferedReader;
  4.   4 import java.io.BufferedWriter;
  5.   5 import java.io.FileReader;
  6.   6 import java.io.FileWriter;
  7.   7 import java.sql.Connection;
  8.   8 import java.sql.PreparedStatement;
  9.   9 import java.sql.ResultSet;
  10.  10 import org.junit.Test;
  11.  11 import me.gacl.utils.JdbcUtils;
  12.  12
  13.  13 /**
  14.  14 * @ClassName: JdbcOperaOracleClob
  15.  15 * @Description:Oracle中字符型大型对象（Character Large Object）数据处理
  16.  16 * @author:
  17.  17 * @date: 2014-10-7 下午3:53:19
  18.  18 *
  19.  19 */
  20.  20 public class JdbcOperaOracleClob {
  21.  21
  22.  22     /**
  23.  23     CREATE TABLE TEST_CLOB ( ID NUMBER(3), CLOBCOL CLOB)
  24.  24      */
  25.  25     /**
  26.  26     * @Method: clobInsert
  27.  27     * @Description:往数据库中插入一个新的CLOB对象
  28.  28     * @Anthor:
  29.  29     *
  30.  30     * @throws Exception
  31.  31     */
  32.  32     @Test
  33.  33     public void clobInsert() throws Exception {
  34.  34         Connection conn = null;
  35.  35         PreparedStatement stmt = null;
  36.  36         ResultSet rs = null;
  37.  37         conn = JdbcUtils.getOracleConnection();
  38.  38         boolean defaultCommit = conn.getAutoCommit();
  39.  39         /*开启事务，设定不自动提交 */
  40.  40         conn.setAutoCommit(false);
  41.  41         try {
  42.  42             /* 插入一个空的CLOB对象 */
  43.  43             String sql = "INSERT INTO TEST_CLOB VALUES (?, EMPTY_CLOB())";
  44.  44             stmt = conn.prepareStatement(sql);
  45.  45             stmt.setInt(1, 1);
  46.  46             stmt.executeUpdate();
  47.  47             /* 查询此CLOB对象并锁定 */
  48.  48             sql = "SELECT CLOBCOL FROM TEST_CLOB WHERE ID=? FOR UPDATE";
  49.  49             stmt = conn.prepareStatement(sql);
  50.  50             stmt.setInt(1, 1);
  51.  51             rs = stmt.executeQuery();
  52.  52             if (rs.next()) {
  53.  53                 /* 取出此CLOB对象 */
  54.  54                 oracle.sql.CLOB clob = (oracle.sql.CLOB) rs.getClob("CLOBCOL");
  55.  55                 /* 向CLOB对象中写入数据 */
  56.  56                 BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
  57.  57                 //这种方式获取的路径，其中的空格会被使用“%20”代替
  58.  58                 String path = JdbcOperaClob.class.getClassLoader().getResource("data.txt").getPath();
  59.  59                 //将“%20”替换回空格
  60.  60                 path = path.replaceAll("%20", " ");
  61.  61                 BufferedReader in = new BufferedReader(new FileReader(path));
  62.  62                 int c;
  63.  63                 while ((c = in.read()) != -1) {
  64.  64                     out.write(c);
  65.  65                 }
  66.  66                 in.close();
  67.  67                 out.close();
  68.  68             }
  69.  69             /* 正式提交 */
  70.  70             conn.commit();
  71.  71             System.out.println("插入成功");
  72.  72         } catch (Exception ex) {
  73.  73             /* 出错回滚 */
  74.  74             conn.rollback();
  75.  75             throw ex;
  76.  76         }finally{
  77.  77             /* 恢复原提交状态 */
  78.  78             conn.setAutoCommit(defaultCommit);
  79.  79             JdbcUtils.release(conn,stmt,rs);
  80.  80         }
  81.  81
  82.  82     }
  83.  83
  84.  84     /**
  85.  85     * @Method: clobRead
  86.  86     * @Description: CLOB对象读取
  87.  87     * @Anthor:孤傲苍狼
  88.  88     *
  89.  89     * @throws Exception
  90.  90     */
  91.  91     @Test
  92.  92     public void clobRead() throws Exception {
  93.  93         Connection conn = null;
  94.  94         PreparedStatement stmt = null;
  95.  95         ResultSet rs = null;
  96.  96         conn = JdbcUtils.getOracleConnection();
  97.  97         boolean defaultCommit = conn.getAutoCommit();
  98.  98         conn.setAutoCommit(false);
  99.  99         try {
  100. 100             /* 查询CLOB对象 */
  101. 101             String sql = "SELECT * FROM TEST_CLOB WHERE ID=?";
  102. 102             stmt = conn.prepareStatement(sql);
  103. 103             stmt.setInt(1, 1);
  104. 104             rs = stmt.executeQuery();
  105. 105             if (rs.next()) {
  106. 106                 /* 获取CLOB对象 */
  107. 107                 oracle.sql.CLOB clob = (oracle.sql.CLOB) rs.getClob("CLOBCOL");
  108. 108                 /* 以字符形式输出 */
  109. 109                 BufferedReader in = new BufferedReader(clob.getCharacterStream());
  110. 110                 BufferedWriter out = new BufferedWriter(new FileWriter("D:\\2.txt"));
  111. 111                 int c;
  112. 112                 while ((c = in.read()) != -1) {
  113. 113                     out.write(c);
  114. 114                 }
  115. 115                 out.close();
  116. 116                 in.close();
  117. 117             }
  118. 118         } catch (Exception ex) {
  119. 119             conn.rollback();
  120. 120             throw ex;
  121. 121         }finally{
  122. 122             /* 恢复原提交状态 */
  123. 123             conn.setAutoCommit(defaultCommit);
  124. 124             JdbcUtils.release(conn,stmt,rs);
  125. 125         }
  126. 126     }
  127. 127
  128. 128     /**
  129. 129     * @Method: clobModify
  130. 130     * @Description:修改CLOB对象（是在原CLOB对象基础上进行覆盖式的修改）
  131. 131     * @Anthor:孤傲苍狼
  132. 132     *
  133. 133     * @throws Exception
  134. 134     */
  135. 135     @Test
  136. 136     public void clobModify() throws Exception {
  137. 137         Connection conn = null;
  138. 138         PreparedStatement stmt = null;
  139. 139         ResultSet rs = null;
  140. 140         conn = JdbcUtils.getOracleConnection();
  141. 141         boolean defaultCommit = conn.getAutoCommit();
  142. 142         // 开启事务
  143. 143         conn.setAutoCommit(false);
  144. 144         try {
  145. 145             /* 查询CLOB对象并锁定 */
  146. 146             String sql = "SELECT CLOBCOL FROM TEST_CLOB WHERE ID=? FOR UPDATE";
  147. 147             stmt = conn.prepareStatement(sql);
  148. 148             stmt.setInt(1, 1);
  149. 149             rs = stmt.executeQuery();
  150. 150             if (rs.next()) {
  151. 151                 /* 获取此CLOB对象 */
  152. 152                 oracle.sql.CLOB clob = (oracle.sql.CLOB) rs.getClob("CLOBCOL");
  153. 153                 /* 进行覆盖式修改 */
  154. 154                 BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
  155. 155                 // 这种方式获取的路径，其中的空格会被使用“%20”代替
  156. 156                 String path = JdbcOperaClob.class.getClassLoader().getResource("data2.txt").getPath();
  157. 157                 // 将“%20”替换回空格
  158. 158                 path = path.replaceAll("%20", " ");
  159. 159                 BufferedReader in = new BufferedReader(new FileReader(path));
  160. 160                 int c;
  161. 161                 while ((c = in.read()) != -1) {
  162. 162                     out.write(c);
  163. 163                 }
  164. 164                 in.close();
  165. 165                 out.close();
  166. 166             }
  167. 167             /*提交事务 */
  168. 168             conn.commit();
  169. 169         } catch (Exception ex) {
  170. 170             /*出错回滚事务 */
  171. 171             conn.rollback();
  172. 172             throw ex;
  173. 173         }finally{
  174. 174             /*恢复原提交状态 */
  175. 175             conn.setAutoCommit(defaultCommit);
  176. 176             JdbcUtils.release(conn,stmt,rs);
  177. 177         }
  178. 178     }
  179. 179
  180. 180     /**
  181. 181     * @Method: clobReplace
  182. 182     * @Description:替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象）
  183. 183     * @Anthor:孤傲苍狼
  184. 184     *
  185. 185     * @throws Exception
  186. 186     */
  187. 187     @Test
  188. 188     public void clobReplace() throws Exception {
  189. 189         Connection conn = null;
  190. 190         PreparedStatement stmt = null;
  191. 191         ResultSet rs = null;
  192. 192         conn = JdbcUtils.getOracleConnection();
  193. 193         boolean defaultCommit = conn.getAutoCommit();
  194. 194         // 开启事务
  195. 195         conn.setAutoCommit(false);
  196. 196         try {
  197. 197             /* 清空原CLOB对象 */
  198. 198             String sql = "UPDATE TEST_CLOB SET CLOBCOL=EMPTY_CLOB() WHERE ID=?";
  199. 199             stmt = conn.prepareStatement(sql);
  200. 200             stmt.setInt(1, 1);
  201. 201             stmt.executeUpdate();
  202. 202
  203. 203             /* 查询CLOB对象并锁定 */
  204. 204             sql = "SELECT CLOBCOL FROM TEST_CLOB WHERE ID=? FOR UPDATE";
  205. 205             stmt = conn.prepareStatement(sql);
  206. 206             stmt.setInt(1, 1);
  207. 207             rs = stmt.executeQuery();
  208. 208             if (rs.next()) {
  209. 209                 /* 获取此CLOB对象 */
  210. 210                 oracle.sql.CLOB clob = (oracle.sql.CLOB) rs.getClob("CLOBCOL");
  211. 211                 /* 更新数据 */
  212. 212                 BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
  213. 213                 // 这种方式获取的路径，其中的空格会被使用“%20”代替
  214. 214                 String path = JdbcOperaClob.class.getClassLoader().getResource("db.properties").getPath();
  215. 215                 // 将“%20”替换回空格
  216. 216                 path = path.replaceAll("%20", " ");
  217. 217                 BufferedReader in = new BufferedReader(new FileReader(path));
  218. 218                 int c;
  219. 219                 while ((c = in.read()) != -1) {
  220. 220                     out.write(c);
  221. 221                 }
  222. 222                 in.close();
  223. 223                 out.close();
  224. 224             }
  225. 225             /* 正式提交 */
  226. 226             conn.commit();
  227. 227         } catch (Exception ex) {
  228. 228             /* 出错回滚 */
  229. 229             conn.rollback();
  230. 230             throw ex;
  231. 231         } finally {
  232. 232             /* 恢复原提交状态 */
  233. 233             conn.setAutoCommit(defaultCommit);
  234. 234             JdbcUtils.release(conn, stmt, rs);
  235. 235         }
  236. 236     }
  237. 237 }
  1.  
  1.  

3.2、JDBC处理BLOB数据

　　Oracle定义了一个BLOB字段用于保存二进制数据，但这个字段并不能存放真正的二进制数据，只能向这个字段存一个指针，然后把数据放到指针所指向的Oracle的LOB段中， LOB段是在数据库内部表的一部分。因而在操作Oracle的Blob之前，必须获得指针（定位器）才能进行Blob数据的读取和写入。
　　如何获得表中的Blob指针呢？

可以先使用insert语句向表中插入一个空的blob（调用oracle的函数empty_blob()），这将创建一个blob的指针，然后再把这个empty的blob的指针查询出来，这样就可得到BLOB对象，从而读写blob数据了。

　　1、插入空blob：insert into testblob(id,image) values(?,empty_blob())
　　2、获得blob的cursor：

　　　　select image from testblob where id=? for update 注意: 必 须加for update锁定该行，直至该行被修改完毕，保证不产生并发冲突。

　　　　Blob b = rs.getBlob("image");
　　　　
　　3、利用 io和获取到的cursor往数据库读写数据
　　注意：以上操作需开启事务。

　　BLOB对象的存取范例

  1.   1 package me.gacl.demo;
  2.   2
  3.   3 import java.io.BufferedInputStream;
  4.   4 import java.io.BufferedOutputStream;
  5.   5 import java.io.FileOutputStream;
  6.   6 import java.sql.Connection;
  7.   7 import java.sql.PreparedStatement;
  8.   8 import java.sql.ResultSet;
  9.   9 import org.junit.Test;
  10.  10 import me.gacl.utils.JdbcUtils;
  11.  11
  12.  12 /**
  13.  13 * @ClassName: JdbcOperaOracleBlob
  14.  14 * @Description:Oracle中大数据处理
  15.  15 * @author:
  16.  16 * @date: 2014-10-7 下午3:53:19
  17.  17 *
  18.  18 */
  19.  19 public class JdbcOperaOracleBlob {
  20.  20
  21.  21     /**
  22.  22      * @Method: blobInsert
  23.  23      * @Description: 向数据库中插入一个新的BLOB对象
  24.  24      * @Anthor:
  25.  25      *
  26.  26      * @throws Exception
  27.  27      */
  28.  28     @Test
  29.  29     public void blobInsert() throws Exception {
  30.  30         Connection conn = null;
  31.  31         PreparedStatement stmt = null;
  32.  32         ResultSet rs = null;
  33.  33         boolean defaultCommit = true;
  34.  34         try {
  35.  35             conn = JdbcUtils.getOracleConnection();
  36.  36             //得到数据库事务处理的默认提交方式
  37.  37             defaultCommit = conn.getAutoCommit();
  38.  38             //1、开启事务
  39.  39             conn.setAutoCommit(false);
  40.  40             //2、插入一个空的BLOB对象
  41.  41             String sql = "INSERT INTO TEST_BLOB VALUES (?, EMPTY_BLOB())";
  42.  42             stmt = conn.prepareStatement(sql);
  43.  43             stmt.setInt(1, 1);
  44.  44             stmt.executeUpdate();
  45.  45             //3、查询此BLOB对象并锁定。注意: 必 须加for update锁定该行，直至该行被修改完毕，保证不产生并发冲突
  46.  46             sql = "SELECT BLOBCOL FROM TEST_BLOB WHERE ID=? FOR UPDATE";
  47.  47             stmt = conn.prepareStatement(sql);
  48.  48             stmt.setInt(1, 1);
  49.  49             rs = stmt.executeQuery();
  50.  50             if (rs.next()) {
  51.  51                 //4、取出此BLOB对象 ，并强制转换成Oracle的BLOB对象
  52.  52                 oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("BLOBCOL");
  53.  53                 //5、使用IO向BLOB对象中写入数据
  54.  54                 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
  55.  55                 BufferedInputStream in = new BufferedInputStream(JdbcOperaOracleBlob.class.getClassLoader().getResourceAsStream("01.jpg"));
  56.  56                 int c;
  57.  57                 while ((c = in.read()) != -1) {
  58.  58                     out.write(c);
  59.  59                 }
  60.  60                 in.close();
  61.  61                 out.close();
  62.  62             }
  63.  63             //6、提交事务
  64.  64             conn.commit();
  65.  65         } catch (Exception ex) {
  66.  66             //7、出错回滚事务
  67.  67             conn.rollback();
  68.  68             throw ex;
  69.  69         } finally {
  70.  70             //8、恢复数据库事务处理的默认提交方式
  71.  71             conn.setAutoCommit(defaultCommit);
  72.  72             //释放资源
  73.  73             JdbcUtils.release(conn, stmt, rs);
  74.  74         }
  75.  75
  76.  76     }
  77.  77
  78.  78     /**
  79.  79      * @Method: blobModify
  80.  80      * @Description:修改BLOB对象（是在原BLOB对象基础上进行覆盖式的修改）
  81.  81      * @Anthor:孤傲苍狼
  82.  82      *
  83.  83      * @throws Exception
  84.  84      */
  85.  85     @Test
  86.  86     public void blobModify() throws Exception {
  87.  87         Connection conn = null;
  88.  88         PreparedStatement stmt = null;
  89.  89         ResultSet rs = null;
  90.  90         boolean defaultCommit = true;
  91.  91         try {
  92.  92             conn = JdbcUtils.getOracleConnection();
  93.  93             //得到数据库事务处理的默认提交方式
  94.  94             defaultCommit = conn.getAutoCommit();
  95.  95             //1、开启事务
  96.  96             conn.setAutoCommit(false);
  97.  97             //2、查询此BLOB对象并锁定。注意: 必 须加for update锁定该行，直至该行被修改完毕，保证不产生并发冲突
  98.  98             String sql = "SELECT BLOBCOL FROM TEST_BLOB WHERE ID=? FOR UPDATE";
  99.  99             stmt = conn.prepareStatement(sql);
  100. 100             stmt.setInt(1, 1);
  101. 101             rs = stmt.executeQuery();
  102. 102             if (rs.next()) {
  103. 103                 //3、取出此BLOB对象 ，并强制转换成Oracle的BLOB对象
  104. 104                 oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("BLOBCOL");
  105. 105                 //4、使用IO向BLOB对象中写入数据
  106. 106                 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
  107. 107                 BufferedInputStream in = new BufferedInputStream(JdbcOperaOracleBlob.class.getClassLoader().getResourceAsStream("02.jpg"));
  108. 108                 int c;
  109. 109                 while ((c = in.read()) != -1) {
  110. 110                     out.write(c);
  111. 111                 }
  112. 112                 in.close();
  113. 113                 out.close();
  114. 114             }
  115. 115             //5、提交事务
  116. 116             conn.commit();
  117. 117         } catch (Exception ex) {
  118. 118             //6、出错回滚事务
  119. 119             conn.rollback();
  120. 120             throw ex;
  121. 121         } finally {
  122. 122             //8、恢复数据库事务处理的默认提交方式
  123. 123             conn.setAutoCommit(defaultCommit);
  124. 124             //释放资源
  125. 125             JdbcUtils.release(conn, stmt, rs);
  126. 126         }
  127. 127     }
  128. 128
  129. 129     /**
  130. 130      * @Method: blobReplace
  131. 131      * @Description:替换BLOB对象（将原BLOB对象清除，换成一个全新的BLOB对象）
  132. 132      * @Anthor:孤傲苍狼
  133. 133      *
  134. 134      * @throws Exception
  135. 135      */
  136. 136     @Test
  137. 137     public void blobReplace() throws Exception {
  138. 138         Connection conn = null;
  139. 139         PreparedStatement stmt = null;
  140. 140         ResultSet rs = null;
  141. 141         boolean defaultCommit = true;
  142. 142         try {
  143. 143             conn = JdbcUtils.getOracleConnection();
  144. 144             //得到数据库事务处理的默认提交方式
  145. 145             defaultCommit = conn.getAutoCommit();
  146. 146             //1、开启事务
  147. 147             conn.setAutoCommit(false);
  148. 148             //2、清空原BLOB对象
  149. 149             String sql = "UPDATE TEST_BLOB SET BLOBCOL=EMPTY_BLOB() WHERE ID=?";
  150. 150             stmt = conn.prepareStatement(sql);
  151. 151             stmt.setInt(1, 1);
  152. 152             stmt.executeUpdate();
  153. 153             //3、查询此BLOB对象并锁定。注意: 必 须加for update锁定该行，直至该行被修改完毕，保证不产生并发冲突
  154. 154             sql = "SELECT BLOBCOL FROM TEST_BLOB WHERE ID=? FOR UPDATE";
  155. 155             stmt = conn.prepareStatement(sql);
  156. 156             stmt.setInt(1, 1);
  157. 157             rs = stmt.executeQuery();
  158. 158             if (rs.next()) {
  159. 159                 //4、取出此BLOB对象 ，并强制转换成Oracle的BLOB对象
  160. 160                 oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("BLOBCOL");
  161. 161                 //5、使用IO向BLOB对象中写入数据
  162. 162                 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
  163. 163                 BufferedInputStream in = new BufferedInputStream(JdbcOperaOracleBlob.class.getClassLoader().getResourceAsStream("01.jpg"));
  164. 164                 int c;
  165. 165                 while ((c = in.read()) != -1) {
  166. 166                     out.write(c);
  167. 167                 }
  168. 168                 in.close();
  169. 169                 out.close();
  170. 170             }
  171. 171             //6、提交事务
  172. 172             conn.commit();
  173. 173         } catch (Exception ex) {
  174. 174             //7、出错回滚事务
  175. 175             conn.rollback();
  176. 176             throw ex;
  177. 177         } finally {
  178. 178             //8、恢复数据库事务处理的默认提交方式
  179. 179             conn.setAutoCommit(defaultCommit);
  180. 180             //释放资源
  181. 181             JdbcUtils.release(conn, stmt, rs);
  182. 182         }
  183. 183     }
  184. 184
  185. 185     /**
  186. 186      * @Method: blobRead
  187. 187      * @Description:BLOB对象读取
  188. 188      * @Anthor:孤傲苍狼
  189. 189      *
  190. 190      * @throws Exception
  191. 191      */
  192. 192     @Test
  193. 193     public void blobRead() throws Exception {
  194. 194         Connection conn = null;
  195. 195         PreparedStatement stmt = null;
  196. 196         ResultSet rs = null;
  197. 197         boolean defaultCommit = true;
  198. 198         try {
  199. 199             conn = JdbcUtils.getOracleConnection();
  200. 200             //得到数据库事务处理的默认提交方式
  201. 201             defaultCommit = conn.getAutoCommit();
  202. 202             //1、开启事务
  203. 203             conn.setAutoCommit(false);
  204. 204             //2、查询BLOB对象
  205. 205             String sql = "SELECT BLOBCOL FROM TEST_BLOB WHERE ID=?";
  206. 206             stmt = conn.prepareStatement(sql);
  207. 207             stmt.setInt(1, 1);
  208. 208             rs = stmt.executeQuery();
  209. 209             if (rs.next()) {
  210. 210                 //3、取出此BLOB对象 ，并强制转换成Oracle的BLOB对象
  211. 211                 oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("BLOBCOL");
  212. 212                 //4、以二进制流的形式输出
  213. 213                 BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("D:/1.jpg"));
  214. 214                 BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream());
  215. 215                 int c;
  216. 216                 while ((c = in.read()) != -1) {
  217. 217                     out.write(c);
  218. 218                 }
  219. 219                 in.close();
  220. 220                 out.close();
  221. 221             }
  222. 222             //5、提交事务
  223. 223             conn.commit();
  224. 224         } catch (Exception ex) {
  225. 225             //6、出错回滚事务
  226. 226             conn.rollback();
  227. 227             throw ex;
  228. 228         } finally {
  229. 229             //8、恢复数据库事务处理的默认提交方式
  230. 230             conn.setAutoCommit(defaultCommit);
  231. 231             //释放资源
  232. 232             JdbcUtils.release(conn, stmt, rs);
  233. 233         }
  234. 234
  235. 235     }
  236. 236 }

四、使用JDBC处理Oracle大数据总结

　　通过JDBC操纵Oracle数据库的LOB字段，不外乎插入、修改、替换、读取四种方式，掌握起来并不难。观察上述程序对LOB类型字段的存取，我们可以看出，较之其它类型字段，有下面几个显著不同的特点：

　　1、必须取消自动提交。

　　存取操作开始前，必须用setAutoCommit(false)取消自动提交。其它类型字段则无此特殊要求。这是因为存取LOB类型字段时，通常要进行多次操作可以完成。不这样的话，Oracle将抛出“读取违反顺序”的错误。

　　2、插入方式不同。

　　LOB数据不能象其它类型数据一样直接插入（INSERT）。插入前必须先插入一个空的LOB对象，CLOB类型 的空对象为EMPTY_CLOB()，BLOB类型的空对象为EMPTY_BLOB()。之后通过SELECT命令查询得到先前插入的记录并锁定，继而将 空对象修改为所要插入的LOB对象。

　　3、修改方式不同。

　　其它类型的字段修改时，用UPDATE … SET…命令即可。而LOB类型字段，则只能用SELECT … FOR UPDATE命令将记录查询出来并锁定，然后才能修改。且修改也有两种改法：一是在原数据基础上的修改（即覆盖式修改），执行SELECT … FOR UPDATE后再改数据；二是替换（先将原数据清掉，再修改），先执行UPDATE命令将LOB字段之值设为空的LOB对象，然后进行第一种改法。建议使 用替换的方法，以实现与其它字段UPDATE操作后一样的效果。

　　4、存取时应使用由数据库JDBC驱动程序提供的LOB操作类。

　　对于Oracle数据库，应使用oracle.sql.CLOB和oracle.sql.BLOB。不使用由数据库JDBC驱动程序提供的LOB类时，程序运行时易于出现“抽象方法调用”的错误，这是因为JDBC所定义的java.sql.Clob与 java.sql.Blob接口，其中的一些方法并未在数据库厂家提供的驱动程序中真正实现。

　　5、存取手段与文件操作相仿。

　　对于BLOB类型，应用InputStream/OutputStream类，此类不进行编码转换，逐个字节存取。oracle.sql.BLOB类相应提供了getBinaryStream()和getBinaryOutputStream()两个方法，前一个 方法用于读取Oracle的BLOB字段，后一个方法用于将数据写入Oracle的BLOB字段。

　　对于CLOB类型，应用Reader/Writer类，此类进行编码转换。oracle.sql.CLOB类相应 提供了getCharacterStream()和getCharacterOutputStream()两个方法，前一个方法用于读取Oracle的 CLOB字段，后一个方法用于将数据写入Oracle的CLOB字段。

　　需要说明的是，为了大幅提高程序执行效率，对BLOB/CLOB字段的读写操作，应该使用缓冲操作类（带 Buffered前缀），即：BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter。 例程中全部使用了缓冲操作类。

转：http://www.cnblogs.com/xdp-gacl/p/4009399.html

使用JDBC处理Oracle大数据的更多相关文章

  1. 利用jdbc处理oracle大数据---大文件和二进制文件

    一.Oracle中大数据处理 在Oracle中,LOB(Large Object,大型对象)类型的字段现在用得越来越多了.因为这种类型的字段,容量大(最多能容纳4GB的数据),且一个表中可以有多个这种 ...

  2. JavaWeb学习总结(三十五)——使用JDBC处理Oracle大数据

    一.Oracle中大数据处理 在Oracle中,LOB(Large Object,大型对象)类型的字段现在用得越来越多了.因为这种类型的字段,容量大(最多能容纳4GB的数据),且一个表中可以有多个这种 ...

  3. JavaWeb(三十五)——使用JDBC处理Oracle大数据

    一.Oracle中大数据处理 在Oracle中,LOB(Large Object,大型对象)类型的字段现在用得越来越多了.因为这种类型的字段,容量大(最多能容纳4GB的数据),且一个表中可以有多个这种 ...

  4. javaweb学习总结(三十四)——使用JDBC处理MySQL大数据

    一.基本概念 大数据也称之为LOB(Large Objects),LOB又分为:clob和blob,clob用于存储大文本,blob用于存储二进制数据,例如图像.声音.二进制文等. 在实际开发中,有时 ...

  5. Oracle 大数据集成实施

    Oracle 大数据实施架构 Oracle为广大客户提供了一个预装的用于测试和学习目的的免费大数据环境.你可以在这个环境中对Oracle大数据一体机(Big Data Appliance)上的可选软件 ...

  6. javaweb(三十四)——使用JDBC处理MySQL大数据

    一.基本概念 大数据也称之为LOB(Large Objects),LOB又分为:clob和blob,clob用于存储大文本,blob用于存储二进制数据,例如图像.声音.二进制文等. 在实际开发中,有时 ...

  7. Mysql学习总结（13）——使用JDBC处理MySQL大数据

    一.基本概念 大数据也称之为LOB(Large Objects),LOB又分为:clob和blob,clob用于存储大文本,blob用于存储二进制数据,例如图像.声音.二进制文等. 在实际开发中,有时 ...

  8. Oracle大数据解决方案》学习笔记5——Oracle大数据机的配置、部署架构和监控-1（BDA Config, Deployment Arch, and Monitoring）

    原创预见未来to50 发布于2018-12-05 16:18:48 阅读数 146  收藏 展开 这章的内容很多,有的学了. 1. Oracle大数据机——灵活和可扩展的架构 2. Hadoop集群的 ...

  9. 十七：使用JDBC处理MySQL大数据

    一.基本概念 大数据也称之为LOB(Large Objects),LOB又分为:clob和blob,clob用于存储大文本,blob用于存储二进制数据,例如图像.声音.二进制文等. 在实际开发中,有时 ...

随机推荐

  1. Android请求网络权限

    1,新建一个项目,在AndroidManiifest中添加 <uses-permission android:name="android.permission.INTERNET&quo ...

  2. Linux下使用yum安装MariaDB

    版本:centos7 Linux下安装MariaDB官方文档参见:https://mariadb.com/kb/zh-cn/installing-mariadb-with-yum/ 1.创建Maria ...

  3. 从零开始学习Node.js例子四 多页面实现数学运算 续一(使用connect和express框架)

    1.使用connect框架 .use方法用于绑定中间件到connect服务器,它会配置一系列在接到请求时调用的中间件模块,此例中我们要配置的中间件有favicon logger static rout ...

  4. echo、print、sprint、sprintf输出

    echo() 函数 定义和用法 echo() 函数输出一个或多个字符串. 语法 echo(strings) 参数 描述 strings 必需.一个或多个要发送到输出的字符串. 提示和注释 注释:ech ...

  5. 修改crontab默认的编辑器

    1.crontab默认的编辑器为nano; 2.修改为vi或其他编辑器 export EDITOR="/usr/bin/vim" ; crontab -e

  6. 关于路径的使用，assi下载和

    直接给一个路径下载图片,这函数直接使用assi -(void)downloadWithURL:(NSString*)RequestUrl SavePath:(NSString*)savepath wi ...

  7. source insight shift+tab问题

    之前用的好好的,shift+tab功能为向左缩进(即tab的相反功能),但是突然就有问题了:现象为只是光标向左移动,但文本不动. 解决方法: 1 使用快捷键f9 2 重新定义快捷键,把shift+ta ...

  8. cd hit使用

    ~~和唐老师一个实验室的人开发的~~ CD-HIT is a very widely used program for clustering and comparing protein or nucl ...

  9. Android——配置文件的保存SharedPreferences进行数据存储

    很多时候我们开发的软件需要向用户提供软件参数设置功能,例如我们常用的QQ,用户可以设置是否允许陌生人添加自己为好友.对于软件配置参数的保存,如果是window软件通常我们会采用ini文件进行保存,如果 ...

  10. EDIUS手绘遮罩功能如何用

    学了这么久的EDIUS视频编辑软件,你们学的怎么样了呢?你们知道EIDUS手绘遮罩的用法么,会熟练地使用它么?如果你们还没有学到这一知识点的话也不要着急,因为你们看完下面这篇文章就会明白了.事不宜迟, ...