Hibernate注解

Hibernate 注解： 注解可以用在一个类中。


1. 好处： 
可以把两个文件合成一个，减少配置文件。Java文件里的检查工具比较强大，出的时候容易检查。


使用Annotation的步骤：
        
1. 在hibernate的基础上添加包：
a) Hibernate-annotations.jar
b) Ejb3-persistence.jar
c) Hibernate-commons-annotation.jar


2. 引入注解:
@entity, 通过这个注解知道这个类是做持久化操作的。
需导入的包：javax.pesistence(不管你采用哪种框架使用都可以)        
org.hibernate.annotations.entity（表明一定规范要使用hibernate框架）


一般写在get()方法上面，
@id（为主键）
@GeneratedValue(strategy=GenerationType . IDENTITY) //自增
//它的默认值是GenerationType.AUTO，相当于xml时的native。
Public Integer getId(){
this.id = id;
}
@Column(name= “name”)
Public String getName(){
return this.name;
}
@Temporal(TemporalType . DATE/TINESTAMP(具体的)) 
//指定日期时间的类型。(TIMESTAMP,DATE,TIME)
@Table(name= “tbl_sky”) //表明要跟数据库的表名一致
@Transient配置瞬时的,不要跟数据库对应，// @Transient 指定属性不需要持久化.


也可以注解在属性上面。




 3. 使用：
在Hibernate全局配置文件中使用声明映射类的方式：
1.引入持久化对象类：<mapping class="实体类的全限定名"/>  < mapping class=”bean . Student”>
2.使用AnnotationConfiguration类
SessionFactory factory = new AnnotationConfiguration().configure().buildSessionFactory();






映射关联关系
如何配置一对多(Set集合)/多对一
通过Annotation注解进来， 


1. 映射多对一
  1) @ManyToOne
  2) 指定关联列@JoinColumn(name="xxx_id")
  
2. 映射一对多
  1) @OneToMany  默认会使用连接表做一对多的关联。
  2) 添加@JoinColumn(name="xxx_id")后，就会使用外键关联，而不使用连接表了。


3. 映射双向一对多
  1) 在多端： 
     @ManyToOne
     @JoinColumn(name="外键名")
  2) 在一端：(一对多关联，把关系维护权交给多端更有效率)
     @OneToMany(mappedBy="多端的关联属性名")
     @JoinColumn(name="外键名")


4. mappedBy属性：用在双向关联中，把关系的维护权反转.


/一对多：
@OneToMany(mappedBy = “cla”) //配的是指多的一方指向一的一方
 // mappedBy = “cla”指 多的一方的 private Cla cla;


/多对一：
@ManyToOne( fetch= FetchType. LAZY) //表明要不要延迟加载，
Public Cla getCla(){
return cla;
}


/多对多：
@ManyToMany(mappedBy=”teacher”)
Stu类在维护：private Set<Student> teachers = new HashSet(0)


由维护端产生中间表。
放弃维护的这一端（Stu的一端）在中间表的外键的哪一个列：inverseJoinColumns = @JoinColumns(name = “t _id”)
joinColumns设置维护端在中间表的列名:JoinColumns = @JoinColumns(name = “s _id”)






注：写约束的配置
< columns name =”age” check= “age between 15 and 30”> 








主页




在过去几年里，Hibernate不断发展，几乎成为Java数据库持久性的事实标准。它非常强大、灵活，而且具备了优异的性能。在本文中，我们将了解如何使用Java 5 注释来简化Hibernate代码，并使持久层的编码过程变得更为轻松。
　　传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。创建这些映射有很多方法，可以从已有数据库模式或Java类模型中自动创建，也可以手工创建。无论如何，您最终将获得大量的 Hibernate 映射文件。此外，还可以使用工具，通过javadoc样式的注释生成映射文件，尽管这样会给您的构建过程增加一个步骤。
　　在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中，并提供一种强大及灵活的方法来声明持久性映射。籍由自动代码完成和语法突出显示功能，最近发布的Java IDE也为其提供了有力的支持。
　　Hibernate Annotation还支持新的 EJB 3 持久性规范。这些规范旨在提供一种标准化的 Java 持久性机制。由于 Hibernate 3 还提供了一些扩展，因此您可以十分轻松地遵从这些标准，并使用 EJB 3 编程模型来对 Hibernate 持久层进行编码。
　　现在，让我们来动手使用Hibernate Annotation。
安装 Hibernate Annotation
　　要使用 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）。如果您正在使用 Maven，只需要向 POM 文件添加相应的依赖项即可，如下所示：
       ...
       <dependency>
         <groupId>org.hibernate</groupId>
         <artifactId>hibernate</artifactId>
         <version>3.2.1.ga</version>
       </dependency>
       <dependency>
         <groupId>org.hibernate</groupId>
         <artifactId>hibernate-annotations</artifactId>
         <version>3.2.0.ga</version>
       </dependency>
       <dependency>
         <groupId>javax.persistence</groupId>
         <artifactId>persistence-api</artifactId>
         <version>1.0</version>
       </dependency>
       ...
