Hibernate知识点总结

最新推荐文章于 2023-01-11 15:43:19 发布
最新推荐文章于 2023-01-11 15:43:19 发布
阅读量248 收藏
点赞数
分类专栏： Hibernate

Hibernate

对象的三种状态

 

Hibernate 中Java对象的状态

1.临时状态 (transient)

特征：

   1】不处于Session 缓存中

   2】数据库中没有对象记录

Java如何进入临时状态

   1】通过new语句刚创建一个对象时

   2】当调用Session 的delete()方法，从Session 缓存中删除一个对象时。 

 

2.持久化状态(persisted)

特征：

   1】处于Session 缓存中

   2】持久化对象数据库中设有对象记录

   3】Session 在特定时刻会保持二者同步

Java如何进入持久化状态

   1】Session 的save()把临时－》持久化状态

   2】Session 的load(),get()方法返回的对象

   3】Session 的find()返回的list集合中存放的对象

   4】Session 的update(),saveOrupdate()使游离－》持久化

3.游离状态(detached)

特征：

   1】不再位于Session 缓存中

   2】游离对象由持久化状态转变而来，数据库中可能还有对应记录。

Java如何进入持久化状态－》游离状态

   1】Session 的close()方法

   2】Session 的evict()方法，从缓存中删除一个对象。提高性能。少用。

 

顺序问题

在实际应用中，一般是先建表后用反向工程生成类。

slf（日志）

它是一套规范。其实现有这几种：slf4j-nodep,log4j,jdk logging api,apachecommons-logging

Log4J日志环境搭建

1、         slf4j-api-1.6.1.jar是一个规范，需要加log4j-1.2.15.jar，不可以有slf4j-nop-1.6.1.jar（slf自己的实现）文件，否则会有两个实现，出错！

2、         添加slf4j-1.6.1目录下的slf4j-log4j12-1.6.1.jar（slf接口转换为log4j接口）

3、         从hibernate-distribution-3.3.2.GA-dist\project\etc目录下复制log4j.properties文件到src下。

4、         可以修改log4j.properties文件，按自己要求输出信息。

注解位置

应放在get方法上。放在字段上的话破坏封装。不能放在set方法上面。

hbm2ddl（查文档）

 四中状态：create：每次都将原来的删除，重新建新表

          update：检查是否发生变化，变化就更新

ID生成策略

1、  XML

标签id的子标签：<generator class="native"/>

常用的类型：native、uuid、sequence、identity

2、  Annotation

@GeneratedValue，默认为aoto，也可以这么写：@GeneratedValue(strategy=GenerationType.AUTO)

可指定生成器Generator（在Oracle中自动生成的序列名为hibernate_sequence，指定生成器就可命名序列）。两种生成器：

1）@SequenceGenerator

2）@TableGenerator   （跨平台）

 这两种生成器需写在类上，在主键字段上指定策略为sequence并用generator引用生成器名

联合字段做主键（查文档）不重要

1、Annotation

1、将组件类注解为@Embeddable,并将组件的属性（实体类中而非主键类）注解为@Id

2、将组件的属性注解为@EmbeddedId

3、将类注解为@IdClass,并将该实体中所有属于主键的属性都注解为@Id

2、XML

<composite-id……>

<key-property……/>

<key-property……/>

</composite-id>

openSession()和getCurrentSession()的区别

1、前者需要手动关闭session，后者不需要手动关闭session，在线程消亡后自动关闭。

2、前者永远都打开新的session，后者先从上下文找，如果没有找到则产生新的session，在事务提交之前永远都是同一个session。

3、getCurrentSession()可以用来界定事务边界。

几种类型属性的映射：

@Transient//透明，意思是说不映射到表

1、XML：

       指定其type

2、Annotation：

枚举类型：

        @Enumerated(EnumType.STRING)

日期类型：

        @Temporal(TemporalType.DATE)

映射类型

核心开发接口

1、 Configuration管理配置文件

Config()  buildSessionFactoty()

2、 sessionFactory管理多个连接池，产生session

3、 Session可以理解为一个数据库连接

4、 AnnotationConfiguration  用注解@来映射的时候要newAnnotationConfiguration（）；

