Oracle读取Blob数据-通过hibernate

通过hibernate向Oracle存储字节类型的数据(如byte[]等),在定义实体对象的时候不能用"private byte[] content", 这样定义我试过,在存储数据的时候(session.save(user))是没有问题的,但是在读取Blob字段(Oracle中存储byte[]使用的是"BLOB"类型)时就会出现问题,读出来的东西就成了乱码.

使用hibernate读取Blob字段时,实体对象(对应的byte[]类型字段)应该这样定义:

  1. import java.io.Serializable; 
  2. import java.sql.Blob; 
  3.  
  4. public class User implements Serializable {                 
  5.     // Fields                    
  6.     private long id;            
  7.     private String name;            
  8.     private String email;            
  9.     private String addr;            
  10.     // 定义Blob的pthto             
  11.     private Blob photo; 
  12.      
  13.     // getter and setters  
  14.     ...... 

对应的hibernate文件配置:

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
  4. <Hibernate-mapping>          
  5.     <class name="com.xxx.xxx.User" table="user">              
  6.         <id name="id" type="java.lang.Long">                  
  7.             <column name="id" />                  
  8.             <generator class="increment" />              
  9.         </id>              
  10.         <property name="name" type="java.lang.String">                  
  11.             <column name="name" length="45" not-null="true" />              
  12.         </property>              
  13.         <property name="email" type="java.lang.String">                  
  14.             <column name="email" length="45" />              
  15.         </property>              
  16.         <property name="addr" type="java.lang.String">                  
  17.             <column name="addr" length="45" />              
  18.         </property>              
  19.         <!-- 映射blob类型 -->              
  20.         <property name="photo" type="java.sql.Blob">                  
  21.             <column name="photo" />              
  22.         </property>          
  23.     </class>      
  24. </Hibernate-mapping>   

读取Blob数据方法:

  1. // 写方法  
  2. public void testCreate(){                       
  3.     User user = new User();           
  4.     user.setName("linweiyang");           
  5.     user.setAddr("beijing");           
  6.     user.setEmail("linweiyang@163.com");           
  7.     Blob photo = null;                   
  8.     try {               
  9.         //将图片读进输入流                
  10.         FileInputStream fis = new FileInputStream("c:\a.jpg");               
  11.         //转成Blob类型                
  12.         photo = Hibernate.createBlob(fis);                           
  13.     } catch (FileNotFoundException e) {               
  14.         e.printStackTrace();           
  15.     } catch (IOException e) {               
  16.         e.printStackTrace();           
  17.     }                           
  18.     user.setPhoto(photo);                      
  19.     Session session = factory.openSession();           
  20.     Transaction tr = session.beginTransaction();           
  21.     session.save(user);           
  22.     tr.commit();           
  23.     session.close();          
  24. }               
  25.  
  26. // 读方法  
  27. public void testRerieve(){                       
  28.     Session session = factory.openSession();           
  29.     User user = (User)session.load(User.class, new Long(3));           
  30.     try {               
  31.         //从数据库中要读取出来                
  32.         InputStream is = user.getPhoto().getBinaryStream();               
  33.         //在把写到一个图片格式的文件里                
  34.         FileOutputStream fos = new FileOutputStream("c:\linweihan.jpg");                           
  35.         byte[] buffer = new byte[1024];               
  36.         int len = 0;               
  37.         //从数据库中读取到指定的字节数组中                
  38.         while((len = is.read(buffer) )!= -1){                   
  39.             //从指定的数组中读取,然后输出来,所以这里buffer好象是连接inputStream和outputStream的一个东西                    
  40.             fos.write(buffer,0,len);               
  41.         }           
  42.     } catch (FileNotFoundException e) {               
  43.         e.printStackTrace();           
  44.     } catch (SQLException e) {               
  45.         e.printStackTrace();           
  46.     } catch (IOException  e) {               
  47.         e.printStackTrace();           
  48.     }                      
  49.     session.close();       
  50. }    

关于输入输出流

读入流自然要有读入的源头,输出也要输出到某个地方,输出一般是先要输读入,这里连接输入和输出的是一个在内存中的字节数组buffer.这样从数据库中读到这个数组里,输出流在从这个数组中输出到特定的文件格式里

原文地址:https://www.cnblogs.com/ios9/p/13048205.html