　　下一步就是获取 Hibernate 会话工厂。尽管无需惊天的修改，但这一工作与使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 类来建立会话工厂：
sessionFactory = newAnnotationConfiguration().buildSessionFactory();
　　尽管通常使用 <mapping> 元素来声明持久性类，您还是需要在 Hibernate 配置文件（通常是 hibernate.cfg.xml）中声明持久性类：
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
       "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
           <hibernate-configuration>
             <session-factory>
               <mapping class="com.onjava.modelplanes.domain.PlaneType"/>
               <mapping class="com.onjava.modelplanes.domain.ModelPlane"/>
             </session-factory>
           </hibernate-configuration>
　　近期的许多 Java 项目都使用了轻量级的应用框架，例如 Spring。如果您正在使用 Spring 框架，可以使用 AnnotationSessionFactoryBean 类轻松建立一个基于注释的 Hibernate 会话工厂，如下所示：
<!-- Hibernate session factory -->
     <bean id="sessionFactory" 
           class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
      <property name="dataSource">
        <ref bean="dataSource"/>
      </property>
      <property name="hibernateProperties">
        <props>
          <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
          <prop key="hibernate.hbm2ddl.auto">create</prop>
          ...
        </props>
      </property>
      <property name="annotatedClasses">
        <list>
          <value>com.onjava.modelplanes.domain.PlaneType</value>
          <value>com.onjava.modelplanes.domain.ModelPlane</value>
          ...
        </list>
      </property>
</bean>
第一个持久性类
　　既然已经知道了如何获得注释所支持的 Hibernate 会话，下面让我们来了解一下带注释的持久性类的情况：
　　像在其他任何 Hibernate应用程序中一样，带注释的持久性类也是普通 POJO。差不多可以说是。您需要向 Java 持久性 API （javax.persistence.*）添加依赖项，如果您正在使用任何特定于 Hibernate的扩展，那很可能就是 Hibernate Annotation 程序包（org.hibernate.annotations.*），但除此之外，它们只是具备了持久性注释的普通 POJO 。下面是一个简单的例子：
@Entity
public class ModelPlane {
       private Long id;
       private String name;
       @Id
       public Long getId() {
           return id;
       }
       public void setId(Long id) {
           this.id = id;
       }
       public String getName() {
           return name;
       }
       public void setName(String name) {
           this.name = name;
       }
}
　　正像我们所提到的，这非常简单。@Entity 注释声明该类为持久类。@Id 注释可以表明哪种属性是该类中的独特标识符。事实上，您既可以保持字段（注释成员变量），也可以保持属性（注释getter方法）的持久性。后文中将使用基于属性的注释。基于注释的持久性的优点之一在于大量使用了默认值（最大的优点就是 “惯例优先原则（convention over configuration）”）。例如，您无需说明每个属性的持久性——任何属性都被假定为持久的，除非您使用 @Transient 注释来说明其他情况。这简化了代码，相对使用老的 XML 映射文件而言也大幅地减少了输入工作量。
生成主键
　　Hibernate 能够出色地自动生成主键。Hibernate/EBJ 3 注释也可以为主键的自动生成提供丰富的支持，允许实现各种策略。下面的示例说明了一种常用的方法，其中 Hibernate 将会根据底层数据库来确定一种恰当的键生成策略：
@Id
       @GeneratedValue(strategy=GenerationType.AUTO)
       public Long getId() {
           return id;
       }