5、 hibernate.cfg.xml文件可以直接放在src下，配置的时候可以直接用config()，不需要参数；也可以放在包下面，这时候就要将包的路径加入，如：com/bjsxt/hibernate/hibernate.cfg.xml。其他的文件类似的效果。

6、 hibernate中的mapping标签，当用xml文件的时候：resource=” com/bjsxt/hibernate/hibernate.cfg.xml”；当用注解@的时候：class=“com.bjsxt.hibernate.Teacher”，要用完整的类名。

CRUD（时刻注意对象的状态）

get和load都是先从缓存找，如果没有，才去数据库中找。

1、get()和load()的区别：

1、            get()是直接从数据库加载，不会延迟，而load()获取到的是代理对象，只有当用到对象中的内容时才会发送sql语句。

2、            get()方法将从数据库加载的数据存放到对象中，事务提交后对象中还可以取到值

3、            如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。

1）  在使用getCurrentSession()方法时，load()方法事务提交后就不能获取值，会报LazyInitializationException异常，因为此时线程已经消亡，找不到session，不能初始化代理。因为getCurrentSession会自动close。

2）  在使用openSession()时，在session.close()之前，load()方法获取的代理对象中的内容还可以使用。

3）  总之一句话：不管是openSession()还是getCurrentSession()。在session关闭之后，load()方法获取的代理对象中的内容不可以使用，异常，get()可以。

update()：

     注意：session.get()时，对象状态为persistent,在事务提交之前如果更改了对象的属性值（调用set方法），事务提交后会自动发送一条update语句（即使没有session.update(*)）。保持缓存和数据库的同步。

 

     如果个别字段不需要更改：

1、 可以注解@Column(updatable = false)或XML中property标签属性update=”false”

2、 XML中指定class标签的属性dynamic-update=”true”

3、 跨session：(上个session1.get()的对象obj)在session2中可以这样调用session2.merge(obj)，意思是合并。（了解即可）

2、saveOrUpdate()

3、clear()  清空session缓存

4、flush() 强制让缓存内容和数据库同步，用session.flushMode()方法指定flush时间，性能调优

5、find 过时

SchemaExport

可以在应用程序中创建表。

newSchemaExport(new Configuration().configure()).create(true,true);

关系映射（文档里有很全的例子说明）

一个异常：Exceptionin thread "main" java.lang.NoSuchMethodError:javax.persistence.OneToOne.orphanRemoval()Z

原因hibernate的jar包里面加了那个ejb3的jar包与JPA包冲突 ejb删就OK了。

对象之间的关系：

1、  多对多

2、  多对一

3、  一对一

严格来说只有一个那就是 多对多

多对一是多对多的一种特殊情况

一对一是多对一的一种特殊情况

数据库的表和表之间只有一种关系：外键

1、 一对一

1)     单向外键关联：

Annotation：在持有外键引用的类中：@OneToOne可用 @JoinColumn指定关联字段

XML：<many-to-onename="wife" column="wifeId" unique="true"/>

2)     双向外键关联：

Annotation：在两个实体类中都注解：@OneToOne ，mappedBy 意思是说对方是主导，由对方引用自己。

XML：<many-to-onename="wife" column="wifeId" unique="true"/>

被引用的实体类配置文件：

<one-to-onename="husband" property-ref="wife"></one-to-one>

3） 单向主键关联：

Annotation： @OneToOne，@PrimaryKeyJoinColumn

XML：通常使用一个特定的id 生成器

3)     联合主键关联

@joinColumns(

        {

@joinColumn(name=”wifeId”,referencedColumnName=”id”),

@joinColumn(name=”wifeName”,referencedColumnName=”name”)

}

)

2、 组件映射（只生成一张表）

1） Annotation：一个实体类持一个组件类的外键引用，在被引用组件对象的get方法上@Embedded,配置文件中只映射持有引用的那个类。

Xml：<componentname="wife">

               <propertyname="wifeId"></property>

               <propertyname="wifeName"></property>

        </component>

3、 多对一

建表时，可以在多的一方持有一的外键，会减少冗余。

1)     多对一单向关联：

Annotation：在多的一方@ManyToOne

Xml：<many-to-one name=”person” />

2)     一对多单向关联：

Annotation：在一的一方@OneToMany

@JoinColumn(name="personId")，”personId”是随便写的。如果没有@JoinColumn则会生成一个中间表。

