【hibernate框架】一对多(多对一)双向CRUD-Fetch2

继续对Fetch注解进行测试

User.java:

package cn.edu.hpu.one2many;


import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name="m_user")
public class User {
	private int id;
	private String name;
	private Group group;
	
	//只要有双向就要指定制定一个属性(mapedby)
	//不指定的话会有两个相同的字段产生
    @ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY)
	public Group getGroup() {
		return group;
	}
	public void setGroup(Group group) {
		this.group = group;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

Group.java:

package cn.edu.hpu.one2many;


import java.util.HashSet;
import java.util.Set;


import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name="m_group")
public class Group {
	private int id;
	private String name;
	private Set<User> users=new HashSet<User>();
	//选择set的原因是因为，set互相之间不会有重复的
	//跟数据库模型比较匹配
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@OneToMany(mappedBy="group",
		cascade={CascadeType.ALL},
		fetch=FetchType.EAGER
	)
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
	
}

如果在User里面的Group上设置fetch=FetchType.LAZY

 

@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY)
	public Group getGroup() {
		return group;
	}

那么此时就不会取出group_id

虽然是LAZY，但是不代表不会取，那么什么时候给取呢？

比如说，在这里用到了

Sysotem.out.println(u.getGroup().getName());

这个时候会取出相应的group_id

在getUser的时候没有取group_id，当需要用的时候采取。

以上必须在session提交事务之前去做，session关闭之后就

不能这么干了。

原理：数据库里有两条记录，A和B记录(A和B有级联)。然后

我们getA的时候，会把这个对象拿到内存里，但是如果A到B的

关系导航为LAZY的话，知道我们用到getB的时候，他才会把这个

对象放到内存里，但是如果此时session已经关闭了，肯定就拿不

出来了，会报错(session找不到)。

Load方式:

@Test
public void testLoadUser(){
	sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory


();
	Session s=sessionFactory.openSession();
	s.beginTransaction();
	User u=(User)s.load(User.class,3);
	System.out.println(u.getGroup().getName());
    s.getTransaction().commit();
}

(此时在User里面的Group上设置的是fetch=FetchType.LAZY)

输出的sql语句：

Hibernate: 

     select

         user0_.id as id1_0_,

         user0_.group_id as group3_1_0_,

         user0_.name as name1_0_ 

     from

         m_user user0_ 

     where

         user0_.id=?

 Hibernate: 

     select

         group0_.id as id0_1_,

         group0_.name as name0_1_,

         users1_.group_id as group3_0_3_,

         users1_.id as id3_,

         users1_.id as id1_0_,

         users1_.group_id as group3_1_0_,

         users1_.name as name1_0_ 

     from

         m_group group0_ 

     left outer join

         m_user users1_ 

             on group0_.id=users1_.group_id 

     where

         group0_.id=?

 g1

使用load的时候，会先发一条语句取user，然后发一句语句关联group，取出group_id,

和前面没什么区别

(如果在User里面的Group上设置的是fetch=FetchType.EAGER/默认)

Hibernate: 

     select

         user0_.id as id1_1_,

         user0_.group_id as group3_1_1_,

         user0_.name as name1_1_,

         group1_.id as id0_0_,

         group1_.name as name0_0_ 

     from

         m_user user0_ 

     left outer join

         m_group group1_ 

             on user0_.group_id=group1_.id 

     where

         user0_.id=?

 Hibernate: 

     select

         users0_.group_id as group3_0_1_,

         users0_.id as id1_,

         users0_.id as id1_0_,

         users0_.group_id as group3_1_0_,

         users0_.name as name1_0_ 

     from

         m_user users0_ 

     where

         users0_.group_id=?

 g1

发现先关联Group_id，取出Group_id，之后才取出user

原因：

先说说EAGER/默认的情况，设断点查看情况，可以看看输出的

sql语句，前面关联group的时候，明明已经取出了user，但是

