Hibernate Annotations

1、HibernateAnnotation依赖包

要使用HibernateAnnotation，您可以从Hibernate站点下载Hibernate3.6和HibernateAnnotation库。除了标准的HibernateJAR和依赖项之外，您还需要如下二个库：

　　1.HibernateAnnotationjar文件（hibernate-annotations.jar）

　　2.Java持久性API（lib/ejb3-persistence.jar）

下一步就是获取Hibernate会话工厂。近期的许多Java项目都使用了轻量级的应用框架，例如Spring。如果您正在使用Spring框架，可以使用AnnotationSessionFactoryBean类轻松建立一个基于注释的Hibernate会话工厂。

2、Hibernate注解语法

Hibernate的注解语法列表：

@Entity	声明为一个实体bean
@MappedSuperclass	用在实体的继承过程中的父类上
@Table(name="promotion_info")	为实体bean映射指定表
@Id	声明了该实体bean的标识属性
@GeneratedValue	可以定义标识字段的生成策略
@Transient	将忽略这些字段和属性，不用持久化到数据库
@Column(name="promotion_remark")	声明列，属性还包括(length=200等)
@Temporal(TemporalType.TIMESTAMP)	声明时间格式，支持DATE、TIME、 和 TIMESTAMP三种精度
@Enumerated	声明枚举
@Version	声明添加对乐观锁定的支持
@OneToOne	可以建立实体bean之间的一对一的关联
@OneToMany	可以建立实体bean之间的一对多的关联
@ManyToOne	可以建立实体bean之间的多对一的关联
@ManyToMany	可以建立实体bean之间的多对多的关联
@Formula	一个SQL表达式，这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)
@OrderBy	Many端某个字段排序(List)

详细说明：

　　1.使用annotation，既可以保持字段的持久性（注释写在成员变量之上），也可以保持属性（注释写在getter方法之上）的持久性。

　　2.Hibernate 能够出色地自动生成主键。Hibernate/EBJ 3 注释也可以为主键的自动生成提供丰富的支持，允许实现各种策略。其生成规则由@GeneratedValue设定的。这里的@id和@GeneratedValue都是JPA的标准用法，JPA提供的四种标准用法为TABLE、SEQUENCE、IDENTITY、AUTO。在指定主键时，如果不指定主键生成策略，默认为AUTO。

　　TABLE：使用一个特定的数据库表格来保存主键。

　　SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。

　　IDENTITY：主键由数据库自动生成（主要是自动增长型）

　　AUTO：主键由程序控制。

IDENTITY:使用SQL Server 和 MySQL 的自增字段，这个方法不能放到 Oracle 中，Oracle 不支持自增字段，要设定SEQUENCE，也可采用uuid，native等其它策略。如果要采用uuid的生成方式，由于JPA注解不支持此种方法，则要用hibernate的注解联合起来使用具体的用法如下:

@GenericGenerator(name="idGenerator", strategy="uuid") //这个是hibernate的注解
@GeneratedValue(generator="idGenerator") //使用uuid的生成策略

　　3.一对多注解。使用@OneToMany注释“一”方，双向一对多时，需使用mappedBy属性标注己方为被控方。使用@ManyToOne注释“多”方，双向一对多时，需同时使用@JoinColumn(name=”外键字段”)表明己方为控制方。@OneToMany和@ManyToOne还有cascade与fetch属性。

　　cascade属性可取值：

　　CascadeType.PERSIST （级联新建） 
　　CascadeType.REMOVE  （级联删除） 
　　CascadeType.REFRESH （级联刷新） 
　　CascadeType.MERGE   （级联更新）中选择一个或多个。 
　　CascadeType.ALL

　　fetch属性可取值：

　　LAZY（默认值）采用延时加载，查询数据时，不一起查询关联对象的数据。而是当访问关联对象时(如：getStudnets()时)才触发相应的查询操作，获取关联对象数据。
　　EAGER：是在查询数据时，也直接一起获取关联对象的数据。

　　4．多对多注解。在多对多注解中，双方都采用@ManyToMany。其中被控方，像一对多注解中设置一样，也要设置mappedBy。其中主控方，不像一对多注解那样，采用@joinColumn，而是采用@joinTable。如下：

@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})

其中，如上所说，mappedBy，相当于inverse="true"，所以，在@joinTable中的inverseJoinColumns中定义的字段为mappedBy所在类的主键。joinColumns定义的字段,就是当前类的主键。

　　5.如果需要从父类继承公共属性，同时还不将该父类作为映射的实体(也就是该实体没有对应的表). 这个时候需要使用@MappedSuperclass注解来进行映射：

@MappedSuperclass
public class BaseEntity {
    @Basic
    @Temporal(TemporalType.TIMESTAMP)
    public Date getLastUpdate() { ... }
    public String getLastUpdater() { ... }
    ...
}

@Entity class Order extends BaseEntity {
    @Id public Integer getId() { ... }
    ...
}

3、Spring中的配置

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="packagesToScan">
        <list>
            <value>com.habuma.spitter.domain</value>
        </list>
    </property>
</bean>

4、使用示例

@Entity
@Table(name = "T_MODEL_PLANE")
public class ModelPlane implements Serializable {
    @Id
    @Column(name = "PLANE_ID")
    @GeneratedValue(strategy = GenerationType.AUTO) //注解于属性中 
/* 
对于oracle想使用各自的Sequence,设置如下:        
@GeneratedValue(strategy = GenerationType.AUTO,generator="PROMOTION_SEQ")        
@SequenceGenerator(name="PROMOTION_SEQ",sequenceName="PROMOTION_SEQ")    
 
另外:
对于自动增长后,在数据表中的相应字段,要设置字段为auto_increment.
*/
    private Long id;

