hibernate关系映射

[本文中只说明使用Annotaion注解方式配置hibernate关系映射的方法和注意事项]

所谓关系，不是指数据库表与表之间的关系，因为数据库表之间只有主外键关系（数据库设计时一般遵循主键关联和单向外键关联，比较清晰）。

关系映射中的“关系”指的是对象之间的关系，不是继承、实现，而是指对象数量之间的四种关系：一对一，一对多，多对一，多对多。

关系还分为单向和双向之分。例如，一夫一妻，丈夫中有妻子的外键，妻子也有丈夫的外键，就是双向的一对一关系，但数据库有冗余，建立了一个外键即可。所以双向的对象数量之间的关系无论哪一种，在hibernate中必须使用mappedBy指明建立哪一个外键，否则数据库设计不合格，在指明后，生成的数据库与单向一对一生成的数据库无差别。

本例使用Myeclipse自带的Junit4进行测试，使用log4j配置 log4j.logger.org.hibernate.tool.hbm2ddl=debug 查看DDL日志，每次测试时都在hibernate配置文件中hibernate.cfg.xml映射对应的实体类，并设置<property name="hbm2ddl.auto">create</property>，以自动创建数据库表及结构。hibernateUtil包的HibernateUtil.getSessionFactory().getCurrentSession();方法可获取当前Session。

双向关系一般很少用，一对一，多对多关系也很少用，用到的大多数情况下是单向多对一、单向一对多。

单向一对一：

一对一在数据库中该怎么设计？把一个表的id设置为另一个表的外键即可并切只设置一个外键，不需要互相都设置成外键，否则冗余。

所以在一个实体类中加入另一个实体类的对象并在get方法上@OneToOne即可

Husband.java

package com.ibm.hibernateOneToOne;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.OneToOne;@Entitypublic class Husband {private int id;private String name;//加入Wife的对象引用，在数据库生成时Husband表中加入妻子idprivate Wife wife;@OneToOne//@JoinColumn(name="wifeid")可以改变外键字段名，默认为wife_idpublic Wife getWife() {return wife;}public void setWife(Wife wife) {this.wife = wife;}@Id@GeneratedValuepublic 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;}}

Wife.java

package com.ibm.hibernateOneToOne;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToOne;@Entitypublic class Wife {private int id;private String name;/*private Husband husband;@OneToOne(mappedBy=""wife)//Husband中Wife对象的名字。@JoinColumn(name="husband_id")<strong>//指定外键的字段名，默认为husband_id</strong>public Husband getHusband() {return husband;}public void setHusband(Husband husband) {this.husband = husband;}*/@Id@GeneratedValuepublic 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;}}

单向一对一DDL/双向加mappedBy一对一DDL：

Hibernate: drop table if exists Husband
Hibernate: drop table if exists Wife
Hibernate: create table Husband (id integer not null auto_increment, name varchar(255),wife_id integer, primary key (id))
Hibernate: create table Wife (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Husband add constraint FK_4565w2c4f1cj082spdiok0w6 foreign key (wife_id) references Wife (id)

含有mappedBy=""实体类不再生成外键，表示由对方实体类中的某对象名主导。
Wife中如果去点/**/引用的部分则为双向一对一。

不加mappedBy的双向DDL：

Hibernate: drop table if exists Husband
Hibernate: drop table if exists Wife
Hibernate: create table Husband (id integer not null auto_increment, name varchar(255),wife_id integer, primary key (id))
Hibernate: create table Wife (id integer not null auto_increment, name varchar(255),husband_id integer, primary key (id))
Hibernate: alter table Husband add constraint FK_4565w2c4f1cj082spdiok0w6 foreign key (wife_id) references Wife (id)
Hibernate: alter table Wife add constraint FK_n86d0ervyo0jv9a18yx655329 foreign key (husband_id) references Husband (id)

若不加有冗余，因为只需要一个外键即可确定一对一关系，在OneToOne后加入(mappedBy="wife"),则DDL结果与单向一对一无差别。

为何要用双向：虽然数据库结果一样，但是对象中却是双向的，可从wife得到husband，也可从husband达到wife。

单向多对一：

多对一在数据库中怎么设置？一般在“多”的表中设置一个“少”的一方的外键。反过来会有冗余哦。

所以在"多"的实体类中加入"少"的实体类对象并在get方法上@ManyToOne即可

例如：一个人有多个梦想，一个梦想只能被一个人拥有：

Dream.java

package com.ibm.hibernateManyToOne;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.ManyToOne;@Entitypublic class Dream {private int id;private String dream;private Person person;@ManyToOne@JoinColumn(name="personid")public Person getPerson() {return person;}public void setPerson(Person person) {this.person = person;}@Id@GeneratedValuepublic int getId() {return id;}public void setId(int id) {this.id = id;}public String getDream() {return dream;}public void setDream(String dream) {this.dream = dream;}}

Person.java

package com.ibm.hibernateManyToOne;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;@Entitypublic class Person {private int id;private String name;@Id@GeneratedValuepublic 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;}}

单向多对一DDL：

