【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语句是：
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
发现取group的时候没有取出多余的user。


细节是不是太多？其实学hibernate，最实际的是要记住那些
“最佳实践”，即一般情况下我们怎么做，然后写对应程序就
行了。一般情况下我们设多对一方是EAGER，在一对多的是LAZY。


在特殊情况下会有一对多的是EAGER。只有在一对多，多的那一方
本身数量不是那么多，数量很少。实际上的例子：一个版块里面有
好多帖子，这个就是一对多，在这种情况下一对多就不能用EAGER。
那什么情况下能用EAGER呢？
打比方说一个用户有好多不同的权限，我想取出来，可以，顶多几十个
权限，取出来的好处就是权限给放内存了，我们想查看的时候不需要
再次去取了，直接可以拿来看。
还有一种情况，树状结构，公司-分公司-区域公司-部门-小组，这些我们

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

转载请注明出处:http://blog.csdn.net/acmman