    private String name;//注解写于getter方法之上.请见下. 

    //DATE            - java.sql.Date        
    //TIME            - java.sql.Time        
    //TIMESTAMP - java.sql.Timestamp        
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "start_time")
    private Date startTime;

    //显示0 隐藏1        
    public static enum DisplayType {
        显示, 隐藏
    }

    @Enumerated(value = EnumType.ORDINAL)//ORDINAL序数        
    private DisplayType displayType = DisplayType.显示;

    //1.sql语句中的字段和表名都应该和数据库相应,而不是类中的字段,        
    //若带有参数如la.id= id,这个=id才是类中属性        
    //2.操作字段一定要用别名        
    @Formula(select COUNT(la.id) from largess la)
    private int count;

    //注解于方法中 
    @Column(name = "PLANE_ID", length = 80, nullable = true) //较详细定义 
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    其它的setter,getter省略......
}

该内容将映射到下表中：
        CREATE TABLE T_MODEL_PLANE
        (
        PLANE_ID long,
        PLANE_NAME varchar
        其它字段省略...
        )

package oneToMany; 
import java.util.Set; 
import javax.persistence.*; 
/* 
注意导入时，是导入：import javax.persistence.*;    
非导入org.hibernate的相关类：import org.hibernate.annotations.Entity; 
*/ 
@Entity 
@Table(name="classes") 
public class Classes implements Serializable { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int id; 
  private String name; 
    
  @OneToMany(cascade=CascadeType.ALL,mappedBy="classes")    
  private Set<Student> students; 
//getter,setter省略 
} 


package oneToMany; 
import javax.persistence.*; 
@Entity 
@Table(name="student") 
public class Student implements Serializable  { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int sid; 
    
  private String sname; 
    
  //若有多个cascade，可以是：{CascadeType.PERSIST,CascadeType.MERGE} 
  @ManyToOne(cascade={CascadeType.ALL})         
  @JoinColumn(name="classid")     //student类中对应外键的属性：classid 
  private Classes classes; 
//getter,setter省略 
} 


public class TestOneToMany { 
/* 
CREATE TABLE    student (    --要定义外键!!!!!!! 
    `sid` double NOT NULL auto_increment, 
    `classid` double NULL, 
    `sname` varchar(255) NOT NULL, 
    PRIMARY KEY    (sid), 
    INDEX par_ind (classid), 
    FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE 
) ENGINE=InnoDB 
*/    
  public static void main(String[] args) throws SQLException    
  { 
    try 
    { 
      SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
      Session session=sf.openSession(); 
      Transaction tx=session.beginTransaction();         
/*
因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以,
1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据;
2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student.
*/
      Classes classes=new Classes(); 
      classes.setName("access"); 
        
      Student st1=new Student(); 
      st1.setSname("jason"); 
      st1.setClasses(classes); 
      session.save(st1); 
        
      Student st2=new Student(); 
      st2.setSname("hwj"); 
      st2.setClasses(classes); 
      session.save(st2); 
      tx.commit();
/* 
输出如下:
Hibernate: insert into classes (name) values (?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
*/
/*
因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类(class)建立关系，因为这样建立的关系是不会在数据库中存储的。
如上的代码倒过来,则插入时,student的外键值为空.如下:
*/
//      Student st1=new Student(); 
//      st1.setSname("jason"); 
//      session.save(st1); 
//        
//      Student st2=new Student(); 
//      st2.setSname("hwj"); 
//      session.save(st2); 
//        
//      Set<Student> students=new HashSet<Student>(); 
//      students.add(st1); 
//      students.add(st2); 
//        
//      Classes classes=new Classes(); 
//      classes.setName("access"); 
//      classes.setStudents(students); 
//      session.save(classes); 
/*
输出如下:
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into classes (name) values (?)
*/
    } 
    catch(HibernateException e) 
    { 
      e.printStackTrace();        
    } 
  } 
}

@Entity 
@Table(name="jcourse") 
public class Jcourse { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int cid; 
  private String cname; 
    
  @ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY ,mappedBy="courses") 
  private Set<Jstudent> students; 
//setter,getter省略....    
} 


@Entity 
@Table(name="jstudent") 
public class Jstudent { 
  @Id 
  @GeneratedValue(strategy=GenerationType.AUTO) 
  private int sid; 
    
  private String sname; 
    
  @ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.EAGER) 
  //inverseJoinColumns中对应的id为以下属性course的对应id. 
  @JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")}) 
  private Set<Jcourse> courses; 
//setter,getter省略....    
} 


public class Test { 
  public static void main(String[] args) { 
    try 
    { 
      SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
      Session session=sf.openSession(); 
      Transaction tx=session.beginTransaction(); 
        
      Jcourse course=new Jcourse(); 
      course.setCname("jason-english"); 
      session.save(course); //先各自保存. 
        
      Jcourse course2=new Jcourse(); 
      course2.setCname("herry-english"); 
      session.save(course2); 
        
      Set<Jcourse> courses=new HashSet<Jcourse>(); 
      courses.add(course); 
      courses.add(course2); 
        
      Jstudent student=new Jstudent(); 
      student.setSname("jason"); 
      student.setCourses(courses); 
        
      session.save(student);// 要用非mapby定义的类(studet)来作为主者(会控制级联关系),一对多,多对一也一样道理. 
      //可以尝试反过来. 
      tx.commit(); 
    } 
    catch(HibernateException e) 
    { 
      e.printStackTrace();        
    } 
  } 
}

 5、参考：

　　http://blog.csdn.net/xingfeng0501/article/details/7005917

　　http://docs.jboss.org/hibernate/annotations/3.4/reference/zh_cn/html_single/