Hibernate 框架学习——Hibernate的优化方案

最新推荐文章于 2022-03-31 14:24:40 发布
最新推荐文章于 2022-03-31 14:24:40 发布
阅读量262 收藏
点赞数
分类专栏： Hibernate
任何你写的代码，超过6个月不去看它，当你再看时，都像是别人写的
本文链接：https://blog.csdn.net/qq_38977097/article/details/81359511
版权

HQL优化

  • 使用参数绑定
    1. 使用绑定参数的原因是让数据库一次解析SQL，对后续的重复请求可以使用生成好的执行计划，这样做节省CPU时间和内存。
    2. 避免SQL注入。
  • 尽量少使用NOT
    如果where子句中包含not关键字，那么执行时该字段的索引失效。
  • 尽量使用where来替换having
    having在检索出所有记录后才对结果集进行过滤，这个处理需要一定的开销，而where子句限制记录的数目，能减少这方面的开销。
  • 减少对表的查询
    在含有子查询的HQL中，尽量减少对表的查询，降低开销。
  • 使用表的别名
    当在HQL语句中连接多个表时，使用别名，提高程序阅读性，并把别名前缀与每个列连接上，这样一来，可以减少解析时间并减少列歧义引起的语法错误。
  • 实体的更新与删除
    在Hibernate3以后支持hql的update与delete操作。可参考度娘。

一级缓存优化

一级缓存也叫做session缓存，在一个hibernate session有效，这级缓存的可干预性不强，大多于hibernate自动管理，但它提供清除缓存的方法，这在大批量增加(更新)操作是有效果的，例如，同时增加十万条记录，按常规进行，很可能会出现异常，这时可能需要手动清除一级缓存，session.evict以及session.clear。

检索策略（抓取策略）

延迟加载

延迟加载是Hibernate为提高程序执行的效率而提供的一种机制，即只有真正使用该对象的数据时才会创建。load方法采用的策略是延迟加载；get方法采用的策略是立即加载。
检索策略分为两种：

  1. 类级别检索
  2. 关联级别检索

类级别检索

类级别检索是通过session直接检索某一类对应的数据，例如：

Customer c = session.load(Customer.class, 1);

或

session.createQuery("from Order");

类级别检索策略分为立即检索与延迟检索，默认是延迟检索，类级别的检索策略可以通过<class>元素的lazy属性来设置，默认值是true。所以我们可在hbm映射配置文件中设置如下：

<class name="Customer" table="t_customer" catalog="hibernateTest" lazy="true">
    ...
</class>

除此之外，我们也可在PO类中使用@Proxy注解，例如：

@Proxy(lazy = true)
public class Customer {
    ...
}

现在我着重来讲一下在PO类中@Proxy注解的使用。提示，以下所有案例代码的编写都是建立在Hibernate检索方式概述一文案例基础之上的。首先将@Proxy(lazy = true)这样的注解加在PO类——Customer类上，这样Customer类的代码就变成：

// 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
@NamedQuery(name="myHql", query="from Customer")
// @SqlResultSetMapping注解才真正帮我们去规定执行sql语句如何将结果封装到Customer对象
@SqlResultSetMapping(name="customerSetMapping",entities={ @EntityResult(entityClass=Customer.class,fields={ 
        @FieldResult(name="id",column="id"),@FieldResult(name="name",column="name") }) })
        // fields指定类里面的每一个属性跟表中的列是如何对应的
@NamedNativeQuery(name="findCustomer",query="select * from t_customer",resultSetMapping="customerSetMapping")
                                                                   // resultSetMapping需要指定一个名字，它用来指定结果如何封装的操作
@Proxy(lazy = true)
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    /*
     * targetEntity="..."：相当于<one-to-many class="...">
     * mappedBy="..."：相当于inverse=true，即放弃关联关系的维护，不然会生成一个中间表
     */
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

为了便于演示延迟加载，在cn.itheima.test包下编写一个LoadTest单元测试类，并在该类中编写如下测试方法：

// 演示延迟加载
public class LoadTest {

    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c1 = session.load(Customer.class, 1);
        // Customer c1 = session.get(Customer.class, 1);
        String name = c1.getName();

        System.out.println(name);

        session.getTransaction().commit();
        session.close();
    }

}