Hibernate: drop table if exists Dream
Hibernate: drop table if exists Person
Hibernate: create table Dream (id integer not null auto_increment, dream varchar(255),personid integer, primary key (id))
Hibernate: create table Person (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream add constraint FK_hg1723l9yhysmlxywmgmdgd39 foreign key (personid) references Person (id)

单向一对多：

数据库怎么设计？与一对多一样，只不过"一"的实体类中需加入Set类型的"多"的实体类。其他都一样。

Person1.java

package com.ibm.hibernateOneToMany;import java.util.Set;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToMany;@Entitypublic class Person1 {private int id;private String name;private Set<Dream1> dream1;@OneToMany@JoinColumn(name="personid")public Set<Dream1> getDream1() {return dream1;}public void setDream1(Set<Dream1> dream1) {this.dream1 = dream1;}@Id@GeneratedValuepublic 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;}}

Dream.java

package com.ibm.hibernateOneToMany;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;@Entitypublic class Dream1 {private int id;private String dream;@Id@GeneratedValuepublic int getId() {return id;}public void setId(int id) {this.id = id;}public String getDream() {return dream;}public void setDream(String dream) {this.dream = dream;}}

单向一对多DDL：(与单向多对一一样，数据库一样)

Hibernate: drop table if exists Dream1
Hibernate: drop table if exists Person1
Hibernate: create table Dream1 (id integer not null auto_increment, dream varchar(255), personid integer, primary key (id))
Hibernate: create table Person1 (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream1 add constraint FK_lswteige4aru1ov44wxodqmos foreign key (personid) references Person1 (id)

双向多对一 = 双向一对多：

数据库与单向一对多多对一都一样，只是实体类之间可以相互引用。

dream2.java

package com.ibm.hibernateBi_ManyToOne_OneToMany;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.ManyToOne;@Entitypublic class Dream2 {private int id;private String dname;private Person2 person2;@ManyToOnepublic Person2 getPerson2() {return person2;}public void setPerson2(Person2 person2) {this.person2 = person2;}@Id@GeneratedValuepublic int getId() {return id;}public void setId(int id) {this.id = id;}public String getDname() {return dname;}public void setDname(String dname) {this.dname = dname;}}

Person2.java

package com.ibm.hibernateBi_ManyToOne_OneToMany;import java.util.Set;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.OneToMany;@Entitypublic class Person2 {private int id;private String name;private Set<Dream2> dream2;@OneToMany(mappedBy="person2")public Set<Dream2> getDream2() {return dream2;}public void setDream2(Set<Dream2> dream2) {this.dream2 = dream2;}@Id@GeneratedValuepublic 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;}}

双向多对一（也即双向一对多）DDL:(与单向一对多，单向多对一一样，因为数据库设计的都一样)

Hibernate: drop table if exists Dream2
Hibernate: drop table if exists Person2
Hibernate: create table Dream2 (id integer not null auto_increment, dname varchar(255), person2_id integer, primary key (id))
Hibernate: create table Person2 (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream2 add constraint FK_5v0q0beloi3kwr4d4ue44kg2e foreign key (person2_id) references Person2 (id)

单向多对多：
数据库设计？生成一个新的中间表，外键是两个表的id，单向所以一个实体类中加另一个实体类的set类型的对象，并在get方法上@ManyToMany

例如：学生与课程，一个学生可以选多个课程，一个课程可以被多个学生选择。

Course.java

package com.ibm.hibernateManyToMany;import java.util.Set;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.JoinColumns;import javax.persistence.JoinTable;import javax.persistence.ManyToMany;@Entitypublic class Course {private int id;private String courseName;private Set<Student> student;@Id@GeneratedValuepublic int getId() {return id;}public void setId(int id) {this.id = id;}public String getCourseName() {return courseName;}public void setCourseName(String courseName) {this.courseName = courseName;}@ManyToMany//新生成的表名，当前实体类外键的id名字，另一个实体类外键的id名字@JoinTable(name="c_s",   joinColumns={@JoinColumn(name="courseid")},   inverseJoinColumns={@JoinColumn(name="studentid")})public Set<Student> getStudent() {return student;}public void setStudent(Set<Student> student) {this.student = student;}}

Student.java

package com.ibm.hibernateManyToMany;import java.util.Set;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.ManyToMany;@Entitypublic class Student {private int id;private String name;/*private Set<Course> course;@ManyToMany(mappedBy="student")public Set<Course> getCourse() {return course;}public void setCourse(Set<Course> course) {this.course = course;}*/@Id@GeneratedValuepublic 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;}}

单向多对多DDL：

Hibernate: drop table if exists Course
Hibernate: drop table if exists c_s
Hibernate: create table Course (id integer not null auto_increment, courseName varchar(255), primary key (id))
Hibernate: create table Student (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: create table c_s (courseid integer not null, studentid integer not null, primary key (courseid, studentid))
Hibernate: alter table c_s add constraint FK_sqya4biyhu2bcn3e3o6b6m61l foreign key(studentid) references Student (id)
Hibernate: alter table c_s add constraint FK_p020gm1dfqwc75g7rs9in4126 foreign key (courseid) references Course (id)

双向多对多：去掉Student.java中的/**/注释中的内容，DDL跟单向的一样。只不过Course和Student之间可以引用

总结一下：双向就在两个实体类互相加入对方对象，是"多的一方"则为Set类型，去掉一方的引用则为单向。单向双向生成的数据库表结构完全一致，只不过双向中对象可以相互引用。一般在多的一方加入对象引用，建立外键。