这个是hibernate的一对多建表实例：一的一端是部门（Department），对的一端是员工（Employee），下面贴上成员源代码：其中@mappedBy是加在@OneToMany一端，并且它的name属性=多的那一端（N端）属性是一的那一端的属性名，mappedBy是定义在Department类中,即Department类不负责维护级联关系.即维护者是Employee类
Department类：
package com.javabean; import java.io.Serializable; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; @SuppressWarnings("serial") @Entity @Table(name="department") public class Department implements Serializable{ @Id @GeneratedValue(strategy=GenerationType.AUTO) private int id; @Column(name="name") private String name; @OneToMany(mappedBy="depart",cascade=CascadeType.ALL) private Set<Employee> emps; 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; } public Set<Employee> getEmps() { return emps; } public void setEmps(Set<Employee> emps) { this.emps = emps; } }
//Employee类：
package com.javabean; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.Table; @SuppressWarnings("serial") @Entity @Table(name="employee") public class Employee implements Serializable { @Id @GeneratedValue(strategy=GenerationType.AUTO) private int id; @Column(name="name") private String name; @ManyToOne @JoinColumn(name="depart_id") private Department depart; 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; } public Department getDepart() { return depart; } public void setDepart(Department depart) { this.depart = depart; } }
补充知识：
注释的含义学习：
双向一对一映射
class Card{
@OneToOne(optional=false,cascade={CascadeType.MERGE,CascadeType.REMOVE},mappedBy="card",fetch=FetchType.EAGER)
Person getPerson(){}
}
mappedBy 单向关系不需要设置该属性，双向关系必须设置，避免双方都建立外键字段
数据库中1对多的关系，关联关系总是被多方维护的即外键建在多方，我们在单方对象的@OneToMany(mappedby=" ")
把关系的维护交给多方对象的属性去维护关系
对于mappedBy复习下：
a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；
b) mappedBy标签一定是定义在the owned side(被拥有方的)，他指向the owning side(拥有方)；
c) 关系的拥有方负责关系的维护，在拥有方建立外键。所以用到@JoinColumn
d)mappedBy跟JoinColumn/JoinTable总是处于互斥的一方
cascade 设定级联关系，这种关系是递归调用
可以是CascadeType.PERSIST（级联新建）CascadeType.REMOVE（级联删除）CascadeType.REFRESH（级联刷 新）CascadeType.MERGE（级联更新）CascadeType.ALL（全部级联）
fetch 预加载策略和@Basic差不多FetchType.LAZY，FetchType.EAGER
optional 设置关联实体是否必须存在false必须存在 即不是随意的，true关联实体可以不存在即是随意 的。
比如Card（身份证）中的person（人）optional为false意味有身份证就必须有人对应，但是在实体Person中Card的optional为true意味有人不一定要有身份证。
@JoinColumn(name="cardid",referencedColumnName="cid")设置外键，
name该外键的字段名，referencedColumnName外键对应主表的字段
因为card和person是双向关系而在card端已经mappedBy="card"设定card为主表，
所以要在person端的关联项设置外键@JoinColumn
双向一对多与多对一 ，单向一对多与多对一 @OneToMany @ManyToOne 其它的可以参考上面的
双向多对多（实际开发中多对多通常是双向的）
@JoinTable(
name="teacher_student",
joinColumns={@JoinColumn(name="teacher_id",referencedColumnName="tid")},
inverseJoinColumns={@JoinColumn(name="student_id",referencedColumnName="sid")}
)
old：
@ManyToMany 注释：表示此类是多对多关系的一边，mappedBy 属性定义了此类为双向关系的维护端，注意：mappedBy 属性的值为此关系的另一端的属性名。
例如，在Student类中有如下方法：
被控方:
@ManyToMany(fetch = FetchType.LAZY, mappedBy = "students")
public Set<Teacher> getTeachers() {
return teachers;
}
那么这里的“students”就是Teachers的一个属性，通常应该是这样的：
Set<Student> students;
另一端的getStudents方法如下所示：
主控方:
@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
@
JoinTable(name = "Teacher_Student",
joinColumns = {@JoinColumn(name = "Teacher_ID", referencedColumnName = "teacherid")},
inverseJoinColumns = {@JoinColumn(name = "Student_ID", referencedColumnName ="studentid")})
public Set<Student> getStudents() {
return students;
}
@ManyToMany 注释表示Teacher 是多对多关系的一端。@
JoinTable 描述了多对多关系的数据表关系。name 属性指定
中间表名称，joinColumns 定义
中间表与Teacher 表的外键关系。上面的代码中，
中间表Teacher_Student的Teacher_ID 列是Teacher 表的主键列对应的外键列，inverseJoinColumns 属性定义了
中间表与另外一端(Student)的外键关系。
可以通过上面的定义看到有三个表学生表--老师表--老师学生中间表
以上提到主控方和被控方。。本人不赞同这种写法：
理由是： 1.既然是多对多关系。。为什么还要分主动方和被动方？
2.为什么需要删除老师后才级联中间表。。。请注意：以上定义方法时，删除学生是无法级联删除中间表的。
正确的写法应该是两边都用主控方的写法：
只是joinColumns和inverseJoinColumns属性的地方互换就可以了
new：（个人观点，，欢迎大家一起来讨论此问题）
总结：
个人的定义：
@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
@JoinTable(name = "Teacher_Student",
joinColumns = {@JoinColumn(name = "Student_ID", referencedColumnName = "studentid")},
inverseJoinColumns = {@JoinColumn(name = "Teacher_ID", referencedColumnName ="teacherid")})
public Set<Teacher> getTeachers() {
return teachers;
}
@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
@
JoinTable(name = "Teacher_Student",
joinColumns = {@JoinColumn(name = "Teacher_ID", referencedColumnName = "teacherid")},
inverseJoinColumns = {@JoinColumn(name = "Student_ID", referencedColumnName ="studentid")})
public Set<Student> getStudents() {
return students;
}
hibernate调用seeion的工具类：
HibernateUtils类：
package utils; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtils { private static SessionFactory factory; static{ try{ Configuration cfg=new Configuration().configure(); factory=cfg.buildSessionFactory(); }catch(Exception e){ e.printStackTrace(); } } public static Session getSession(){ return factory.openSession(); } public static void closeSession(Session session){ if(session!=null){ if(session.isOpen()){ session.close(); } } } public static SessionFactory getSessionFactory(){ return factory; } }
测试类：测试类中，标红的部分是建立两个表的维护关系必须有的（想想为什么？）如果缺少标红的部分，那么在employee数据表中（下文提到的表）中depart_id的值就为null
package test; import java.util.HashSet; import java.util.Set; import com.javabean.Department; import com.javabean.Employee; public class Many2One { public static void main(String[] args) { Many2oneDao mvso=new Many2oneDao(); Employee e1=new Employee(); e1.setName("wanglitao_guodiantong"); Employee e2=new Employee(); e2.setName("wuwenzhao_guodiantong"); Department depart=new Department(); depart.setName("guodiantong_guowang"); e1.setDepart(depart); e2.setDepart(depart); Set<Employee> emps=new HashSet<Employee>(); emps.add(e1); emps.add(e2); depart.setEmps(emps); mvso.saveObject(depart); } }
测试结果：
数据库中的表：
多的那一端的表：（employee）
一的那一端的数据表（department表）：
结果说明：在employee的表中，depart_id是关联外键。
另附一篇比较好的一对多建表实例，作为共同参考：
package oneToMany; import java.util.Set; import javax.persistence.*; /* 注意导入时，是导入：import javax.persistence.*; 非导入org.hibernate的相关类：import org.hibernate.annotations.Entity; */ @Entity @Table(name="classes") public class Classes implements Serializable { @Id @GeneratedValue(strategy=GenerationType.AUTO) private int id; private String name; @OneToMany(cascade=CascadeType.ALL,mappedBy="classes") private Set<Student> students; //getter,setter省略 } package oneToMany; import javax.persistence.*; @Entity @Table(name="student") public class Student implements Serializable { @Id @GeneratedValue(strategy=GenerationType.AUTO) private int sid; private String sname; //若有多个cascade，可以是：{CascadeType.PERSIST,CascadeType.MERGE} @ManyToOne(cascade={CascadeType.ALL}) @JoinColumn(name="classid") //student类中对应外键的属性：classid private Classes classes; //getter,setter省略 } public class TestOneToMany { /* CREATE TABLE student ( --要定义外键!!!!!!! `sid` double NOT NULL auto_increment, `classid` double NULL, `sname` varchar(255) NOT NULL, PRIMARY KEY (sid), INDEX par_ind (classid), FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE ) ENGINE=InnoDB */ public static void main(String[] args) throws SQLException { try { SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); Session session=sf.openSession(); Transaction tx=session.beginTransaction(); /* 因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以, 1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据; 2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student. */ Classes classes=new Classes(); classes.setName("access"); Student st1=new Student(); st1.setSname("jason"); st1.setClasses(classes); session.save(st1); Student st2=new Student(); st2.setSname("hwj"); st2.setClasses(classes); session.save(st2); tx.commit(); /* 输出如下: Hibernate: insert into classes (name) values (?) Hibernate: insert into student (classid, sname) values (?, ?) Hibernate: insert into student (classid, sname) values (?, ?) */ /* 因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类(class)建立关系，因为这样建立的关系是不会在数据库中存储的。 如上的代码倒过来,则插入时,student的外键值为空.如下: */ // Student st1=new Student(); // st1.setSname("jason"); // session.save(st1); // // Student st2=new Student(); // st2.setSname("hwj"); // session.save(st2); // // Set<Student> students=new HashSet<Student>(); // students.add(st1); // students.add(st2); // // Classes classes=new Classes(); // classes.setName("access"); // classes.setStudents(students); // session.save(classes); /* 输出如下: Hibernate: insert into student (classid, sname) values (?, ?) Hibernate: insert into student (classid, sname) values (?, ?) Hibernate: insert into classes (name) values (?) */ } catch(HibernateException e) { e.printStackTrace(); } } }