Hibernate框架中get和load查询

时间  2021-02-19
标签 html java sql 数据库 session yii ide 性能 学习 测试 栏目 Hibernate 繁體版
原文   原文链接

原文连接：http://www.yiidian.com/hibern...html

1 演示get和load方法的基本使用

/**
 * 演示基本对象的查询
 * @author http://www.yiidian.com
 *
 */
public class Demo {

    /**
     * get()方法: 查询一个对象
     */
    @Test
    public void test1(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        
        Customer cust = session.get(Customer.class,1);
        Set<Order> orders = cust.getOrders();
        System.out.println(cust.getName()+"的订单：");
        for (Order order : orders) {
            System.out.println(order.getOrderno());
        }
        
        tx.commit();
        session.close();
    }
    
    /**
     * load()方法: 查询一个对象
     */
    @Test
    public void test2(){
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        
        Customer cust = session.load(Customer.class,1);
        Set<Order> orders = cust.getOrders();
        System.out.println(cust.getName()+"的订单：");
        for (Order order : orders) {
            System.out.println(order.getOrderno());
        }
        
        tx.commit();
        session.close();
    }
}

源码下载：https://pan.baidu.com/s/1c2HD7tmjava

2 分析get和load方法的区别

在hibernate中咱们知道若是要从数据库中获得一个对象，一般有两种方式，一种是经过session.get()方法，另外一种就是经过session.load()方法，而后其实这两种方法在得到一个实体对象时是有区别的，在查询性能上二者是不一样的。sql

2.1 load加载方式

当使用load方法来获得一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当咱们使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前获得的这个对象实际上是一个代理对象，这个代理对象只保存了实体对象的id值，只有当咱们要使用这个对象，获得其它属性时，这个时候才会发出sql语句，从数据库中去查询咱们的对象。　　　数据库

session = HibernateUtil.openSession();
/*
 * 经过load的方式加载对象时，会使用延迟加载机制，此时并不会发出sql语句，只有当咱们须要使用的时候才会从数据库中去查询
*/
User user = (User)session.load(User.class, 2);

咱们看到，若是咱们仅仅是经过load来加载咱们的User对象，此时从控制台咱们会发现并不会从数据库中查询出该对象，即并不会发出sql语句，但若是咱们要使用该对象时：　　　session

session = HibernateUtil.openSession();
User user = (User)session.load(User.class, 2);
System.out.println(user);

此时咱们看到控制台会发出了sql查询语句，会将该对象从数据库中查询出来：yii

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
User [id=2, username=aaa, password=111, born=2013-10-16 00:14:24.0]

这个时候咱们可能会想，那么既然调用load方法时，并不会发出sql语句去从数据库中查出该对象，那么这个User对象究竟是个什么对象呢？ide

其实这个User对象是咱们的一个代理对象，这个代理对象仅仅保存了id这个属性：　　　性能

session = HibernateUtil.openSession();
/*
* 经过load的方式加载对象时，会使用延迟加载机制，此时获得的User对象实际上是一个
* 代理对象，该代理对象里面仅仅只有id这个属性
*/
User user = (User)session.load(User.class, 2);
System.out.println(user.getId());

咱们看到，若是咱们只打印出这个user对象的id值时，此时控制台会打印出该id值，可是一样不会发出sql语句去从数据库中去查询。这就印证了咱们的这个user对象仅仅是一个保存了id的代理对象，但若是我须要打印出user对象的其余属性值时，这个时候会不会发出sql语句呢？答案是确定的：学习

session = HibernateUtil.openSession();
/*
* 经过load的方式加载对象时，会使用延迟加载机制，此时获得的User对象实际上是一个
* 代理对象，该代理对象里面仅仅只有id这个属性
*/
User user = (User)session.load(User.class, 2);
System.out.println(user.getId());
// 若是此时要获得user其余属性，则会从数据库中查询
System.out.println(user.getUsername());

此时咱们看控制台的输出：测试

2
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
aaa

相信经过上述的几个例子，你们应该很好的了解了load的这种加载对象的方式了吧。

