hibernate一对多多对多映射(注解)

4,一对多多对一单向关联
–@ManyToOne:在多的一方维护记录(在tuser2表维护记录)
(1)表结构:tuser2表的groupid字段关联tgroup表的主键id,tuser2是多的一方,tgroup是一的一方:
hibernate一对多多对多映射(注解)_第1张图片
hibernate一对多多对多映射(注解)_第2张图片
(2)bean:

@Entity
@Table(name="tuser2")
public class TUser2 implements Serializable{
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @ManyToOne  //代表是一对多关联
    @JoinColumn(name="groupid")  //关联的字段是groupid
    private Group group;
...get,set...
}
//Group不需要写任何东西
@Entity
@Table(name="tgroup")
public class Group implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;
...get,set...
}

(3)测试
–保存记录

Group group=new Group();
group.setName("manager");
TUser2 user=new TUser2();
user.setName("hyman");
user.setGroup(group);
session.save(group);
session.save(user);

–获取记录(此种写法只能从user一方获取group一方的数据)

TUser2 user=(TUser2)session.get(TUser2.class,1);
System.out.println(user.getName());
System.out.println(user.getGroup().getName());

–更新记录

Group group=new Group();
group.setName("name2");
TUser2 user=(TUser2)session.get(TUser2.class, 1);
user.setGroup(group);
session.save(group);
session.save(user);

–删除记录

Group group=(Group)session.get(Group.class, 5);
session.delete(group);
//如果tuser表中存在groupid为5的记录,后台会报错,因为tuser表中引用了groupid,因此不能删除group

TUser2 user=(TUser2)session.get(TUser2.class, 1);
session.delete(user);

–如果在@ManyToOne后面设置了cascade=CascadeType.ALL,那么就有两种情况:
(1)tuser2不存在相同的groupid的其他记录,此时会删除tuser2表中id为1的记录,也会级联删除group表中相应的记录;
(2)tuser2表存在相同的groupid的其他记录,后台会报错,无法删除。
如果没有设置cascade=CascadeType.ALL,则会删除tuser2表的记录,不会删除group表的记录。

–@OneToMany:在一的一方维护记录(在group表维护记录)
(1)表结构和上面的一样;
(2)bean:

@Entity
@Table(name="tgroup")
public class Group implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    @JoinColumn(name="userid")  //意味着在user表会多出一列userid,如果不设置这个属性,那么会多出一个中间表,表中两个字段分别是group和user表的id
    private Set users;
...get,set...
}
@Entity
@Table(name="tuser2")
public class TUser2 implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;
...get,set...
}

(3)测试:
–保存记录

TUser2 user21=new TUser2();
user21.setName("name1");
TUser2 user22=new TUser2();
user22.setName("name2");
Set set=new HashSet<>();
set.add(user21);
set.add(user22);
Group group=new Group();
group.setName("groupname");
group.setUsers(set);
session.save(group);

–获取记录

Group group=(Group)session.get(Group.class, 9);
Set users=group.getUsers();
Iterator us=users.iterator();
while(us.hasNext()){
    TUser2 user=(TUser2)us.next();
    System.out.println(user.getName());
}

//只能从group一方获取user一方的数据,而不能从user一方获取group一方的数据

–更新记录

Group group=(Group)session.get(Group.class, 9);
group.setName("updatedName");
session.save(group);

–删除记录

Group group=(Group)session.get(Group.class, 9);
session.delete(group);

如果在@OneToMany后面设置了cascade=CascadeType.ALL,那么会级联删除user表中的记录,如果没有设置,那么会清空user表的groupid字段,然后删除group表记录。

5,一对多多对一双向关联
上面的一对多或多对一的关联都有一个不足之处,就是只能从一方获取另一方的数据,双向关联下,就可以从任何一方获取另一方的数据了。
(1)表结构:
hibernate一对多多对多映射(注解)_第3张图片
hibernate一对多多对多映射(注解)_第4张图片
(2)bean:在一的一方需要设置@OneToMany和mappedby,在多的一方需要设置@ManyToOne和@JoinColumn:

@Entity
@Table(name="tgroup")
public class Group implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY,mappedBy="group")
    private Set users;
...set,get...
}
@Entity
@Table(name="tuser2")
public class TUser2 implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @ManyToOne(fetch=FetchType.LAZY,cascade=CascadeType.ALL)
    @JoinColumn(name="groupid") //会在user表中多出一列:groupid,如果不设置这个属性,数据库会新增一个中间表维护user和group的记录
    private Group group;
    ...set,get...
}

(3)测试:
–保存记录

TUser2 user21=new TUser2();
user21.setName("name1");
TUser2 user22=new TUser2();
user22.setName("name2");
Set<TUser2> set=new HashSet<>();
set.add(user21);
set.add(user22);

Group group=new Group();
group.setName("groupname2");
group.setUsers(set);
user21.setGroup(group);//必须,否则user表groupid字段为空
user22.setGroup(group);//必须,否则user表groupid字段为空
session.save(group);

–获取记录
(1)从一的一方获取多的一方的记录

Group group=(Group)session.get(Group.class, 9);
Set users=group.getUsers();
Iterator us=users.iterator();
while(us.hasNext()){
    TUser2 user=(TUser2)us.next();
    System.out.println(user.getName());
}

(2)从多的一方获取一的一方的记录:

TUser2 user=(TUser2)session.get(TUser2.class, 18);
System.out.println(user.getGroup().getName());

–更新记录