在String name = c1.getName();这句代码上加上一个断点，然后以Debug的方式调试该程序，就能得到你想要的东西哟！！！
如果将lazy设置为false，代表类级别检索也使用立即检索，这时load与get方法就完全一样了，都是立即检索。
虽然我们是知道了load方法采用的策略是延迟加载；get方法采用的策略是立即加载，但是什么时候用get方法，什么时候用load方法呢？——如果你查询的数据非常大，例如说它里面有一些大的字段，这个时候建议你采用load方法，不要一上来就立即加载，把我们的内存占满，这样可以让我们的性能得到一部分的提升；如果你查询的数据非常少，直接get就无所谓了，因为它不会占用我们很多的内存。
还有一个问题：Hibernate这个框架是在Dao层进行操作的，如果说我现在采用了一个load的方案去获取了一个对象，我们最终会把Session关闭再返回，那么我们就要把这个对象返回到Service层，再返回到Web层，这个时候load出来的代理对象其实还没有对数据进行初始化，也即它里面还没有真正有数据，返回的时候就出问题了，那如何对一个延迟的代理对象进行初始化呢？以码明示，在LoadTest单元测试类中编写如下测试方法：

public class LoadTest {

    // 如果对一个延迟的代理对象进行初始化?
    @Test
    public void test2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Customer c1 = session.load(Customer.class, 1);
        Hibernate.initialize(c1);

        session.getTransaction().commit();
        session.close();

        // return c1;
    }

}

在Customer c1 = session.load(Customer.class, 1);这句代码上加上一个断点，然后以Debug的方式调试该程序，就能得到你想要的东西哟！！！

关联级别检索

查询到某个对象，获得其关联的对象或属性，这种就称为关联级别检索，例如：

c.getOrders().size()
c.getName()

对于关联级别检索我们就要研究其检索策略(抓取策略)了。

检索策略(抓取策略)

抓取策略介绍

抓取策略指的是查找到某个对象后，通过这个对象去查询关联对象的信息时的一种策略。Hibernate中对象之间的关联关系有：

  1. 一对一：<one-to-one>
  2. 一对多（多对一）：<set>下有<one-to-many>，与<many-to-one>
  3. 多对多：<set>下有<many-to-many>

此处我们主要讲的是在<set>与<many-to-one>或<one-to-one>标签上设置fetch、lazy这两个属性。

  • fetch主要描述的是SQL语句的格式(例如是多条，子查询，多表联查)
  • lazy用于控制SQL语句何时发送

例如，查询一个客户，要关联查询它的订单。客户代表一的一方，在客户中有set集合来描述其订单，在配置中我们是使用的：

<set>
    <one-to-many>
</set>

此时就可以在set标签上设置这两个属性fetch、lazy。
再比如，查询一个订单时，要查询关联的客户信息。订单代表多的一方，在订单中有Customer对象来描述其关联的客户，在配置中我们是使用<many-to-one>标签，此时也可以在该标签上设置这两个属性fetch、lazy。当然了，也可在标签<one-to-one>上设置这两个属性fetch、lazy。

注解配置抓取策略

以一个问题来引出该小节的讲解，如何使用注解来配置抓取策略？

  • 在<set>标签上设置的fetch与lazy可以使用下面注解来描述：

@Fetch(FetchMode.SUBSELECT)
@LazyCollection(LazyCollectionOption.EXTRA)
private Set<Order> orders = new HashSet<Order>();

若是在映射配置文件中进行设置，则如下：
这里写图片描述

  • 在<many-to-one>或<one-to-one>标签上设置的fetch与lazy可以使用下面注解来描述：

  • @Fetch(FetchMode.SELECT)
