Hibernate 映射对象标识符（ID生成策略）

最新推荐文章于 2020-07-31 18:07:45 发布
最新推荐文章于 2020-07-31 18:07:45 发布
阅读量2k 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate 数据库 insert equals java sql

Java语言按内存地址来识别或区分一个类的不同对象，在关系数据库中按主键值来识别或区分同一个表中的不同记录，hibernate使用OID来建立内存对象与关系数据库表中记录的对应关系，OID在关系数据库表中的值是唯一的，内对中的java对象OID保存了数据库表中的主键值，确保OID的唯一性和久性，开发人员不应该让java应用程序来设定OID（很容易出现几个相同的OID），应该让数据库或者hibernate来管理这些OID（有些历史系统让java应用程序管理OID）。那么hibernate的OID生成策略是什么样子的呢？

1.  关系数据库按主键区分不同的记录

我们知道在关系数据库中，为了确保记录的唯一性，使用主键来区分不同的记录，主键必须有一定的约束条件。

Ø  不允许为null。

Ø  每条记录具有唯一的主键值，不允许主键值重复。

Ø  主键值是永久性的，不能改变的（相当于java中的final对象）。

一般来说，主键不应该含有业务含义（维护性问题），含有业务含义的主键称为自然主键，尽管可行，但有业务含义的主键不利于系统的维护，如某项业务改变可能会涉及到数据库表的改变，给维护带来了困难。比较合理的方式是使用代理主键（一般为ID），使主键不具备业务含义。

通常情况下，把主键（代理主键）定义为自动增长的标识符类型（代理主键的类型一般为short、int、long），许多数据库提供了自动增长的供，但不尽相同。

2.  Java语言按内存地址区分不同对象

Java中的同一个对象是指引用指向同一块内存地址。”==” 比较的地址（哈希地址），equals(Object o)在没有重写的情况下也是按地址比较，他是Object类的一个方法，任何对象都拥有该方法并能重写，根据自己需要重写equals（Object o）（按值比较）对象。

    

[java]  view plain copy
  1. public class Customer {  
  2.   
  3.        private String name;  
  4.   
  5.        public String getName() {  
  6.   
  7.            return name;  
  8.   
  9.        }  
  10.   
  11.        public void setName(String name) {  
  12.   
  13.            this.name = name;  
  14.   
  15.        }  
  16.   
  17.        /**重写equals,按名字比较*/  
  18.   
  19.        @Override  
  20.   
  21.        public boolean equals(Object o) {  
  22.   
  23.            if (this == o)  
  24.   
  25.               return true;  
  26.   
  27.            if (!(o instanceof Customer))  
  28.   
  29.               return false;  
  30.   
  31.            final Customer other = (Customer) o;  
  32.   
  33.            if (this.getName().equals(other.getName()))  
  34.   
  35.               return true;  
  36.   
  37.            else  
  38.   
  39.               return false;  
  40.   
  41.        }  
  42.   
  43.     }  

 JavaAPI中一些类已经重写,equals方法，按非值比较

Ø  String类和Date类。

Ø  Java包装类。

Ø  对于String来说，有点不同，new出来的对象在退栈区，直接赋值的在静态数据区。

[java]  view plain copy
  1. String s1 = new String("11");      //堆栈中  
  2.   
  3. String s2 = new String("11");      //堆栈中  
  4.   
  5. System.out.println(s1 == s2);      //false  
  6.   
  7. System.out.println(s1.equals(s2)); //true  
  8.   
  9. String s3 = "11";               //String池中  
  10.   
  11. String s4 = "11";               //String池中  
  12.   
  13. System.out.println(s1 == s3);      //false  
  14.   
  15. System.out.println(s1.equals(s3)); //true  
  16.   
  17. System.out.println(s3 == s4);      //true  
  18.   
  19. System.out.println(s3.equals(s4)); //true  

