mysql和Oracle在对clob和blob字段的处理

一、MySQL与Oracle数据库如何处理Clob，Blob数据类型

(1)不通数据库中对应clob,blob的类型如下：

  MySQL中：clob对应text，blob对应blob

  DB2/Oracle中：clob对应clob，blob对应blob

(2)domain中对应的类型：

  clob对应String，blob对应byte[]

  clob对应java.sql.Clob，blob对应java.sql.Blob

(3)hibernate配置文件中对应类型：

  clob-->clob ，blob-->binary

  也可以直接使用数据库提供类型，例如：oracle.sql.Clob，oracle.sql.Blob

二、jdbc操作clob(以oracle为例)

首先操作clob/blob不像操作varchar类型那样简单，插入步骤一般分为两步：第一步插入一个空值，第二步锁住此行，更新clob/blob字段。

//插入空值
conn.setAutoCommit(false);
String sql = "INSERT INTO T_FILE(NAME, FILE_CONTENT) VALUES ('Jambhala', EMPTY_CLOB())";
PreparedStatement pstmt = conn.prepareStatement(sql); 
pstmt.executeUpdate();
//锁住此行
String sql_lockstr = "SELECT FILE_CONTENT FROM T_FILE WHERE NAME='Jambhala' FOR UPDATE";
pstmt = conn.prepareStatement(sql_lockstr); 
ResultSet rs = pstmt.executeQuery(); 
oracle.sql.Clob clob = (oracle.sql.Clob)rs.getClob(1);
java.io.OutputStream writer = clob.getAsciiOutputStream(); 
byte[] temp = newFileContent.getBytes(); 
writer.write(temp); 
writer.flush(); 
writer.close();
pstmt.close();

读取内容：

oracle.sql.Clob clob = rs.getClob("FILE_CONTENT");
if(clob != null){
  Reader is = clob.getCharacterStream();
  BufferedReader br = new BufferedReader(is);
  String s = br.readLine();
  while(s != null){
  content += s+"<br>";
    s = br.readLine();
  }
}

三、jdbc操作blob

conn.setAutoCommit(false);
String sql = "INSERT INTO T_PHOTO(NAME, PHOTO) VALUES ('Jambhala', EMPTY_BLOB())";
pstmt = conn.prepareStatement(sql); 
pstmt = conn.executeUpdate();
sql = "SELECT PHOTO FROM T_PHOTO WHERE NAME='Jambhala'";
pstmt = conn.prepareStatement(sql); 
rs = pstmt.executeQuery(sql);
if(rs.next()){
  oracle.sql.Blob blob = (oracle.sql.Blob)rs.getBlob(1);
}
//write to a file
File file=new File("C:\test.rar");
FileInputStream fin = new FileInputStream(file);
OutputStream out = blob.getBinaryOutputStream();
int count=-1,total=0;
byte[] data = new byte[blob.getBufferSize()];
while((count=fin.read(data)) != -1){
  total += count;
  out.write(data, 0, count);
} 

四、hibernate处理clob

MyFile file = new MyFile();
file.setName("Jambhala");
file.setContent(Hibernate.createClob(""));
session.save(file);
session.flush();
session.refresh(file, LockMode.UPGRADE);
oracle.sql.Clob clob = (oracle.sql.Clob)file.getContent();
Writer pw = clob.getCharacterOutputStream();
pw.write(longText);  //写入长文本
pw.close();
session.close();

五、使用hibernate处理blob

原理基本相同：

Photo photo = new Photo();
photo.setName("Jambhala");
photo.setPhoto(Hibernate.createBlob(""));
session.save(photo);
session.flush();

session.refresh(photo, LockMode.UPGRADE);  //锁住此对象
oracle.sql.Blob blob = photo.getPhoto();  //取得此blob的指针
OutputStream out = blob.getBinaryOutputStream();
//写入一个文件
File f = new File("C:\test.rar");
FileInputStream fin = new FileInputStream(f);
int count=-1,total=0;
byte[] data = new byte[(int)fin.available()];
out.write(data);
fin.close();
out.close();
session.flush();


String DRIVER = "oracle.jdbc.driver.OracleDriver";
//Oracle连接用URL
private static final String URL = "jdbc:oracle:thin:@testora:1521:orac";
//用户名
private static final String USER = "scott";
//密码
private static final String PASSWORD = "pswd";
//数据库连接
private static Connection conn = null;
//SQL语句对象
private static Statement stmt = null;
//@roseuid 3EDA089E02BC
public LobPros(){}