@LazyToOne(LazyToOneOption.FALSE)
private Customer c; // 描述订单属于某一个客户

    若是在映射配置文件中进行设置，则如下：
    这里写图片描述

    set上的fetch与lazy

    set上的fetch与lazy主要是用于设置关联的集合信息的抓取策略。
    fetch可取值有：

    1. SELECT：多条简单的sql（默认值）
    2. JOIN：采用迫切左外连接
    3. SUBSELECT：将生成子查询的SQL

    lazy可取值有：

    1. TURE：延迟检索（默认值）
    2. FALSE：立即检索
    3. EXTRA：加强延迟检索（及其懒惰）

    这样说来，fetch与lazy的组合就有九种了，其实不然，fetch与lazy的组合实际上只有七种，且听我娓娓道来。

    第一种组合

    首先修改cn.itheima.domain包下的两个PO类，如下：

    • 客户类

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SELECT)
    @LazyCollection(LazyCollectionOption.TRUE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

  • 订单类

  • // 订单 ---- 多的一方
@Entity
@Table(name="t_order")
public class Order {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private Double money;
    private String receiverInfo; // 收货地址

    // 订单与客户关联
    @ManyToOne(targetEntity=Customer.class)
    @JoinColumn(name="c_customer_id") // 指定外键列
    @Cascade(CascadeType.SAVE_UPDATE)
    private Customer c; // 描述订单属于某一个客户

    public Customer getC() {
        return c;
    }
    public void setC(Customer c) {
        this.c = c;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public String getReceiverInfo() {
        return receiverInfo;
    }
    public void setReceiverInfo(String receiverInfo) {
        this.receiverInfo = receiverInfo;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
    }

}

    接着在cn.itheima.test包下编写一个SetFetchTest单元测试类，并在该类中编写如下测试方法：

    public class SetFetchTest {

    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.得到id=1的Customer
        Customer customer = session.get(Customer.class, 1);

        // 2.得到id=1的Customer关联的Order信息
        int size = customer.getOrders().size();

        System.out.println(size);

        session.getTransaction().commit();
        session.close();
    }

}

    在int size = customer.getOrders().size();这句代码上加上一个断点，然后以Debug的方式调试该程序，就能得出结论：会首先查询客户信息，当需要订单信息时，才会关联查询订单信息，并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.id as id1_1_0_,
        orders0_.id as id1_1_1_,
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.money as money2_1_1_,
        orders0_.receiverInfo as receiver3_1_1_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id=?
    第二种组合

    首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SELECT)
    @LazyCollection(LazyCollectionOption.FALSE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    然后以Debug的方式运行SetFetchTest单元测试类中的test1方法，就能得出结论：当查询客户信息时，就会将订单信息也查询，也就是说订单信息没有进行延迟查询。并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.id as id1_1_0_,
        orders0_.id as id1_1_1_,
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.money as money2_1_1_,
        orders0_.receiverInfo as receiver3_1_1_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id=?
    第三种组合

    首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SELECT)
    @LazyCollection(LazyCollectionOption.EXTRA)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    然后以Debug的方式运行SetFetchTest单元测试类中的test1方法，就能得出结论：当查询客户信息时，不会查询订单信息，当需要订单的个数时，也不会查询订单信息，只会通过count来统计订单个数，当我们使用size()、contains()或isEmpty()方法时也不会查询订单信息。并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        count(id) 
    from
        t_order 
    where
        c_customer_id =?
    第四种组合

    如果fetch选择的是join方案，那么lazy它就会失效。生成SQl语句采用的是迫切左外连接(left outer join fetch)，也即这个时候会多表联查，既然是多表联查，就会把信息都查询出来，它既然是一个迫切左外连接，会根据你的需求把信息封装到你指定的对象里面，所以lazy它就会失效。
    为了测试这第四种组合，首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.JOIN)
    @LazyCollection(LazyCollectionOption.FALSE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    然后以Debug的方式运行SetFetchTest单元测试类中的test1方法，在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_,
        orders1_.c_customer_id as c_custom4_1_1_,
        orders1_.id as id1_1_1_,
        orders1_.id as id1_1_2_,
        orders1_.c_customer_id as c_custom4_1_2_,
        orders1_.money as money2_1_2_,
        orders1_.receiverInfo as receiver3_1_2_ 
    from
        t_customer customer0_ 
    left outer join
        t_order orders1_ 
            on customer0_.id=orders1_.c_customer_id 
    where
        customer0_.id=?
    第五种组合

    首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SUBSELECT)
    @LazyCollection(LazyCollectionOption.TRUE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    接着在SetFetchTest单元测试类中编写如下测试方法：

    public class SetFetchTest {

    @SuppressWarnings("unchecked")
    @Test
    public void test2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.查询出所有的客户信息
        List<Customer> list = session.createQuery("from Customer").list();

        for (Customer customer : list) {
            System.out.println(customer.getOrders().size());
        }

        session.getTransaction().commit();
        session.close();
    }

}

    在List<Customer> list = session.createQuery("from Customer").list();这句代码上加上一个断点，然后以Debug的方式调试该程序，就能得出结论：会生成子查询，但是我们在查询订单时采用的是延迟加载。并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_,
        customer0_.name as name2_0_ 
    from
        t_customer customer0_
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.id as id1_1_1_,
        orders0_.id as id1_1_0_,
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.money as money2_1_0_,
        orders0_.receiverInfo as receiver3_1_0_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id in (
            select
                customer0_.id 
            from
                t_customer customer0_
        )
    第六种组合

    首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SUBSELECT)
    @LazyCollection(LazyCollectionOption.FALSE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    然后以Debug的方式运行SetFetchTest单元测试类中的test2方法，就能得出结论：会生成子查询，在查询客户信息时，就会将订单信息也查询出来。并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        customer0_.id as id1_0_,
        customer0_.name as name2_0_ 
    from
        t_customer customer0_
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.id as id1_1_1_,
        orders0_.id as id1_1_0_,
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.money as money2_1_0_,
        orders0_.receiverInfo as receiver3_1_0_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id in (
            select
                customer0_.id 
            from
                t_customer customer0_
        )
    第七种组合

    首先将客户类的代码改为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SUBSELECT)
    @LazyCollection(LazyCollectionOption.EXTRA)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    然后以Debug的方式运行SetFetchTest单元测试类中的test2方法，就能得出结论：在查询订单时，只会根据情况来确定是否要订单信息，如果不需要，例如我们程序中的size操作，那么就会发出select count(*) from Order where c_customer_id=?这样的语句。这时Eclipse控制台会打印：

    Hibernate: 
    select
        customer0_.id as id1_0_,
        customer0_.name as name2_0_ 
    from
        t_customer customer0_