String池是按字符串的哈希码比较的，一个串的地址只有一个，如果几个对象的值相同，那么他们指向同一个地址。

3.  Hibernate用对象标识符（OID-关系数据库中的主键）来区分对象

1)  Java语言按内存地址识别或区分同一个类的不同对象。

2)  关系数据库使用主键来识别或区分同一张表中的不同记录。

3)  Hibernate使用OID区分对象。

Hibernate作为中间者使用OID来统一这两者（对象-关系数据）的矛盾，主键—OID—java对象模型。

[java]  view plain copy
  1. Transaction tx = session.beginTransaction();                      //1  
  2.   
  3. Customer c1 = (Customer)session.get(Customer.class,new Long(1));//2  
  4.   
  5. Customer c2 = (Customer)session.get(Customer.class,new Long(1));//3  
  6.   
  7. Customer c3 = (Customer)session.get(Customer.class,new Long(2));//4  
  8.   
  9. System.out.println(c1 == c2); //true                           //5  
  10.   
  11. System.out.println(c1 == c3); //false                          //6  
  12.   
  13. tx.commit();                                                  //7  

// 2 第一次加载OID为1的Customer对象时，从数据库拉出数据创建Customer对象实例，并保存到Session缓存中（SessionFactory一级缓存）,c1引用指向该对象

// 3 第二次加载OID为1的Customer对象时，Hibernate首先在Session缓存中查找OID为1的对象(估计是使用反射机制自动比较OID，因为没有重写equals方法)，若存在，直接把Session中的Customer的OID为1的对象的引用赋值给c2，此时c1与c2指向同一个对象。（在eclipse中使用日志并且设置显示SQL语句时会看到加载第二次时不会发送SQL语句）

//4 加载OID为3的Customer对象时，由于Session不存在OID为3的对象，所以要从数据库中拉出数据后创建Customer对象，并保存到Session缓存中。

Session有个clear（）的函数，可以把Session中的缓存清除，如果在第一次加载OID为1的Customer对象后就清空Session缓存，那么在第二次加载OID为1的Customer对象时，由于缓存中没有OID为1的对象，所以要从数据库中拉出数据后创建Customer对象（与第一次加载OID为1的Customer对象不是同一个对象，所以c1 != c2），清空Session缓存可能在性能调优的时候用或者在某些特别事务里面不能使用缓存必须重新从数据库中读出数据后重新创建对象（安全性要求较高业务）。

为了持久化对象生成的标识符（OID-表的主键）的唯一性和不可变性，通常由hibernate或者底层数据库来给OID赋值（生成主键值）。把setID设为private就可以防止Java应用程序访问设置OID。

[java]  view plain copy
  1. private Long id;  
  2.   
  3.     private void setId(Long id) {  
  4.   
  5.        this.id = id;  
  6.   
  7.     }  
  8.   
  9.     public Long getId() {  
  10.   
  11.         return this.id;  
  12.   
  13. }  

在对象-关系映射文件中，<id>元素用来设置对象的标识符。

<id name="id"type="long" column="ID">

       <generator class="increment"/>

</id>

上面的设置使用了hibernate生成标识符（OID）的策略，class 属性是生成OID所采用的策略，是一个类类型，生成标识符（OID）的类在org.hibernate.id包中，该包还包含了其他的标识符生成策略。increment是org.hibernate.id.IncrementGenerator的缩写。当然class的属性值可以使用全类名如 class=org.hibernate.id.IncrementGenerator

Hibernate提供的内置标识符（OID）生成器

                                                                                      
 

标识符生成器

 		 

适用对象

 		 

描述

 		 

支持的数据库

 
 

increment

 		 

代理主键

 		 

由hibernate自动一递升的方式生成标识符，每次增量为1

 
 

indentify

 		 

代理主键

 		 

由数据库底层生成标识符，前提是底层数据库支持自动增长字段类型

 		 

