https://blog.csdn.net/dada678/article/details/51786201
1、普通属性
@Entity：修饰的持久化类的所有属性都会被映射到底层数据库。
@Column:修饰属性
@Transient：修饰不想持久化保存的属性。
@Lob:修饰大数据属性。
当属性为byte[]、Byte[]时数据库对应Blob
当属性为char[]、character[]、String时，对应为Clob.
@Temporal修饰日期类型
支持TemporalType.DATE、TemporalType.TIME、TemporalType.TIMESTAMP
@GenericGenerator注解主键生成器 name strategy
例如：
@GenericGenerator(name="fk_hilo",strategy="hilo" ) //指定主键生成策略为hilo
@GeneratedValue(generator="fk_hilo") //使用该主键生成策略
2、映射集合属性
集合分为两种类型：一、List、Set、数组
二、Map
hibernate要求持久化集合值字段必须声明为接口。
不论哪种集合，统一使用@ElementCollection注释
属性fetch指定抓取策略 targetClass:指定集合类型。
外键列@JoinColumn
当集合元素为基础数据类型时，用@Column注释定义集合元素即可
@OrderColumn可以定义List集合、数组的索引列
@MapKeyColumn用于映射Map集合的索引列
例如：数组、list集合可以这样写
@ElementCollection(targetClass=String.class) //集合属性保存对象关联关系
@CollectionTable(name="school_inf",joinColumns=@joinColumn(name="person_id",nullable=false)) //映射保存集合属性的表
@Column(name="school_name") //指定保存集合元素的列为school_name
@OrderColumn(name="array_order") //映射集合的索引列【数组的写法】
@OrderColumn(name="list_order") //映射保存集合元索引列
private String[] schools;
private List<String> schools = new ArrayList<>();
例如：set集合，set集合无序，所以不用写OrderColumn
<list name="school_name" table="school_inf">
<key>
<column name="person_id" not-null="true"/>
</key>
<list-index>
<column name="array_order"/>
<list-index>
<element type="String" column="school_name"></element>
</list>
例如：
@ElementCollection(targetClass=String.class) //集合属性保存对象关联关系
@CollectionTable(name="school_inf",joinColumns=@joinColumn(name="person_id",nullable=false)) //映射保存集合属性的表,nullable=false说明该列为非空。
@Column(name="school_name",nullable=faluse) //指定保存集合元素的列为school_name
private Set<String> schools;
<set name="school_name" table="school_inf" >
<key>
<column name="person_id" not-null="true" />
</key>
<element type="string" column="school_name"></element>
</set>
例如：
List集合
@ElementCollection(targetClass=Float.class) //集合属性保存对象关联关系
@CollectionTable(name="score_inf",joinColumns=@joinColumn(name="person_id",nullable=false)) //映射保存集合属性的表,nullable=false说明该列为非空。
@MapKeyColumn(name="subject_name") //指定Map Key
@Column(name="mark") //指定保存集合元素的列为school_name
@OrderColumn(name="list_order") //映射保存集合元索引列
Map集合属性
@ElementCollection(targetClass=Float.class)
//映射保存集合属性的表
@CollectionTable(name="score_inf",//指定表名
joinColumns=@JoinColumn(name= "person_id",nullable=false))
@MapKeyColumn(name="subject_name")
//指定Mapkey的类型为String类型
@MapKeyClass(String.class)
//映射保存MapValue的数据列
@Column(name="mark")
private Map<String, Float> scores = new HashMap<>();
3、集合属性性能分析
在初始化持久化实体时，立即抓取所有的集合属性，将导致性能急剧下降，对于集合属性，通常使用延时加载策略。
@ElementCollection(fetch=FetchType.EAGER)
无序集合只能遍历，性能差
虽然数组也是有序结合，但是数据无法使用延时加载（因为数组长度不可变），所以实际上用数组作为集合性能并不高，通常认为List、Map集合性能较高，而
Set紧随其后
提高性能的策略：
对于删除集合中的元素，保留部分元素的情况，应该先清空集合，再插入保留元素。
List<String> tmp=person.getSchools();
person.setSchools(null); //清空操作
person.setSchools(tmp);
4、有序集合映射
如果希望数据库查询自己对集合元素排序，可以利用Hibernate自己提供的@OrderBy注解
1
@OrderBy("traing_name desc");
2
//有序集合属性
@ElementCollection(targetClass=String.class)
//映射保存集合元素的
@CollectionTable(name=@"training_inf",joinColumns=@JointColumn(name="person_id",nullable=false))
//定义保存集合元素的数据列
@Column(name="training_name",nullable=false)
//使用@SortNatural指定使用自然排序
@SortNatural
private SortedSet<String>trainings = new TreeSet<>();
5、映射数据库对象
如果希望在映射文件中创建和删除触发器，存储过程等数据库对象，hibernate提供了<database-object/>元素来满足这种需求
1.在映射文件显示生命create和drop命令
<hibernate-mapping>
<database-object>
<create>create trigger t_full_conent_gen ..</create>
<drop>create trigger t_full_content_gen</drop>
<!----指定某些数据库仅在特定的方言中使用--->
<!---指定仅对MySQL数据库有效-->
<dialect-scope name="org.hibernate.dialect.MySQL5Dialect"/>
<dialect-scope name="org.hibernate.dialect.MySQL5InnoDBDialect"/>
</database-object>
</hibernate-mapping>
2.提供一个类，这个类组织create和drop命令 这个类必须实现org.hibernate.mapping.AuxiliaryDatabaseObject接口
<hibernate-mapping>
<database-object>
<definition class="MyTriggerDefinition">
</database-object>
</hibernate-mapping>
<database-object>
<create>create table test(t_name varchar(255))</create>
<!--指定仅对特定方言有效-->
<dialect-scope name="org........"/>
</database-object>
这样在创建sessionFactory对象时，上面代码就生效了，数据库中就新建了test表。
Hibernate提供了schemaExport工具，生成数据库对象。[仅根据映射文件来生成数据库对象]
Configuration conf=new Configuration().configure();
SchemaExport se=new SchemaExport(conf);
se.setFormat(true) //格式化sql
.setOutputFile("news.sql") //设置保存sql脚本的文件
.create(true,true); //输入sql脚本并执行
//////SchemaExport工具类 使用java命令来解释执行工具类 命令格式如下
java -cp hibernate_classpaths org.hibernate.toolw.hbm2ddl.SchemaExport options mapping_files
6、映射组件属性：
持久化类属性并不是基础数据类型，例如privte Name name;
一、可以用@Embeddable注释Name类，作为组件使用，用@Parent修饰该属性。（修饰Name里的 private Person owner）
二、直接在Person实体类中，包含一个组件类型（Name类）
1.
@Embeddable
class Name{
//引用拥有该Name的Person对象
@Parent
private Person owner;
}
class Person{
//Name组件
private Name name;
}
2.class Person{
//主键属性Name
@Embedded
@AttributeOverrides({
@AttributeOverride(name="first",column=@Column(name="person_firstname")),
@AttributeOverride(name="last",column=@Column(name="person_lastname")),
})
}
3.组件属性为集合
class Name{
@ElementCollection(targetClass=Integer.class)
@CollecitonTable(name="power_inf",joinColumns=@JoinColumn(name="person_name_id",nullable=false))
@MapKeyColumn(name="power_inf")////////////
@Column(name="name_power",nullable=false)
@MapKeyClass(String.class)
prvate Map<String,Integer> power = new HashMap<>();
@OrderColumn(name="power_inf")/////
private List<String> power = new ArraryList<>();
}
4.集合属性的元素为组件
@Embeddable
class Name{}
@Entity
@Table(name="person_inf")
class Person{
//Map集合元素是组件
@ElementCollection(TargetClass=Score.class)
@CollectionTable(name="score_inf",joinColumns=@JoinColumn(name="person_id",nullable=false))
@MapKeyColumn(name="subject_name")
@MapKeyClass(String.class)
private Map<String,Score>scores = new HashMap<>();
//List集合元素是组件
@ElementColleciton(TargetClass=Name.class)
@CollectionTable(name="nick_inf",joinColumns=@JoinColun(name="person_id",nullable=false))
@OrderColumn(name="list_order")
private List<Name> nicks = new ArrayList<>();
}
5.组件作为Map的索引
@Embeddable
class Name{
//重写equals 和 hasCode方法
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (obj != null && obj.getClass() == Name.class) {
Name target = (Name)obj;
//属性值比较 自定义属性的比较
return target.getFirst().equals(getFirst()) && target.getLast().equals(getLast);
}
}
// 重写HasCode（）方法， 根据first、last计算hashCode值
retun getFirst().hasCode* 31 + getLast().hasCode();
}
@Enitity
@Table()
class Person{
//集合属性nickPower
@ElementColleciton(targetClass=Integer.class)
@CollectionTable(name="nbick_power_inf",JoinColumns=@JoinColumn(name="person_id",nullable=false))
@Column(name="nick_power",nullable=false)
@MapKeyClass(Name.class)//指定mapKey的类型
}
7.组件作为符合主键
class Name implements java.io.Serializable{
//重写equal（）和 hashCode（）
}
@Entity
@Table(name="")
class Person{
//以Name组件作为标识属性 用法同@Embedded @Embedded用于修饰普通的组件属性
//@EmbeddedId用于修饰组件类型的组件 同样可以结合@AttributeOverrides 和@AttributeOverride两个注释
@EmbeddedId
@AttributeOverrides({
//指定 组件内各属性与底层数据列之间的映射
@AtributeOverride(name="first",column=@Column(name="person_firstname"))
@AtributeOverride(name="last",column=@Column(name="person_lastname"))
})
}
8.多列作为联合主键
持久化类必须满足
1）无参数的构造器 2）实现java.io.Serializable 3)联合主键所映射的属性重写equals（）和 hashCode（）
@Entity
@Table(name="")
class Person{
//使用联合主键 只需要使用@Id修饰两个成员变量即可
@Id
prvate String first;
@Id
private String last;
//重写Equals（）方法 和 hashCode（）方法
}
---------------------
原文：https://blog.csdn.net/dada678/article/details/51786201
版权声明：本文为博主原创文章，转载请附上博文链接！
9使用xml映射符合主键
在person.hbm.xml中
<hibernate-configuration>
<class name="Person" table="person_inf">
<!--映射组件类型的标识属性,映射复合主键-->
<composite-id name="name" class="Name">
<!--映射符合主键里的各个属性-->
<key-property name="first" type="string"/>
<key-property name="last" type="string"/>
</composite-id>
<!--映射普通属性-->
<property name="email" type="string">
<!--映射组件属性cat，组件属性的类型为Cat-->
<component>
<!--指定owner属性代表容器实体-->
<parent name="owner"/>
<!--映射组件属性的fisrt属性-->
<property name="name" column="cat_name"/>
<!--映射组件属性的last属性-->
<property name="color" column="cat_color"/>
</component>
</class>
</hibernate-configuration>
Hibernate提供了如下三种方式将POJO变成PO类。
1使用持久化注解(以JPA标准注解为主,如果有一些特殊要求,则依然需要使用 Hibernate本身提供的注解
种方式可以
2使用JPA2提供的XML配置描述文件(XML deployment descriptor)，使用这种方式可以让Hibernate的PO类与JPA实体类兼容。
3使用 Hibernate传统的XML映射文件(* hbm. xml文件的形式),由于这种方式是传统 Hibernate
对于 Hibernate PO类而言,通常可以采用如下两个注解来修饰它。
@ Entity:被该注解修饰的POJO就是一个实体。使用该注解时可指定一个name属性,name属性指定该实体类的名称,但大部分时候无须指定该属性,因为系统默认以该类的类名作为实体类的名称
@ Table::该注解指定持久化类所映射的表。
使用Table注解可指定如表52所示的属性
|
属性 |
是否必须 |
说明 |
|
catalog |
否 |
设置将持久化类映射的表放入指定的 catalog中,如果没有指定该属性,数据表将放入默认的 catalog中 |
|
indexes |
否 |
为持久化类所映射的表设置索引。该属性的值是一个@Index注解数组 |
|
name |
否 |
设置持久化类所映射的表的表名。如果没有指定该属性,那么该表的表名将与持 久化类的类名相同 |
|
schema |
否 |
设置将持久化类所映射的表放入指定的 schema中。如果没有指定该属性，数据表将放入默认的schema中 |
|
uniqueConstraints |
否 |
为持久化类所映射的表设置唯一约束。该属性的值是一个@ UniqueConstraint注解数组 |
@UniqueConstraint用于为数据表定义唯一约束。它的用法非常简单,使用该注解时可以指定如下唯一的属性
columnNames
该属性的值是一个字符串数组,每个字符串元素代表一个数据列
@Index用于为数据表定义索引。该注解可指定如表53所示的属性。
|
属性 |
是否必须 |
说明 |
|
columnList |
是 |
设置对哪些列建立索引,该属性的值可指定多个数据列的列名 |
|
name |
否 |
置该索引的名字 |
|
unique |
否 |
设置该索引是否具有唯一性。该属性的值只能是 boolean值 |
如果希望改变 Hibernate的属性访问策略,则可使用标准的@ Access注解修改该持久化类,该注解的value属性支持 AccessType.PROPERTY和 Access.TypeFIELD两个值。其默认值为 AccessType PROPERTY,
即使用 getter/setter法访问属性两个方法
如果将@Acess注解的value指定为 AccessType FIELD, Hibernate将直接通过成员变量来访问属性。
除此之外, Hibernate还为持久化类提供了如下特殊的注解。
@ Proxy:该注解的 proxyClass属性指定一个接口,在延迟加载时作为代理使用,也可以在这里
指定该类自己的名字
@ DynamicInsert:指定用于插入记录的 Insert语句是否在运行时动态生成,并且只插入那些非空字段。该属性的值默认是 false。开启该属性将导致 Hibernate需要更多时间来生成SQL语句。
@ DynamicUpdate:指定用于更新记录的 update语句是否在运行时动态生成,并且只更新那些改变过的字段。该属性的值默认是 false。开启该属性将导致 Hibernate需要更多的时间来生成SOL语句
提示
程序打开了@ DynamicUpdate之后,持久化注解可以指定如下几种乐观锁定的策略
- OptimisticLockType.VERSION:检查 version/timestamp字段
- OptimisticLockType.ALL:检查全部字段
- OptimisticLockType.DIRTY:只检查修改过的字段
- OptimisticLockType.NONE:不使用乐观锁定
强烈建议在 Hibernate中使用 version/timestamp字段来进行乐观锁定。对性能来说,这是最妤的选择,并且也是唯一能够处理在 Session外进行脱管操作的策略。
@SelectBeforeUpdate:指定 Hibernate在更新( update)某个持久对象之前是否需要先进行一次查询(select)。如果将该注解的 value值设为ture,则 Hibernat可以保证只有当持久化对象的状态被修改过时,才会使用 update语句来保存其状态(即使程序显式使用 save OrUpdateO来保存该对象,但如果 Hibernate查询到对应记录与该持久化对象的状态相同,也不会使用update语句来保存其状态)。该注解的 value值默认为 false。通常来说,将@SelectBeforeUpdate的 value值设为ture会降低性能,如果应用程序中，某个持久化对象的状态经常会发生改变,那么该属性应该设置为 false;如果该持久化对象的状态很少发生改变,而程序又经常要保存该对象,则可将该属性设置为ture
@PolymorphismType:当采用 TABLE_PER_CLASS继承映射策略时,该注解用于指定是否需要采用隐式多态查询。该注解的 value的默认值为 PolymorphismType.IMPLICIT,即支持隐式多态查询
将@PolymorphismType的vaue值设为 PolymorphismType.IMPLICIT时,如果查询时给出的是任何超类、该类实现的接口或该类的名字,那么都会返回该类(及其子类)的实例;如果查询中给出的是子类的名字,则只返回子类的实例;否则,只有在查询时明确给出某个类名时,才会返回这个类的实例。大部分时候都需要使用隐式多态查询
@ Where:该注解的 clause属性可指定一个附加的SQL语句过滤条件(类似于添加 where子句),如果一旦指定了该注解,则不管采用load()、get()还是其他查询方法,只要试图加载该持久化类对象时,该 where条件就会生效。也就是说,只有符合该where条件的记录才会被加载。
@ BatchSize:当 Hibernate抓取集合属性或延迟加载的实体时,该注解的size属性指定每批抓取的实例数。
@OptimisticLocking该注解的type属性指定乐观锁定策略。 Hibernate支持OptimisticLockType.ALL、OptimisticLockType.DIRTY、 OptimisticLockType.NONE、 OptimisticLocklype.VERSION这4个枚举值默认值为 OptimisticLockType.VERSION
@ Check:该注解可通过 constraints指定一个SQL表达式,用于为该持久化类所对应的表指定一个 Check约束。
@ Subselect::该注解用于映射不可变的、只读实体。通俗地说,就是将数据库的子查询映射成Hibernate持久化对象。当需要使用视图(其实质就是一个查询)来代替数据表时,该注解比较有用
在默认情况下,被@Entity修饰的持久化类的所有属性都会被映射到底层数据表,为了指定某个属性映射的数据列的详细信息,如列名、列字段长度等,可以在实体类中使用@Column修饰该属性
使用@ Column时可指定如表所示的常用属性
|
属性 |
是否必须 |
说明 |
|
columnDefinition |
否 |
属性的值是一个代表列定义的SQL字符串(列名后面部分),指定创建该数据列的SQL语句 |
|
insertable |
否 |
指定该列是否包含在围生成的insert语句列表中,默认值true |
|
length |
否 |
指定列所能保存的数据的最大长度,默认值:255 |
|
name |
否 |
指定该列的列名,该到的列名默认与Coum修饰的成员变量名相同 |
|
nullable |
否 |
指定该列是否允许为null.默认值:true |
|
precision |
否 |
当该列是 decimal类型时,该属性指定该列最大支持的最大有效数字位 |
|
scale |
否 |
当该列是 decimal类型时,该属性指定该列最大支持的小数位数 |
|
table |
否 |
指定该列所属的表名,当需要用多个表来保存一个实体时,需要指定 |
|
unique |
否 |
指定列是否具有准一的束,默认值为false,即不具有唯一约束 |
|
updatable |
否 |
指定该列是否包含在 Hibemate生成的update语句的列到表中,默认值true |
Hiberate同样允许使用 @Access注解修饰该属性,用于单独改变 Hibemate对该属性的访问策略@Access用于覆盖在持久化类上指定的 @Access注解除此之外, Hibemate还为属性映射提供了如下特殊的注解
@Formula该注解的value属性可指定一个SQL表达式,指定该属性的值将根据表达式来计算，持久化类对应的表中没有和计算属性对应的数据列----因为该属性值是动态计算出来的,无需保存到数据库
@Generated设置该属性映射的数据列的值是否由数据库生成,该注解的 value属性可以接受GerationTime.NEVER(不由数据库生成)、 GenerationTime.INSERT(该属性值在执行insert句时生成,但不会在执行update语句时重新生成)和 Generationtime.ALWAYS该属性值在执行insert和update语句时都会重新生成)这三不值的其中之一。
@Formula的 value属性允许对象属性包含表达式,包括运用sum、 average,mux函数求值的结果
va1ue=”(select avg(p.price) from Product p)”
@Formula甚至可以根据另外一个表的查询结果来计算当前记录的属性值,例如,下面代码把currency表查询的结果作为当前记录的计算属性值
Value="(select cus.same from currency cur where cur.id=curreneyID)">
使用 @Formula注解时有如下几个注意点
- value="(sql)"的英文括号不能少
- value="(sql)"的括号里面是SOL表达式,SQL表达式中的列名与表名都应该和数据库对应,而不是和持久化对象的属性对应
- 如果需要在@Formula的value属性中使用参数,则直接使用 where cur.id= currencyID形式,其中 currencyID就是参数,当前持久化对象的 curreneyID属性将作为参数传入
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
import javax.swing.JList.DropLocation;
import org.hibernate.annotations.Formula;
import org.hibernate.annotations.Generated;
import org.hibernate.annotations.GenerationTime;
public class News implements Serializable {
public enum SeasonTime
{
springTime,summer,fall,winter
}
//使用@Enumerate修饰枚举
@Enumerated(EnumType.ORDINAL)
@Column(name="happen_season",length=50)//指定数据列表名称和长度 底层会保存数据序号来保存枚举值
private SeasonTime happenSeason;
/***
* 使用@Lob、@Basic修饰大数据类型的属性
* 用于数据库保存图片、保存大段文章的场景，数据库通常采用Blob、Clob类型的数据列来保存他们；
* JDBC则采用java.sql.Blob、java.sql、Clob表示大数据类型
* Hibernate使用@Lob来修饰这种大数据类型
* 1.当持久化类的属性为byte[]、Byte[]或java.io.Serializable类型修饰的属性将映射为底层的Blob列
* 2.当持久化类的属性为char[]、Character[]或java.lang.Strign类型时，@Lob修饰的属性将映射为底层的Clob列
* 使用@Basic指定延迟加载，可以指定如下属性
* 1)fetch:指定是否延迟加载该属性。
* FetchType.EAGER立即加载、FetchType.LAZY延迟加载
* 2）optional:指定该属性映射的数据列是否允许使用null值
* **/
@Lob
@Basic(fetch=FetchType.LAZY)
private byte[] pic;
/***
* @GeneratedValue支持的属性
* strategy 否 指Hibernate对该主键使用怎样的主键生成策略。该属性使用如下4个属性值
* 1）GenerationType.AUTO:Hibernate自动选择最适合底层数据库的主键生成策略。这是默认值
* 2）GenerationType.IDENTITY:对于MySQL、SQL Server这样的数据库，选择自增长这样的主键生成策略
* 3）GenerationType.SEQUENCE:对于Oracle数据库，选择使用基于Sequence的主键生成策略。
* 与@SequenceGennerator一起使用
* 4）GenerationType.TABLE:使用辅助表来生成主键。与@TableGenerator一起使用
* generator 否 当使用GeneatonType.SEQUENCE、GenerationType.TABLE主键生成策略时，
* 该属性引用@SequenceGenerator、@TableGenerator所定义的生成器的名称
* **/
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String title;
private String autohor;
/***
* 使用@Temporal修饰日期类型的属性
* java.util.Date既包括日期部分，也包括时间部分；使用@Temporal(TemporalType.DATE)将该属性映射到date类型的数据列
* **/
@Temporal(TemporalType.DATE)
private Date date;
//指定@Generated的value为ALWAYS,表明该属性的值由数据库生成
//Hibernate会在每次执行insert、update时执行select语句来查询获取该属性的值
//使用此属性需要数据库触发器支持
/**
* drop database hibernate;
create database hibernate;
use hibernate;
create table news
(
id int auto_increment primary key,
title varchar(255) not null,
content varchar(255),
full_content varchar(2555)
);
DELIMITER |
create trigger t_full_content_gen BEFORE INSERT ON news
FOR EACH ROW BEGIN
set new.full_content=concat(new.title,new.content);
END;
|
DELIMITTER;
* **/
@Generated(GenerationTime.ALWAYS)
private String generContent;
//此属性由系统根据公式生成
@Formula("(select concat(nt.title,nt.autohor)"+"from NEWS nt where nt.id = id)")
private String fullConent;
//使用@Transient修饰不想持久保存的属性
@Transient
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAutohor() {
return autohor;
}
public void setAutohor(String autohor) {
this.autohor = autohor;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public News() {
// super();
// TODO Auto-generated constructor stub
}
public News(String title, String autohor, Date date) {
super();
this.title = title;
this.autohor = autohor;
this.date = date;
}
@Override
public String toString() {
return "News [id=" + id + ", title=" + title + ", autohor=" + autohor + ", date=" + date + "]";
}
}
@SequenceGenerator支持的属性
|
属性 |
是否必须 |
说明 |
|
name |
是 |
该属性指定该主键生成器的名称 |
|
allocationSize |
否 |
该属性指定底层 Sequence每次生成主键值的个数,对于Oracle而言,该属性指定的整数值, 将作为定义 Sequence时 increment by的值 |
|
schema |
否 |
该属性指定将底层 Sequence放入指定shema中,如果不指定该属性,该 Sequence将放入默认的 schema中 |
|
catalog |
否 |
该属性指定将底层Sequence放入指定 catalog中,如果不指定该属性,该 Sequence将放入默catalog中 |
|
initialValue |
否 |
该属性指定底层Sequence的初始值。对于Oracle而言，该属性指定的整数值将作为定义Sequence时startwith的值 |
|
sequenceName |
否 |
该属性指定底层Sequnece的名称 |
@TableGenerator支持的属性
|
属性 |
是否必须 |
说明 |
|
name |
是 |
该属性指定该主键生成器的名称 |
|
allocationSize |
否 |
该属性指定底层辅助表每次生成主键值的个数 |
|
catalog |
否 |
该属性指定将辅助表放入指定catalog中，如果不指定该属性，该辅助表将放入默认的catalog中 |
|
schema |
否 |
该属性指定将底层辅助表放入指定catalog中，如果不指定该属性，该辅助表将放入默认的schema中 |
|
table |
否 |
指定辅助表的表明 |
|
initialValue |
否 |
该属性指定的整数值将作为辅助表的初始值。默认值：0 |
|
pkColumnName |
否 |
该属性指定存放主键名的列名 |
|
pkColumnValue |
否 |
该属性指定主键名 |
|
valueColumnValue |
否 |
该属性指定存放主键名的列名 |
|
indexes |
否 |
该属性值是一个@Index数组，用于为辅助表定义索引 |
|
uniqueConstraints |
否 |
该属性值是一个@UniqueConstraint数组，用于为辅助表创建唯一约束 |
主键生成策略
1.
@TableGenerator(name="newsGen",table="NEWS_ID_GEN",pkColumnName="gen_key",
valueColumnName="gen_value",pkColumnValue="news_id")
@TableGenerator(name="newsGen",table="NEWS_ID_GEN",
pkColumnName="gen_key",valueColumnName="gen_value",
pkColumnValue="news_id")
//使用GeneratedValue.TABLE主键生成策略
@GeneratedValue(strategy=GenerationType.TABLE,generator="newsGen")
2.使用Hibernate的主键生成策略
@GenericGenerator注解支持的属性
- name:必须属性指定主键生成器的名称，可以被@GeneratedValue的generator属性引用
- strategy:必须属性。设置主键生成策略
- Increment:主键类型long、short、int类型，只有在没有其他进程往同一表中插入数据时使用
- Identity：DB2、MySQL、MicsortSQL Server、Sybase和HypersonicSQL等。主键类型long、short、Int类型
- SequenceDB2、PostgreSQL、Oracle、SAPDB、McKoi等主键类型：long、short、int
- Hilo：高低位高效算法long、short、int类型的标识符
- seqhilo ：高低位高效算法long、short、int类型的标识符，需要给定一个Sequence的数据库名，如Oracle
- uuid：128位UUID算法生成字符串类型的标识符号，UUID被编码为一个32位十六进制数的字符串
- guid： 在MicsortSQLSever和MySQL中使用数据库生成GUID字符串
- native： 根据底层数据库的能力选择identity、Sequence、或hilo中一个
- assigned：让应用程序在save（）之前为对象分配一个标识符。相当于在不指定主键生成策略所采用默认策略
- select： 通过数据库触发器选择某个唯一主键的行，并返回器主键值作为标识属性值
- foreign： 直接使用另一个关联的对象的标识属性值、这种主键生成器只用于1-1关联