//往数据库中插入一个新的Clob对象
//@param infile  数据文件
//@throws java.lang.Exception
//@roseuid 3EDA089E02BC
public static void clobInsert(String infile) throws Exception {
  //设定不自动提交
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false);
  try{
//插入一个空的Clob对象
    stmt.executeUpdate("INSERT INTO TEST_CLOB VALUES ('111', EMPTY_CLOB())");
    //查询此Clob对象并锁定
    ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
    while(rs.next()){
 //取出此Clob对象
      oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
      //向Clob对象中写入数据
      BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream()); 
      BufferedReader in = new BufferedReader(new FileReader(infile));
      int c;
      while((c=in.read()) != -1){
   out.write(c);
      }
      in.close();
      out.close();
    }
    //正式提交
    conn.commit();
  }catch(Exception e){
   //出错回滚
   conn.rollback();
   throw e;
  }

  //恢复原提交状态
  conn.setAutoCommit(defaultCommit);
}

//修改Clob对象(是在原Clob对象基础上进行覆盖式的修改)
//@param infile  数据文件
//@throws java.lang.Exception
//@roseuid 3EDA089E02BC
public static void clobModify(String infile) throws Exception {
  //设定不自动提交
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false);
  try{
//查询Clob对象并锁定
    ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
    while(rs.next()){
 //获取此Clob对象
      oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
      //进行覆盖式修改
      BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream()); 
      BufferedReader in = new BufferedReader(new FileReader(infile)); 
      int c;
      while ((c=in.read())!=-1) { 
       out.write(c); 
      } 
      in.close(); 
      out.close(); 
    }
    //正式提交
    conn.commit();
  }catch(Exception e){
   //出错回滚
   conn.rollback();
   throw e;
  }
  //恢复原提交状态
  conn.setAutoCommit(defaultCommit);
}

//替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象
//@param infile  数据文件
//@throws java.lang.Exception
//@roseuid 3EDA04BF01E1
public static void clobReplace(String infile) throws Exception {
  //设定不自动提交
  boolean defaultCommit = conn.getAutoCommit();
  conn.setAutoCommit(false);
  try{
//清空原CLOB对象
    stmt.executeUpdate("UPDATE TEST_CLOB SET CLOBCOL=EMPTY_CLOB() WHERE ID='111'");
    //查询CLOB对象并锁定
    ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
    while (rs.next()) {
 //获取此CLOB对象
      oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
      //更新数据
      BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
      BufferedReader in = new BufferedReader(new FileReader(infile)); 
      int c;
      while ((c=in.read())!=-1) { 
   out.write(c); 
 } 
 in.close(); 
 out.close();
    }
//正式提交
conn.commit();
  }catch(Exception e){
//出错回滚
conn.rollback(); 
throw e;
  }
  //恢复原提交状态
  conn.setAutoCommit(defaultCommit);
}

//CLOB对象读取
//@param outfile  输出文件名
//@throws java.lang.Exception
//@roseuid 3EDA04D80116
public static void clobRead(String outfile) throws Exception {
  //设定不自动提交
  boolean defaultCommit = conn.getAutoCommit();
  conn.setAutoCommit(false);
  try{
    //查询CLOB对象
    ResultSet rs = stmt.executeQuery("SELECT * FROM TEST_CLOB WHERE ID='111'");
    while (rs.next()) {
 //获取CLOB对象
      oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
      //以字符形式输出
      BufferedReader in = new BufferedReader(clob.getCharacterStream()); 
      BufferedWriter out = new BufferedWriter(new FileWriter(outfile)); 
      int c;
      while ((c=in.read())!=-1) {
       out.write(c);
      }
 out.close(); 
 in.close();
    }
  }catch(Exception e){
    conn.rollback(); 
    throw e;
  }
  //恢复原提交状态
  conn.setAutoCommit(defaultCommit);
}

//向数据库中插入一个新的BLOB对象 
//@param infile  数据文件 
//@throws java.lang.Exception 
//@roseuid 3EDA04E300F6
public static void blobInsert(String infile) throws Exception { 
  //设定不自动提交
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false); 
  try { 
//插入一个空的BLOB对象 
stmt.executeUpdate("INSERT INTO TEST_BLOB VALUES ('222', EMPTY_BLOB())"); 
//查询此BLOB对象并锁定 
ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE"); 
while (rs.next()) { 
 //取出此BLOB对象 
 oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL"); 
 //向BLOB对象中写入数据 
 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream()); 
 BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile)); 
 int c; 
 while ((c=in.read())!=-1) { 
out.write(c); 
 } 
 in.close(); 
 out.close(); 
} 
//正式提交 
conn.commit(); 
  } catch (Exception e) { 
//出错回滚 
conn.rollback(); 
throw e; 
  } 
  //恢复原提交状态 
  conn.setAutoCommit(defaultCommit); 
} 