Hibernate: 
    select
        count(id) 
    from
        t_order 
    where
        c_customer_id =?
10
Hibernate: 
    select
        count(id) 
    from
        t_order 
    where
        c_customer_id =?
10
Hibernate: 
    select
        count(id) 
    from
        t_order 
    where
        c_customer_id =?
0

    many-to-one或one-to-one上的fetch与lazy

    set上的fetch与lazy主要是设置在获取到代表一的一方时，如何去查询代表多的一方。那么在<many-to-one>或<one-to-one>标签上如何设置fetch与lazy，然后去查询对方。对于我们的程序来说，就是在代表多的一方如何查询代表一的一方的信息。例如，获取到一个订单对象，要查询客户信息。
    fetch可取值有：

    1. select：默认值，代表发送一条或多条简单的select语句
    2. join：发送一条迫切左外连接

    lazy可取值有：

    1. false：不采用延迟加载
    2. proxy：默认值，是否采用延迟不由本方说了算，而是需要由另一方的类级别延迟策略来决定
    3. no-proxy：在此不讨论
    第一种组合

    首先修改Order类的代码为：

    // 订单 ---- 多的一方
@Entity
@Table(name="t_order")
public class Order {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private Double money;
    private String receiverInfo; // 收货地址

    // 订单与客户关联
    @ManyToOne(targetEntity=Customer.class)
    @JoinColumn(name="c_customer_id") // 指定外键列
    @Cascade(CascadeType.SAVE_UPDATE)
    @Fetch(FetchMode.SELECT)
    @LazyToOne(LazyToOneOption.PROXY)
    private Customer c; // 描述订单属于某一个客户

    public Customer getC() {
        return c;
    }
    public void setC(Customer c) {
        this.c = c;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public String getReceiverInfo() {
        return receiverInfo;
    }
    public void setReceiverInfo(String receiverInfo) {
        this.receiverInfo = receiverInfo;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
    }

}

    然后将Customer类的类级别延迟策略置为lazy=true，此时Customer类变为：