定制表和字段映射
　　默认情况下，Hibernate 会将持久类以匹配的名称映射到表和字段中。例如，前一个类可以与映射到以如下代码创建的表中：
CREATE TABLE MODELPLANE 
(
       ID long,
       NAME varchar
)
　　如果您是自己生成并维护数据库，那么这种方法很有效，通过省略代码可以大大简化代码维护。然而，这并不能满足所有人的需求。有些应用程序需要访问外部数据库，而另一些可能需要遵从公司的数据库命名惯例。如果有必要，您可以使用 @Table 和 @Column 注释来定制您自己的持久性映射，如下所示：
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
       private Long id;
       private String name;
       @Id
       @Column(name="PLANE_ID")
       public Long getId() {
           return id;
       }
       public void setId(Long id) {
           this.id = id;
       }
       @Column(name="PLANE_NAME") 
       public String getName() {
           return name;
       }
       public void setName(String name) {
           this.name = name;
       }
}
　　该内容将映射到下表中：
CREATE TABLE T_MODEL_PLANE 
(
       PLANE_ID long,
       PLANE_NAME varchar
)
　　也可以使用其他图和列的属性来定制映射。这使您可以指定诸如列长度、非空约束等详细内容。Hibernate支持大量针对这些注释的属性。下例中就包含了几种属性：
       ...
       @Column(name="PLANE_ID", length=80, nullable=true)
       public String getName() {
           return name;
       }
       ...
映射关系
　　Java 持久性映射过程中最重要和最复杂的一环就是确定如何映射表间的关系。像其他产品一样， Hibernate 在该领域中提供了高度的灵活性，但却是以复杂度的增加为代价。我们将通过研究几个常见案例来了解如何使用注释来处理这一问题。
　　其中一种最常用的关系就是多对一的关系。假定在以上示例中每个 ModelPlane 通过多对一的关系（也就是说，每个飞机模型只与一种飞机类型建立联系，尽管指定的飞机类型可以与七种飞机模型建立联系）来与 PlaneType 建立联系。可如下进行映射：
       @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
       public PlaneType getPlaneType() {
                       return planeType;
             }
　　CascadeType 值表明 Hibernate 应如何处理级联操作。
　　另一种常用的关系与上述关系相反：一对多再对一关系，也称为集合。在老式的 Hibernate 版本中进行映射或使用注释时，集合令人头疼，这里我们将简要加以探讨，以使您了解如何处理集合，例如，在以上示例中每个 PlaneType 对象都可能会包含一个 ModelPlanes 集合。可映射如下：
@OneToMany(mappedBy="planeType",
                      cascade=CascadeType.ALL, 
                      fetch=FetchType.EAGER)
       @OrderBy("name")
       public List<ModelPlane> getModelPlanes() {
           return modelPlanes;
       }
命名查询
　　Hibernate 最优秀的功能之一就在于它能够在您的映射文件中声明命名查询。随后即可通过代码中的名称调用此类查询，这使您可以专注于查询，而避免了 SQL 或者 HQL 代码分散于整个应用程序中的情况。
　　也可以使用注释来实现命名查询，可以使用 @NamedQueries 和 @NamedQuery 注释，如下所示：
@NamedQueries(
{         
     @NamedQuery(
       name="planeType.findById",
       query="select p from PlaneType p left join fetch p.modelPlanes where id=:id"
     ),
     @NamedQuery(
       name="planeType.findAll",
       query="select p from PlaneType p" 
     ),
     @NamedQuery(
             name="planeType.delete",
             query="delete from PlaneType where id=:id" 
           )  
}
)
　　一旦完成了定义，您就可以像调用其他任何其他命名查询一样来调用它们。
结束语
　　Hibernate 3 注释提供了强大而精致的 API，简化了 Java 数据库中的持久性代码，本文中只进行了简单的讨论。您可以选择遵从标准并使用 Java 持久性 API，也可以利用特定于 Hibernate的扩展，这些功能以损失可移植性为代价提供了更为强大的功能和更高的灵活性。无论如何，通过消除对 XML 映射文件的需求，Hibernate 注释将简化应用程序的维护，同时也可以使您对EJB 3 有初步认识。来试试吧！