//修改BLOB对象（是在原BLOB对象基础上进行覆盖式的修改） 
//@param infile  数据文件 
//@throws java.lang.Exception 
//@roseuid 3EDA04E90106 
public static void blobModify(String infile) throws Exception { 
  //设定不自动提交 
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false); 
  try { 
//查询BLOB对象并锁定 
ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE"); 
while (rs.next()) { 
 //取出此BLOB对象 
 oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL"); 
 //向BLOB对象中写入数据 
 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream()); 
 BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile)); 
 int c; 
 while ((c=in.read())!=-1) { 
   out.write(c); 
 } 
 in.close(); 
 out.close(); 
} 
//正式提交 
conn.commit(); 
  } catch (Exception e) { 
//出错回滚 
conn.rollback(); 
throw e; 
  } 
  //恢复原提交状态 
  conn.setAutoCommit(defaultCommit); 
} 

//替换BLOB对象（将原BLOB对象清除，换成一个全新的BLOB对象） 
//@param infile  数据文件 
//@throws java.lang.Exception 
//@roseuid 3EDA0505000C 
public static void blobReplace(String infile) throws Exception { 
  //设定不自动提交 
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false); 
  try { 
//清空原BLOB对象 
stmt.executeUpdate("UPDATE TEST_BLOB SET BLOBCOL=EMPTY_BLOB() WHERE ID='222'"); 
//查询此BLOB对象并锁定 
ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE"); 
while (rs.next()) { 
 //取出此BLOB对象 
 oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL"); 
 //向BLOB对象中写入数据 
 BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream()); 
 BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile)); 
 int c; 
 while ((c=in.read())!=-1) { 
   out.write(c); 
 } 
 in.close(); 
 out.close(); 
    } 
//正式提交 
conn.commit(); 
  } catch (Exception e) { 
//出错回滚 
conn.rollback(); 
throw e; 
  } 
  //恢复原提交状态 
  conn.setAutoCommit(defaultCommit); 
} 

//BLOB对象读取 
//@param outfile  输出文件名 
//@throws java.lang.Exception 
//@roseuid 3EDA050B003B 
public static void blobRead(String outfile) throws Exception { 
  //设定不自动提交 
  boolean defaultCommit = conn.getAutoCommit(); 
  conn.setAutoCommit(false); 
  try { 
     //查询BLOB对象 
ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222'"); 
while (rs.next()) { 
  //取出此BLOB对象 
  oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL"); 
  //以二进制形式输出 
  BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile)); 
  BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream()); 
  int c; 
  while ((c=in.read())!=-1) { 
   out.write(c); 
      } 
  in.close(); 
  out.close(); 
     } 
//正式提交 
     conn.commit(); 
  } catch (Exception e) { 
//出错回滚 
conn.rollback(); 
throw e; 
  } 
  //恢复原提交状态 
  conn.setAutoCommit(defaultCommit); 
} 

//建立测试用表格 
//@throws Exception 
public static void createTables() throws Exception { 
  try { 
stmt.executeUpdate("CREATE TABLE TEST_CLOB (ID NUMBER(3), CLOBCOL CLOB)"); 
stmt.executeUpdate("CREATE TABLE TEST_BLOB (ID NUMBER(3), BLOBCOL BLOB)"); 
  } catch (Exception e) { } 
} 

//@param args - 命令行参数 
//@throws java.lang.Exception 
//@roseuid 3EDA052002AC 
public static void main(String[] args) throws Exception { 
  //装载驱动,建立数据库连接 
  Class.forName(DRIVER); 
  conn = DriverManager.getConnection(URL,USER,PASSWORD); 
  stmt = conn.createStatement(); 
  //建立测试表格 
  createTables(); 
  //CLOB对象插入测试 
  clobInsert("c:/clobInsert.txt"); 
  clobRead("c:/clobInsert.out"); 
  //CLOB对象修改测试 
  clobModify("c:/clobModify.txt"); 
  clobRead("c:/clobModify.out"); 
  //CLOB对象替换测试 
  clobReplace("c:/clobReplace.txt"); 
  clobRead("c:/clobReplace.out"); 
  //BLOB对象插入测试 
  blobInsert("c:/blobInsert.doc"); 
  blobRead("c:/blobInsert.out"); 
  //BLOB对象修改测试 
  blobModify("c:/blobModify.doc"); 
  blobRead("c:/blobModify.out"); 
  //BLOB对象替换测试 
  blobReplace("c:/blobReplace.doc"); 
  blobRead("c:/bolbReplace.out"); 
  //关闭资源退出 
  conn.close(); 
  System.exit(0); 
}