DB2、Mysql、MS SQL Service、Sybase、HypersonicSQL

 
 

sequence

 		 

代理主键

 		 

hibernate根据底层数据库的序列来生成标识符，前提是底层数据库支持序列

 		 

DB2、PostgreSQL、Oracle、SAP  DB

 
 

hilo

 		 

代理主键

 		 

 hibernate根据high/low算法来生成标识符，hibernate把特定表的字段作为"hight"的部分，默认情况下选用hibernate_unique_key表的next_hi字段

 
 

native

 		 

代理主键

 		 

根据底层数据库对自动生成标识符的支持能力，来选择identity、sequence、hilo

 
 

uuid.hex

 		 

代理主键

 		 

hibernate采用128位的UUID（Universal Unique Identification）算法来生成标识符，UUID能够在网络环境生成唯一的字符串标志符（估计跟MAC有关），不常用，占用空间多

 
 

assigned

 		 

自然主键

 		 

由java应用程序负责生成标识符，为了能让java应用程序设置OID，不能把setId()方法声明为private类型，应该尽量避免使用自然主键

 
 

select

 		 

遗留数据库代理/自然

 		 

有数据库的触发器生成标识符

 
 

foreign

 		 

一对一关联

 		 

用另一个关联的对象的标识符作为当期的标识符

 

 

4.  Hibernate的内置生成器标识符生成器（OID-主键）的用法

以customers的ID字段（主键）和name字段为例

(1) increment标识符生成器

increment标识符生成器有hibernate递升的方式为代理主键赋值。

[html]  view plain copy
  1. *.hbm.xml  
  2.   
  3. <hibernate-mapping package="com.model">  
  4.   
  5.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  6.   
  7.        <id name="id" type="long"column="ID">  
  8.   
  9.            <meta attribute="scope-set">private</meta>  
  10.   
  11.            <generator class="increment"></generator>  
  12.   
  13.        </id>  
  14.   
  15.        <property name="name" type="string">  
  16.   
  17.            <column name="NAME" length="15"></column>  
  18.   
  19.        </property>  
  20.   
  21.     </class>  
  22.   
  23. </hibernate-mapping>  

生成java代码。

[java]  view plain copy
  1. private Long id;  
  2.  private void setId(Long id) {  
  3.     this.id = id;  
  4. }  
  5. public Long getId() {  
  6.     return this.id;  
  7. }  

[java]  view plain copy
  1. 生成的SQL。  

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigint not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

Insert SQL语句。

insert into customers(NAME,ID)values(?,?);

可以看出在insert语句时含有ID字段，说明Hibernate在持久化时会议递升的方式生成标识符，hibernate先从customers表中选出最大键，然后增量为1.

select max(ID) from customers;

这种标识符生成方式一般只在拥有一个服务器的数据库使用，在集群环境下会出现生成的标识符相同的问题。（好像是多线程问题无法执行数据库事务问题）

(2) identity标识符生成器

identity标识符生成器有底层数据库来负责生成标识符，他要求底层数据库把主键定义为自动增长字段类型。

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <id name="id" type="long"column="ID">  
  6.   
  7.            <meta attribute="scope-set">private</meta>  
  8.   
  9.            <generator class="identity"></generator>  
  10.   
  11.        </id>  
  12.   
  13.        <property name="name" type="string">  
  14.   
  15.            <column name="NAME" length="15"></column>  
  16.   
  17.        </property>  
  18.   
  19.     </class>  
  20.   
  21. </hibernate-mapping>  

 Mysql数据库的SQL。

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigintauto_increment not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

MS SQL Server数据库的SQL.

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigintidentity not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

Insert SQL语句。

insert into customers(NAME) values(?);

插入SQL语句中没有ID字段，标识符生成有底层数据库完成。

Identity依赖于底层数据库，要求数据库支持自动增长字段类型，Oracle数据库不支持。

(3) sequence标识符生成器

