fetch = FetchType.EAGER 作用

转载 2013年12月04日 00:11:30

如果是EAGER,那么表示取出这条数据时,它关联的数据也同时取出放入内存中

如果是LAZY,那么取出这条数据时,它关联的数据并不取出来,在同一个session中,什么时候要用,就什么时候取(再次访问数据库)。

但是,在session外,就不能再取了。用EAGER时,因为在内存里,所以在session外也可以取。

 

一般只在一边设Eager,JPA接口默认为一对多为Lazy,多对一为Eager,但是Hibernate反向工程生成Entity时,多对一为Lazy,需要手动改为Eager

 

而两边都设Eager,那么代码中取一条记录时,会发2次SQL。

 

Tgroup:

Java代码  收藏代码
  1. package com.hibernate.entity;  
  2.   
  3. import java.util.HashSet;  
  4.   
  5. /** 
  6.  * Tgroup entity. @author MyEclipse Persistence Tools 
  7.  */  
  8. @Entity  
  9. @Table(name = "tgroup", catalog = "test")  
  10. public class Tgroup implements java.io.Serializable {  
  11.   
  12.     // Fields  
  13.   
  14.     /** 
  15.      *  
  16.      */  
  17.     private static final long serialVersionUID = -7208715716759269846L;  
  18.     private Integer id;  
  19.     private String name;  
  20.     private Set<Tuser> tusers = new HashSet<Tuser>(0);  
  21.   
  22.     // Constructors  
  23.   
  24.     /** default constructor */  
  25.     public Tgroup() {  
  26.     }  
  27.   
  28.     /** full constructor */  
  29.     public Tgroup(String name, Set<Tuser> tusers) {  
  30.         this.name = name;  
  31.         this.tusers = tusers;  
  32.     }  
  33.   
  34.     // Property accessors  
  35.     @Id  
  36.     @GeneratedValue  
  37.     @Column(name = "id", unique = true, nullable = false)  
  38.     public Integer getId() {  
  39.         return this.id;  
  40.     }  
  41.   
  42.     public void setId(Integer id) {  
  43.         this.id = id;  
  44.     }  
  45.   
  46.     @Column(name = "name")  
  47.     public String getName() {  
  48.         return this.name;  
  49.     }  
  50.   
  51.     public void setName(String name) {  
  52.         this.name = name;  
  53.     }  
  54.   
  55.     @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "tgroup")  
  56.     public Set<Tuser> getTusers() {  
  57.         return this.tusers;  
  58.     }  
  59.   
  60.     public void setTusers(Set<Tuser> tusers) {  
  61.         this.tusers = tusers;  
  62.     }  
  63.   
  64. }  

 

 

Tuser:

Java代码  收藏代码
  1. package com.hibernate.entity;  
  2.   
  3. import javax.persistence.Column;  
  4.   
  5. /** 
  6.  * Tuser entity. @author MyEclipse Persistence Tools 
  7.  */  
  8. @Entity  
  9. @Table(name = "tuser", catalog = "test")  
  10. public class Tuser implements java.io.Serializable {  
  11.   
  12.     // Fields  
  13.   
  14.     /** 
  15.      *  
  16.      */  
  17.     private static final long serialVersionUID = -7792597282750540598L;  
  18.     private Integer id;  
  19.     private Tgroup tgroup;  
  20.     private String name;  
  21.   
  22.     // Constructors  
  23.   
  24.     /** default constructor */  
  25.     public Tuser() {  
  26.     }  
  27.   
  28.     /** full constructor */  
  29.     public Tuser(Tgroup tgroup, String name) {  
  30.         this.tgroup = tgroup;  
  31.         this.name = name;  
  32.     }  
  33.   
  34.     // Property accessors  
  35.     @Id  
  36.     @GeneratedValue  
  37.     @Column(name = "id", unique = true, nullable = false)  
  38.     public Integer getId() {  
  39.         return this.id;  
  40.     }  
  41.   
  42.     public void setId(Integer id) {  
  43.         this.id = id;  
  44.     }  
  45.   
  46.     @ManyToOne(fetch = FetchType.EAGER)//<span style="color: #ff0000;">注意这行代码</span>  
  47.   
  48.   
  49.   
  50.   
  51.   
  52.   
  53.   
  54.     @JoinColumn(name = "groupid")  
  55.     public Tgroup getTgroup() {  
  56.         return this.tgroup;  
  57.     }  
  58.   
  59.     public void setTgroup(Tgroup tgroup) {  
  60.         this.tgroup = tgroup;  
  61.     }  
  62.   
  63.     @Column(name = "name")  
  64.     public String getName() {  
  65.         return this.name;  
  66.     }  
  67.   
  68.     public void setName(String name) {  
  69.         this.name = name;  
  70.     }  
  71.   
  72. }  
 

