继续对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
