Hibernate检索策略

一、Hibernate的检索策略分类

　　1、立即检索

　　 　　立即查询方式，调用get方法只会，会马上去查询数据库。

public void Test2(){
            SessionFactory sessionFactory = null;
            Session session = null;
            Transaction tx = null;
            try {
                sessionFactory = HibernateUtils.getFactory();
                session = sessionFactory.openSession();
                tx = session.beginTransaction();
                //调用get方法查询出一条记录，调用只后会马上发送sql语句去查询数据库
                Sort food = session.get(Sort.class, 1);
                System.out.println(food);
                tx.commit();
            } catch (Exception e) {
                tx.rollback();
            }finally{
                session.close();
                sessionFactory.close();
            }
        }

　　2、延迟检索

　　　　 延迟查询方式，使用session对象的load方法查询时，调用load方法后不会立即查询数据库，

　　　　而是等需要得到该查询对象里面的属性的时候才会去查询数据库。

    @Test
                
                public void Test13(){
                    SessionFactory sessionFactory = null;
                    Session session = null;
                    Transaction tx = null;
                    try {
                        sessionFactory = HibernateUtils.getFactory();
                        session = sessionFactory.openSession();
                        tx = session.beginTransaction();
                        //调用get方法查询出一条记录，调用只后不会会马上发送sql语句去查询数据库
                        Sort food = session.load(Sort.class, 1);
                        //不发送SQL语句，返回的对象里面只有id值
                        System.out.println(food.getSid());
                        //发送SQL语句，查询数据库
                        System.out.println(food.getSname());
                        tx.commit();
                    } catch (Exception e) {
                        tx.rollback();
                    }finally{
                        session.close();
                        sessionFactory.close();
                    }
                }

二、延迟检索分类

　　1、类级别的延迟

　 　　　　延迟查询方式，使用session对象的load方法查询时，调用load方法后不会立即查询数据库，

　　　　而是等需要得到该查询对象里面的属性的时候才会去查询数据库。

    @Test
                
                public void Test13(){
                    SessionFactory sessionFactory = null;
                    Session session = null;
                    Transaction tx = null;
                    try {
                        sessionFactory = HibernateUtils.getFactory();
                        session = sessionFactory.openSession();
                        tx = session.beginTransaction();
                        //调用get方法查询出一条记录，调用只后不会会马上发送sql语句去查询数据库
                        Sort food = session.load(Sort.class, 1);
                        //不发送SQL语句，返回的对象里面只有id值
                        System.out.println(food.getSid());
                        //发送SQL语句，查询数据库
                        System.out.println(food.getSname());
                        tx.commit();
                    } catch (Exception e) {
                        tx.rollback();
                    }finally{
                        session.close();
                        sessionFactory.close();
                    }
                }

　　2、关联级别延迟

　　　　查询某个类别，再查询这个类别的所有商品，查询类别的所有商品的过程是否需要延迟，这个过程称为关联级别延迟。

　　　　

@Test
    
    public void Test1(){
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            //1、使用get方法查询出食品类
            Sort food = session.get(Sort.class, 1);
            //2、使用sort对象的方法得到所有食品类中的食品，没有发送SQL语句
            Set<Good> set = food.getSetGoods();
            //3、发送SQL语句
            System.out.println(set.size());
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        }finally{
            session.close();
            sessionFactory.close();
        }
    }

三、关联级别延迟操作

　　　1 在映射文件中进行配置实现

　　　　（1）根据类别得到所有的商品，在类别映射文件中配置

 　　2 在set标签上使用属性

　　　　（1）fetch：值select（默认）

　　　　（2）lazy：值

　　　　　　　　- true：延迟（默认）

　　　　　　　　- false：不延迟

　　　　　　　　- extra：极其延迟

　　　　（3）延迟效果

　　　　　　默认延迟效果：

@Test
    
    public void Test1(){
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            //1、使用get方法查询出食品类
            Sort food = session.get(Sort.class, 1);
            //2、使用sort对象的方法得到所有食品类中的食品，发送SQL语句
            Set<Good> set = food.getSetGoods();
            //3、发送SQL语句
            System.out.println(set.size());
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        }finally{
            session.close();
            sessionFactory.close();
        }
    }

　　　　不延迟效果

@Test
    
    public void Test1(){
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            //1、使用get方法查询出食品类
            Sort food = session.get(Sort.class, 1);
            //2、使用sort对象的方法得到所有食品类中的食品，没有发送SQL语句
            Set<Good> set = food.getSetGoods();
            //3、发送SQL语句
            System.out.println(set.size());
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        }finally{
            session.close();
            sessionFactory.close();
        }
    }

　　　　　　　极度延迟效果：

　　　　

@Test
    
    public void Test1(){
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            //1、使用get方法查询出食品类
            Sort food = session.get(Sort.class, 1);
            //2、使用sort对象的方法得到所有食品类中的食品，没有发送SQL语句
            Set<Good> set = food.getSetGoods();
            //3、发送SQL语句，但发送的查询数量的count聚集函数语句
            System.out.println(set.size());
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        }finally{
            session.close();
            sessionFactory.close();
        }
    }