《Hibernate学习笔记三》：联合主键的映射

于 2017-09-26 11:19:59 发布
阅读量299 收藏
点赞数
分类专栏： hibernate 文章标签： 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;
    }   
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

上面的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();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

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>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在我们的例子中完整的映射文件内容如下：

<?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>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

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>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

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();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

运行结果在数据库中的反应如下：

这样我们就完成了联合主键的映射。

第二种：使用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();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

第二步：将组件的属性注解为@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;
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

测试类

配置文件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();
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

在控制台输出的建表数据如下：

因此，利用将组件类注解为@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;
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

主键类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();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

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;
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

主键类代码如下：

不用任何注解来进行修饰。

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();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

测试类代码如下：

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();
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

hibernate.cfg.xml文件内容与上面介绍的一样。

运行程序后在数据库中Teacher表结构如下：

以上就是第三种注解方式来完成联合主键的映射。

from: http://blog.csdn.net/u010412719/article/details/51275744


jiruirui213
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate学习——（七）联合主键映射以及组件映射
WangQYoho的博客
03-18 802
如果有时候需要将多个属性合并在一起作为主键，则需要使用使用联合主键映射的形式。 首先将联合主键需要的属性包装在一个class中： ManagerPK.java： package cn.wqy.dao; import java.io.Serializable; public class ManagerPK implements Serializable{ private int mana
Hibernate联合主键映射
weixin_38170137的博客
12-10 58
1.联合主键的映射规则 1）类中的每个主键属性都对应到数据表中的每个主键列。 Hibernate要求具有联合主键的实体类实现Serializable接口，并且重写hashCode与equals方法，重写这两个方法的原因在于Hibernate要根据数据库的联合主键来判断某两行记录是否是一样的，如果一样那么就认为是同一个对象，如果不一样，那么就认为是不同的对象。这反映到程序领域中就是根...
联合主键的映射运用
weixin_30484247的博客
01-22 57
1.联合主键的映射规则 1）类中的每个主键属性都对应到数据表中的每个主键列。 Hibernate要求具有联合主键的实体类实现Serializable接口，并且重写hashCode与equals方法，重写这两个方法的原因在于Hibernate要根据数据库的联合主键来判断某两行记录是否是一样的，如果一样那么就认为是同一个对象，如果不一样，那么就认为是不同的对象。这反映到程序领域中就是根...
Hibernate联合主键配置
xys_00
06-16 371
实体类 public class AuthReferOtherUsers implements java.io.Serializable {     private SysDicWorker sysDicWorker;     private SysDicUserRole sysDicUserRole;          public SysDicUserRole getSys
邹波老师Hibernate教程学习笔记
11-10
7. **一对多、多对一、一对一和多对多关系映射**：在数据库设计中常见的关联关系，笔记会详细讲解如何在Hibernate中配置和操作这些关系，包括联合主键、外键约束等。 8. **懒加载与立即加载**：Hibernate提供了懒...
hibernate学习笔记
05-24
《Hibernate学习笔记》 在Java世界中，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作，让开发者可以专注于业务逻辑而无需过多关注底层SQL语句的编写。这篇学习笔记将深入探讨Hibernate...
Hibernate学习笔记
03-16
《Hibernate学习笔记》 在Java世界中，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作，让开发者可以专注于业务逻辑而无需过多关注底层SQL的编写。本学习笔记将深入探讨Hibernate的核心...
Hibernate Annotation 学习笔记
03-01
**Hibernate Annotation 学习笔记** Hibernate 是一个流行的Java ORM（对象关系映射）框架，它允许开发者使用面向对象的方式操作数据库。Annotation 在 Hibernate 中扮演着关键角色，它们为数据库对象提供了元数据...
hibernate如何建立联合主键
xiangjingjing
09-11 173
近日学习了如何用hibernate建立联合主键的小知识，分享给大家，希望和大家共同探讨 1. 首先确定好在这个类中的哪些属性将作为联合主键，然后将这属性单独放到一个类中， 该类必须实现Serializable接口，同时需要重写equals和hashCode方法 2. 在映射文件中这样配置联合主键 public class Balances { pri...
hibernate主键冲突问题
12-25
“increment” 主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：不能在集群下使用。
使用Hibernate配置联合主键的两种方式
巨峰的专栏
03-01 2599
1.主键字段和非主键字段在同一个实体类中，Hibernate配置文件如下 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 脱机版版本
13、复合主键映射（联合主键）
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
11-12 5128
联合主键的映射 1、类中的每个主键属性都对应到数据表中的每个主键的列 Hibernate要求具有联合主键的类首先要实现Serializable接口，其次要重写hashCode和equals方法，这两个方法可以使用Myeclipse帮助我们自动生成。重写这两个方法的原因在于Hibernate要根据数据库的联合主键来判断某两行记录是否是一样的，如果一样那么就认为是同一个对象，如果不一样，那么就认为
Hibernate映射文件中双主键配置
Bin
08-09 2698
在Hibernate映射文件中配置双主键使用  “   ”标签，在该标签里建立子标签    如例子所示:
Hibernate几种常用 主键生成方式
更多惊喜欢迎访问www.itlife365.com和www.jiandanjie.com
03-01 277
Hibernate主键还是比较常用的，于是我研究了一下Hibernate主键生成，在这里拿出来和大家分享一下，希望对大家有用。 1.assigned: 主键由外部程序负责生成，无需Hibernate参与。----如果要由程序代码来指定主键,就采有这种. 2.increment: 对 long ， short 或 int 的数据列生成自动增长主键。increment主键生成...
hibernate联合主键hbm.xml配置
rrz634171的专栏
07-24 5342
//联合主键                                          //单个主键
Hibernate主键
何虎军
04-01 409
1、选择主键 备选的键是能够用来识别表中一个特定行的一列或者一组列。要变成主键，备选键必须满足下列属性： 1）它的值（对于备选键的任意列而言）永远不为空。 2）每一行都有唯一的值。 3）一个特定行的值永远不变。 2、选择键生成器 Hibernate有几个内建的标识符生成策略。 生成器名称：native 选项：无 生成器描述：native同一性生成器挑选其他同一性生成器，如iden
Hibernate的中使用<generator>设置主键的生成方式
幽若梦蓝的角落
05-09 2215
在Hibernate的映射文件中，我们配置与数据库中的表所对应的主键时，要使用generator元素，而该元素的作用是指定主键的生成器。如果需要传递参数，则需要通过子元素param指定。这里我们就使用主键ID来举例说明。Hibernate所提供的内置生成器 assigned算法 　　主键由外部程序负责生成，无须Hibernate参与，因此需要应用程序在执行save()之前为对象分配一个标示符。这是
hibernate学习笔记1
最新发布
08-08
hibernate学习笔记1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值