建一个学生类
package model;
import java.util.Set;
public class Student {
private Integer id;
private String sname;
/**
* 多对一关系:外键在类中无需声明,取而代之用POJO类型进行声明
*/
private Clazz clazz;
/**
*多对多关系
*/
private Set<Teacher> teacherSet;
/**
* 一对一
*/
private Card card;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}
public Set<Teacher> getTeacherSet() {
return teacherSet;
}
public void setTeacherSet(Set<Teacher> teacherSet) {
this.teacherSet = teacherSet;
}
public Card getCard() {
return card;
}
public void setCard(Card card) {
this.card = card;
}
//重写equals和hascode比较俩对象是否相同
/*
@Override
public boolean equals(Object obj) {
if(this==obj){
return true;
}
Student student = (Student) obj;
if(this.getId()==student.getId()){
return true;
}
return false;
}
@Override
public int hashCode() {
return this.getId()+1000;
}*/
}
配置文件
多个学生对应一个班级,多个学生对应多个老师,一个学生对应一个学生卡
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="model">
<class name="Student" table="STUDENT" lazy="false">
<id name="id" column="ID">
<generator class="increment"></generator>
</id>
<property name="sname" column="SNAME"></property>
<!--多对一关系的映射说明:
name是指Student类中的pojo类型属性
column指的是关联外键
class:属性的类型,完全限定名-->
<many-to-one name="clazz" column="CID" class="Clazz" lazy="false" cascade="save-update" ></many-to-one>
<!--多对多关系的映射说明:
table:表示中间表的名称-->
<set name="teacherSet" table="STU_TEACH" lazy="false">
<!--主动方表到中间表的外键-->
<key column="SID"></key>
<!--Column:中间表到关联表的外键-->
<many-to-many class="Teacher" column="TID"></many-to-many>
</set>
<!--一对一关系的映射说明-->
<one-to-one name="card" class="Card"></one-to-one>
</class>
</hibernate-mapping>
建班级类
package model;
import java.util.Set;
public class Clazz {
private Integer id;
private String cname;
/**
* 一对多关联
*/
private Set<Student> studentSet;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public Set<Student> getStudentSet() {
return studentSet;
}
public void setStudentSet(Set<Student> studentSet) {
this.studentSet = studentSet;
}
}
配置文件
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="model">
<class name="Clazz" table="CLAZZ" lazy="false">
<id name="id" column="ID">
<generator class="increment"></generator>
</id>
<property name="cname" column="CNAME"></property>
<!--一对多关联关系说明:
set标签:集合属性的说明
key标签:对外键说明
class:对集合中元素类型的说明
-->
<!--Cascade:
1.none(默认取值),不支持级联
2.save-update,在保存和更新时进行级联
3.delete,在删除时进行级联
4.all,在增删改时都进行级联-->
<!--
inverse:表示关联关系的维护权要不要交给另一方维护,true表示交出去,false表示本方维护
一方可以设置是否把关联关系维护权交出去,但多方没有这个属性,也hibernate默认,多方肯定要维护外键关系.
一般情况下,最好的做法是让一方不维护关联关系.
-->
<set name="studentSet" cascade="save-update,delete" lazy="false" inverse="true">
<!--外键说明-->
<key column="CID"></key>
<one-to-many class="Student"></one-to-many>
</set>
</class>
</hibernate-mapping>
建一个老师类
package model;
import java.util.Set;
public class Teacher {
private Integer id;
private String tname;
private Set<Student> studentSet;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTname() {
return tname;
}
public void setTname(String tname) {
this.tname = tname;
}
public Set<Student> getStudentSet() {
return studentSet;
}
public void setStudentSet(Set<Student> studentSet) {
this.studentSet = studentSet;
}
}
配置
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="model">
<class name="Teacher" table="TEACHER" lazy="false">
<id name="id" column="ID">
<generator class="increment"></generator>
</id>
<property name="tname" column="TNAME"></property>
<!--多对多关系-->
<set name="studentSet" table="STU_TEACH">
<!--主动方表到中间表的外键-->
<key column="TID"></key>
<!--Column:中间表到关联表的外键-->
<many-to-many class="Student" column="SID"></many-to-many>
</set>
</class>
</hibernate-mapping>
学生卡类
package model;
public class Card {
private Integer id;
private String cardname;
private Student student;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCardname() {
return cardname;
}
public void setCardname(String cardname) {
this.cardname = cardname;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
配置
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="model">
<class name="Card" table="CARD" lazy="false">
<id name="id" column="ID">
<generator class="increment"></generator>
</id>
<property name="cardname" column="CARDNAME"></property>
<!--一对一关系的映射说明-->
<one-to-one name="student" class="Student"></one-to-one>
</class>
</hibernate-mapping>
因为是级联操作所以dao书写比较简单
package dao;
import model.Clazz;
import org.hibernate.Session;
import util.SessionUtil;
public class ClazzDao {
public Clazz selectById(int id){
Session session = SessionUtil.getCurrentSession();
return session.load(Clazz.class, id);
}
public void insert(Clazz clazz){
Session session = SessionUtil.getCurrentSession();
session.save(clazz);
}
public void delete(Clazz clazz){
Session session = SessionUtil.getCurrentSession();
session.delete(clazz);
}
public void update(Clazz clazz){
Session session = SessionUtil.getCurrentSession();
session.update(clazz);
}
}
package dao;
import model.Student;
import org.hibernate.Session;
import util.SessionUtil;
public class StudentDao {
public Student selectById(int id){
Session session = SessionUtil.getCurrentSession();
return session.load(Student.class, id);
}
public void insert(Student student){
Session session = SessionUtil.getCurrentSession();
session.save(student);
}
}
service
package service;
import dao.ClazzDao;
import dao.StudentDao;
import jdk.nashorn.internal.runtime.UserAccessorProperty;
import model.Clazz;
import model.Student;
import org.hibernate.Session;
import org.hibernate.Transaction;
import util.SessionUtil;
public class ClazzService {
ClazzDao dao = new ClazzDao();
public Clazz findById(int id){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
Clazz clazz = dao.selectById(id);
tx.commit();
return clazz;
}
public void save (Clazz clazz){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
dao.insert(clazz);
tx.commit();
}
public void remove (Clazz clazz){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
dao.delete(clazz);
tx.commit();
}
public void modify (Clazz clazz){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
dao.update(clazz);
tx.commit();
}
}
package service;
import dao.StudentDao;
import model.Student;
import org.hibernate.Session;
import org.hibernate.Transaction;
import util.SessionUtil;
public class StudentService {
StudentDao dao = new StudentDao();
public Student findById(int id){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
Student student = dao.selectById(id);
tx.commit();
return student;
}
public void save(Student student){
Session session = SessionUtil.getCurrentSession();
Transaction tx = session.beginTransaction();
dao.insert(student);
tx.commit();
}
}
测试班级级联学生操作
package test;
import model.Clazz;
import model.Student;
import org.hibernate.Session;
import org.junit.Test;
import service.ClazzService;
import service.StudentService;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class ClazzTest {
ClazzService service = new ClazzService();
StudentService service2 = new StudentService();
/**
* 新增加一个班级,同时向班级中添加两个学生
* Hibernate的级联操作(Cascade),Hibernate默认不支持级联操作
*
* 从一方进行级联操作时,会发送额外的update语句去维护外键关系(关联关系)
*/
@Test
public void testSave() {
Clazz clazz = new Clazz();
clazz.setCname("java四班");
Student student1 = new Student();
student1.setSname("aaaa");
Student student2 = new Student();
student2.setSname("bbbb");
Set<Student> set = new HashSet<Student>();
set.add(student1);
set.add(student2);
//对像间关系维护
clazz.setStudentSet(set);
service.save(clazz);
}
/**
* 删除一个班级,同时删除班级中的所有学生(尽量使用逻辑删除,不用物理删除)
*/
@Test
public void testRemove() {
Clazz clazz = new Clazz();
clazz.setId(4);
Student student1 = new Student();
student1.setId(9);
Student student2 = new Student();
student2.setId(10);
Set<Student> set = new HashSet<Student>();
set.add(student1);
set.add(student2);
//对像间关系维护
clazz.setStudentSet(set);
service.remove(clazz);
}
/**
* 如果学生的ID相同,在逻辑上就认为他们是同一个对像
*/
@Test
public void testModify() {
Clazz clazz = service.findById(4);
//通过重写equals()和hashcode()方法判断对像相等
/* Student student = new Student();
student.setId(10);
clazz.getStudentSet().remove(student);
*/
/* System.out.println(clazz.getStudentSet().size());
//集合不能for循环删除操作!!!!!!会报并发异常
for (Student student : clazz.getStudentSet()) {
if (student.getId() == 10) {
clazz.getStudentSet().remove(student);
}
}
System.out.println(clazz.getStudentSet().size());*/
Iterator<Student>iterator = clazz.getStudentSet().iterator();
while(iterator.hasNext()){
Student student = iterator.next();
if(student.getId()==10){
iterator.remove();
}
}
service.modify(clazz);
}
}
学生级联班级操作
package test;
import model.Clazz;
import model.Student;
import org.junit.Test;
import service.StudentService;
public class StudentTest {
StudentService service = new StudentService();
/**
* 增加两个学生,并添加到一个新的班级中
*
* 默认情况下:默认情况下,多方和一方都会发送update语句去维护外键关系,
* 在一方有inverse属性,通常把一方的inverse设置为true,即交出关联关系维护权,
* 多方没有inverse属性,hibernate要求多方必须维护外键关系.
* 这样做的好外是,当从多方进行操作时,会减少update语句(对关联关系维护的update语句)
*/
@Test
public void testSave(){
Clazz clazz = new Clazz();
clazz.setCname("java五班");
Student student1 = new Student();
student1.setSname("cccc");
Student student2 = new Student();
student2.setSname("dddd");
//维护对像间关系
student1.setClazz(clazz);
student2.setClazz(clazz);
service.save(student1);
service.save(student2);
}
/**
* 多对多查询:查询一个学生,把其授课老师会部关联出来
*/
@Test
public void testFindById(){
Student student = service.findById(1);
System.out.println(student.getTeacherSet());
System.out.println(student.getCard());
}
}