2.2 get加载方式

相对于load的延迟加载方式，get就直接的多，当咱们使用session.get()方法来获得一个对象时，无论咱们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来：　

session = HibernateUtil.openSession();
/*
* 经过get方法来加载对象时，无论使不使用该对象，都会发出sql语句，从数据库中查询
*/
User user = (User)session.get(User.class, 2);

此时咱们经过get方式来获得user对象，可是咱们并无使用它，可是咱们发现控制台会输出sql的查询语句：

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?

所以咱们能够看到，使用load的加载方式比get的加载方式性能要好一些，由于load加载时，获得的只是一个代理对象，当真正须要使用这个对象时再去从数据库中查询。

2.3 使用get和load时的小问题

当了解了load和get的加载机制之后，咱们此时来看看这两种方式会出现的一些小问题：

①若是使用get方式来加载对象，当咱们试图获得一个id不存在的对象时，此时会报NullPointException的异常

session = HibernateUtil.openSession();
/*
* 当经过get方式试图获得一个id不存在的user对象时，此时会报NullPointException异常
*/
User user = (User)session.get(User.class, 20);
System.out.println(user.getUsername());

此时咱们看控制台的输出信息，会报空指针的异常：

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
java.lang.NullPointerException　　.........

这是由于经过get方式咱们会去数据库中查询出该对象，可是这个id值不存在，因此此时user对象是null，因此就会报NullPointException的异常了。

②若是使用load方式来加载对象，当咱们试图获得一个id不存在的对象时，此时会报ObjectNotFoundException异常：

session = HibernateUtil.openSession();
/*
* 当经过get方式试图获得一个id不存在的user对象时，此时会报ObjectNotFoundException异常
*/
User user = (User)session.load(User.class, 20);
System.out.println(user.getId());
System.out.println(user.getUsername());

咱们看看控制台的输出：

20
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
org.hibernate.ObjectNotFoundException: No row with the given identifier exists: [com.yiidian.bean.User#20]......

为何使用load的方式和get的方式来获得一个不存在的对象报的异常不一样呢？？其缘由仍是由于load的延迟加载机制，使用load时，此时的user对象是一个代理对象，仅仅保存了当前的这个id值，当咱们试图获得该对象的username属性时，这个属性实际上是不存在的，因此就会报出ObjectNotFoundException这个异常了。

③org.hibernate.LazyInitializationException异常

接下来咱们再来看一个例子：

public class UserDAO
{
    public User loadUser(int id)
    {
        Session session = null;
        Transaction tx = null;
        User user =  null;
        try
        {
            session = HibernateUtil.openSession();
            tx = session.beginTransaction();
            user = (User)session.load(User.class, 1);
            tx.commit();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            tx.rollback();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        return user;
    }
}
 

@Test
public void testLazy06(){
        UserDAO userDAO = new UserDAO();
        User user = userDAO.loadUser(2);
        System.out.println(user);
}

模拟了一个UserDAO这样的对象，而后咱们在测试用例里面来经过load加载一个对象，此时咱们发现控制台会报LazyInitializationException异常

org.hibernate.LazyInitializationException: could not initialize proxy - no Session　　.............

这个异常是什么缘由呢？？仍是由于load的延迟加载机制，当咱们经过load()方法来加载一个对象时，此时并无发出sql语句去从数据库中查询出该对象，当前这个对象仅仅是一个只有id的代理对象，咱们还并无使用该对象，可是此时咱们的session已经关闭了，因此当咱们在测试用例中使用该对象时就会报LazyInitializationException这个异常了。

因此之后咱们只要看到控制台报LazyInitializationException这种异常，就知道是使用了load的方式延迟加载一个对象了，解决这个的方法有两种，一种是将load改为get的方式来获得该对象，另外一种是在表示层来开启咱们的session和关闭session。

欢迎关注个人公众号：：一点教程。得到独家整理的学习资源和平常干货推送。
若是您对个人系列教程感兴趣，也能够关注个人网站： yiidian.com
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程