    // 客户 ---- 一的一方
@Entity
@Table(name="t_customer")
@Proxy(lazy=true)
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SUBSELECT)
    @LazyCollection(LazyCollectionOption.EXTRA)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

    接着在cn.itheima.test包下编写一个OneFetchTest单元测试类，并在该类中编写如下测试方法：

    public class OneFetchTest {

    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.得到一个订单
        Order order = session.get(Order.class, 1);

        // 2.得到订单对应的客户
        Customer c = order.getC();

        System.out.println(c.getName());
        session.getTransaction().commit();
        session.close();
    }

}

    在Order order = session.get(Order.class, 1);这句代码上加上一个断点，然后以Debug的方式调试该程序，就能得出结论：会首先发送一条sql只查询订单信息，客户信息会延迟，只有真正需要客户信息时，才会发送sql来查询客户信息。并在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        order0_.id as id1_1_0_,
        order0_.c_customer_id as c_custom4_1_0_,
        order0_.money as money2_1_0_,
        order0_.receiverInfo as receiver3_1_0_ 
    from
        t_order order0_ 
    where
        order0_.id=?
Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
    第二种组合

    首先Order类的代码不用修改，只将Customer类的类级别延迟策略置为lazy=false，即在Customer类上加上@Proxy(lazy=false)注解。
    然后以Debug的方式运行OneFetchTest单元测试类中的test1方法，就能得出结论：当查询订单时，就会将客户信息也查询到，原因是Customer类的类级别延迟策略为false，也就是立即查询。而且在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        order0_.id as id1_1_0_,
        order0_.c_customer_id as c_custom4_1_0_,
        order0_.money as money2_1_0_,
        order0_.receiverInfo as receiver3_1_0_ 
    from
        t_order order0_ 
    where
        order0_.id=?
Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
    第三种组合

    首先将Order类的代码修改为：

    // 订单 ---- 多的一方
@Entity
@Table(name="t_order")
public class Order {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private Double money;
    private String receiverInfo; // 收货地址

    // 订单与客户关联
    @ManyToOne(targetEntity=Customer.class)
    @JoinColumn(name="c_customer_id") // 指定外键列
    @Cascade(CascadeType.SAVE_UPDATE)
    @Fetch(FetchMode.SELECT)
    @LazyToOne(LazyToOneOption.FALSE)
    private Customer c; // 描述订单属于某一个客户

    public Customer getC() {
        return c;
    }
    public void setC(Customer c) {
        this.c = c;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public String getReceiverInfo() {
        return receiverInfo;
    }
    public void setReceiverInfo(String receiverInfo) {
        this.receiverInfo = receiverInfo;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
    }

}

    然后以Debug的方式运行OneFetchTest单元测试类中的test1方法，就能得出结论：当查询订单时，不会对客户信息进行延迟，会立即查询客户信息。而且在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        order0_.id as id1_1_0_,
        order0_.c_customer_id as c_custom4_1_0_,
        order0_.money as money2_1_0_,
        order0_.receiverInfo as receiver3_1_0_ 
    from
        t_order order0_ 
    where
        order0_.id=?
Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?

    提示：这种组合不用理Customer类的类级别延迟策略。

    第四种组合

    首先将Order类的代码修改为：

    // 订单 ---- 多的一方
@Entity
@Table(name="t_order")
public class Order {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private Double money;
    private String receiverInfo; // 收货地址

    // 订单与客户关联
    @ManyToOne(targetEntity=Customer.class)
    @JoinColumn(name="c_customer_id") // 指定外键列
    @Cascade(CascadeType.SAVE_UPDATE)
    @Fetch(FetchMode.JOIN)
    @LazyToOne(LazyToOneOption.FALSE)
    private Customer c; // 描述订单属于某一个客户

    public Customer getC() {
        return c;
    }
    public void setC(Customer c) {
        this.c = c;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public String getReceiverInfo() {
        return receiverInfo;
    }
    public void setReceiverInfo(String receiverInfo) {
        this.receiverInfo = receiverInfo;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
    }

}

    然后以Debug的方式运行OneFetchTest单元测试类中的test1方法，就能得出结论：如果fetch的值为join，那么lazy将失效，这时会发送一条迫切左外连接来查询，也就立即查询。而且在Eclipse控制台打印如下sql语句：

    Hibernate: 
    select
        order0_.id as id1_1_0_,
        order0_.c_customer_id as c_custom4_1_0_,
        order0_.money as money2_1_0_,
        order0_.receiverInfo as receiver3_1_0_,
        customer1_.id as id1_0_1_,
        customer1_.name as name2_0_1_ 
    from
        t_order order0_ 
    left outer join
        t_customer customer1_ 
            on order0_.c_customer_id=customer1_.id 
    where
        order0_.id=?

    这种组合当然也就不需要搭理Customer类的类级别延迟策略了。

    批量抓取

    我们在查询多个对象的关联对象时，可以采用批量抓取方式来对程序进行优化。要想实现批量抓取，可以在映射配置文件中通过batch-size属性来设置，也可以使用注解@BatchSize(size=4)来设置，其中size表示一次抓取的条数。