Java代码  收藏代码
  1. @ManyToOne(fetch = FetchType.EAGER)//注意这行代码  
  2. @JoinColumn(name = "groupid")  
  3.     public Tgroup getTgroup() {  
  4.         return this.tgroup;  
  5.     }  

 时

 

Java代码  收藏代码
  1. @Test  
  2.     public void getUser() {  
  3.         Session s = sessionFactory.getCurrentSession();  
  4.         s.beginTransaction();  
  5.         Tuser user = (Tuser)s.get(Tuser.class1);  
  6.         System.out.println(user.getName());  
  7.         s.getTransaction().commit();  
  8.         System.out.println(user.getTgroup().getName());//这行代码OK,当然,也可以把这行代码放在commit()之前  
  9.     }  

 

如果

Java代码  收藏代码
  1. @ManyToOne(fetch = FetchType.LAZY)//注意这行代码  
  2. @JoinColumn(name = "groupid")  
  3.     public Tgroup getTgroup() {  
  4.         return this.tgroup;  
  5.     }  

时,

Java代码  收藏代码
  1. @Test  
  2.     public void getUser() {  
  3.         Session s = sessionFactory.getCurrentSession();  
  4.         s.beginTransaction();  
  5.         Tuser user = (Tuser)s.get(Tuser.class1);  
  6.         System.out.println(user.getName());  
  7.         s.getTransaction().commit();  
  8.         System.out.println(user.getTgroup().getName());//这行代码错误,不过,这行代码放在commit()之前,是正确的。  
  9.     }  
分享到:

@ManyToOne(fetch=FetchType.LAZY)

@ManyToOne(fetch=FetchType.LAZY)  ---> ManyToOne指定了多对一的关系,fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对...

Hibernate 实体类注解 Entity方式5、@Basic(fetch=FetchType,optional=true) 可选 @Basic表示一个简单的属性到数据库表的字段的映射,对于没有

Hibernate注解 1。@Entity(name="EntityName") 必须,name为可选,对应数据库中一的个表 2、@Table(name="",catalog...

fetch为LAZY、EAGER在load时的区别

有两个类,Group,User,设置它们之间为多对一的双向关联关系 分别如下: Group类 package com.chen.hibernate.ormapping; import ja...
  • CHEN_JP
  • CHEN_JP
  • 2012年08月29日 21:24
  • 10011

Hibernate Eager vs Lazy Fetch Type

BackgroundThe topic of Fetch types in Hibernate is a fairly advanced topic, as it requires you to ha...

Hibernate Fetch 的作用

  • 2014年03月24日 09:51
  • 260KB
  • 下载

【SSH三大框架】Hibernate基础第十三篇:lazy、constrained、fetch三个属性的作用和使用方法

lazy、constrained、fetch三个属性的作用和使用方法

Hibernate中的fetch, lazy, outer-join,inverse和cascade作用

1.fetch,outer-join 和 lazy 主要用于级联查询(select) 而 inverse和cascade主要用于级联增加,删除,修改(sava-update,delete)。    ...

hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size 作用

hibernate.jdbc.fetch_size 50 hibernate.jdbc.batch_size 25   这两个选项非常非常非常重要!!!将严重影响Hibernate的...

关于Hibernate中fetch作用描述

"fetch"连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化,这种方法在使用到集合的情况下尤其有用,对于关联和集合来说,它有效的代替了映射文件中的外联接 ...
  • a510750
  • a510750
  • 2017年07月27日 17:46
  • 143

关于Hibernate中fetch作用描述

"fetch"连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化,这种方法在使用到集合的情况下尤其有用,对于关联和集合来说,它有效的代替了映射文件中的外联接 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:fetch = FetchType.EAGER 作用
举报原因:
原因补充:

(最多只允许输入30个字)