关联关系的CRUD（增删改查）
一、增加数据
1、User和Group的关联关系：User对Group是Many-To-One，Group对User是One-To-Many
2、默认情况下，不会自动保存尚未保存关联的对象。因为对象没有保存的情况下，对象是Transient状态，此时数据库中并没有存储，所以获取不到该对象。
3、使用级联cascade方式可以自动将关联的对象进行存储。其取值有ALL,PERSIST,REFRESH,REMOVE,DETACH,MERGE这几种取值。其中，ALL表示在任何情况下进行级联操作。PERSIST表示持久化的时候进行级联。
3、实验1（只保存User对象的情况下，自动保存Group）
Group.java
package com.zgy.hibernate.model;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_group")
public class Group {
private int id;
private String name;
private Set<User> users = new HashSet<User>();
@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")
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
}
4、User.java
package com.zgy.hibernate.model;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User {
private int id;
private String name;
private 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;
}
@ManyToOne(cascade={CascadeType.ALL})
public Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
5、JUnit测试
package com.zgy.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class ORMapppingTest {
public static SessionFactory sf = null;
@BeforeClass
public static void beforeClass(){
Configuration configure =new Configuration().configure();
new SchemaExport(configure).create(true, true);
sf = configure.buildSessionFactory();
}
@Test
public void testSaveUser() {
User user = new User();
user.setName("user1");
Group group = new Group();
group.setName("group");
user.setGroup(group);
Session s = sf.openSession();
s.beginTransaction();
//s.save(group);
s.save(user);
s.getTransaction().commit();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}
6、结果：
（1）不保存group的情况下，运行JUnit会报错
（2）在User.java中加入@ManyToOne(cascade={CascadeType.ALL})，那么再次运行JUnit时将不会再报错。
（3）查看生成的sql语句：
Hibernate: create table t_group (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: create table t_user (id integer not null auto_increment, name varchar(255), group_id integer, primary key (id))
Hibernate: alter table t_user add constraint FK_e5f24mh6aryt9hsy99oydps6g foreign key (group_id) references t_group (id)
Hibernate: insert into t_group (name) values (?)
Hibernate: insert into t_user (group_id, name) values (?, ?)
7、实验2（仅保存Group对象的情况下，自动保存User）
（1）修改Group.java
package com.zgy.hibernate.model;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.CascadeType;
@Entity
@Table(name="t_group")
public class Group {
private int id;
private String name;
private Set<User> users = new HashSet<User>();
@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}
)
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
}
（2）去除User.java中加入的cascade={CascadeType.ALL}这段Annotation
package com.zgy.hibernate.model;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User {
private int id;
private String name;
private 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;
}
@ManyToOne
public Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
（3）测试
要建立User和Group两者的双向关系，并且只保存Group对象
package com.zgy.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class ORMapppingTest {
public static SessionFactory sf = null;
@BeforeClass
public static void beforeClass(){
Configuration configure =new Configuration().configure();
new SchemaExport(configure).create(true, true);
sf = configure.buildSessionFactory();
}
@Test
public void testSaveUser() {
User user1 = new User();
user1.setName("user1");
User user2 = new User();
user2.setName("user2");
Group group = new Group();
group.setName("group1");
group.getUsers().add(user1);
group.getUsers().add(user2);
user1.setGroup(group);
user2.setGroup(group);
Session s = sf.openSession();
s.beginTransaction();
s.save(group);
//s.save(user);
s.getTransaction().commit();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}
（4）观察结果
生成的SQL语句：
create table t_group (
id integer not null auto_increment,
name varchar(255),
primary key (id)
)
create table t_user (
id integer not null auto_increment,
name varchar(255),
group_id integer,
primary key (id)
)
alter table t_user
add constraint FK_e5f24mh6aryt9hsy99oydps6g
foreign key (group_id)
references t_group (id)
查看数据库中的信息：
select * from t_group;
select * from t_user;
数据保存成功。
8.双向关系在程序中要设置双向关联
9.双向关系要使用mappedBy
二、读取数据
还是一上面的例子做说明
1、读取User数据，是否能读取Group中的数据？
2、ManyToOne默认的情况下是可以取出One里的数据的，也就是说，获取User对象的数据的时候，是可以获取Group对象中的数据的。
3、读取Group数据的时候，是否能读取User中的数据？
4、cascade并不会影响读取，fetch管理读取
5、fetch的属性是Enum类型，分别为LAZY,EAGER。取值为LAZY时，不会获取User中的数据；取值为EAGER时，可以获取User的数据
6、JPA接口默认为一对多为Lazy，多对一为Eager，但是Hibernate反向工程生成Entity时，多对一为Lazy，需要手动改为Eager。
7、实验：
8、Group.java
package com.zgy.hibernate.model;
import java.util.HashSet;
import java.util.Set;
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;
import javax.persistence.CascadeType;
@Entity
@Table(name="t_group")
public class Group {
private int id;
private String name;
private Set<User> users = new HashSet<User>();
@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;
}
}
9、User.java
package com.zgy.hibernate.model;
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="t_user")
public class User {
private int id;
private String name;
private 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;
}
@ManyToOne(cascade={CascadeType.ALL},
fetch=FetchType.LAZY
)
public Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
10、JUnit测试
@Test
public void testGetUser() {
testSaveGroup();
Session s = sf.openSession();
s.beginTransaction();
User u = (User)s.get(User.class, 1);
s.getTransaction().commit();
}
@Test
public void testGetGroup() {
testSaveGroup();
Session s = sf.openSession();
s.beginTransaction();
Group g = (Group)s.get(Group.class, 1);
s.getTransaction().commit();
for(User u : g.getUsers()){
System.out.println(u.getName());
}
}
11、结论
（1）将User设置为@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY的时候，将不再取得Group的属性。在session关闭前，如果使用到Group属性还是可以手动取得。Session关闭后将去得到Group的属性。
（2）@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.LAZY的时候，先取出的是User,再取出的是两者之间的关系。
Hibernate: select user0_.id as id1_1_0_, user0_.group_id as group_id3_1_0_, user0_.name as name2_1_0_ from t_user user0_ where user0_.id=?
Hibernate: select group0_.id as id1_0_0_, group0_.name as name2_0_0_, users1_.group_id as group_id3_0_1_, users1_.id as id1_1_1_, users1_.id as id1_1_2_, users1_.group_id as group_id3_1_2_, users1_.name as name2_1_2_ from t_group group0_ left outer join t_user users1_ on group0_.id=users1_.group_id where group0_.id=?
（3）@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER的时候，先取出的是关系，然后取出的是User
Hibernate: select user0_.id as id1_1_0_, user0_.group_id as group_id3_1_0_, user0_.name as name2_1_0_, group1_.id as id1_0_1_, group1_.name as name2_0_1_ from t_user user0_ left outer join t_group group1_ on user0_.group_id=group1_.id where user0_.id=?
Hibernate: select users0_.group_id as group_id3_0_0_, users0_.id as id1_1_0_, users0_.id as id1_1_1_, users0_.group_id as group_id3_1_1_, users0_.name as name2_1_1_ from t_user users0_ where users0_.group_id=?
（4）两边都设置EAGER的时候，会发出两次select语句。所以，一般是在一遍设置EAGER就可以了。
三、更新数据
1.cascade={CascadeType.ALL}的时候，默认会级联。因此在修改User属性的时候，会修改Group的属性。例如：
@Test
public void testUpdateUser() {
testSaveGroup();
Session s = sf.openSession();
s.beginTransaction();
User u = (User)s.load(User.class, 1);
u.setName("user");
u.getGroup().setName("ggg");
s.getTransaction().commit();
}
此处修改了Group的name属性，因此，在更新User对象的时候，会更新Group对象的属性。
如下SQL语句说明了以上观点：
Hibernate: update t_user set group_id=?, name=? where id=?
Hibernate: update t_group set name=? where id=?
2.在User.java中，配置cascade={CascadeType.MERGE}，此时在JUnit中，使用merge()方法后，将会产生级联，即只保存User对象的情况下，会自动保存Group对象。使用merge()来合并两个session中的同一对象。
以下是JUnit中的测试方法
@Test
public void testUpdateUser() {
testSaveGroup();
Session s = sf.getCurrentSession();
s.beginTransaction();
User u = (User)s.get(User.class, 1);
s.getTransaction().commit();
u.setName("u");
u.getGroup().setName("g");
Session s2 = sf.getCurrentSession();
s2.beginTransaction();
s2.merge(u);
s2.getTransaction().commit();
}
同理，设置cascade的值的时候，在session中使用对应的方法将可以实现级联操作。
四、删除数据
1、ORMapping编程模型:
|映射模型
|以Hibernate为例
|jpa annotation
|Hibernate annotation extension
|Hibernate xml
|jpa xml
|接口编程
|jpa编程接口
|Hibernate
2、@Test
public void testDeleteUser() {
testSaveGroup();
Session s = sf.openSession();
s.beginTransaction();
User u = (User)s.load(User.class, 1);
s.delete(u);
s.getTransaction().commit();
}
如下的测试方法会删除User和Group中的所有数据。原因是因为两者是级联关系。User.java中设置的@ManyToOne(cascade={CascadeType.ALL}，Group.java中设置的是@OneToMany(mappedBy="group",
cascade={CascadeType.ALL}，所以删除User的时候会关联到该User对象的Group属性，从而删除该Group属性，而Group属性又关联了User属性，所以又会删除User的内容，从而导致了删除了两张表中的全部内容。
3.解决如上的问题的方法是消除关联关系，再进行删除。
@Test
public void testDeleteUser() {
testSaveGroup();
Session s = sf.openSession();
s.beginTransaction();
User u = (User)s.load(User.class, 1);
u.setGroup(null);
s.delete(u);
s.getTransaction().commit();
}
查看生成的SQL语句：
Hibernate: delete from t_user where id=?
还有一种方式就是使用HQL语句：
s.createQuery("delete from User where u.id = 1").executeUpdate();
也可以达到效果。
4.想要消除关联关系，先设定关系为null，在删除对应的记录。如果不删除记录，那么该记录就会变为垃圾数据。