    先查询客户，然后再查询订单

    首先检查两个PO类的代码是否如下：

    • 客户类

    @Entity
@Table(name="t_customer")
@Proxy(lazy=true)
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id; // 主键
    private String name; // 姓名

    // 描述客户可以有多个订单
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    @Fetch(FetchMode.SELECT)
    @LazyCollection(LazyCollectionOption.TRUE)
    private Set<Order> orders = new HashSet<Order>();

    public Customer() {

    }

    public Customer(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + "]";
    }

}

  • 订单类

  • @Entity
@Table(name="t_order")
public class Order {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private Double money;
    private String receiverInfo; // 收货地址

    // 订单与客户关联
    @ManyToOne(targetEntity=Customer.class)
    @JoinColumn(name="c_customer_id") // 指定外键列
    @Cascade(CascadeType.SAVE_UPDATE)
    private Customer c; // 描述订单属于某一个客户

    public Customer getC() {
        return c;
    }
    public void setC(Customer c) {
        this.c = c;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public String getReceiverInfo() {
        return receiverInfo;
    }
    public void setReceiverInfo(String receiverInfo) {
        this.receiverInfo = receiverInfo;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", money=" + money + ", receiverInfo=" + receiverInfo + "]";
    }

}

    为了查询出所有用户的订单信息，我在cn.itheima.test包下编写一个BatchFetchTest单元测试类，并在该类中编写如下测试方法：

    // 演示批量抓取
public class BatchFetchTest {

    // 查询出所有用户的订单信息
    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.得到所有客户
        List<Customer> list = session.createQuery("from Customer").list();

        // 2.得到客户的订单信息
        for (Customer customer : list) {
            System.out.println(customer.getOrders().size());
        }

        session.getTransaction().commit();
        session.close();
    }

}

    运行以上方法，可发现Eclipse控制台打印如下：

    Hibernate: 
    select
        customer0_.id as id1_0_,
        customer0_.name as name2_0_ 
    from
        t_customer customer0_
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.id as id1_1_0_,
        orders0_.id as id1_1_1_,
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.money as money2_1_1_,
        orders0_.receiverInfo as receiver3_1_1_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id=?
10
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.id as id1_1_0_,
        orders0_.id as id1_1_1_,
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.money as money2_1_1_,
        orders0_.receiverInfo as receiver3_1_1_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id=?
10
Hibernate: 
    select
        orders0_.c_customer_id as c_custom4_1_0_,
        orders0_.id as id1_1_0_,
        orders0_.id as id1_1_1_,
        orders0_.c_customer_id as c_custom4_1_1_,
        orders0_.money as money2_1_1_,
        orders0_.receiverInfo as receiver3_1_1_ 
    from
        t_order orders0_ 
    where
        orders0_.c_customer_id=?
0

    上述代码操作，当我们执行时，首先发出一条sql来查询所有客户信息，然后根据客户的id来查询订单信息，因为有三个客户，所以发送了三条sql，完成了查询订单信息的操作。以上一共执行了四条sql语句来完成操作，这就引出了一个N+1的经典问题。这里，就可以采用批量抓取来解决N+1问题。
    我们不仅可以在客户类映射配置文件中的<set>标签上配置batch-size，如下：
    这里写图片描述
    而且也可使用注解@BatchSize(size=3)来进行配置，即需要在Customer类中的orders属性上加上@BatchSize(size=3)注解。
    这样再次运行test1方法，就可发现Eclipse控制台打印如下：
    这里写图片描述
    提示：size的值要根据你当前的环境来设置，但是它的值不要太大，最好不要超过50。

    先查询订单，然后再查询客户

    为了查询出所有的订单，然后根据订单再查询出客户信息，我在BatchFetchTest单元测试类再编写如下测试方法：

    public class BatchFetchTest {

    // 查询出所有的订单，然后根据订单再查询出客户信息
    @Test
    public void test2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.得到所有订单
        List<Order> list = session.createQuery("from Order").list();

        // 2.得到客户信息
        for (Order order : list) {
            System.out.println(order.getC().getName());
        }

