`
yangmeng_3331
  • 浏览: 91237 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

Hibernate操作Oracle中clob、blob总结

hibernateoraclebolbclob 
阅读更多
一、区别与定义
LONG: 可变长的字符串数据，最长2G，LONG具有VARCHAR2列的特性，可以存储长文本一个表中最多一个LONG列
LONG RAW: 可变长二进制数据，最长2G
CLOB:  字符大对象Clob 用来存储单字节的字符数据
NCLOB: 用来存储多字节的字符数据
BLOB: 用于存储二进制数据
BFILE: 存储在文件中的二进制数据，这个文件中的数据只能被只读访。但该文件不包含在数据库内。
bfile字段实际的文件存储在文件系统中,字段中存储的是文件定位指针.bfile对oracle来说是只读的,也不参与事务性控制和数据恢复。
二、clob、blob实现方式
1、Clob字段 - 注解方式的实现
2、Clob字段 - 映射文件的实现
3、Blob字段 - 注解方式的实现
4、Blob字段 - 映射文件的实现


1、Clob字段 - 注解方式的实现 
package michael.hibernate.bigstring.oracle;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
import javax.persistence.Lob;  
import javax.persistence.Table;  
  
import org.hibernate.annotations.Type;  
  
/** 
 *  
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
@Entity  
@Table(name = "MY_TB_BIG_STR_CLOB")  
public class TbBigStrClob {  
  
    private Integer id;  
  
    private String name;  
  
    private String content;  
  
    /** 
     * @return the id 
     */  
    @Id  
    @GeneratedValue  
    @Column(name = "ID")  
    public Integer getId() {  
        return id;  
    }  
  
    /** 
     * @return the name 
     */  
    @Column(name = "NAME", length = 20)  
    public String getName() {  
        return name;  
    }  
  
    /** 
     * @return the content 
     */  
    @Lob  
    //@Type(type = "text")  
    @Column(name = "CONTENT", columnDefinition = "CLOB")  
    public String getContent() {  
        return content;  
    }  
  
    /** 
     * @param pId the id to set 
     */  
    public void setId(Integer pId) {  
        id = pId;  
    }  
  
    /** 
     * @param pName the name to set 
     */  
    public void setName(String pName) {  
        name = pName;  
    }  
  
    /** 
     * @param pContent the content to set 
     */  
    public void setContent(String pContent) {  
        content = pContent;  
    }  
  
    /* 
     * (non-Javadoc) 
     * @see java.lang.Object#toString() 
     */  
    @Override  
    public String toString() {  
        return "TbBigStrClob :: id = [" + id + "],name = [" + name  
                + "],content = [" + content + "].";  
    }  
  
}

Hibernate 配置文件：hibernate.cfg.xml 
<!DOCTYPE hibernate-configuration  
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"  
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  
<hibernate-configuration>  
  
    <session-factory>  
        <property name="connection.driver_class">  
            oracle.jdbc.driver.OracleDriver  
        </property>  
        <property name="connection.url">  
            jdbc:oracle:thin:@192.168.8.49:1521:ora9i  
        </property>  
        <property name="connection.username">mytest</property>  
        <property name="connection.password">123456</property>  
  
        <property name="dialect">  
            org.hibernate.dialect.Oracle9Dialect  
        </property>  
  
        <property name="connection.useUnicode">true</property>  
        <property name="connection.characterEncoding">UTF-8</property>  
        <property name="connection.SetBigStringTryClob">true</property>  
        <property name="connection.pool_size">10</property>  
        <property name="hibernate.jdbc.batch_size">10</property>  
  
  
        <property name="show_sql">true</property>  
        <property name="format_sql">false</property>  
        <property name="current_session_context_class">thread</property>  
        <property name="hbm2ddl.auto">update</property>  
  
        <!-- 注释  -->  
        <mapping  
            class="michael.hibernate.bigstring.oracle.TbBigStrClob" />  
  
    </session-factory>  
</hibernate-configuration>

测试程序： 
package michael.hibernate.bigstring.oracle;  
  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.AnnotationConfiguration;  
import org.hibernate.cfg.Configuration;  
  
/** 
 * 大字段Clob测试 
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
public class TestTbBigStr {  
  
    /** 
     * @param args 
     */  
    @SuppressWarnings("unchecked")  
    public static void main(String[] args) {  
  
        // 测试Hibernate 注释方法 操作 大字段 Clob  
        TestTbBigStr.testClob();  
  
    }  
  
    /** 
     * 测试Hibernate 注释方法 操作 大字段 Clob 
     */  
    @SuppressWarnings("unchecked")  
    public static void testClob() {  
        SessionFactory sessionFactory = null;  
        Transaction ta = null;  
        try {  
            System.out.println("../../hibernate.cfg.xml configure");  
            Configuration config = new AnnotationConfiguration()  
                    .configure("michael/hibernate/bigstring/oracle/hibernate.cfg.xml");  
  
            sessionFactory = config.buildSessionFactory();  
            Session session = sessionFactory.getCurrentSession();  
            String hsql = "select t from TbBigStrClob t ";  
            System.out.println("start test clob ...");  
            ta = session.beginTransaction();  
            org.hibernate.Query query = session.createQuery(hsql);  
            List<TbBigStrClob> list = query.list();  
            if (list.size() == 0) {  
                System.out.println("start to init clob data");  
                List<TbBigStrClob> initlist = initClobData(5);  
                for (TbBigStrClob po : initlist) {  
                    session.save(po);  
                }  
  
                list = query.list();  
            }  
            System.out.println("query data list size = " + list.size());  
            for (TbBigStrClob vo : list) {  
                System.out.println(vo);  
            }  
            ta.commit();  
        } catch (Exception e) {  
            e.printStackTrace();  
            ta.rollback();  
        } finally {  
            if (null != sessionFactory) {  
                sessionFactory.close();  
            }  
  
        }  
    }  
  
    /** 
     *  
     * @param dataSize 
     * @return List 
     */  
    public static List<TbBigStrClob> initClobData(int dataSize) {  
        List<TbBigStrClob> list = new ArrayList<TbBigStrClob>();  
        for (int i = 1; i <= dataSize; i++) {  
            TbBigStrClob vo = new TbBigStrClob();  
            vo.setName("test_" + i);  
            vo.setContent("我是大字段<Clob>,at date：" + new Date());  
            list.add(vo);  
        }  
        return list;  
    }  
  
}

提示:
1. 在Oracle10g + 10g驱动（或者Oracle11g + 11g驱动）的环境下，只需要在Clob字段上，增加注解@Column(name = "CONTENT", columnDefinition = "CLOB")，即可成功实现建表、Clob字段的读写操作。
2. 在Oracle9i+9i的驱动环境下，仅增加注释@Column(name = "CONTENT", columnDefinition = "CLOB")时，建表、写人数据均能正常，但读取时会显示数据为空。如果在Oracle9i下又必须用9i的驱动，可以在Clob字段中再增加一行注解@Lob 或者 @Type(type = "text")。（[color=blue]运用spring中org.springframework.jdbc.support.lob.OracleLobHandler，这个没有具体实践过，就不在本文展开了 ）
3. 在Oracle9i+10g的驱动环境下，增加注解@Column(name = "CONTENT", columnDefinition = "CLOB")，同样可以成功实现建表、Clob字段的读写操作，可见9i的驱动对Clob支持不是很好，但10g、11g已经做了更新。[/color]
2、Clob字段 - 映射文件的实现
Bean文件: 
package michael.hibernate.bigstring.oracle;  
  
/** 
 *  
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
  
public class BigStrClob {  
  
    private Integer id;  
  
    private String name;  
  
    private String content;  
  
    /** 
     * @return the id 
     */  
    public Integer getId() {  
        return id;  
    }  
  
    /** 
     * @return the name 
     */  
    public String getName() {  
        return name;  
    }  
  
    /** 
     * @return the content 
     */  
    public String getContent() {  
        return content;  
    }  
  
    /** 
     * @param pId the id to set 
     */  
    public void setId(Integer pId) {  
        id = pId;  
    }  
  
    /** 
     * @param pName the name to set 
     */  
    public void setName(String pName) {  
        name = pName;  
    }  
  
    /** 
     * @param pContent the content to set 
     */  
    public void setContent(String pContent) {  
        content = pContent;  
    }  
  
    /* 
     * (non-Javadoc) 
     * @see java.lang.Object#toString() 
     */  
    @Override  
    public String toString() {  
        return "BigStrClob :: id = [" + id + "],name = [" + name  
                + "],content = [" + content + "].";  
    }  
  
}

映射文件:tb_bigstr.hb.xml 
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC  
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"  
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  
<hibernate-mapping package="michael.hibernate.bigstring.oracle">  
  
    <class name="BigStrClob" table="MY_HB_BIG_STR_CLOB">  
  
        <id name="id" type="int" unsaved-value="null">  
            <generator class="increment" />  
        </id>  
  
        <property name="name" column="NAME" type="string"  
            not-null="false" length="20" />  
  
        <property name="content" column="CONTENT" type="text"  
            not-null="false" />  
  
    </class>  
  
</hibernate-mapping>

在hibernate.cfg.xml文件中增加域对象的映射文件： 
 <mapping resource="michael/hibernate/bigstring/oracle/tb_bigstr.hb.xml" />

测试程序： 
package michael.hibernate.bigstring.oracle;  
  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.AnnotationConfiguration;  
import org.hibernate.cfg.Configuration;  
  
/** 
 * 大字段Clob测试 
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
public class TestHbBigStr {  
  
    /** 
     * @param args 
     */  
  
    public static void main(String[] args) {  
  
        // 测试Hibernate 映射文件 操作 大字段 Clob  
        TestHbBigStr.testClob();  
    }  
  
    /** 
     * 测试Hibernate 映射文件 操作 大字段 Clob 
     */  
    @SuppressWarnings("unchecked")  
    public static void testClob() {  
        SessionFactory sessionFactory = null;  
        Transaction ta = null;  
        try {  
            System.out.println("../../hibernate.cfg.xml configure");  
            Configuration config = new AnnotationConfiguration()  
                    .configure("michael/hibernate/bigstring/oracle/hibernate.cfg.xml");  
  
            sessionFactory = config.buildSessionFactory();  
            Session session = sessionFactory.getCurrentSession();  
            String hsql = "select t from BigStrClob t ";  
            ta = session.beginTransaction();  
            org.hibernate.Query query = session.createQuery(hsql);  
            List<BigStrClob> list = query.list();  
            if (list.size() == 0) {  
                System.out.println("start to init clob data");  
                List<BigStrClob> initlist = initClobData(5);  
                for (BigStrClob po : initlist) {  
                    session.save(po);  
                }  
                list = query.list();  
            }  
            System.out.println("Query data list size = " + list.size());  
            for (BigStrClob vo : list) {  
                System.out.println(vo);  
            }  
  
            ta.commit();  
        } catch (Exception e) {  
            e.printStackTrace();  
            ta.rollback();  
        } finally {  
            if (null != sessionFactory) {  
                sessionFactory.close();  
            }  
  
        }  
    }  
  
    /** 
     *  
     * @param dataSize 
     * @return List 
     */  
    public static List<BigStrClob> initClobData(int dataSize) {  
        List<BigStrClob> list = new ArrayList<BigStrClob>();  
        for (int i = 1; i <= dataSize; i++) {  
            BigStrClob vo = new BigStrClob();  
            vo.setName("test_" + i);  
            vo.setContent("我是大字段<Clob>,at date：" + new Date());  
            list.add(vo);  
        }  
        return list;  
    }  
  
}

提示:
如果是映射文件的，只需要把Clob字段的类型指定为text即：type="text"。

3、Blob字段 - 注解 方式的实现 
package michael.hibernate.bigstring.oracle;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
import javax.persistence.Lob;  
import javax.persistence.Table;  
  
/** 
 *  
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
@Entity  
@Table(name = "MY_TB_BIG_STR_BLOB")  
public class TbBigStrBlob {  
  
    private Integer id;  
  
    private String name;  
  
    private byte[] content;  
  
    /** 
     * @return the id 
     */  
    @Id  
    @GeneratedValue  
    @Column(name = "ID")  
    public Integer getId() {  
        return id;  
    }  
  
    /** 
     * @return the name 
     */  
    @Column(name = "NAME", length = 20)  
    public String getName() {  
        return name;  
    }  
  
    /** 
     * @return the content 
     */  
    @Lob  
    @Column(name = "CONTENT", columnDefinition = "BLOB")  
    public byte[] getContent() {  
        return content;  
    }  
  
    /** 
     * @param pId the id to set 
     */  
    public void setId(Integer pId) {  
        id = pId;  
    }  
  
    /** 
     * @param pName the name to set 
     */  
    public void setName(String pName) {  
        name = pName;  
    }  
  
    /** 
     * @param pContent the content to set 
     */  
    public void setContent(byte[] pContent) {  
        content = pContent;  
    }  
  
    /* 
     * (non-Javadoc) 
     * @see java.lang.Object#toString() 
     */  
    @Override  
    public String toString() {  
        return "TbBigStrBlob :: id = [" + id + "],name = [" + name  
                + "],content = [" + new String(content) + "].";  
    }  
  
}

在hibernate.cfg.xml中增加域对象： 
<mapping  class="michael.hibernate.bigstring.oracle.TbBigStrBlob" />

运行测试程序： 
package michael.hibernate.bigstring.oracle;  
  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.AnnotationConfiguration;  
import org.hibernate.cfg.Configuration;  
  
/** 
 * 大字段Clob测试 
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
public class TestTbBigStr {  
  
    /** 
     * @param args 
     */  
    @SuppressWarnings("unchecked")  
    public static void main(String[] args) {  
        // 测试Hibernate 注释方法 操作 大字段 Blob  
        TestTbBigStr.testBlob();  
    }  
  
    /** 
     * 测试Hibernate 注释方法 操作 大字段 Blob 
     */  
    @SuppressWarnings("unchecked")  
    public static void testBlob() {  
        SessionFactory sessionFactory = null;  
        Transaction ta = null;  
        try {  
            System.out.println("../../hibernate.cfg.xml configure");  
            Configuration config = new AnnotationConfiguration()  
                    .configure("michael/hibernate/bigstring/oracle/hibernate.cfg.xml");  
  
            sessionFactory = config.buildSessionFactory();  
            Session session = sessionFactory.getCurrentSession();  
            String hsql = "select t from TbBigStrBlob t ";  
            System.out.println("start test clob ...");  
            ta = session.beginTransaction();  
            org.hibernate.Query query = session.createQuery(hsql);  
            List<TbBigStrBlob> list = query.list();  
            if (list.size() == 0) {  
                System.out.println("start to init blob data");  
                List<TbBigStrBlob> initlist = initBlobData(5);  
                for (TbBigStrBlob po : initlist) {  
                    session.save(po);  
                }  
  
                list = query.list();  
            }  
            System.out.println("query data list size = " + list.size());  
            for (TbBigStrBlob vo : list) {  
                System.out.println(vo);  
            }  
            ta.commit();  
        } catch (Exception e) {  
            e.printStackTrace();  
            ta.rollback();  
        } finally {  
            if (null != sessionFactory) {  
                sessionFactory.close();  
            }  
  
        }  
    }  
  
    /** 
     *  
     * @param dataSize 
     * @return List 
     */  
    public static List<TbBigStrBlob> initBlobData(int dataSize) {  
        List<TbBigStrBlob> list = new ArrayList<TbBigStrBlob>();  
        for (int i = 1; i <= dataSize; i++) {  
            TbBigStrBlob vo = new TbBigStrBlob();  
            vo.setName("test_" + i);  
            vo.setContent(("我是大字段<Blob>,at date：" + new Date()).getBytes());  
            list.add(vo);  
        }  
        return list;  
    }  
}

提示:
对于byte[] 类型的字段如果要映射成Blob字段，只需要在该字段增加如下注解即可： 
@Lob  
@Column(name = "CONTENT", columnDefinition = "BLOB")

4、Blob字段 - 映射文件的实现
bean文件 
package michael.hibernate.bigstring.oracle;  
  
/** 
 *  
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
  
public class BigStrBlob {  
  
    private Integer id;  
  
    private String name;  
  
    private byte[] content;  
  
    /** 
     * @return the id 
     */  
    public Integer getId() {  
        return id;  
    }  
  
    /** 
     * @return the name 
     */  
    public String getName() {  
        return name;  
    }  
  
    /** 
     * @return the content 
     */  
    public byte[] getContent() {  
        return content;  
    }  
  
    /** 
     * @param pId the id to set 
     */  
    public void setId(Integer pId) {  
        id = pId;  
    }  
  
    /** 
     * @param pName the name to set 
     */  
    public void setName(String pName) {  
        name = pName;  
    }  
  
    /** 
     * @param pContent the content to set 
     */  
    public void setContent(byte[] pContent) {  
        content = pContent;  
    }  
  
    /* 
     * (non-Javadoc) 
     * @see java.lang.Object#toString() 
     */  
    @Override  
    public String toString() {  
        return "BigStrBlob :: id = [" + id + "],name = [" + name  
                + "],content = [" + new String(content) + "].";  
    }  
  
}

映射文件：tb_bigstr.hb.xml 
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC  
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"  
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  
<hibernate-mapping package="michael.hibernate.bigstring.oracle">  
  
    <class name="BigStrBlob" table="MY_HB_BIG_STR_BLOB">  
  
        <id name="id" type="int" unsaved-value="null">  
            <generator class="increment" />  
        </id>  
  
        <property name="name" column="NAME" type="string"  
            not-null="false" length="20" />  
  
        <property name="content" column="CONTENT" type="binary"  
            not-null="false" />  
  
    </class>  
  
</hibernate-mapping>

测试程序： 
package michael.hibernate.bigstring.oracle;  
  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  
import org.hibernate.cfg.AnnotationConfiguration;  
import org.hibernate.cfg.Configuration;  
  
/** 
 * 大字段Clob测试 
 * @blog http://sjsky.iteye.com 
 * @author Michael 
 */  
public class TestHbBigStr {  
  
    /** 
     * @param args 
     */  
  
    public static void main(String[] args) {  
        // 测试Hibernate 映射文件 操作 大字段 Blob  
        TestHbBigStr.testBlob();  
    }  
  
    /** 
     * 测试Hibernate 映射文件 操作 大字段 Clob 
     */  
    @SuppressWarnings("unchecked")  
    public static void testBlob() {  
        SessionFactory sessionFactory = null;  
        Transaction ta = null;  
        try {  
            System.out.println("../../hibernate.cfg.xml configure");  
            Configuration config = new AnnotationConfiguration()  
                    .configure("michael/hibernate/bigstring/oracle/hibernate.cfg.xml");  
  
            sessionFactory = config.buildSessionFactory();  
            Session session = sessionFactory.getCurrentSession();  
            String hsql = "select t from BigStrBlob t ";  
            ta = session.beginTransaction();  
            org.hibernate.Query query = session.createQuery(hsql);  
            List<BigStrBlob> list = query.list();  
            if (list.size() == 0) {  
                System.out.println("start to init blob data");  
                List<BigStrBlob> initlist = initBlobData(5);  
                for (BigStrBlob po : initlist) {  
                    session.save(po);  
                }  
                list = query.list();  
            }  
            System.out.println("Query data list size = " + list.size());  
            for (BigStrBlob vo : list) {  
                System.out.println(vo);  
            }  
  
            ta.commit();  
        } catch (Exception e) {  
            e.printStackTrace();  
            ta.rollback();  
        } finally {  
            if (null != sessionFactory) {  
                sessionFactory.close();  
            }  
  
        }  
    }  
  
    /** 
     *  
     * @param dataSize 
     * @return List 
     */  
    public static List<BigStrBlob> initBlobData(int dataSize) {  
        List<BigStrBlob> list = new ArrayList<BigStrBlob>();  
        for (int i = 1; i <= dataSize; i++) {  
            BigStrBlob vo = new BigStrBlob();  
            vo.setName("test_" + i);  
            vo.setContent(("我是大字段<Blob>,at date：" + new Date()).getBytes());  
            list.add(vo);  
        }  
        return list;  
    }  
  
}

提示
对于是映射文件的方式，Blob字段的类型指定为binary即：type=" binary "。



本文转自：http://sjsky.iteye.com/blog/1154916
分享到：
| Hibernate不同数据库的链接及方言
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate操作Oarcle中Clob、Blob字段小结

    这篇博客文章“Hibernate操作Oracle中Clob、Blob字段小结”可能会探讨如何在Hibernate中有效地处理这两种类型的数据。 1. **Clob与Blob的理解**： - Clob：Clob是用于存储大量字符数据的类型，例如长篇文章、XML...

    spring+hibernate操作oracle的clob字段

    在J2EE开发中，处理大数据对象（如大文本或二进制数据）时，Oracle数据库的CLOB...通过以上配置和操作，你可以在Spring和Hibernate的环境中顺利地对Oracle数据库的CLOB字段进行读写，满足J2EE应用中的大数据存储需求。

    关于在Hibernate中对于Clob，Blob字段的处理方法

    总结起来，在Hibernate中处理Oracle数据库中的Clob和Blob字段，主要涉及以下几个步骤： 1. 在实体类中定义Clob和Blob字段，并使用`@Lob`注解。 2. 配置Hibernate的JDBC连接，使用支持Clob和Blob高效操作的Oracle ...

    使用hibernate对oracle读取blob

    综上所述，使用Hibernate和JDBC读取Oracle数据库中的Blob数据涉及多个步骤，包括实体类的设计、数据库操作和文件流的处理。理解这些知识点对于处理大对象存储至关重要。在实际项目中，根据需求和性能考虑，选择合适...

    Hibernate对BLOB CLOB操作

    在Hibernate中，BLOB和CLOB可以通过`SerializableBlob`和`SerializableClob`类来操作。以下是一个简单的示例，展示如何创建一个`Users`对象，并设置其`img`（BLOB）和`txt`（CLOB）属性： ```java Users u = new ...

    hibernate保存blob,clob对象

    总结，Hibernate通过`@Lob`注解支持BLOB和CLOB的持久化，开发者需要适当地将数据转换为对应的对象类型，然后使用Hibernate的CRUD操作进行保存和检索。同时，要注意性能优化，如懒加载和数据库特定的最佳实践。

    Struts2 Hibernate存取Oracle数据库中的BLOB数据.pdf

    在实际操作中，可以通过Hibernate实现Oracle数据库中BLOB数据的存储和删除操作，然后利用Struts2框架展示这些BLOB数据。这样的结合，不仅可以提高开发效率，还能保证应用的性能和稳定性。 ### 实际操作步骤 在实际...

    hibernate动态映射表处理oracle的clob类型

    本主题“hibernate动态映射表处理Oracle的CLOB类型”主要聚焦于如何在Hibernate中有效地管理和操作CLOB字段。在Oracle 10g中，CLOB数据类型的处理有时会遇到一些挑战，尤其是在与ORM框架结合使用时。以下将详细介绍...

    spring+hibernate 解决大字段（clob）

    本文将详细介绍如何在Spring与Hibernate框架结合的情况下，有效地处理Oracle 10g数据库中的CLOB字段。 #### 一、环境配置 为了确保项目能够顺利运行，首先需要搭建好开发环境。本示例中使用的环境配置如下： 1. *...

    关于Clob类型在Hibernate中 的应用小结

    在Java世界中，尤其是在持久化框架Hibernate中，处理Clob类型的数据需要特别的方法和配置。 在Hibernate中，Clob类型的字段通常有两种处理方式： 1. **传统JDBC方式**： 在这种模式下，开发者需要直接操作Clob...

    解析使用jdbc,hibernate处理clob/blob字段的详解

    在Java的数据库操作中，`CLOB...总之，无论是使用JDBC还是Hibernate，处理`CLOB`和`BLOB`字段都需要特殊的处理方式，尤其是在Oracle等数据库中。了解这些处理方法对于开发涉及大数据量文本和二进制数据的应用至关重要。

    oracle+hibernate 处理blob +uploadify实例

    在本示例中，我们将探讨如何使用Oracle数据库、Hibernate ORM框架以及Uploadify插件处理Blob类型的大数据，如图片或文件上传。Blob（Binary Large Object）是数据库中用于存储二进制大对象的类型，常用于存储图片、...

    详解jdbc实现对CLOB和BLOB数据类型的操作

    JDBC实现对CLOB和BLOB数据类型的操作 在数据库中，存在两种类型的数据：CLOB（Character Large OBject）和BLOB（Binary Large OBject），它们用于存储大型数据，如文本、图片、音频、视频等。对CLOB和BLOB数据类型...

    使用Jdbc4操作Blob,Clob

    在提供的`Hibernate4_Spring3_Blob_Test`压缩包中，可能包含了使用Hibernate4和Spring3来测试Blob操作的例子。Spring可以帮助管理数据库连接和事务，而Hibernate则提供了方便的对象关系映射，使得处理LOB如同操作...

    java将图片写入数据库，并读出来（blob clob）

    这个过程通常涉及到Blob和Clob数据类型，它们是Java中的两种特殊对象，用于存储大对象（LOB）。Blob用于存储二进制数据，如图片、音频或视频文件，而Clob则用于存储字符数据，比如长文本。以下是如何使用Java处理...

    Spring+Hibernate处理Oracle lob字段（一）

    在Oracle数据库中，LOB字段主要有BLOB（Binary Large Object）和CLOB（Character Large Object）两种类型，分别用于存储二进制和字符数据。处理这些字段时，我们需要配置Hibernate的实体类和映射文件。 在实体类中...

    spring+hbernate对clob、blob字段的处理

    一个完整的工程，主要功能为：spring+hbernate对clob、blob字段的处理 包括：数据脚本、典型的SSH框架处理，以及spring、hibernate数据批量保存等功能源码、所用到的lib包 数据环境为：oracle 10G 开发:Mycelipse5.1...

    Spring,SpringMVC,Hibernate,Oracle知识汇总

    Oracle支持复杂的数据类型，如BLOB和CLOB，以及高级的数据库特性，如物化视图、分区表和触发器。在Java开发中，通常通过JDBC驱动与Oracle进行交互，或者利用Hibernate等ORM框架进行更高级别的操作。 这四个技术的...

Magicbox
Global site tag (gtag.js) - Google Analytics