为什么后面还要取出user呢？也就是说，在取group得时候，有

没有必要再一次取出user呢？很显然是不需要的。为什么呢？

因为我们在Group那边设了EAGER，我们要把它改成LAZY/默认，

看看输出的sql语句：

Hibernate: 

     select

         user0_.id as id1_1_,

         user0_.group_id as group3_1_1_,

         user0_.name as name1_1_,

         group1_.id as id0_0_,

         group1_.name as name0_0_ 

     from

         m_user user0_ 

     left outer join

         m_group group1_ 

             on user0_.group_id=group1_.id 

     where

         user0_.id=?

 g1

这个时候只取了一次user。

总结，取的时候在一边设置EAGER就可以了，不要在两边

都设EAGER。

JPA做的就很好，在多对一方默认的就是EAGER，在一对多

设置的是LAZY，所以一般用默认的就好了。或者两边全

设成LAZY。

在XML里面也有对此问题的控制，是在set上加inverse=true，

inverse是逆转的意思，就是说关联关系在对方那里设定。

取我就不要拿对方，取对方就一定要拿我。

样例：

<set name="users" inverse="true">
    <key column="groupId"></key><!-- 指定关联字段的名字叫什么 -->
    <one-to-many class="cn.edu.hpu.one2many.User"/>
</set>

接下来我们继续测试User一方fetch=FetchType.LAZY和Group一方

的fetch=FetchType.EAGER，的情况。

Load的时候

@Test
public void testLoadUser(){
	sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory


();
	Session s=sessionFactory.openSession();
	s.beginTransaction();
	User u=(User)s.load(User.class,3);
	System.out.println(u.getGroup().getName());
    s.getTransaction().commit();
}

输出的sql语句：

Hibernate: 

     select

         user0_.id as id1_0_,

         user0_.group_id as group3_1_0_,

         user0_.name as name1_0_ 

     from

         m_user user0_ 

     where

         user0_.id=?

 Hibernate: 

     select

         group0_.id as id0_1_,

         group0_.name as name0_1_,

         users1_.group_id as group3_0_3_,

         users1_.id as id3_,

         users1_.id as id1_0_,

         users1_.group_id as group3_1_0_,

         users1_.name as name1_0_ 

     from

         m_group group0_ 

     left outer join

         m_user users1_ 

             on group0_.id=users1_.group_id 

     where

         group0_.id=?

 g1

发现是先取出user，之后取出关联的group_id，那为什么

第二次会再次取出user？因为group的fetch是EAGER，所以

将与group关联的user取出来了。

如果将roup的fetch设置成LAZY，输出的sql语句是：

发现取group的时候没有取出多余的user。

Hibernate: 

     select

         user0_.id as id1_0_,

         user0_.group_id as group3_1_0_,

         user0_.name as name1_0_ 

     from

         m_user user0_ 

     where

         user0_.id=?

 Hibernate: 

     select

         group0_.id as id0_0_,

         group0_.name as name0_0_ 

     from

         m_group group0_ 

     where

         group0_.id=?

 g1

细节是不是太多？其实学hibernate，最实际的是要记住那些

“最佳实践”，即一般情况下我们怎么做，然后写对应程序就

行了。一般情况下我们设多对一方是EAGER，在一对多的是LAZY。

在特殊情况下会有一对多的是EAGER。只有在一对多，多的那一方

本身数量不是那么多，数量很少。实际上的例子：一个版块里面有

好多帖子，这个就是一对多，在这种情况下一对多就不能用EAGER。

那什么情况下能用EAGER呢？

打比方说一个用户有好多不同的权限，我想取出来，可以，顶多几十个

权限，取出来的好处就是权限给放内存了，我们想查看的时候不需要

再次去取了，直接可以拿来看。

还有一种情况，树状结构，公司-分公司-区域公司-部门-小组，这些我们

都可以直接拿到缓存中去，下次用直接读出来。