        session.getTransaction().commit();
        session.close();
    }

}

    运行以上方法，可发现Eclipse控制台打印如下：

    Hibernate: 
    select
        order0_.id as id1_1_,
        order0_.c_customer_id as c_custom4_1_,
        order0_.money as money2_1_,
        order0_.receiverInfo as receiver3_1_ 
    from
        t_order order0_
Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        customer0_.id as id1_0_0_,
        customer0_.name as name2_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.id=?

    订单一共有两种，在查询时会首先发送一条sql查询出所有订单，然后再根据订单查询出所有客户，一共3条语句完成。这时也出现同样的N+1问题，当然也可以采用批量抓取来解决这个N+1问题。
    注意：订单与客户，客户它是一个主表，订单是一个从表。在设置批量抓取时都是在主表中设置。故我们不仅可以在客户类映射配置文件中的<class>标签上配置batch-size，如下：
    这里写图片描述
    而且也可使用注解@BatchSize(size=10)来进行配置，即需要在Customer类上加上@BatchSize(size=10)注解。
    这样再次运行test2方法，就可发现Eclipse控制台打印如下：
    这里写图片描述

    总结

    无论是根据哪一方来查询另一方，在进行批量抓取时，都是在父方设置。如果是要查询子方信息，那么我们是在父方那个映射配置文件的<set>标签上来设置batch-size属性，如果是从子方来查询父方，也是在父方那个映射配置文件的<class>标签上设置batch-size属性。
    父方与子方的区分：有外键的表是子方(从表)，关联方就是父方(主表)。

已改行
关注
专栏目录
Hibernate 框架学习——Hibernate注解
热心网友
08-02 8385
前言 在Hibernate中我们一般都会使用注解，这样可以帮助我们大大简化hbm映射文件的配置。下面我就来为大家详细介绍。 PO类注解配置 首先肯定是搭建好Hibernate的开发环境啦，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.domain包，并在该包下创建一个Book实体类，由于Book实体类中写有注解配置，所以就不用编写那个映射配置文件啦！ ...
Hibernate入门第一讲——Hibernate框架的快速入门
热门推荐
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
Hibernate优化
04-08
NULL 博文链接：https://onlyLove.iteye.com/blog/1591620
Hibernate优化方法解析
Mr.Kevin-From human to God,how much time needs?
07-17 136
[b]Hibernate优化方法一：批量修改和删除 [/b] 在Hibernate 2中，如果需要对任何数据进行修改和删除操作，都需要先执行查询操作，在得到要修改或者删除的数据后，再对该数据进行相应的操作处理。在数据量少的情况下采用这种处理方式没有问题，但需要处理大量数据的时候就可能存在以下的问题： ◆占用大量的内存。 ◆需要多次执行update/delete语句，而每次执行...
（转）Hibernate的优化方案
06-08 165
http://blog.csdn.net/yerenyuan_pku/article/details/70768603 HQL优化 使用参数绑定 使用绑定参数的原因是让数据库一次解析SQL，对后续的重复请求可以使用生成好的执行计划，这样做节省CPU时间和内存。 避免SQL注入。 尽量少使用NOT如果where子句中包含not关键字，那么执行时该字段的索引失效。 ...
Hibernate性能优化技巧
liaomin416100569的专栏
05-06 798
一、在处理大数据量时，会有大量的数据缓冲保存在Session的一级缓存中，这缓存大太时会严重显示性能，所以在使用Hibernate处理大数据量的，可以使用session. clear()或者session. evict(Object) 在处理过程中，清除全部的缓存或者清除某个对象。二、对大数据量查询时，慎用list()或者iterator()返回查询结果，. 使用List()返回结果时，H
Hibernate框架基础——Hibernate入门
李阿昀的博客
10-04 5万+
Hibernate入门Hibernate介绍Hibernate是一个基于jdbc的开源的持久化框架，是一个优秀的ORM实现，它很大程度的简化了dao层编码工作。Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 在分层结构中处于持久化层，封装对数据库的访问细节，使业务逻辑层更专注于实现业务逻辑。 Hibernate的主页为：http://www.hibe
hibernate框架开发2016版视频 四天学习笔记完整版
04-18
【hibernate框架开发2016版视频 四天学习笔记完整版】 在软件开发领域，特别是Java Web开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它极大地简化了数据库操作，使开发者可以更专注于业务逻辑而不是...
Hibernate框架学习二——hibernate中的实体规则
朝着晨光
07-20 227
 终于考完试了，全过，不错！！！接下来我们继续学习hibernate框架，上次我们初识了hibernate框架，并学习了其基本的一些配置类，那么这次我们继续学习，之前写的文章大都有些长，所以博主之后会将这些知识点拆成不同的部分来写 hibernate中的实体规则 1.实体类创建的注意事项： 前面了解到我们的hibernate框架是类与数据库表间映射而成的，类即表，表即类，hibernate...