sequence标识符生成器利用底层数据库提供的序列来生成标识符。

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <id name="id" type="long"column="ID">  
  6.   
  7.            <meta attribute="scope-set">private</meta>  
  8.   
  9.            <generator class="sequence">  
  10.   
  11.               <param name="sequence">customers_id_seq</param>  
  12.   
  13.            </generator>  
  14.   
  15.        </id>  
  16.   
  17.        <property name="name" type="string">  
  18.   
  19.            <column name="NAME" length="15"></column>  
  20.   
  21.        </property>  
  22.   
  23.     </class>  
  24.   
  25. </hibernate-mapping>  

Oracle数据库SQL.

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigint not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

create sequencecustomers_id_seq;

生成了sequence序列。

Insert SQL

[sql]  view plain copy
  1. insert into customers(NAME,ID)values(?,?);  

insert SQL中包含有ID字段，可见hibernate先从数据库中的customers_id_seq序列中获得一个唯一的序列号。

Sequence依赖底层数据库的序列，需要数据库支持序列才行，但是Mysql不支持。

(4) hilo标识符生成器

hilo标识符生成器有hibernate按照hight/low算法生成标识符，从数据库特定表中获取一个high值。 

[html]  view plain copy
  1.   <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <id name="id" type="long"column="ID">  
  6.   
  7.            <meta attribute="scope-set">private</meta>  
  8.   
  9.            <generator class="hilo">  
  10.   
  11.               <param name="table">hi_value</param>  
  12.   
  13.               <param name="column">next_value</param>  
  14.   
  15.               <param name="max_lo">100</param>  
  16.   
  17.            </generator>  
  18.   
  19.        </id>  
  20.   
  21.        <property name="name" type="string">  
  22.   
  23.            <column name="NAME" length="15"></column>  
  24.   
  25.        </property>  
  26.   
  27.     </class>  
  28.   
  29. </hibernate-mapping>  

SQL

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigint not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  
create table hi_value(
    next_value_integer
);

insert into hi_value values(0);

insert SQL

[sql]  view plain copy
  1. insert into customers(NAME,ID)values(?,?);  

insert SQL中含有ID字段，hibernate负责生成标识符，hilo生成标识符时读取hi_valu表中的next_value的值，并修改，这是由数据库的事务处理的，不是hibernate事务。

Hilo不依赖与底层数据库，所有具有通用性，，但是只能在一个数据库中保证唯一。，但用户自行提供数据库连接时或者使用JTA时，应用程序无法使用hilo，这种情况下如果数据库支持序列，可以使用seqhilo

(5) native标识符生成

native根据底层数据库对自动生成标识符的支持能力，选择identity、sequence、hilo标识符生成器。

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <id name="id" type="long"column="ID">  
  6.   
  7.            <meta attribute="scope-set">private</meta>  
  8.   
  9.            <generator class="native"></generator>  
  10.   
  11.        </id>  
  12.   
  13.        <property name="name" type="string">  
  14.   
  15.            <column name="NAME" length="15"></column>  
  16.   
  17.        </property>  
  18.   
  19.     </class>  
  20.   
  21. </hibernate-mapping>  

MySQL SQL

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigintauto_increment not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

MS SQL Server SQL

[sql]  view plain copy
  1. create table customers(  
  2.   
  3.     ID bigintidentity not null,  
  4.   
  5.     NAME varchar(15) not null  
  6.   
  7.     primary key (ID)  
  8.   
  9. );  

Insert SQL

[sql]  view plain copy
  1. insert into customers(NAME) values(?);  

insert SQL语句中没有ID字段，由数据库底层生成标识符。

由于是根据各种数据库的自动生成序列，，适合跨平台开发。同一个hibernate连接多种数据库系统。

5.  映射自然主键

自然主键是具有业务含义的主键。（设计时应尽量避免使用）

(1) 映射单个自然主键