Xml： <setname="dreams">

      <keycolumn="personId"></key>

                     <one-to-manyclass="Dream"/>

              </set>

3） 多对一，一对多双向关联：

Annotation： @ManyToOne

              @JoinColumn(name="personId")

     在一的一方：

                     @OneToMany(mappedBy="person")

Xml：在一的一方：

<set name="dreams">

        <keycolumn="personId"></key>

                            <one-to-many class="Dream"/>

                     </set>

在多的一方：<many-to-onename="person" column="personId" />

4、 多对多

1） 多对多单向关联：

Annotation：  @ManyToMany

       @JoinTable(name="t_s",

                     joinColumns={@JoinColumn(name="studentId")},

                     inverseJoinColumns={@JoinColumn(name="teacherId")}

       )

Xml：<set name="teachers" table="t_s">

                     <keycolumn="studentId"></key>

                     <many-to-manyclass="Teacher" column="teacherId"/>

</set>

2）多对多双向关联：

 

说下Hibernate的缓存机制：

Hibernate缓存的作用：

    Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据

Hibernate缓存分类：

  Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存

Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。

Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。

什么样的数据适合存放到第二级缓存中？ 　　

1 很少被修改的数据 　　

2 不是很重要的数据，允许出现偶尔并发的数据 　　

3 不会被并发访问的数据 　　

4 常量数据 　　

不适合存放到第二级缓存的数据？ 　　

1经常被修改的数据 　　

2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　

3 与其他应用共享的数据。

 

如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态

7. 表字段要少，表关联不要怕多，有二级缓存撑腰

 

