HIbernate注解说明
- 1、@Entity(name="EntityName")
- 必须,name为可选,对应数据库中一的个表,此处的EntryName要注意,在代码中使用hql进行查询时,需要from Xxx,那么Xxx就是对应的此处的EntryName,所以要注意EntryName的命名,否则会出现映射问题。
-
-
-
- 2、@Table(name="",catalog="",schema="")
- 可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息
-
- name:可选,表示表的名称。默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名
- catalog:可选,表示Catalog名称。默认为Catalog("")
- schema:可选,表示Schema名称。默认为Schema("")
-
-
- 3、@id
- 必须
-
- @id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键。置于getXxxx()前
-
-
-
- 4、@GeneratedValue(strategy=GenerationType,generator="")
- 可选
-
- strategy:表示主键生成策略,有AUTO、INDENTITY、SEQUENCE和 TABLE 4种,分别表示让ORM框架自动选择、根据数据库的Identity字段生成、根据数据库表的Sequence字段生成、以及根据一个额外的表生成主键。默认为AUTO
-
- generator:表示主键生成器的名称,这个属性通常和ORM框架相关。例如,Hibernate可以指定uuid等主键生成方式
-
- 示例:
-
- @Id
-
- @GeneratedValues(strategy=StrategyType.SEQUENCE)
-
- public int getPk() {
-
- return pk;
-
- }
-
-
-
- 5、@Basic(fetch=FetchType,optional=true)
- 可选
-
- @Basic表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的getXxxx()方法。默认即为@Basic
-
- fetch:表示该属性的读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载。默认为EAGER
- optional:表示该属性是否允许为null,默认为true
- 示例:
-
- @Basic(optional=false)
-
- public String getAddress() {
-
- return address;
-
- }
-
-
-
- 6、@Column
- 可选
-
- @Column描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有作用
- name:表示数据库表中该字段的名称。默认情形属性名称一致
- nullable:表示该字段是否允许为null。默认为true
- unique:表示该字段是否是唯一标识。默认为false
- length:表示该字段的大小,仅对String类型的字段有效
- insertable:表示在ORM框架执行插入操作时,该字段是否应出现INSETRT语句中。默认为true
- updateable:表示在ORM框架执行更新操作时,该字段是否应该出现在UPDATE语句中,默认为true。对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段
- columnDefinition:表示该字段在数据库中的实际类型。通常ORM框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE、TIME还是TIMESTAMP。此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或TEXT字段类型,该属性非常有用
- 示例:
-
- @Column(name="BIRTH",nullable="false",columnDefinition="DATE")
-
- public String getBithday() {
-
- return birthday;
-
- }
-
-
-
- 7、@Transient
- 可选
-
- @Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性
-
- 如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic
-
- 示例:
-
-
-
- @Transient
-
- public int getAge() {
-
- return getYear(new Date()) -getYear(birth);
-
- }
-
-
-
- 8、@ManyToOne(fetch=FetchType,cascade=CascadeType)
- 可选
-
- @ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键
-
- optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为true
- fetch:表示抓取策略,默认为FetchType.EAGER
- cascade:表示默认的级联操作策略,可以指定为ALL、PERSIST、MERGE、REFRESH和REMOVE中的若干组合,默认为无级联操作
- targetEntity:表示该属性关联的实体类型,该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity
-
-
- 示例:
-
-
-
-
-
- @ManyToOne()
-
- @JoinColumn(name="USER")
-
- public User getUser() {
-
- return user;
-
- }
-
-
-
- 9、@JoinColumn
- 可选
-
- @JoinColumn和@Column类似,介量描述的不是一个简单字段,而是一个关联字段,例如,描述一个@ManyToOne的字段.
-
-
-
- name:该字段的名称,由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.
-
-
- 例如,实体Order有一个user属性来关联实体User,则Order的user属性为一个外键
-
- 其默认的名称为实体User的名称+下划线+实体User的主键名称
-
- 示例:
-
- 见@ManyToOne
-
-
-
- 10、@OneToMany(fetch=FetchType,cascade=CascadeType)
- 可选
-
- @OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段
-
-
-
- fetch:表示抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库预先读取到内存
- cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除时,其关联的实体也应当被更新或删除
-
-
- 例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除
-
- 示例:
-
- @OneTyMany(cascade=ALL)
-
- public List getOrders() {
-
- return orders;
-
- }
-
-
-
- 11、@OneToOne(fetch=FetchType,cascade=CascadeType)
- 可选
-
- @OneToOne描述一个一对一的关联
-
- fetch:表示抓取策略,默认为FetchType.LAZY
-
- cascade:表示级联操作策略
-
- 示例:
-
- @OneToOne(fetch=FetchType.LAZY)
-
- public Blog getBlog() {
-
- return blog;
-
- }
-
-
-
- 12、@ManyToMany
- 可选
-
- @ManyToMany描述一个多对多的关联,多对多关联上是两个一对多关联,但是在ManyToMany描述中,中间表是由ORM框架自动处理
-
- targetEntity:表示多对多关联的另一个实体类的全名,例如:package.Book.class
-
- mappedBy:表示多对多关联的另一个实体类的对应集合属性名称
-
-
-
- 13、@MappedSuperclass
- 可选
-
- @MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解
-
- 示例:
-
- @MappedSuperclass
-
- public class Employee() {
-
- ....
-
- }
-
-
-
- @Entity
-
- public class Engineer extends Employee {
-
- .....
-
- }
-
- @Entity
-
- public class Manager extends Employee {
-
- .....
-
- }
-
-
-
- 14、@Embedded
- 可选
-
- @Embedded将几个字段组合成一个类,并作为整个Entity的一个属性
-
- 例如User包括id、name、city、street、zip属性
-
- 我们希望city、street、zip属性映射为Address对象。这样,User对象将具有id、name和address这三个属性.
-
-
- Address对象必须定义为@Embededable
-
- 示例:
-
- @Embeddable
-
- public class Address {city,street,zip}
-
- @Entity
-
- public class User {
-
- @Embedded
-
- public Address getAddress() {
-
- ..........
-
- }
-
- }
1、Hibernate注解关系处理关系映射
2、Hibernate基于注解的双向one-to-many映射关系的实现
项目中用到了一对多的实体类关系映射,之前接触的都是基于配置文件的映射实现,但是公司的大部分都是基于注解的,因此自己参考之前的代码捣鼓了基于注解的一对多的映射关系实现。
背景:
一的一端:QingAoCenterInfo:青奥场所信息,
多的一端:QingAoPlaceInfo:青奥场馆信息,
其中一个青奥场所下可以包含多个青奥场馆
one端:QingAoCenterInfo,持有QingAoPlaceInfo的List引用,
通过注解@OneToMany(mappedBy="qingAoCenterInfo",cascade= CascadeType.ALL)
mappedBy: 由One的一方指向Many的一方,并且,这个属性应该等于Many的一方中含有One类的属性的属性名,否则会出错啦
cascade:
many端:QingAoPlaceInfo,持有QingAoCenterInfo的引用
通过@ManyToOne(fetch=FetchType.LAZY ) @JoinColumn(name="f_center_id")设置关联关系
fetch和lazy是用来定义级联查询的方式:
fetch:官方文档里对fetch有如下描述,Hibernate3 定义了如下几种抓取策略:
-
连接抓取(Join fetching):Hibernate 通过在 SELECT
语句使用 OUTER JOIN
(外连接)来获得对象的关联实例或者关联集合。
-
查询抓取(Select fetching):另外发送一条 SELECT
语句抓取当前对象的关联实体或集合。除非你显式的指定 lazy="false"
禁止 延迟抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条 select 语句。
-
子查询抓取(Subselect fetching):另外发送一条 SELECT
语句抓取在前面查询到(或者抓取到)的所有实体对象的关联集合。除非你显式的指定 lazy="false"
禁止延迟抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条 select 语句。
-
批量抓取(Batch fetching):对查询抓取的优化方案,通过指定一个主键或外键列表,Hibernate 使用单条 SELECT
语句获取一批对象实例或集合。
3、Hibernate4 注解版关系案例
一对多和多对一
公司用的maven 所以我也是建的maven工程,导入hibernate4的jar包
- <dependency>
- <groupId>org.hibernategroupId>
- <artifactId>hibernate-coreartifactId>
- <version>4.1.6.Finalversion>
- dependency>
但是oracle的驱动包,好像要自己手动加。不知道有没有用maven直接从网上加的方法。
hibernate.cfg.xml 文件
-
- "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
- "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
-
- <hibernate-configuration>
- <session-factory>
-
-
- <property name="dialect">
- org.hibernate.dialect.Oracle10gDialect
- property>
- <property name="connection.url">jdbc:oracle:thin:@192.168.15.102:1521:ora11gproperty>
- <property name="connection.driver_class">oracle.jdbc.driver.OracleDriverproperty>
- <property name="connection.username">iris_ecnu_devproperty>
- <property name="connection.password">iris_ecnu_devproperty>
-
-
- <property name="show_sql">trueproperty>
- <property name="hbm2ddl.auto">updateproperty>
- <property name="format_sql">trueproperty>
-
-
- <mapping class="cn.lzg.Order" />
- <mapping class="cn.lzg.Person" />
- session-factory>
- hibernate-configuration>
Order.java 文件
- package cn.lzg;
-
- import java.util.Date;
-
- import javax.persistence.Column;
- import javax.persistence.Entity;
- import javax.persistence.FetchType;
- import javax.persistence.GeneratedValue;
- import javax.persistence.GenerationType;
- import javax.persistence.Id;
- import javax.persistence.JoinColumn;
- import javax.persistence.ManyToOne;
- import javax.persistence.SequenceGenerator;
- import javax.persistence.Table;
-
- @Entity
- @Table(name = "order_lzg")
- public class Order {
-
- @Id
- @SequenceGenerator(name = "order_lzg", sequenceName = "o_seq", allocationSize = 1)
- @GeneratedValue(generator = "order_lzg", strategy = GenerationType.SEQUENCE)
- private Long order_id;
-
- @Column(name = "submit_time")
- private Date submit_time;
-
- @ManyToOne(fetch = FetchType.LAZY)
- @JoinColumn(name = "p_id")
-
- private Person person_lzg;
-
- public Order() {
- }
-
- public Long getOrder_id() {
- return order_id;
- }
-
- public void setOrder_id(Long order_id) {
- this.order_id = order_id;
- }
-
- public Date getSubmit_time() {
- return submit_time;
- }
-
- public void setSubmit_time(Date submit_time) {
- this.submit_time = submit_time;
- }
-
- public Person getPerson_lzg() {
- return person_lzg;
- }
-
- public void setPerson_lzg(Person person_lzg) {
- this.person_lzg = person_lzg;
- }
-
- }
Person.java 文件
- package cn.lzg;
-
- import java.util.HashSet;
- import java.util.Set;
-
- import javax.persistence.CascadeType;
- import javax.persistence.Column;
- import javax.persistence.Entity;
- import javax.persistence.FetchType;
- import javax.persistence.GeneratedValue;
- import javax.persistence.GenerationType;
- import javax.persistence.Id;
- import javax.persistence.OneToMany;
- import javax.persistence.SequenceGenerator;
- import javax.persistence.Table;
-
- @Entity
- @Table(name = "person_lzg")
- public class Person {
-
- @Id
- @SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)
- @GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)
- private Long p_id;
-
- @Column(name = "name")
- private String name;
-
- @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "person_lzg")
-
- private Set orderSet = new HashSet();
-
- public Long getp_id() {
- return p_id;
- }
-
- public void setp_id(Long p_id) {
- this.p_id = p_id;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public Set getOrderSet() {
- return orderSet;
- }
-
- public void setOrderSet(Set orderSet) {
- this.orderSet = orderSet;
- }
-
- }
-
多对多
其实它的和 一对多 差不多,但是按照网上写法出现了一个问题,使得 双向的关系变成了单向的。
Person类
- package cn.lzg;
-
- import java.util.ArrayList;
- import java.util.List;
-
- import javax.persistence.Column;
- import javax.persistence.Entity;
- import javax.persistence.FetchType;
- import javax.persistence.GeneratedValue;
- import javax.persistence.GenerationType;
- import javax.persistence.Id;
- import javax.persistence.JoinColumn;
- import javax.persistence.JoinTable;
- import javax.persistence.ManyToMany;
- import javax.persistence.SequenceGenerator;
- import javax.persistence.Table;
-
- @Entity
- @Table(name = "person_lzg")
- public class Person {
-
- @Id
- @SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)
- @GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)
- private Long p_id;
-
- @Column(name = "name")
- private String name;
-
- @ManyToMany(targetEntity = cn.lzg.Book.class, fetch = FetchType.LAZY)
- @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "p_id") }, inverseJoinColumns = { @JoinColumn(name = "b_id") })
-
- private List books = new ArrayList();
-
- public Long getP_id() {
- return p_id;
- }
-
- public void setP_id(Long p_id) {
- this.p_id = p_id;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public List getBooks() {
- return books;
- }
-
- public void setBooks(List books) {
- this.books = books;
- }
-
- }
Book类
- package cn.lzg;
-
- import java.util.ArrayList;
- import java.util.List;
-
- import javax.persistence.Column;
- import javax.persistence.Entity;
- import javax.persistence.FetchType;
- import javax.persistence.GeneratedValue;
- import javax.persistence.GenerationType;
- import javax.persistence.Id;
- import javax.persistence.JoinColumn;
- import javax.persistence.JoinTable;
- import javax.persistence.ManyToMany;
- import javax.persistence.SequenceGenerator;
- import javax.persistence.Table;
-
- @Entity
- @Table(name = "book_lzg")
- public class Book {
- @Id
- @SequenceGenerator(name = "book_lzg", sequenceName = "b_seq", allocationSize = 1)
- @GeneratedValue(generator = "book_lzg", strategy = GenerationType.SEQUENCE)
- private Long b_id;
-
- @Column(name = "name")
- private String name;
-
- @ManyToMany(targetEntity = cn.lzg.Person.class, fetch = FetchType.LAZY)
- "color:#FF0000;">
-
- @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "b_id") }, inverseJoinColumns = { @JoinColumn(name = "p_id") })
- private List persons = new ArrayList();
-
- public Long getB_id() {
- return b_id;
- }
-
- public void setB_id(Long b_id) {
- this.b_id = b_id;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public List getPersons() {
- return persons;
- }
-
- public void setPersons(List persons) {
- this.persons = persons;
- }
-
- }
注意
- "color:#FF0000;">如果在上面ManyToMany注解中使用mappedBy,就成单向的了.因为mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人
-
- "color:#330033;">测试类
-
"code" class="java">package cn.lzg;
-
- import java.util.ArrayList;
- import java.util.Date;
- import java.util.List;
-
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.Transaction;
- import org.hibernate.cfg.Configuration;
- import org.hibernate.service.ServiceRegistry;
- import org.hibernate.service.ServiceRegistryBuilder;
- import org.junit.Test;
-
- public class TestHibernate {
- private static Configuration configuration = null;
- private static SessionFactory sessionFactory = null;
- private static ServiceRegistry serviceRegistry = null;
- private static Session session = null;
-
- static {
-
-
-
- configuration = new Configuration().configure();
-
- serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
- .buildServiceRegistry();
-
- sessionFactory = configuration.buildSessionFactory(serviceRegistry);
- session = sessionFactory.openSession();
- }
-
-
-
- @Test
-
- public void testM2M() {
- Person p1 = new Person();
- p1.setName("张三");
- Person p2 = new Person();
- p2.setName("李四");
- Person p3 = new Person();
- p3.setName("王五");
- List persons = new ArrayList();
- persons.add(p1);
- persons.add(p2);
- persons.add(p3);
-
- Book b1 = new Book();
- b1.setName("书本1");
- Book b2 = new Book();
- b2.setName("书本2");
- Book b3 = new Book();
- b3.setName("书本3");
- List books = new ArrayList();
- books.add(b1);
- books.add(b2);
- books.add(b3);
-
- p1.setBooks(books);
- b3.setPersons(persons);
-
- Transaction tx = session.beginTransaction();
- session.save(p1);
- session.save(p2);
- session.save(p3);
- session.save(b1);
- session.save(b2);
- session.save(b3);
- tx.commit();
- session.close();
- }
- }
结果生成了中间表
- lzgp_lzgb 里面的关系p1 有三本书, p1,p2,p3都有b3
HIbernate注解多对多关系要点总结
最近在公司做一个小项目,框架的持久层我选用的是Hibernate annotation,用户和他收藏的网站的关系是多对多的关系,一个用户可以收藏多个他喜爱的网站;反过来,一个网站也可以被多个用户收藏。
因此在设计类的时候,我设计了一个Sysuser(用户)类和一个Website(网站)类。
在配置注解的时候,由于在用户和网站之前,用户是主控方,网站是被控方。所以我在Sysuser类的getWebsite()方法上加了下面一段内容进行注解。
- @ManyToMany(fetch=FetchType.EAGER,cascade={CascadeType.PERSIST,CascadeType.MERGE})
- @JoinTable(name="user_web",joinColumns=@JoinColumn(name="userid"),
- inverseJoinColumns=@JoinColumn(name="webid"))
- public Set getWebsite() {
- return website;
- }
- public void setWebsite(Set website) {
- this.website = website;
- }
其中@ManyToMany就不用说了,指明用户和网站之前是多对多的关系。这里需要说的是,在主控方的get那个set集合的方法上面需要再加上@JoinTable进行注解,其中name="user_web"就是指在数据库中体现多对多关系的中间表是user_web,指定之后在首次运行项目的时候会在数据库中自动生成这个中间表,而且这个中间表不需要写个类去对应,可以通过这两个有多对多关系的类去维护第三章表的数据。joinColumns=@JoinColumn(name="userid")这句话的意思是是定义中间表与Sysuser这个类外键关系,中间表是通过userid这一列产生外键关联的,而inverseJoinColumns是中间表参考另一张的表的主键生成的列。
在Website类的getSysuser()方法上加了下面一段内容进行注解
- @ManyToMany(cascade={CascadeType.MERGE,CascadeType.PERSIST},mappedBy="website")
- public Set getSysuser() {
- return sysuser;
- }
- public void setSysuser(Set sysuser) {
- this.sysuser = sysuser;
- }
其中的@ManyToMany也不用说了,指明网站与用户之间是多对多的关系。需要说明的是在被控方,需要加上mappedBy,例如这里的mappedBy="website"是产生关系的属性。
总结一下需要注意的几点:
1、只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性,ManyToOne不存在该属性;
2、mappedBy标签一定是定义在the owned side(被控方,或者叫被拥有方),他指向the owning side(主控方,或者叫做拥有方);
3、mappedBy跟JoinColumn/JoinTable总是处于互斥的一方,可以理解为正是由于拥有方的关联被拥有方的字段存在,拥有方才拥有了被拥有方。mappedBy这方定义的JoinColumn/JoinTable总是失效的,不会建立对应的字段或者表。
Hibernate Annotation关系映射的几种类型映射用法及使用方法
- Hibernate Annotation关系映射的几种类型映射用法及使用方法(说明:以前实例的实体是user和role,主键分别是userid和roleid)
-
- 1)一对一外键关联映射(单向)
- @OneToOne(cascade=CascadeType.ALL)
- @JoinColumn(name="userid",unique=true)
-
- 2)一对一外键关联映射(双向)
- @OneToOne(mappedBy=" role",cascade=CascadeType.ALL)
-
-
- 3)一对一主键关联映射(不重要)
- 在实际中很少用,使用注解@PrimaryKeyJoinColumn,意思是说,我的主键去参考另外一张表中的主键,作为我的主键,但是在我测试使用注解一对一主键关联映射,在生成表的时候,数据库中并没有生成关联,使用XML映射可以生成。Annotation注解一对一主键关联映,有些bug。不过没空去研究它。因为在实际开发中一对一很少用。在实际开发中我机会没有用过,主键关联就更少了
-
- 4)多对一关联映射
- 多端配置
- @ManyToOne(targetEntity=role.class)
- @JoinColumn(name="userid")
-
- 5)一对多关联映射(单向)
- @OneToMany
- @JoinColumn(name="roleid")
-
- 6)一对多关联映射(双向)
- 一端配置
- @OneToMany(mappedBy="role")
- @JoinColumn(name="roleid")
-
- 多端配置
- @ManyToOne
- @JoinColumn(name=" roleid ")
-
- 7)多对多关联映射(单向)
- @ManyToMany
-
- 默认中间表的名称 :user_role中间表,字段的名称user_id role_id,如果想更换表名和字段名称,注解如下:
- @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})
-
- 8)多对多关联映射(双向)
- user端
- @ManyToMany
- 如果想更换表名和字段名称,注解如下:
- @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})
-
- role端
- @ManyToMany(mappedBy="role")
Hibernate Annotation笔记
在过去几年里,Hibernate不断发展,几乎成为Java数据库持久性的事实标准。它非常强大、灵活,而且具备了优异的性能。在本文中,我们将了解如何使用Java 5 注释来简化Hibernate代码,并使持久层的编码过程变得更为轻松。
传统上,Hibernate的配置依赖于外部 XML 文件:数据库映射被定义为一组 XML 映射文件,并且在启动时进行加载。
在最近发布的几个Hibernate版本中,出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库,即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的Java 类中,并提供一种强大及灵活的方法来声明持久性映射。
即利用hibernate注解后,可不用定义持久化类对应的*.hbm.xml文件,直接以注解方式写入在持久化类中来实现。
Hibernate annotation使用了ejb JPA的注解,所以,下面安装配置hibernate annotation环境时,需要导入ejb的包。许多网上的资料都是jpa hibernate annotation方面的资料。
(2)
安装 Hibernate Annotation
第一步,
环境与jar包:
要使用 Hibernate Annotation,您至少需要具备 Hibernate 3.2和Java 5。可以从 Hibernate 站点下载 Hibernate 3.2 和 Hibernate Annotation库。除了标准的 Hibernate JAR 和依赖项之外,您还需要 Hibernate Annotations .jar 文件(hibernate-annotations.jar)、Java 持久性 API (lib/ejb3-persistence.jar)。
添加hibernate3.2.jar,hibernate-annotations-3.3.0.jar,hibernate-commons-annotations.jar和ejb3-persistence.jar 。这样就可以使用hibernate的annotation了。
如果您正在使用 Maven,只需要向 POM 文件添加相应的依赖项即可,如下所示:
...
org.hibernate
hibernate
3.2.1.ga
org.hibernate
hibernate-annotations
3.2.0.ga
javax.persistence
persistence-api
1.0
第二步,
获取 Hibernate 会话工厂。尽管无需惊天的修改,但这一工作与使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 类来建立会话工厂:
sessionFactory = new AnnotationConfiguration().buildSessionFactory();
第三步,
尽管通常使用 元素来声明持久性类,您还是需要在 Hibernate 配置文件(通常是 hibernate.cfg.xml)中声明持久性类:
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
" http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
近期的许多 Java 项目都使用了轻量级的应用框架,例如 Spring。如果您正在使用 Spring 框架,可以使用
AnnotationSessionFactoryBean 类轻松建立一个基于注释的 Hibernate 会话工厂,如下所示:
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
org.hibernate.dialect.DerbyDialect
create
...
com.onjava.modelplanes.domain.PlaneType
com.onjava.modelplanes.domain.ModelPlane
...
(3)
hibernate Annotation标签的使用:
[1]
1.带注释的持久性类也是普通 POJO,它们只是具备了持久性注释的普通 POJO 。
2.事实上,您既可以保持字段的持久性(注释写在成员变量之上),也可以保持属性(注释写在getter方法之上)的持久性。