Customers使用name作为自然主键.

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <id name="name" column="NAME"type="string">  
  6.   
  7.            <generator class="assigned"></generator>  
  8.   
  9.        </id>  
  10.   
  11.        <version name="version" column="VERSION"unsaved-value="null"></version>  
  12.   
  13.     </class>  
  14.   
  15. </hibernate-mapping>  

<version>版本控制元素，如果Customer对象的version属性为null，表示临时对象，Customers类必要version属性.saveorUpdate（）根据version的值来决定是save()还是update（）.如果没有定义则必须手工控制（选择调用save（）或者update(0）或者使用hibernate的拦截器（interceptor）.

可以通过Session的getIdentifier()返回对象的OID.

(2) 映射复合自然主键

若使用name 和student_id作为复合主键（OID）.

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <composite-id>  
  6.   
  7.            <key-property name="name" column="NAME"type="string"/>  
  8.   
  9.            <key-property name="student_id" column="STUDENT_ID" type="long"/>  
  10.   
  11.        </composite-id>  
  12.   
  13.        <version name="version" column="VERSION"unsaved-value="null"></version>  
  14.   
  15.     </class>  
  16.   
  17. </hibernate-mapping>  

但是Customer必须实现java.io.Serializable接口，并且重新定义equals()和hashCode()方法。equals()判断两个Customer对象相等得条件，两个Customer的nameh属性和studentId属性都相等。hashCode()方法实现原则：用equals()方法判断相等的两个Customer对象具有相同的哈希码.

不同还可以单独定义主键类，如CustomerId，实现java.io.Serializable接口并重写java.io.Serializable equals()和hashCode()方法。在Customer类中把CustomerId作为属性值。

[html]  view plain copy
  1. <hibernate-mapping package="com.model">  
  2.   
  3.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  4.   
  5.        <composite-id>  
  6.   
  7.            <key-property name="name" column="NAME"type="string"/>  
  8.   
  9.            <key-property name="student_id" column="STUDENT_ID" type="long"/>  
  10.   
  11.        </composite-id>  
  12.   
  13.        <version name="version" column="VERSION"unsaved-value="null"></version>  
  14.   
  15.     </class>  
  16.   
  17. </hibernate-mapping>  

如studentId还作为外键参考Student，那么在Customer类中还需添加Student的属性。

[html]  view plain copy
  1. Customer.hbm.xml  
  2.   
  3. <hibernate-mapping package="com.model">  
  4.   
  5.     <class name="Customer" dynamic-insert="true"dynamic-update="true">  
  6.   
  7.        <composite-id name="customerId" class="com.model.CustomerId">  
  8.   
  9.            <key-property name="name" column="NMAE"type="string"/>  
  10.   
  11.            <key-property name="studentid" column="STUDENT_ID"type="long"/>  
  12.   
  13.        </composite-id>  
  14.   
  15.        <version name="version" column="VERSION"unsaved-value="null"/>  
  16.   
  17.        <many-to-one name="student" class="Student"column="STUDENT_ID" insert="false" update="false"/>  
  18.   
  19.     </class>  
  20.   
  21. </hibernate-mapping>  

设置insert和update的属性为false，表名当Customer更新时会忽略student的属性。

[html]  view plain copy
  1. Student.hbm.xml  
  2.   
  3. <hibernate-mapping package="com.model">  
  4.   
  5.     <class name="Student" dynamic-insert="true"dynamic-update="true">  
  6.   
  7.        <composite-id name="customerId" class="CustomderId">  
  8.   
  9.            <key-property name="name" column="NAME"type="string"/>  
  10.   
  11.            <key-many-to-one name="student" class="Student"column="STUDENT_ID"/>  
  12.   
  13.        </composite-id>  
  14.   
  15.        <version name="version" column="VERSION"unsaved-value="null"/>  
  16.   
  17.     </class>  
  18.   
  19. </hibernate-mapping>  

6.  总结

Java语言按内存地址识别和区分同一个类的不同对象实例，关系数据库根据主键识别和区分同一张表中的不同记录值。Hibernate根据对象标识符（OID）识别和区分对象，它作为联系java对象和关系数据库库中表中的记录对应的桥梁。关系数据库表的主键尽量不要含有业务逻辑。Hibernate提供了几种内置标识符生成器，生成唯一的且不可改变的OID.不同数据所支持的标识符生成器不同。

Ø  MySQL:identity、increment、hilo、native

Ø  MS SQL Server：identity、increment、hilo、native

Ø  Oracle：sequence、seqhilo、hilo、increment、native

Ø  跨平台开发：native

7.  参考书目

《精通Hibernate：Java对象持久化技术详解》 ( 第二版) 电子工业出版社 作者：孙卫琴

jazwoo
关注
专栏目录
孙卫琴的《精通JPA与Hibernate》的读书笔记：映射对象标识符的基本原理
csdnuserlala的博客
05-04 282
Java语言按内存地址来识别或区分同一个类的不同对象，而关系数据库按主键值来识别或区分同一个表的不同记录。Hibernate使用OID来统一两者之间的矛盾，OID是关系数据库中的主键（通常为代理主键）在Java对象模型中的等价物。 在运行时，Hibernate根据OID来维持Java对象和数据库表中记录的对应关系。例如： Transaction tx = session.beginTransaction(); Customer c1=session.get(Customer.class, Long.va
Hibernate内置标识符生成器
05-20
Hibernate 是一个流行的对象关系映射（ORM）框架，它允许开发者用 Java 对象的方式来操作数据库。在 Hibernate 中，对象的唯一标识符（OID）是非常重要的，因为它用来区分数据库中的不同记录。OID通常被称为主键...
有关Hibernate_Id_Generator的解释(转载)
orangekent地带
07-19 1077
“assigned”       主键由外部程序负责生成，在   save()   之前指定一个。              “hilo”       通过hi/lo   算法实现的主键生成机制，需要额外的数据库表或字段提供高位值来源。               “seqhilo”       与hilo   类似，通过hi/lo   算法实现的主键生成机制，需要数据库中的   Sequence
映射对象标识符
Bob@CSDN
05-29 673
 Hibernate采用对象标识符,也就是通常我们所说的OID来创建对象和数据库表里记录的对应关系,对象的OID和表里的主键对应,所以说OID是非常重要的,不应该让程序来给它赋值.数据库区分同一表的不同记录是用主键来区分.数据库中的主键最重要的3个基本要素就是不允许为null,不允许有重复值,主键永远不会改变.所以通常我们设计表都会设计主键的值为自动增加,没有业务逻辑含义的一组数字,当然针对每个数
Hibernate学习心得--映射对象标识符
Flyingis
11-14 114
    作者：Flyingis    在关系数据库中的主键可分为自然主键(具有业务含义)和代理主键(不具有业务含义)，其中代理主键可以适应不断变化的业务需求，因此更加流行。代理主键通常为整数类型，与此对应，在持久化类中野应该把OID定义为整数类型，Hibernate允许把OID定义为short、int和long类型，以及它们的包装类型。    Hibernate提供了几种内置标识符生成器，每一种标...
一种全局对象ID生成方法
daemonh
05-05 2140
网游中，角色ID、公会ID和道具ID等一般设计成全局唯一。这样做，一个便于跟踪这些对象的生存状态；另外一个是合区不会产生冲突。 用大区ID+大区内服务器ID+时间+生成序列生成一个64bits的数字作为全局ID，其中0表示非法的ID。       globalID = cl
hibernate 映射文件解释 id
好风的老巢
04-23 1287
看了一下hibernate说明，对主键配置的做下总结：<id name="propertyName" (1) type="typename" (2) column="co
Hibernate映射文件id的generator配置方法
08-28
Hibernate 映射文件 id 的 generator 配置方法是 Hibernate 框架中的一种重要配置，用于生成持久化类实例的唯一标识符。下面将对 Hibernate 映射文件 id 的 generator 配置方法进行详细的解释。 首先，generator ...
ID生成策略
07-12
### ID生成策略详解 在软件开发中，尤其是数据库应用领域，如何高效且合理地生成唯一标识符（ID）是至关重要的。本文将详细介绍几种常见的ID生成策略：`sequence`、`native`、`identity`、`foreign`等，并探讨它们...
Hibernate 映射文件 结构
04-21
【标题】"Hibernate映射文件结构"涉及到的是Java持久化框架Hibernate的核心概念，它用于将对象与数据库表之间的关系进行定义。映射文件是Hibernate工作的重要组成部分，它们以XML格式编写，通常命名为`.hbm.xml`，并...
Hibernate（hibernate.cfg.xml的常用属性、对象关系映射文件、Java 大对象类型的 Hiberante 映射、映射组成关系（一对一一对多多对多））
二月鸟
07-31 391
上一篇 代码基础： //全局配置文件/Hibernate/src/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
分布式唯一id生成策略
weixin_34310785的博客
11-26 181
最近发现公司用的公共jar包里生成唯一主键的方法竟然用的是当前时间戳，这种方式有明显弊端，参考了网上各种生成唯一id的方式之后，做下总结。一、数据库自增ID使用mysql数据库的自增id，数据库的自增id的优点是非常明显的：第一是速度快，而且是按序自增，检索非常有利。第二是自增的id都是数字型，占用空间小，易于程序中排序。 第三是新增记录时可以不用指定id，不用担心主键重复问题。当然，使用数据库自...
hibernate映射文件之id详解
03-08 2025
   id 被映射的类必须声明对应数据库表主键字段。大多数类有一个JavaBeans风格的属性，为每一个实例包含唯一的标识。 元素定义了该属性到数据库表主键字段的映射。        name="propertyName"                      (1)        type="typename"                          (2)        co
看Hibernate源码之 ID Generator
weixin_34306446的博客
04-22 115
 Hibernate的id生成有N种策略, 可以通过hbm文件或者annotation配置. 支持的策略包括:uuid, hilo, assigned, identity, select, sequence, seqhilo, increment, foreign, guid, uuid.hex, sequence-identity. 对应这些策略, 可以在org.hibernate.id...
Hibernate配置文件的编写二（实体类编写规则、状态、操作和OID生成策略）
也许不会看见的博客
11-12 1182
学习笔记： 一、编写实体类的规则： ①hibernate要求实体类有一个属性值是唯一值。 ②属性值都是私有的。 ③私有属性值都有public的set、get方法。 ④实体类属性建议不使用基本数据类型，使用基本类型对应的包装类。比如，学生的分数用int score;当学生的分数得到0分可以：int score = 0;但是如果学生没有参加考试，无法准确的表达，所以用包装类Integer
分布式 - ID生成策略（id-generation）
qq_38946877的博客
03-08 458
分布式 - ID生成策略
利用hibernate映射文件生成表
spbetter的专栏
12-27 1528
还在为下载的的工程里没有数据库文件而苦恼吗？本文介绍的方法将解决你的这个苦恼很简单：产生Hibernate的SessionFactory类及hibernate.cfg.xml文件，然后手动写好Hibernate的映射文件（当然也可以是以前写好的，，在hibernate.cfg.xml中增加对应的mapping source，然后写一个如下的main方法运行即可。（注意：数据库中需得手动建好对应的库）public static void main(String[] args) {   Configuratio
获取hibernate的方言dialect
hety119的专栏
07-17 2263
SessionFactoryImpl sessionFactory = (SessionFactoryImpl)Application.getBeanContext().getBean(SessionFactory.class); System.out.println(sessionFactory.getDialect());
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值