Hibernate学习---第十一节：Hibernate之数据抓取策略&批量抓取

1、hibernate 也可以通过标准的 SQL 进行查询

(1)、将SQL查询写在 java 代码中

/**
 * 查询所有
 */
@Test
public void testQuery(){
    // 基于标准的 sql 语句查询
    String sql = "select * from t_person";
    // 通过 createSQLQuery 获取 SQLQuery，而 SQLQuer 是 Query的子类
    SQLQuery query = session.createSQLQuery(sql);
    // 因为是基于表的操作，所以返回的是标准值的Object数组
    List<Object[]> list = query.list();
    for(Object[] objs : list){
        System.out.println(Arrays.toString(objs));
    }
}

@Test
public void testQuery2(){
    // 基于标准的 sql 语句查询
    String sql = "select * from t_person";
    // 通过 createSQLQuery 获取 SQLQuery，而 SQLQuer 是 Query的子类
    SQLQuery query = session.createSQLQuery(sql);
    // 指定查询结果与某个持久化类绑定
    query.addEntity(Person.class);
    List<Person> list = query.list();
    for(Person p : list){
        System.out.println(p);
    }
}

@Test
public void testQuery3(){
    // 基于标准的 sql 语句查询
    String sql = "select * from t_person where id in (:ids)";
    // 通过 createSQLQuery 获取 SQLQuery，而 SQLQuer 是 Query的子类
    SQLQuery query = session.createSQLQuery(sql);
    // 指定查询结果与某个持久化类绑定
    query.addEntity(Person.class);
    // 绑定参数
    query.setParameterList("ids", new Object[]{3,6,9});
    List<Person> list = query.list();
    for(Person p : list){
        System.out.println(p);
    }
}

(2)、将SQL语句写在配置文件中

配置文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="learn.hibernate.bean">
    <sql-query name="mysqlquery">
        <![CDATA[select *　from t_person where id < :id]]>
    </sql-query>
</hibernate-mapping>

java 代码：

@Test
public void testQuery4(){
    Query query = session.getNamedQuery("mysqlquery");
    query.setInteger("id", 8);
    List<Object[]> list = query.list();
    for(Object[] objs : list){
        System.out.println(Arrays.toString(objs));
    }
}

2、数据抓取策略

数据抓取通过持久化映射文件来配置，代码如下：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="learn.hibernate.bean">
    <class name="Person" table="t_person">
        <id name="id" column="person_id">
            <generator class="native"/>
        </id>
        <property name="name" column="t_name"/>
        <property name="age"/>
        <property name="passwork"/>
        <property name="birthday"/>
        <!--
            fetch 数据抓取策略
                join 表示通过连接语句，将关联的数据获取到，立即查询
                select（默认） 表示通过另外的一条sql语句查询出关联数据，要用到的时候才会发起查询，延迟查询
                subselect 通过另外的一条SQL语句查询，要用到时候才会发起查询，延迟查询
         -->
        <set name="addres" cascade="all" inverse="true" fetch="join">
            <!-- 指定 addres 集合中的数据对应t_person的的一个外键 -->
            <key column="p_id"/>
            <!-- 指定Person 关联的实例类型 -->
            <one-to-many class="Address"/>
        </set>
    </class>
    <class name="Address" table="t_address">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="zipCode"/>
        <property name="address"/>
        <!--
            多的一端使用 many-to-one 进行配置
        -->
        <many-to-one name="person" column="p_id"/>
    </class>
</hibernate-mapping>

java代码如下：

/**
 * 批量写入数据
 */
@Test
public void testAdd(){
    tx = session.beginTransaction();
    for(int i = 0; i < 10; i++){
        Person person = new Person("ldh_"+i, 22+i, 123456+i, new Date());

        Set<Address> addSet = new HashSet<Address>();
        for(int j = 0; j < 10; j++){
            Address add = new Address("5000"+i+j,"湖南郴州"+j);
            add.setPerson(person);
            addSet.add(add);
        }
        person.setAddres(addSet);

        session.persist(person);
        if(i % 10 == 0){
            session.flush();
            session.clear();
        }
    }
    tx.commit();
}

@Test
public void testQuery(){
    Person p = (Person)session.get(Person.class, 1);
    System.out.println(p);
    System.out.println(p.getAddres().size());
}

3、批量抓取

持久化映射文件代码如下：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="learn.hibernate.bean">
    <class name="Person" table="t_person">
        <id name="id" column="person_id">
            <generator class="native"/>
        </id>
        <property name="name" column="t_name"/>
        <property name="age"/>
        <property name="passwork"/>
        <property name="birthday"/>
        <!--
            fetch 数据抓取策略
                join 表示通过连接语句，将关联的数据获取到，立即查询
                select（默认） 表示通过另外的一条sql语句查询出关联数据，要用到的时候才会发起查询，延迟查询
                subselect 通过另外的一条SQL语句查询，要用到时候才会发起查询，延迟查询

            如果查询的数据比较多可以用 batch-size 来提高搜索
            例如：batch-size="3" 批量抓取，表示每次查询出三条关联数据，如果有10条记录，那么会分四次查询出来
         -->
        <set name="addres" cascade="all" inverse="true" batch-size="3">
            <!-- 指定 addres 集合中的数据对应t_person的的一个外键 -->
            <key column="p_id"/>
            <!-- 指定Person 关联的实例类型 -->
            <one-to-many class="Address"/>
        </set>
    </class>
    <class name="Address" table="t_address">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="zipCode"/>
        <property name="address"/>
        <!--
            多的一端使用 many-to-one 进行配置
        -->
        <many-to-one name="person" column="p_id"/>
    </class>
</hibernate-mapping>

java 代码如下：

@Test
public void testQuery2(){
    Query query = session.createQuery("from Person");
    List<Person> list = query.list();
    for(Person p : list){
        System.out.println(p);
        System.out.println("------------------------");
        Set<Address> adds = p.getAddres();
        Address[] arr = new Address[adds.size()];
        adds.toArray(arr);
        System.out.println(Arrays.toString(arr));
    }
}

可以查看：http://www.cnblogs.com/rongxh7/archive/2010/05/12/1733088.html