Hibernate注释大全 2(2010-01-16 14:28:05)转载标签:it
一对多
@OneToMany 注解可定义一对多关联。一对多关联可以是双向的。
双向
规范中多对一端几乎总是双向关联中的主体(owner)端,而一对多的关联注解为 @OneToMany(mappedBy=)
@Entity
public class Troop {
@OneToMany(mappedBy="troop")
public Set<Soldier> getSoldiers() {
...
}
@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name="troop_fk")
public Troop getTroop() {
...
}
Troop 通过troop属性和Soldier建立了一对多的双向关联。在 mappedBy 端不必也不能定义任何物理映射。
单向
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/tangcx/archive/2009/05/06/4152320.aspx
@Entity
public class Customer implements Serializable {
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
public Set<Ticket> getTickets() {
...
}
@Entity
public class Ticket implements Serializable {
... //no bidir
}
一般通过连接表来实现这种关联,可以通过@JoinColumn注解来描述这种单向关联关系。上例 Customer 通过 CUST_ID 列和 Ticket 建立了单向关联关系。
通过关联表来处理单向关联
@Entity
public class Trainer {
@OneToMany
@JoinTable(
name="TrainedMonkeys",
joinColumns = @JoinColumn( name="trainer_id"),
inverseJoinColumns = @JoinColumn( name="monkey_id")
)
public Set<Monkey> getTrainedMonkeys() {
...
}
@Entity
public class Monkey {
... //no bidir
}
通过关联表来处理单向一对多关系是首选,这种关联通过 @JoinTable 注解来进行描述。上例子中 Trainer 通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns).
默认处理机制
通过连接表来建立单向一对多关联不需要描述任何物理映射,表名由一下3个部分组成,主表(owner table)表名 + 下划线 + 从表(the other side table)表名。指向主表的外键名:主表表名+下划线+主表主键列名指向从表的外键定义为唯一约束,用来表示一对多的关联关系。
@Entity
public class Trainer {
@OneToMany
public Set<Tiger> getTrainedTigers() {
...
}
@Entity
public class Tiger {
... //no bidir
}
上述例子中 Trainer 和 Tiger 通过 Trainer_Tiger 连接表建立单向关联关系。其中外键 trainer_id 关联到 Trainer表,而外键 trainedTigers_id 关联到 Tiger 表。
多对多
通过 @ManyToMany 注解定义多对多关系,同时通过 @JoinTable 注解描述关联表和关联条件。其中一端定义为 owner, 另一段定义为 inverse(对关联表进行更新操作,这段被忽略)。
@Entity
public class Employer implements Serializable {
@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")
)
public Collection getEmployees() {
return employees;
}
...
}
@Entity
public class Employee implements Serializable {
@ManyToMany(
cascade = {CascadeType.PERSIST, CascadeType.MERGE},
mappedBy = "employees",
targetEntity = Employer.class
)
public Collection getEmployers() {
return employers;
}
}
默认值:
关联表名:主表表名 + 下划线 + 从表表名;关联表到主表的外键:主表表名 + 下划线 + 主表中主键列名;关联表到从表的外键名:主表中用于关联的属性名 + 下划线 + 从表的主键列名。
用 cascading 实现传播持久化(Transitive persistence)
cascade 属性接受值为 CascadeType 数组,其类型如下:
? CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体是受管状态,或者当 persist() 函数被调用时,触发级联创建(create)操作。
? CascadeType.MERGE: cascades the merge operation to associated entities if merge() is called or if the entity is managed 如果一个实体是受管状态,或者当 merge() 函数被调用时,触发级联合并(merge)操作。
? CascadeType.REMOVE: cascades the remove operation to associated entities if delete() is called 当 delete() 函数被调用时,触发级联删除(remove)操作。
? CascadeType.REFRESH: cascades the refresh operation to associated entities if refresh() is called 当 refresh() 函数被调用时,出发级联更新(refresh)操作。
? CascadeType.ALL: all of the above 以上全部
映射二级列表
使用类一级的 @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"})})
})
public class Cat implements Serializable {
private Integer id;
private String name;
private String storyPart1;
private String storyPart2;
@Id @GeneratedValue
public Integer getId() {
return id;
}
public String getName() {
return name;
}
@Column(table="Cat1")
public String getStoryPart1() {
return storyPart1;
}
@Column(table="Cat2")
public String getStoryPart2() {
return storyPart2;
}
上述例子中, name 保存在 MainCat 表中,storyPart1保存在 Cat1 表中,storyPart2 保存在 Cat2 表中。 Cat1 表通过外键 cat_id 和 MainCat 表关联, Cat2 表通过 id 列和 MainCat 表关联。对storyPart2 列还定义了唯一约束。
映射查询
使用注解可以映射 EJBQL/HQL 查询,@NamedQuery 和 @NamedQueries 是可以使用在类级别或者JPA的XML文件中的注解。
<entity-mappings>
<named-query name="plane.getAll">
<query>select p from Plane p</query>
</named-query>
...
</entity-mappings>
...
@Entity
@NamedQuery(name="night.moreRecentThan", query="select n from Night n where n.date >= :date")
public class Night {
...
}
public class MyDao {
doStuff() {
Query q = s.getNamedQuery("night.moreRecentThan");
q.setDate( "date", aMonthAgo );
List results = q.list();
...
}
...
}
可以通过定义 QueryHint 数组的 hints 属性为查询提供一些 hint 信息。下图是一些 Hibernate hints:
映射本地化查询
通过@SqlResultSetMapping 注解来描述 SQL 的 resultset 结构。如果定义多个结果集映射,则用 @SqlResultSetMappings。
@NamedNativeQuery(name="night&area", query="select night.id nid, night.night_duration, "
+ " night.night_date, area.id aid, night.area_id, area.name "
+ "from Night night, Area area where night.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 * from SpaceShip",
resultSetMapping="implicit")
public class SpaceShip {
private String name;
private String model;
private double speed;
@Id
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name="model_txt")
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
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="select name, model, speed, lname as lastn, fname as firstn, length, width, length * width as resultSetMapping="compositekey")
})
如果查询返回的是单个实体,或者打算用系统默认的映射,这种情况下可以不使用 resultSetMapping,而使用resultClass属性,例如:
@NamedNativeQuery(name="implicitSample", query="select * from SpaceShip",
resultClass=SpaceShip.class)
public class SpaceShip {
Hibernate 独有的注解扩展
Hibernate 提供了与其自身特性想吻合的注解,org.hibernate.annotations package包含了这些注解。
实体
org.hibernate.annotations.Entity 定义了 Hibernate 实体需要的信息。
? mutable: whether this entity is mutable or not 此实体是否可变
? dynamicInsert: allow dynamic SQL for inserts 用动态SQL新增
? dynamicUpdate: allow dynamic SQL for updates 用动态SQL更新
? selectBeforeUpdate: Specifies that Hibernate should never perform an SQL UPDATE unless it is certain that an object is actually modified.指明Hibernate从不运行SQL Update,除非能确定对象已经被修改
? polymorphism: whether the entity polymorphism is of PolymorphismType.IMPLICIT (default) or PolymorphismType.EXPLICIT 指出实体多态是 PolymorphismType.IMPLICIT(默认)还是PolymorphismType.EXPLICIT
? optimisticLock: optimistic locking strategy (OptimisticLockType.VERSION, OptimisticLockType.NONE, OptimisticLockType.DIRTY or OptimisticLockType.ALL) 乐观锁策略
标识符
@org.hibernate.annotations.GenericGenerator和@org.hibernate.annotations.GenericGenerators允许你定义hibernate特有的标识符。
@Id @GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid", strategy = "uuid")
public String getId() {
@Id @GeneratedValue(generator="hibseq")
@GenericGenerator(name="hibseq", strategy = "seqhilo",
parameters = {
@Parameter(name="max_lo", value = "5"),
@Parameter(name="sequence", value="heybabyhey")
}
)
public Integer getId() {
新例子
@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")
public long getObjectVolume()
索引
通过在列属性(property)上使用@Index注解,可以指定特定列的索引,columnNames属性(attribute)将随之被忽略。
@Column(secondaryTable="Cat1")
@Index(name="story1index")
public String getStoryPart1() {
return storyPart1;
}
辨别符
@Entity
@DiscriminatorFormula("case when forest_type is null then 0 else forest_type end")
public class Forest { ... }
过滤 查询 ...
? 其中一个实体通过外键关联到另一个实体的主键。注:一对一,则外键必须为唯一约束。
@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="passport_fk")
public Passport getPassport() {
...
}
@Entity
public class Passport implements Serializable {
@OneToOne(mappedBy = "passport")
public Customer getOwner() {
...
}
通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解,则系统自动处理,在主表中将创建连接列,列名为:主题的关联属性名 + 下划线 + 被关联端的主键列名。上例为 passport_id, 因为Customer 中关联属性为 passport, Passport 的主键为 id.
? 通过关联表来保存两个实体之间的关联关系。注:一对一,则关联表每个外键都必须是唯一约束。
@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinTable(name = "CustomerPassports",
joinColumns = @JoinColumn(name="customer_fk"),
inverseJoinColumns = @JoinColumn(name="passport_fk")
)
public Passport getPassport() {
...
}
@Entity public class Passport implements Serializable {
@OneToOne(mappedBy = "passport")
public Customer getOwner() {
...
}
Customer 通过 CustomerPassports 关联表和 Passport 关联。该关联表通过 passport_fk 外键指向 Passport 表,该信心定义为 inverseJoinColumns 的属性值。 通过 customer_fk 外键指向 Customer 表,该信息定义为 joinColumns 属性值。
分享到:
相关推荐
本篇文章将深入探讨“Hibernate注解大全”,介绍在Hibernate中常用的核心注解及其应用场景。 1. `@Entity`: 这是Hibernate注解中的基础,用于标记一个Java类为实体类,表示这个类将在数据库中对应一张表。例如: ``...
【Hibernate注解详解】 在Java世界中,Hibernate作为一款强大的对象关系映射(ORM)框架,使得开发者可以方便地在Java对象与数据库表之间建立映射。为了简化配置,Hibernate引入了注解机制,允许开发者在Java类和类...
《Hibernate注解详解》 Hibernate 是一款强大的Java对象关系映射(ORM)框架,它极大地简化了数据库操作。在Hibernate中,注解是用于描述Java类及其属性如何映射到数据库表的重要工具。本文将全面解析Hibernate中的...
使用hibernate注解,必须要使用库hibernate-commons-annotations,hibernate-core,hibernate-jpa,ejb3-persistence,javassist等
ssh学习的注解pdf资料
本文档将深入探讨Hibernate注解的使用,帮助开发者更好地理解和利用这些注解来实现对象关系映射(ORM)。 一、Hibernate注解基础 Hibernate注解是一种元数据方式,用于在Java类和属性上声明数据库映射信息,从而...
本主题将深入探讨Hibernate注解的相关知识点。 1. **注解概述**: 注解(Annotations)是Java 5引入的一种元数据,它提供了在源代码中嵌入信息的方式,这些信息可以被编译器或者在运行时的Java虚拟机使用。在...
这个"springmvc+hibernate注解框架整合 demo"是一个示例项目,展示了如何通过注解方式将这两个框架无缝集成。 **Spring MVC 框架** Spring MVC 是 Spring 框架的一部分,它提供了处理HTTP请求、转发响应以及管理...
### Hibernate注解API知识点概述 #### 一、Hibernate注解简介 Hibernate 是一款非常流行的 Java 持久层框架,它极大地简化了数据库操作。在 Hibernate 中,可以通过使用注解来映射对象与数据库表之间的关系,从而...
在Java的ORM框架Hibernate中,注解是一种强大的工具,它允许开发者无需XML配置就能实现对象关系映射。本文主要总结了Hibernate中常见的注解用法,涵盖了类级别和属性级别的注解,以及与主键和非主键相关的注解。 1....
在实际项目中,除了这三个核心的Hibernate注解库,可能还需要其他的依赖,例如: - **jta.jar**:Java Transaction API,用于支持分布式事务处理。 - **javax.persistence-api.jar**:JPA规范的API,包含了一些基础...
hibernate 注解 annotation 教程
下面我们将详细讲解如何配置和使用Spring+Hibernate注解声明式事务: 1. **配置Spring**: - 首先,我们需要在Spring配置文件中启用事务管理器,通常是`HibernateTransactionManager`,并配置数据源。 - 然后,...
本实例"spring-hibernate注解配置源码"旨在展示如何在不使用XML配置的情况下,通过注解的方式整合Struts2、Spring和Hibernate,创建一个完整的MVC(模型-视图-控制器)架构的应用。下面将详细介绍这个过程中的关键...
在本文中,我们将深入探讨Hibernate注解的几个核心方面:级联关系、增删改查操作、二级缓存、日志配置以及注解解析。 1. **级联关系**: Hibernate中的级联关系允许我们在一个实体的操作中自动处理与其关联的其他...
Hibernate 注解映射 Hibernate 注解映射是 Hibernate 框架中的一种映射方式,它使用 Java 注解来描述实体类和数据库表之间的映射关系,提高开发效率。 一、 环境搭建和基本映射 在使用 Hibernate 注解映射之前,...
hibernate注释详解 内含hibernate各种注释说明
【Hibernate注释深入解析】 在Java开发中,Hibernate是一个广泛使用的对象关系映射(ORM)框架,它允许开发者使用面向对象的方式操作数据库。在Hibernate中,注释是一种强大的工具,可以简化配置,使得代码更加简洁...