Hibernate注释大全（转）
声明实体Bean
@Entity
publicclassFlightimplementsSerializable{
Longid;
@Id
publicLonggetId(){returnid;}
publicvoidsetId(Longid){this.id=id;}
}
@Entity注解将一个类声明为实体Bean,@Id注解声明了该实体Bean的标识属性。
Hibernate可以对类的属性或者方法进行注解。属性对应field类别，方法的getXxx()对应property类别。
定义表
通过@Table为实体Bean指定对应数据库表，目录和schema的名字。
@Entity
@Table(name="tbl_sky")
publicclassSkyimplementsSerializable{
...
@Table注解包含一个schema和一个catelog属性，使用@UniqueConstraints可以定义表的唯一约束。
@Table(name="tbl_sky",
uniqueConstraints={@UniqueConstraint(columnNames={"month","day"})}
)
上述代码在"month"和"day"两个field上加上uniqueconstrainst.
@Version注解用于支持乐观锁版本控制。
@Entity
publicclassFlightimplementsSerializable{
...
@Version
@Column(name="OPTLOCK")
publicIntegergetVersion(){...}
}
version属性映射到"OPTLOCK"列，entitymanager使用这个字段来检测冲突。一般可以用数字或者timestamp类型来支持version.
实体Bean中所有非static非transient属性都可以被持久化，除非用@Transient注解。
默认情况下，所有属性都用@Basic注解。
publictransientintcounter;//transientproperty
privateStringfirstname;//persistentproperty
@Transient
StringgetLengthInMeter(){...}//transientproperty
StringgetName(){...}//persistentproperty
@Basic
intgetLength(){...}//persistentproperty
@Basic(fetch=FetchType.LAZY)
StringgetDetailedComment(){...}//persistentproperty
@Temporal(TemporalType.TIME)
java.util.DategetDepartureTime(){...}//persistentproperty
@Enumerated(EnumType.STRING)
StarredgetNote(){...}//enumpersistedasStringindatabase
上述代码中counter,lengthInMeter属性将忽略不被持久化，而firstname,name,length被定义为可持久化和可获取的。
@TemporalType.(DATE,TIME,TIMESTAMP)分别Mapjava.sql.(Date,Time,Timestamp).
@Lob注解属性将被持久化为Blog或Clob类型。具体的java.sql.Clob,Character[],char[]和java.lang.String将被持久化为Clob类型.java.sql.Blob,Byte[],byte[]和serializabletype将被持久化为Blob类型。
@Lob
publicStringgetFullText(){
returnfullText;//clobtype
}
@Lob
publicbyte[]getFullCode(){
returnfullCode;//blogtype
}
@Column注解将属性映射到列。
@Entity
publicclassFlightimplementsSerializable{
...
@Column(updatable=false,name="flight_name",nullable=false,length=50)
publicStringgetName(){...}
定义name属性映射到flight_namecolumn,notnull,can'tupdate,lengthequal50
@Column(
name="columnName";(1)列名
booleanunique()defaultfalse;(2)是否在该列上设置唯一约束
booleannullable()defaulttrue;(3)列可空？
booleaninsertable()defaulttrue;(4)该列是否作为生成insert语句的一个列
booleanupdatable()defaulttrue;(5)该列是否作为生成update语句的一个列
StringcolumnDefinition()default"";(6)默认值
Stringtable()default"";(7)定义对应的表（deault是主表）
intlength()default255;(8)列长度
intprecision()default0;//decimalprecision(9)decimal精度
intscale()default0;//decimalscale(10)decimal长度
嵌入式对象（又称组件）也就是别的对象定义的属性
组件类必须在类一级定义@Embeddable注解。在特定的实体关联属性上使用@Embeddable和@AttributeOverride注解可以覆盖该属性对应的嵌入式对象的列映射。
@Entity
publicclassPersonimplementsSerializable{
//Persistentcomponentusingdefaults
AddresshomeAddress;
@Embedded
@AttributeOverrides({
@AttributeOverride(name="iso2",column=@Column(name="bornIso2")),
@AttributeOverride(name="name",column=@Column(name="bornCountryName"))
})
CountrybornIn;
...
}
@Embeddable
publicclassAddressimplementsSerializable{
Stringcity;
Countrynationality;//nooverridinghere
}
@Embeddable
publicclassCountryimplementsSerializable{
privateStringiso2;
@Column(name="countryName")privateStringname;
publicStringgetIso2(){returniso2;}
publicvoidsetIso2(Stringiso2){this.iso2=iso2;}
publicStringgetName(){returnname;}
publicvoidsetName(Stringname){this.name=name;}
...
}
Person类定义了Address和Country对象，具体两个类实现见上。
无注解属性默认值：
•属性为简单类型，则映射为@Basic
•属性对应的类型定义了@Embeddable注解，则映射为@Embedded
•属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。
•属性的类型为java.sql.Cloborjava.sql.Blob,则映射到@Lob对应的类型。
映射主键属性
@Id注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。
•AUTO-可以是identitycolumn,sequence或者table类型，取决于不同底层的数据库
•TABLE-使用table保存id值
•IDENTITY-identitycolumn
•SEQUENCE-seque
nce
@Id@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_STORE")
publicIntegergetId(){...}
@Id@GeneratedValue(strategy=GenerationType.IDENTITY)
publicLonggetId(){...}
AUTO生成器，适用与可移值的应用，多个@Id可以共享同一个identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator和@TableGenerator可以配置不同的identifier生成器。
<table-generatorname="EMP_GEN"
table="GENERATOR_TABLE"
pk-column-name="key"
value-column-name="hi"
pk-column-value="EMP"
allocation-size="20"/>
//andtheannotationequivalent
@javax.persistence.TableGenerator(
name="EMP_GEN",
table="GENERATOR_TABLE",
pkColumnname="key",
valueColumnname="hi"
pkColumnValue="EMP",
allocationSize=20
)
<sequence-generatorname="SEQ_GEN"
sequence-name="my_sequence"
allocation-size="20"/>
//andtheannotationequivalent
@javax.persistence.SequenceGenerator(
name="SEQ_GEN",
sequencename="my_sequence",
allocationSize=20
)
Thenextexampleshowsthedefinitionofasequencegeneratorinaclassscope:
@Entity
@javax.persistence.SequenceGenerator(
name="SEQ_STORE",
sequencename="my_sequence"
)
publicclassStoreimplementsSerializable{
privateLongid;
@Id@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_STORE")
publicLonggetId(){returnid;}
}
Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。
通过下面语法，你可以定义组合键。
•将组件类注解为@Embeddable，并将组件的属性注解为@Id
•将组件的属性注解为@EmbeddedId
•将类注解为@IdClass，并将该实体中所有主键的属性都注解为@Id
@Entity
@IdClass(FootballerPk.class)
publicclassFootballer{
//partoftheidkey
@IdpublicStringgetFirstname(){
returnfirstname;
}
publicvoidsetFirstname(Stringfirstname){
this.firstname=firstname;
}
//partoftheidkey
@IdpublicStringgetLastname(){
returnlastname;
}
publicvoidsetLastname(Stringlastname){
this.lastname=lastname;
}
publicStringgetClub(){
returnclub;
}
publicvoidsetClub(Stringclub){
this.club=club;
}
//appropriateequals()andhashCode()implementation
}
@Embeddable
publicclassFootballerPkimplementsSerializable{
//samenameandtypeasinFootballer
publicStringgetFirstname(){
returnfirstname;
}
publicvoidsetFirstname(Stringfirstname){
this.firstname=firstname;
}
//samenameandtypeasinFootballer
publicStringgetLastname(){
returnlastname;
}
publicvoidsetLastname(Stringlastname){
this.lastname=lastname;
}
//appropriateequals()andhashCode()implementation
}
@Entity
@AssociationOverride(name="id.channel",joinColumns=@JoinColumn(name="chan_id"))
publicclassTvMagazin{
@EmbeddedIdpublicTvMagazinPkid;
@Temporal(TemporalType.TIME)Datetime;
}
@Embeddable
publicclassTvMagazinPkimplementsSerializable{
@ManyToOne
publicChannelchannel;
publicStringname;
@ManyToOne
publicPresenterpresenter;
}
映射继承关系
EJB支持3种类型的继承。
•TableperClassStrategy:the<union-class>elementinHibernate每个类一张表
•SingleTableperClassHierarchyStrategy:the<subclass>elementinHibernate每个类层次结构一张表
•JoinedSubclassStrategy:the<joined-subclass>elementinHibernate连接的子类策略
@Inheritance注解来定义所选的之类策略。
每个类一张表
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
publicclassFlightimplementsSerializable{
有缺点，如多态查询或关联。Hibernate使用SQLUnion查询来实现这种策略。这种策略支持双向的一对多关联，但不支持IDENTIFY生成器策略，因为ID必须在多个表间共享。一旦使用就不能使用AUTO和IDENTIFY生成器。
每个类层次结构一张表
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name="planetype",
discriminatorType=DiscriminatorType.STRING
)
@DiscriminatorValue("Plane")
publicclassPlane{...}
@Entity
@DiscriminatorValue("A320")
publicclassA320extendsPlane{...}
整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。
Plane是父类。@DiscriminatorColumn注解定义了辨别符列。对于继承层次结构中的每个类,@DiscriminatorValue注解指定了用来辨别该类的值。辨别符列名字默认为DTYPE，其默认值为实体名。其类型为DiscriminatorType.STRING。
连接的子类
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
publicclassBoatimplementsSerializable{...}
@Entity
publicclassFerryextendsBoat{...}
@Entity
@PrimaryKeyJoinColumn(name="BOAT_ID")
publicclassAmericaCupClassextendsBoat{...}
以上所有实体使用JOINED策略Ferry和Boatclass使用同名的主键关联(eg:Boat.id=Ferry.id)，AmericaCupClass和Boat关联的条件为Boat.id=AmericaCupClass.BOAT_ID.
从父类继承的属性
@MappedSuperclass
publicclassBaseEntity{
@Basic
@Temporal(TemporalType.TIMESTAMP)
publicDategetLastUpdate(){...}
publicStringgetLastUpdater(){...}
...
}
@EntityclassOrderextendsBaseEntity{
@IdpublicIntegergetId(){...}
...
}
继承父类的一些属性，但不用父类作为映射实体，这时候需要@MappedSuperclass注解。上述实体映射到数据库中的时候对应Order实体Bean,其具有id,lastUpdate,lastUpdater三个属性。如果没有@MappedSuperclass注解,则父类中属性忽略，这是Order实体Bean只有id一个属性。
映射实体Bean的关联关系
一对一
使用@OneToOne注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。
•关联的实体都共享同样的主键。
@Entity
publicclassBody{
@Id
publicLonggetId(){returnid;}
@OneToOne(cascade=CascadeType.ALL)
@PrimaryKeyJoinColumn
publicHeartgetHeart(){
returnheart;
}
...
}
@Entity
publicclassHeart{
@Id
publicLonggetId(){...}
}
通过@PrimaryKeyJoinColumn注解定义了一对一的关联关系。
•其中一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。
@Entity
publicclassCustomerimplementsSerializable{
@OneToOne(cascade=CascadeType.ALL)
@JoinColumn(name="passport_fk")
publicPassportgetPassport(){
...
}
@Entity
publicclassPassportimplementsSerializable{
@OneToOne(mappedBy="passport")
publicCustomergetOwner(){
...
}
通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解，则系统自动处理，在主表中将创建连接列，列名为：主题的关联属性名+下划线+被关联端的主键列名。上例为passport_id,因为Customer中关联属性为passport,Passport的主键为id.
•通过关联表来保存两个实体之间的关联关系。注：一对一，则关联表每个外键都必须是唯一约束。
@Entity
publicclassCustomerimplementsSerializable{
@OneToOne(cascade=CascadeType.ALL)
@JoinTable(name="CustomerPassports",
joinColumns=@JoinColumn(name="customer_fk"),
inverseJoinColumns=@JoinColumn(name="passport_fk")
)
publicPassportgetPassport(){
...
}
@EntitypublicclassPassportimplementsSerializable{
@OneToOne(mappedBy="passport")
publicCustomergetOwner(){
...
}
Customer通过CustomerPassports关联表和Passport关联。该关联表通过passport_fk外键指向Passport表，该信心定义为inverseJoinColumns的属性值。通过customer_fk外键指向Customer表，该信息定义为joinColumns属性值。
多对一
使用@ManyToOne注解定义多对一关系。
@Entity()
publicclassFlightimplementsSerializable{
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE})
@JoinColumn(name="COMP_ID")
publicCompanygetCompany(){
returncompany;
}
...
}
其中@JoinColumn注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名+下划线+被关联端的主键列名。本例中为company_id,因为关联的属性是company,Company的主键为id.
@ManyToOne注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要targetEntity定义（使用接口作为返回值，而不是常用的实体）。
@Entity()
publicclassFlightimplementsSerializable{
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE},targetEntity=CompanyImpl.class)
@JoinColumn(name="COMP_ID")
publicCompanygetCompany(){
returncompany;
}
...
}
publicinterfaceCompany{
...
多对一也可以通过关联表的方式来映射，通过@JoinTable注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过@JoinTable.inverseJoinColumns）.
@Entity()
publicclassFlightimplementsSerializable{
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE})
@JoinTable(name="Flight_Company",
joinColumns=@JoinColumn(name="FLIGHT_ID"),
inverseJoinColumns=@JoinColumn(name="COMP_ID")
)
publicCompanygetCompany(){
returncompany;
}
...
}
集合类型
一对多
@OneToMany注解可定义一对多关联。一对多关联可以是双向的。
双向
规范中多对一端几乎总是双向关联中的主体（owner）端，而一对多的关联注解为@OneToMany(mappedBy=)
@Entity
publicclassTroop{
@OneToMany(mappedBy="troop")
publicSet<Soldier>getSoldiers(){
...
}
@Entity
publicclassSoldier{
@ManyToOne
@JoinColumn(name="troop_fk")
publicTroopgetTroop(){
...
}
Troop通过troop属性和Soldier建立了一对多的双向关联。在mappedBy端不必也不能定义任何物理映射。
单向
@Entity
publicclassCustomerimplementsSerializable{
@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
publicSet<Ticket>getTickets(){
...
}
@Entity
publicclassTicketimplementsSerializable{
...//nobidir
}
一般通过连接表来实现这种关联，可以通过@JoinColumn注解来描述这种单向关联关系。上例Customer通过CUST_ID列和Ticket建立了单向关联关系。
通过关联表来处理单向关联
@Entity
publicclassTrainer{
@OneToMany
@JoinTable(
name="TrainedMonkeys",
joinColumns=@JoinColumn(name="trainer_id"),
inverseJoinColumns=@JoinColumn(name="monkey_id")
)
publicSet<Monkey>getTrainedMonkeys(){
...
}
@Entity
publicclassMonkey{
...//nobidir
}
通过关联表来处理单向一对多关系是首选，这种关联通过@JoinTable注解来进行描述。上例子中Trainer通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns).
默认处理机制
通过连接表来建立单向一对多关联不需要描述任何物理映射，表名由一下3个部分组成，主表(ownertable)表名+下划线+从表(theothersidetable)表名。指向主表的外键名:主表表名+下划线+主表主键列名指向从表的外键定义为唯一约束，用来表示一对多的关联关系。
@Entity
publicclassTrainer{
@OneToMany
publicSet<Tiger>getTrainedTigers(){
...
}
@Entity
publicclassTiger{
...//nobidir
}
上述例子中Trainer和Tiger通过Trainer_Tiger连接表建立单向关联关系。其中外键trainer_id关联到Trainer表，而外键trainedTigers_id关联到Tiger表。
多对多
通过@ManyToMany注解定义多对多关系，同时通过@JoinTable注解描述关联表和关联条件。其中一端定义为owner,另一段定义为inverse(对关联表进行更新操作，这段被忽略)。
@Entity
publicclassEmployerimplementsSerializable{
@ManyToMany(
targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,
cascade={CascadeType.PERSIST,CascadeType.MERGE}
)
@JoinTable(
name="EMPLOYER_EMPLOYEE",
joinColumns=@JoinColumn(name="EMPER_ID"),
inverseJoinColumns=@JoinColumn(name="EMPEE_ID")
)
publicCollectiongetEmployees(){
returnemployees;
}
...
}
@Entity
publicclassEmployeeimplementsSerializable{
@ManyToMany(
cascade={CascadeType.PERSIST,CascadeType.MERGE},
mappedBy="employees",
targetEntity=Employer.class
)
publicCollectiongetEmployers(){
returnemployers;
}
}
默认值：
关联表名：主表表名+下划线+从表表名；关联表到主表的外键：主表表名+下划线+主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名。
用cascading实现传播持久化（Transitivepersistence）
cascade属性接受值为CascadeType数组，其类型如下：
•CascadeType.PERSIST:cascadesthepersist(create)operationtoassociatedentitiespersist()iscalledoriftheentityismanaged如果一个实体是受管状态，或者当persist()函数被调用时，触发级联创建(create)操作。
•CascadeType.MERGE:cascadesthemergeoperationtoassociatedentitiesifmerge()iscalledoriftheentityismanaged如果一个实体是受管状态，或者当merge()函数被调用时，触发级联合并(merge)操作。
•CascadeType.REMOVE:cascadestheremoveoperationtoassociatedentitiesifdelete()iscalled当delete()函数被调用时，触发级联删除(remove)操作。
•CascadeType.REFRESH:cascadestherefreshoperationtoassociatedentitiesifrefresh()iscalled当refresh()函数被调用时，出发级联更新(refresh)操作。
•CascadeType.ALL:alloftheabove以上全部
映射二级列表
使用类一级的@SecondaryTable和@SecondaryTables注解可以实现单个实体到多个表的映射。使用@Column或者@JoinColumn注解中的table参数可以指定某个列所属的特定表。
@Entity
@Table(name="MainCat")
@SecondaryTables({
@SecondaryTable(name="Cat1",pkJoinColumns={
@PrimaryKeyJoinColumn(name="cat_id",referencedColumnname="id")}),
@SecondaryTable(name="Cat2",uniqueConstraints={
@UniqueConstraint(columnNames={"storyPart2"})})
})
publicclassCatimplementsSerializable{
privateIntegerid;
privateStringname;
privateStringstoryPart1;
privateStringstoryPart2;
@Id@GeneratedValue
publicIntegergetId(){
returnid;
}
publicStringgetName(){
returnname;
}
@Column(table="Cat1")
publicStringgetStoryPart1(){
returnstoryPart1;
}
@Column(table="Cat2")
publicStringgetStoryPart2(){
returnstoryPart2;
}
上述例子中，name保存在MainCat表中，storyPart1保存在Cat1表中，storyPart2保存在Cat2表中。Cat1表通过外键cat_id和MainCat表关联，Cat2表通过id列和MainCat表关联。对storyPart2列还定义了唯一约束。
映射查询
使用注解可以映射EJBQL/HQL查询，@NamedQuery和@NamedQueries是可以使用在类级别或者JPA的XML文件中的注解。
<entity-mappings>
<named-queryname="plane.getAll">
<query>selectpfromPlanep</query>
</named-query>
...
</entity-mappings>
...
@Entity
@NamedQuery(name="night.moreRecentThan",query="selectnfromNightnwheren.date>=:date")
publicclassNight{
...
}
publicclassMyDao{
doStuff(){
Queryq=s.getNamedQuery("night.moreRecentThan");
q.setDate("date",aMonthAgo);
Listresults=q.list();
...
}
...
}
可以通过定义QueryHint数组的hints属性为查询提供一些hint信息。下图是一些Hibernatehints:
映射本地化查询
通过@SqlResultSetMapping注解来描述SQL的resultset结构。如果定义多个结果集映射，则用@SqlResultSetMappings。
@NamedNativeQuery(name="night&area",query="selectnight.idnid,night.night_duration,"
+"night.night_date,area.idaid,night.area_id,area.name"
+"fromNightnight,Areaareawherenight.area_id=area.id",resultSetMapping="joinMapping")
@SqlResultSetMapping(name="joinMapping",entities={
@EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class,fields={
@FieldResult(name="id",column="nid"),
@FieldResult(name="duration",column="night_duration"),
@FieldResult(name="date",column="night_date"),
@FieldResult(name="area",column="area_id"),
discriminatorColumn="disc"
}),
@EntityResult(entityClass=org.hibernate.test.annotations.query.Area.class,fields={
@FieldResult(name="id",column="aid"),
@FieldResult(name="name",column="name")
})
}
)
上面的例子，名为“night&area”的查询和"joinMapping"结果集映射对应，该映射返回两个实体，分别为Night和Area,其中每个属性都和一个列关联，列名通过查询获取。
@Entity
@SqlResultSetMapping(name="implicit",
entities=@EntityResult(
entityClass=org.hibernate.test.annotations.@NamedNativeQuery(
name="implicitSample",query="select*fromSpaceShip",
resultSetMapping="implicit")
publicclassSpaceShip{
privateStringname;
privateStringmodel;
privatedoublespeed;
@Id
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Column(name="model_txt")
publicStringgetModel(){
returnmodel;
}
publicvoidsetModel(Stringmodel){
this.model=model;
}
publicdoublegetSpeed(){
returnspeed;
}
publicvoidsetSpeed(doublespeed){
this.speed=speed;
}
}
上例中model1属性绑定到model_txt列，如果和相关实体关联设计到组合主键，那么应该使用@FieldResult注解来定义每个外键列。@FieldResult的名字组成：定义这种关系的属性名字+"."+主键名或主键列或主键属性。
@Entity
@SqlResultSetMapping(name="compositekey",
entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class,
fields={
@FieldResult(name="name",column="name"),
@FieldResult(name="model",column="model"),
@FieldResult(name="speed",column="speed"),
@FieldResult(name="captain.firstname",column="firstn"),
@FieldResult(name="captain.lastname",column="lastn"),
@FieldResult(name="dimensions.length",column="length"),
@FieldResult(name="dimensions.width",column="width")
}),
columns={@ColumnResult(name="surface"),
@ColumnResult(name="volume")})
@NamedNativeQuery(name="compositekey",
query="selectname,model,speed,lnameaslastn,fnameasfirstn,length,width,length*widthasresultSetMapping="compositekey")
})
如果查询返回的是单个实体，或者打算用系统默认的映射，这种情况下可以不使用resultSetMapping，而使用resultClass属性，例如：
@NamedNativeQuery(name="implicitSample",query="select*fromSpaceShip",
resultClass=SpaceShip.class)
publicclassSpaceShip{
Hibernate独有的注解扩展
Hibernate提供了与其自身特性想吻合的注解，org.hibernate.annotationspackage包含了这些注解。
实体
org.hibernate.annotations.Entity定义了Hibernate实体需要的信息。
•mutable:whetherthisentityismutableornot此实体是否可变
•dynamicInsert:allowdynamicSQLforinserts用动态SQL新增
•dynamicUpdate:allowdynamicSQLforupdates用动态SQL更新
•selectBeforeUpdate:SpecifiesthatHibernateshouldneverperformanSQLUPDATEunlessitiscertainthatanobjectisactuallymodified.指明Hibernate从不运行SQLUpdate，除非能确定对象已经被修改
•polymorphism:whethertheentitypolymorphismisofPolymorphismType.IMPLICIT(default)orPolymorphismType.EXPLICIT指出实体多态是PolymorphismType.IMPLICIT(默认)还是PolymorphismType.EXPLICIT
•optimisticLock:optimisticlockingstrategy(OptimisticLockType.VERSION,OptimisticLockType.NONE,OptimisticLockType.DIRTYorOptimisticLockType.ALL)乐观锁策略
标识符
@org.hibernate.annotations.GenericGenerator和@org.hibernate.annotations.GenericGenerators允许你定义hibernate特有的标识符。
@Id@GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid",strategy="uuid")
publicStringgetId(){
@Id@GeneratedValue(generator="hibseq")
@GenericGenerator(name="hibseq",strategy="seqhilo",
parameters={
@Parameter(name="max_lo",value="5"),
@Parameter(name="sequence",value="heybabyhey")
}
)
publicIntegergetId(){
新例子
@GenericGenerators(
{
@GenericGenerator(
name="hibseq",
strategy="seqhilo",
parameters={
@Parameter(name="max_lo",value="5"),
@Parameter(name="sequence",value="heybabyhey")
}
),
@GenericGenerator(...)
}
)
自然ID
用@NaturalId注解标识
公式
让数据库而不是JVM进行计算。
@Formula("obj_length*obj_height*obj_width")
publiclonggetObjectVolume()
索引
通过在列属性(property)上使用@Index注解，可以指定特定列的索引，columnNames属性(attribute)将随之被忽略。
@Column(secondaryTable="Cat1")
@Index(name="story1index")
publicStringgetStoryPart1(){
returnstoryPart1;
}
辨别符
@Entity
@DiscriminatorFormula("casewhenforest_typeisnullthen0elseforest_typeend")
publicclassForest{...}
过滤查询...