Hibernate优化方案
srj290310202的专栏
03-21 154
一、批量修改和删除 　　在Hibernate 2中，如果需要对任何数据进行修改和删除操作，都需要先执行查询操作，在得到要修改或者删除的数据后，再对该数据进行相应的操作处理。在数据量少的情况下采用这种处理方式没有问题，但需要处理大量数据的时候就可能存在以下的问题： 　　 占用大量的内存。 　　 需要多次执行update/delete语句，而每次执行只能处理一条数据。 　　以上两个问题的出现会...
Hibernate性能优化
oscar999的专栏
10-16 1593
有很多人认为Hibernate天生效率比较低，确实，在普遍情况下，需要将执行转换为SQL语句的 Hibernate的效率低于直接JDBC存取，然而，在经过比较好的性能优化之后，Hibernate的性能还是让人相当满意的，特别是应用二级缓存之 后，甚至可以获得比较不使用缓存的JDBC更好的性能，下面介绍一些通常的Hibernate的优化策略：    1.抓取优化    抓取是指Hiber
加速你的Hibernate引擎（下）
javasalatu
11-03 254
Hibernate是 最流行的对象关系映射（ORM）引擎之一，它提供了数据持久化和查询服务。在你的项目中引入Hibernate并让它跑起来是很容易的。但是，要让它跑得 好却是需要很多时间和经验的。通过我们的使用Hibernate 3.3.1和Oracle 9i的能源项目中的一些例子，本文涵盖了很多Hibernate调优技术。其中还提供了一些掌握Hibernate调优技术所必需的...
Hibernate 性能优化
xueshuangshuang123的专栏
01-03 1万+
为了进一步优化Hibernate的性能，可以使用延迟加载技术、管理数据抓取策略进行缓存管理  等方面考虑来提高Hibernate的性能。 一、 1、 延迟加载 延迟加载（load）是Hibernate为提高程序执行效率而提供的一种机制，即只有真正使用该对象的数据时才会创建。 场合一：当用户要取数据库的一张表的一个字段，这个字段很可能就是一个字符，总而言之长度是比较短的。 场合二：当用户要
Hibernate优化方法
anlovejing的专栏
03-06 464
Hibernate优化方法一：批量修改和删除 　在Hibernate 2中，如果需要对任何数据进行修改和删除操作，都需要先执行查询操作，在得到要修改或者删除的数据后，再对该数据进行相应的操作处理。在数据量少的情况下采用这种处理方式没有问题，但需要处理大量数据的时候就可能存在以下的问题： 　◆占用大量的内存。 　◆需要多次执行update/delete语句，而每次执行只能处理一条数据。 　以
Hibernate 的优化
weixin_59705658的博客
03-31 423
（1）数据库设计调整。 （2）HQL 优化。 （3）API 的正确使用(如根据不同的业务类型选用不同的集合及查询 API)。 （4）主配置参数(日志，查询缓存，fetch_size, batch_size 等)。 （5）映射文件优化(ID 生成策略，二级缓存，延迟加载，关联优化)。 （6）一级缓存的管理。 （7）针对二级缓存，还有许多特有的策略。 （8）事务控制策略。 ...
改善Hibernate应用程序性能的7种方法
最佳 Java 编程
05-29 183
Hibernate是将Java Web应用程序与SQL数据库集成的好工具，但是当应用程序的响应时间开始显着增加时，我们应该怎么做？ 当我们怀疑应用程序是否会随着客户群的增长而扩展时，我们该怎么办？ 在花大价钱托管或重写代码之前，请考虑分析和改进Web应用程序的这7个方面。 ＃1调整JVM内存设置 JVM允许我们配置它将分配给运行我们的应用程序的内存量。 如果未正确配置内存设置（堆大...
Hibernate3.5学习详解
"Hibernate学习笔记，基于Hibernate3.5版本，由整理者懒洋洋于2010年07月23日编撰，涵盖了Hibernate的基础知识、开发细节、对象状态、查询方式以及各种映射关系的配置和使用，旨在帮助读者深入理解Hibernate ORM框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值