malinchong313
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate知识点总结
11-04
本文档适用于J2EE初学者，主要是针对hibernate部分的知识点进行总结，有助于初学者迅速入门
hibernate常用注解
一休哥
04-19 872
一。实体Bean 每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用 @Entity 注解来进行声明。 声明实体Bean @Entity public class Flightimplements Serializable {   Long id;   @Id   public Long getId() { return id; }   public void set
hibernate annotation 很详细的哦
gaohl0501的博客
03-25 109
1./** 2.* 3.* @author liuguangyi 4.* @content ejb3注解的API定义在javax.persistence.*包里面。 5.* 6.* 注释说明： 7.* @Entity —— 将一个类声明为一个实体bean(即一个持久化POJO类) 8.* @Id —— 注解声明了该实体bean的标识属性（...
hibernate注解全解
晨晓溪风丶
12-30 470
一、类级别注解 @Entity 映射实体类 @Table 映射数句库表 @Entity(name=”tableName”) - 必须，注解将一个类声明为一个实体bean。 属性：name - 可选，对应数据库中的一个表。若表名与实体类名相同，则可以省略。 @Table(name=”“,catalog=”“,schema=”“) - 可选，通常和@Entity 配合使用，只能
hibernate 知识点
BINGO的博客
07-04 289
一、入门 1、对于持久化类的唯一标识，我们通常不会操作，因此它的setter方法的访问级别应该声明private，当对象被保存的时候，只有hibernate可以分它分配值。 2、持久化类都要求有无参的构造器，hibernate必须使用java反射机制来创建对象。构造器的访问级别可以是private，然后当生成运行时代理的时候则要求使用至少是package级别的访问控制，这样在没有字节码指令的情况下，从持久化类里获取数据会更有效率。 3、generator指定了标识符生成策略，指定native表示根据已
hibernate
weixin_34342992的博客
06-29 100
Hibernate部分 1.为什么要使用Hibernate开发你的项目呢？Hibernate的开发流程是怎么样的？ 为什么要使用 ①.对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 ②.Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 ③.hibernate的性能非常好，因为它是个轻量级...
Hibernate知识点总结(一).docx
05-03
Hibernate知识点总结，自己学习hibernate所坐的笔记，希望能帮助更多的朋友
Struts2+Spring+Hibernate知识点总结
02-27
该资源总结了java中常见的三大开源框架的知识点，便于初学者学习。
hibernate知识点
05-15
hibernate知识点的总结，适合初学者
Hibernate注解、注释大全
06-10
最全的hibernate注释讲解、涵盖各个知识点的讲解，适合hibernate初学者、更是一个查询的字典。
hibernate注解大全
09-19
hibernate 注解 一对多，多对一，多对多，注解解释
Hibernate全部注解
09-10
ssh框架中hibernate注解，连接数据库
Hibernate注释大全收藏
11-05
Hibernate注释大全收藏 声明实体Bean @Entity public class Flight implements Serializable { Long id; @Id public Long getId() { return id; } public void setId(Long id) { this.id = id; } } @Entity 注解将一个类声明为实体 Bean, @Id 注解声明了该实体Bean的标识属性。 Hibernate 可以对类的属性或者方法进行注解。属性对应field类别，方法的 getXxx()对应property类别。 定义表 通过 @Table 为实体Bean指定对应数据库表，目录和schema的名字。 @Entity @Table(name="tbl_sky") public class Sky implements Serializable { ... @Table 注解包含一个schema和一个catelog 属性，使用@UniqueConstraints 可以定义表的唯一约束。 @Table(name="tbl_sky", uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})} ) 上述代码在 "month" 和 "day" 两个 field 上加上 unique constrainst. @Version 注解用于支持乐观锁版本控制。 @Entity public class Flight implements Serializable { ... @Version @Column(name="OPTLOCK") public Integer getVersion() { ... } } version属性映射到 "OPTLOCK" 列，entity manager 使用这个字段来检测冲突。 一般可以用 数字 或者 timestamp 类型来支持 version. 实体Bean中所有非static 非 transient 属性都可以被持久化，除非用@Transient注解。 默认情况下，所有属性都用 @Basic 注解。 public transient int counter; //transient property private String firstname; //persistent property @Transient String getLengthInMeter() { ... } //transient property String getName() {... } // persistent property @Basic int getLength() { ... } // persistent property @Basic(fetch = FetchType.LAZY) String getDetailedComment() { ... } // persistent property @Temporal(TemporalType.TIME) java.util.Date getDepartureTime() { ... } // persistent property @Enumerated(EnumType.STRING) Starred getNote() { ... } //enum persisted as String in database 上述代码中 counter, lengthInMeter 属性将忽略不被持久化，而 firstname, name, length 被定义为可持久化和可获取的。 @TemporalType.(DATE,TIME,TIMESTAMP) 分别Map java.sql.(Date, Time, Timestamp). @Lob 注解属性将被持久化为 Blog 或 Clob 类型。具体的java.sql.Clob, Character[], char[] 和 java.lang.String 将被持久化为 Clob 类型. java.sql.Blob, Byte[], byte[] 和 serializable type 将被持久化为 Blob 类型。 @Lob public String getFullText() { return fullText; // clob type } @Lob public byte[] getFullCode() { return fullCode; // blog type } @Column 注解将属性映射到列。 @Entity public class Flight implements Serializable { ... @Column(updatable = false, name = "flight_name", nullable = false, length=50) public String getName() { ... } 定义 name 属性映射到 flight_name column, not null, can't update, length equal 50 @Column( name="columnName"; (1) 列名 boolean unique() default false; (2) 是否在该列上设置唯一约束 boolean nullable() default true; (3) 列可空？ boolean insertable() default true; (4) 该列是否作为生成 insert语句的一个列 boolean updatable() default true; (5) 该列是否作为生成 update语句的一个列 String columnDefinition() default ""; (6) 默认值 String table() default ""; (7) 定义对应的表（deault 是主表） int length() default 255; (8) 列长度 int precision() default 0; // decimal precision (9) decimal精度 int scale() default 0; // decimal scale (10) decimal长度 嵌入式对象（又称组件）也就是别的对象定义的属性 组件类必须在类一级定义 @Embeddable 注解。在特定的实体关联属性上使用 @Embeddable 和 @AttributeOverride 注解可以覆盖该属性对应的嵌入式对象的列映射。 @Entity public class Person implements Serializable { // Persistent component using defaults Address homeAddress; @Embedded @AttributeOverrides( { @AttributeOverride(name="iso2", column = @Column(name="bornIso2") ), @AttributeOverride(name="name", column = @Column(name="bornCountryName") ) } ) Country bornIn; ... } @Embeddable public class Address implements Serializable { String city; Country nationality; //no overriding here } @Embeddable public class Country implements Serializable { private String iso2; @Column(name="countryName") private String name; public String getIso2() { return iso2; } public void setIso2(String iso2) { this.iso2 = iso2; } public String getName() { return name; } public void setName(String name) { this.name = name; } ... } Person 类定义了 Address 和 Country 对象，具体两个类实现见上。 无注解属性默认值： • 属性为简单类型，则映射为 @Basic • 属性对应的类型定义了 @Embeddable 注解，则映射为 @Embedded • 属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。 • 属性的类型为 java.sql.Clob or java.sql.Blob, 则映射到 @Lob 对应的类型。 映射主键属性 @Id 注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。 • AUTO - 可以是 identity column, sequence 或者 table 类型，取决于不同底层的数据库 • TABLE - 使用table保存id值 • IDENTITY - identity column • SEQUENCE - seque nce @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE") public Integer getId() { ... } @Id @GeneratedValue(strategy=GenerationType.IDENTITY) public Long getId() { ... } AUTO 生成器，适用与可移值的应用，多个@Id可以共享同一个 identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator 和 @TableGenerator 可以配置不同的 identifier 生成器。 <table-generator name="EMP_GEN" table="GENERATOR_TABLE" pk-column-name="key" value-column-name="hi" pk-column-value="EMP" allocation-size="20"/> //and the annotation equivalent @javax.persistence.TableGenerator( name="EMP_GEN", table="GENERATOR_TABLE", pkColumnName = "key", valueColumnName = "hi" pkColumnValue="EMP", allocationSize=20 ) <sequence-generator name="SEQ_GEN" sequence-name="my_sequence" allocation-size="20"/> //and the annotation equivalent @javax.persistence.SequenceGenerator( name="SEQ_GEN", sequenceName="my_sequence", allocationSize=20 ) The next example shows the definition of a sequence generator in a class scope: @Entity @javax.persistence.SequenceGenerator( name="SEQ_STORE", sequenceName="my_sequence" ) public class Store implements Serializable { private Long id; @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE") public Long getId() { return id; } } Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。 通过下面语法，你可以定义组合键。 • 将组件类注解为 @Embeddable， 并将组件的属性注解为 @Id • 将组件的属性注解为 @EmbeddedId • 将类注解为 @IdClass，并将该实体中所有主键的属性都注解为 @Id @Entity @IdClass(FootballerPk.class) public class Footballer { //part of the id key @Id public String getFirstname() { return firstname; } public void setFirstname(String firstname) { this.firstname = firstname; } //part of the id key @Id public String getLastname() { return lastname; } public void setLastname(String lastname) { this.lastname = lastname; } public String getClub() { return club; } public void setClub(String club) { this.club = club; } //appropriate equals() and hashCode() implementation } @Embeddable public class FootballerPk implements Serializable { //same name and type as in Footballer public String getFirstname() { return firstname; } public void setFirstname(String firstname) { this.firstname = firstname; } //same name and type as in Footballer public String getLastname() { return lastname; } public void setLastname(String lastname) { this.lastname = lastname; } //appropriate equals() and hashCode() implementation } @Entity @AssociationOverride( name="id.channel", joinColumns = @JoinColumn(name="chan_id") ) public class TvMagazin { @EmbeddedId public TvMagazinPk id; @Temporal(TemporalType.TIME) Date time; } @Embeddable public class TvMagazinPk implements Serializable { @ManyToOne public Channel channel; public String name; @ManyToOne public Presenter presenter; } 映射继承关系 EJB支持3种类型的继承。 • Table per Class Strategy: the <union-class> element in Hibernate 每个类一张表 • Single Table per Class Hierarchy Strategy: the <subclass> element in Hibernate 每个类层次结构一张表 • Joined Subclass Strategy: the <joined-subclass> element in Hibernate 连接的子类策略 @Inheritance 注解来定义所选的之类策略。 每个类一张表 @Entity @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) public class Flight implements Serializable { 有缺点，如多态查询或关联。Hibernate 使用 SQL Union 查询来实现这种策略。 这种策略支持双向的一对多关联，但不支持 IDENTIFY 生成器策略，因为ID必须在多个表间共享。一旦使用就不能使用AUTO和IDENTIFY生成器。 每个类层次结构一张表 @Entity @Inheritance(strategy=InheritanceType.SINGLE_TABLE) @DiscriminatorColumn( name="planetype", discriminatorType=DiscriminatorType.STRING ) @DiscriminatorValue("Plane") public class Plane { ... } @Entity @DiscriminatorValue("A320") public class A320 extends Plane { ... } 整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。 Plane 是父类。@DiscriminatorColumn 注解定义了辨别符列。对于继承层次结构中的每个类, @DiscriminatorValue 注解指定了用来辨别该类的值。 辨别符列名字默认为 DTYPE，其默认值为实体名。其类型为DiscriminatorType.STRING。 连接的子类 @Entity @Inheritance(strategy=InheritanceType.JOINED) public class Boat implements Serializable { ... } @Entity public class Ferry extends Boat { ... } @Entity @PrimaryKeyJoinColumn(name="BOAT_ID") public class AmericaCupClass extends Boat { ... } 以上所有实体使用 JOINED 策略 Ferry和Boat class使用同名的主键关联(eg: Boat.id = Ferry.id)， AmericaCupClass 和 Boat 关联的条件为 Boat.id = AmericaCupClass.BOAT_ID. 从父类继承的属性 @MappedSuperclass public class BaseEntity { @Basic @Temporal(TemporalType.TIMESTAMP) public Date getLastUpdate() { ... } public String getLastUpdater() { ... } ... } @Entity class Order extends BaseEntity { @Id public Integer getId() { ... } ... } 继承父类的一些属性，但不用父类作为映射实体，这时候需要 @MappedSuperclass 注解。 上述实体映射到数据库中的时候对应 Order 实体Bean, 其具有 id, lastUpdate, lastUpdater 三个属性。如果没有@MappedSuperclass 注解,则父类中属性忽略，这是 Order 实体 Bean 只有 id 一个属性。 映射实体Bean的关联关系 一对一 使用 @OneToOne 注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。 • 关联的实体都共享同样的主键。 @Entity public class Body { @Id public Long getId() { return id; } @OneToOne(cascade = CascadeType.ALL) @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } ... } @Entity public class Heart { @Id public Long getId() { ...} } 通过@PrimaryKeyJoinColumn 注解定义了一对一的关联关系。 多对一 使用 @ManyToOne 注解定义多对一关系。 @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } 其中@JoinColumn 注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。本例中为company_id,因为关联的属性是company, Company的主键为 id. @ManyToOne 注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要 targetEntity 定义（使用接口作为返回值，而不是常用的实体）。 @Entity() public class Flight implements Serializable { @ManyToOne(cascade= {CascadeType.PERSIST,CascadeType.MERGE},targetEntity= CompanyImpl.class) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } public interface Company { ... 多对一也可以通过关联表的方式来映射，通过 @JoinTable 注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过@JoinTable.inverseJoinColumns）. @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable(name="Flight_Company", joinColumns = @JoinColumn(name="FLIGHT_ID"), inverseJoinColumns = @JoinColumn(name="COMP_ID") ) public Company getCompany() { return company; } ... } 集合类型 一对多 @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 端不必也不能定义任何物理映射。 单向 @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 属性值。 本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/tangcx/archive/2009/05/05/4152320.aspx
Hibernate注解大全
04-19
Hibernate注解大全
EJB3/JPA Annotations 学习
dolphin_ygj
03-07 2361
Document file and example: Hibernate, JBoss etc.   一、 实体 Bean 每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用 @Entity 注解来进行声明。 声明实体Bean @Entitypublic class Flight implements Serializable {  Long id;  @Id  public Lon...
Hibernate 常用注解
lvhui321的博客
01-11 647
Hibernate 常用注解
避免 Hibernate 中用get/load方法获取的实体调用set方法后自动更新
hebeind100的博客
08-02 162
  1、问题症状描述       最近在处理一个新需求问题，代码的大致逻辑是获取一个实体对象，调用该对象的set方法设置其中的某些字段，然后把修改后的实体作为参数供其他地方调用，根据返回值来决定是否更新这个实体到数据库中。      按照这个思路调用了系统中的getByid方法，结果测试的时候发现，不管返回值是什么，这个实体最终都被更新到数据库中了。好吧，这明显是有问题的....【没有问题...
hiberante知识点梳理
最新发布
07-12
Hibernate是一个流行的ORM（对象关系映射）框架，它将Java应用程序中的Java类映射到数据库表中。...这些是Hibernate的一些重要知识点，开发人员可以根据需要深入了解每个知识点，并在实际项目中使用Hibernate。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值