Group group=new Group();
group.setName("newGroup");  
TUser2 user=(TUser2)session.get(TUser2.class, 18);
user.setGroup(group);
session.save(user);//会自动保存新增的group表的记录

–删除记录

Group group=(Group)session.get(Group.class, 13); session.delete(group);//会级联删除user表中的记录

TUser2 user=(TUser2)session.get(TUser2.class, 3); session.delete(user);//会级联删除group中的相关的记录和user表中的相同groupid的记录

6,多对多单向关联
(1)表:
hibernate一对多多对多映射(注解)_第5张图片
hibernate一对多多对多映射(注解)_第6张图片
(2)bean:只在一方维护关系就好,例如在class表一方维护关系,teacher表一方不做处理

@Entity
@Table(name="class")
public class Clazz implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    @JoinTable(
        name="class_teacher",//中间表名
        joinColumns={@JoinColumn(name="classid")},//当前对象id在中间表的列名
        inverseJoinColumns={@JoinColumn(name="teacherid")}//关联的另一个表在中间表的列名
    )
    private Set teachers;
...set,get...
}
@Entity
@Table(name="teacher")
public class Teacher implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;
...set,get...
}

(3)测试:
–保存记录

Clazz clazz1=new Clazz();
Clazz clazz2=new Clazz();
clazz1.setName("class1");
clazz2.setName("class2");
Teacher teacher1=new Teacher();
Teacher teacher2=new Teacher();
Teacher teacher3=new Teacher();
teacher1.setName("teacher1");
teacher2.setName("teacher2");
teacher3.setName("teacher3");
Set teacher1s=new HashSet<>();
Set teacher2s=new HashSet<>();     
teacher1s.add(teacher1);
teacher1s.add(teacher2);
teacher2s.add(teacher2);
teacher2s.add(teacher3);
clazz1.setTeachers(teacher1s);
clazz2.setTeachers(teacher2s);  
session.save(clazz1);//会级联插入class表,teacher表,中间表
session.save(clazz2);//会级联插入class表,teacher表,中间表

–获取记录:由于只在class的乙方做了维护,因此只能从class表记录获取teacher表记录

Clazz clazz=(Clazz)session.get(Clazz.class, 1);
Set teachers=clazz.getTeachers();
Iterator iterator=teachers.iterator();
while(iterator.hasNext()){
    Teacher teacher=iterator.next();
    System.out.println(teacher.getName());
}

–更新记录,更新id为1的class的teachers信息

Clazz clazz=(Clazz)session.get(Clazz.class, 1);
Teacher teacher=(Teacher)session.get(Teacher.class, 1);
Set teachers=new HashSet<>();
teachers.add(teacher);
clazz.setTeachers(teachers);
session.save(clazz);//只更新中间表的id对应关系,插入新记录,删除失效的记录

–删除记录

Clazz clazz=(Clazz)session.get(Clazz.class, 2);
session.delete(clazz);//删除class表记录,删除中间表记录,删除teacher表记录
//注意:如果teacher表中不存在和class对应的其他记录,那么teacher表的相关记录会被删除,如果teacher表中存在和class对应的其他记录,后台会报错,无法删除。

7,多对多双向关联
上面的多对多但相关联有一个不足就是只能从class来维护teacher表的记录,双向关联则可以从任何一方维护另一方的记录:
(1)表结构不变;
(2)bean:class不变,teacher只要设置mappedby属性即可:

@Entity
@Table(name="teacher")
public class Teacher implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    @Column(name="name")
    private String name;

    @ManyToMany(mappedBy="teachers",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    private Set clazzs;
...set,get...
}

(3)测试:
–保存记录
双向关联并不是真的互相维护,还是存在控制权的问题,这里就把控制权交给了class。因此,写法和单向关联是一样的。

–获取记录
在双向关联中,既可以通过class来获取teacher的记录,也可以通过teacher获取class的记录:

Clazz clazz=(Clazz)session.get(Clazz.class, 1);
Set teachers=clazz.getTeachers();
Iterator iterator=teachers.iterator();
while(iterator.hasNext()){
    Teacher teacher=iterator.next();
    System.out.println(teacher.getName());
}

Teacher teacher=(Teacher)session.get(Teacher.class, 5);
Set clazzs=teacher.getClazzs();
Iterator iterator2=clazzs.iterator();
while(iterator2.hasNext()){
Clazz clazz2=iterator2.next();
System.out.println(clazz2.getName());
}

–更新记录
双向关联并不是真的互相维护,还是存在控制权的问题,这里就把控制权交给了class。因此,写法和单向关联是一样的。

–删除记录

Teacher teacher=(Teacher)session.get(Teacher.class, 5);
session.delete(teacher);

//会级联并且一层一层删除。例如:
hibernate一对多多对多映射(注解)_第7张图片
hibernate一对多多对多映射(注解)_第8张图片
hibernate一对多多对多映射(注解)_第9张图片
首先会删除中间表teacherid=17的记录;然后删除teacher表id=17的记录,删除class表相关的记录(不存在与其他teacherid关联的记录),然后删除中间表中classid=6和7的记录,删除class表中id为6和7的记录,删除teacher表中和classid 6,7关联的记录。所以,删除之后的结果是:
hibernate一对多多对多映射(注解)_第10张图片
hibernate一对多多对多映射(注解)_第11张图片
hibernate一对多多对多映射(注解)_第12张图片
因此,在多对多关联的时候,一定要想清楚自己的目的,不要盲目使用cascadeType.all。否则会删除一些本来不想删除的记录。

你可能感兴趣的:(hibernate基础)