《Hibernate学习笔记三》：联合主键的映射
《Hibernate学习笔记三》：联合主键的映射
就如在前面所举的例子一样，是使用的id作为唯一的主键，一般情况下我们也只使用唯一的一个属性作为主键，但是在实际中，我们可能会遇到几个属性作为主键的情况，因此，在本篇博文中，就来介绍下，联合主键的映射关系应该如何来做？？
联合主键的映射有两种方式来进行实现。
1、使用映射文件 XXX.hbm.xml
2、使用Annotation
Hibernate首先需要使用联合主键的实体类必须实现Serializable接口，即为了使序列能够被序列化进行传输，并要求实体类重写equals、hashCode这两个方法，用这两个方法来确保联合主键的唯一性。
下面具体来看一个例子。
先看第一种实现方式。
第一种：使用映射文件XXX.hbm.xml来实现联合主键的映射
a、实体类 Student
package com.hibernate.model;
public class Student {
private StudentPK pk;//主键
public StudentPK getPk() {
return pk;
}
public void setPk(StudentPK pk) {
this.pk = pk;
}
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}上面的private StudentPK pk;就是我们的联合主键，联合主键我们封装在了一个类StudentPK中，也可以之间将联合主键的属性不进行封装，直接写在实体类Student。
b、联合主键类 StudentPK
这个就是对联合主键id和name进行了封装，即使得StudentPK为联合主键类，这个类要实现Serializable接口，并需要重写equals和hashCode方法。来实现组合的标识符的相等判断
package com.hibernate.model;
import java.io.Serializable;
public class StudentPK implements Serializable{
private int id;
private String name;
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;
}
@Override
public boolean equals(Object o){
if (o instanceof StudentPK) {
StudentPK pk = (StudentPK) o;
if(this.id==pk.getId()&&this.name.equals(pk.getName())){
return true;
}
}
return false ;
}
@Override
public int hashCode(){
return this.name.hashCode();
}
}c、联合主键的映射文件 Student.hbm.xml
在前面的例子中我们见到过一个属性作为主键的映射文件如何来写，下面就是几个属性作为主键的映射文件应该如何来写。
在官方文档上有这样一句话：
定义可以访问旧式的多主键数据。 我们强烈不建议使用这种方式。
文档上面给出的composite-id的一般格式如下：
<composite-id
name="propertyName"
class="ClassName"
mapped="true|false"
access="field|property|ClassName"
node="element-name|."
>
<key-property name="propertyName" type="typename" column="column_name"/>
<key-many-to-one name="propertyName class="ClassName" column="column_name"/> ...... </composite-id>在我们的例子中完整的映射文件内容如下：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.model">
<class name="Student" table="Student"> <!-- 如果我们不写table,则默认表名与类名一致 -->
<!-- 联合主键 -->
<composite-id name="pk" class="com.hibernate.model.StudentPK">
<key-property name="id" column="id" />
<key-property name="name" column="name" type="string"/>
</composite-id>
<!-- 其他属性，name对应实体类的属性，column对应关系型数据库表的列 -->
<property name="age"/>
</class>
</hibernate-mapping>d、配置文件 hibernate.cfg.xml
配置文件内容如下：
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost/hibernate</property> <!-- hibernate为数据库名称 -->
<!-- 数据库的用户名和密码 -->
<property name="connection.username">root</property>
<property name="connection.password">123456</property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect 主要看你使用的是那种数据库 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!-- Disable the second-level cache -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- 按一定的格式来进行打印MySQL的SQL语句 -->
<property name="format_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<!-- 属性hbm2ddl.auto 可选值有:create|update|drop-create|invalide create 每次都会给你新建一个表，因此存在数据丢失 update 当你的实体类中添加或删除了其他的属性，即将导致相应的表结构发生变化，因此会更改表的结构 invalide 即对象关系映射的检查。 -->
<property name="hbm2ddl.auto">update</property>
<!-- Student类与表Student的映射关系 -->
<mapping resource="com/hibernate/model/Student.hbm.xml"/>
</session-factory>
</hibernate-configuration>e、测试类 StudentTest
测试类代码如下：
package com.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class StudentTest {
private static SessionFactory sf=null;
@BeforeClass
public static void beforeClass(){
//读取配置 文件 hibernate.cfg.xml
Configuration cf= new Configuration().configure();
sf=cf.buildSessionFactory();
}
@Test
public void testSaveStudent() {
//获取 Session
Session session=sf.openSession();
//开启事务
session.beginTransaction();
StudentPK pk=new StudentPK();
pk.setId(2);
pk.setName("wuranghao");
Student student=new Student();
student.setPk(pk);
student.setAge(19);
//对持久化对象 进行 增删改查 操作
session.save(student);
session.getTransaction().commit();
session.close();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}运行结果在数据库中的反应如下：
这样我们就完成了联合主键的映射。
第二种：使用Annotation来实现联合主键的映射
在文档中，说明了定义组合主键的几张语法如下：
1、将组件类注解为@Embeddable，并将组件的属性注解为@Id。
2、将组件的属性注解为@EmbeddedId
3、将类注解为@IdClass，并将该实体中所有属于主键的属性都注解为@Id。
下面对这三种方式分别举例来进行介绍。
1、将组件类注解为@Embeddable，并将组件的属性注解为@Id。
第一步：将组件类注解为@Embeddable
package com.hibernate.model;
import java.io.Serializable;
import javax.persistence.Embeddable;
/*第一步：将组件类注解为@Embeddable，而第二步并不是在此类中把id和name用注解@Id修饰， 而是在Teacher类中将TeacherPK组件*/
@Embeddable
public class TeacherPK implements Serializable{
private int id;
private String name;
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;
}
@Override
public boolean equals(Object o){
if (o instanceof TeacherPK) {
TeacherPK pk = (TeacherPK) o;
if(this.id==pk.getId()&&this.name.equals(pk.getName())){
return true;
}
}
return false ;
}
@Override
public int hashCode(){
return this.name.hashCode();
}
}第二步：将组件的属性注解为@Id
这里要特别注意的是：并不是在TeacherPK这个组合主键类中把id和name用注解@Id修饰，而是在实体类Teacher类中将TeacherPK组件用@Id来进行注释
package com.hibernate.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Teacher {
private TeacherPK pk;//主键引用
private String title;
@Id
public TeacherPK getPk() {
return pk;
}
public void setPk(TeacherPK pk) {
this.pk = pk;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}测试类
配置文件hibernate.cfg.xml和上面的一样，这里就不再贴代码，而测试类的代码如下：
package com.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class TeacherTest {
private static SessionFactory sf=null;
@BeforeClass
public static void beforeClass(){
//读取配置 文件 hibernate.cfg.xml
Configuration cf= new Configuration().configure();
sf=cf.buildSessionFactory();
}
@Test
public void testSaveTeacher() {
//获取 Session
Session session=sf.openSession();
//开启事务
session.beginTransaction();
TeacherPK pk=new TeacherPK();//联合主键对象
pk.setId(3);
pk.setName("xiaoming");
Teacher t=new Teacher();
t.setPk(pk);
t.setTitle("professior");
//对持久化对象 进行 增删改查 操作
session.save(t);
session.getTransaction().commit();
session.close();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}在控制台输出的建表数据如下：
因此，利用将组件类注解为@Embeddable，并将组件的属性注解为@Id。这种方式我们就成功的对联合主键进行了映射。
2、将组件的属性注解为@EmbeddedId
这种方式比第一种方式更加简单，直接不需要将组件类TeacherPK用注解为@Embeddable，而是直接用@EmbeddedId来注解Teacher类中的主键属性，如下：
package com.hibernate.model;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
@Entity
public class Teacher {
private TeacherPK pk;//主键引用
private String title;
//联合主键映射的第二种方式：直接将组件用注解@EmbeddedId来进行修饰
@EmbeddedId
public TeacherPK getPk() {
return pk;
}
public void setPk(TeacherPK pk) {
this.pk = pk;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}主键类TeacherPK不需要任何的注解。
package com.hibernate.model;
import java.io.Serializable;
public class TeacherPK implements Serializable{
private int id;
private String name;
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;
}
@Override
public boolean equals(Object o){
if (o instanceof TeacherPK) {
TeacherPK pk = (TeacherPK) o;
if(this.id==pk.getId()&&this.name.equals(pk.getName())){
return true;
}
}
return false ;
}
@Override
public int hashCode(){
return this.name.hashCode();
}
}3、将类注解为@IdClass，并将该实体中所有属于主键的属性都注解为@Id。
实体类Teacher
将实体类Teacher注解为@IDClass，并将实体中所有属性主键的属性都注解为@Id,而主键类TeacherPK则不用任何注解来进行修饰。
package com.hibernate.model;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
@Entity
@IdClass(value=TeacherPK.class)
public class Teacher {
//private TeacherPK pk;//主键引用
private int id;
private String name;
private String title;
@Id
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Id
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// public TeacherPK getPk() {
// return pk;
// }
// public void setPk(TeacherPK pk) {
// this.pk = pk;
// }
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}主键类代码如下：
不用任何注解来进行修饰。
package com.hibernate.model;
import java.io.Serializable;
public class TeacherPK implements Serializable{
private int id;
private String name;
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;
}
@Override
public boolean equals(Object o){
if (o instanceof TeacherPK) {
TeacherPK pk = (TeacherPK) o;
if(this.id==pk.getId()&&this.name.equals(pk.getName())){
return true;
}
}
return false ;
}
@Override
public int hashCode(){
return this.name.hashCode();
}
}测试类代码如下：
package com.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class TeacherTest {
private static SessionFactory sf=null;
@BeforeClass
public static void beforeClass(){
//读取配置 文件 hibernate.cfg.xml
Configuration cf= new Configuration().configure();
sf=cf.buildSessionFactory();
}
@Test
public void testSaveTeacher() {
//获取 Session
Session session=sf.openSession();
//开启事务
session.beginTransaction();
// TeacherPK pk=new TeacherPK();//联合主键对象
// pk.setId(3);
// pk.setName("xiaoming");
Teacher t=new Teacher();
t.setId(2);
t.setName("zhangsan");
t.setTitle("professior");
//对持久化对象 进行 增删改查 操作
session.save(t);
session.getTransaction().commit();
session.close();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}hibernate.cfg.xml文件内容与上面介绍的一样。
运行程序后在数据库中Teacher表结构如下：
以上就是第三种注解方式来完成联合主键的映射。