`

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 文件添加相应的依赖项即可,如下所示:
    ...
    <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 = new AnnotationConfiguration().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>
(3)
hibernate Annotation标签的使用:
[1]
1.带注释的持久性类也是普通 POJO,它们只是具备了持久性注释的普通 POJO 。
2.事实上,您既可以保持字段的持久性(注释写在成员变量之上),也可以保持属性(注释写在getter方法之上)的持久性。
3.常用的hibernate annotation标签如下:
@Entity               --注释声明该类为持久类。将一个Javabean类声明为一个实体的数据库表映射类,最好实现序列化.此时,默认情况下,所有的类属性都为映射到数据表的持久性字段.若在类中,添加另外属性,而非映射来数据库的,要用下面的Transient来注解.

@Table(name="promotion_info")      --持久性映射的表(表名="promotion_info).@Table是类一级的注解,定义在@Entity下,为实体bean映射表,目录和schema的名字,默认为实体bean的类名,不带包名.

@Id--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。
@GeneratedValue --定义自动增长的主键的生成策略.
@Transient            --将忽略这些字段和属性,不用持久化到数据库.适用于,在当前的持久类中,某些属性不是用于映射到数据表,而是用于其它的业务逻辑需要,这时,须将这些属性进行transient的注解.否则系统会因映射不到数据表相应字段而出错.
@Temporal(TemporalType.TIMESTAMP)--声明时间格式
@Enumerated          --声明枚举
@Version                --声明添加对乐观锁定的支持
@OneToOne             --可以建立实体bean之间的一对一的关联
@OneToMany           --可以建立实体bean之间的一对多的关联
@ManyToOne           --可以建立实体bean之间的多对一的关联
@ManyToMany         --可以建立实体bean之间的多对多的关联
@Formula                --一个SQL表达式,这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)
@OrderBy                --Many端某个字段排序(List)
1.2
Hibernate 能够出色地自动生成主键。Hibernate/EBJ 3 注释也可以为主键的自动生成提供丰富的支持,允许实现各种策略。
其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法, JPA提供四种标准用法,由@GeneratedValue的源代码可以明显看出.
JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO.
TABLE:使用一个特定的数据库表格来保存主键。
SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。
IDENTITY:主键由数据库自动生成(主要是自动增长型)
AUTO:主键由程序控制。
在指定主键时,如果不指定主键生成策略,默认为AUTO。
@Id
相当于
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
identity:
使用SQL Server 和 MySQL 的自增字段,这个方法不能放到 Oracle 中,Oracle 不支持自增字段,要设定sequence(MySQL 和 SQL Server 中很常用)。
Oracle就要采用sequence了.
同时,也可采用uuid,native等其它策略.(相关用法,上网查询)
[2]
第一个持久性类
@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
         其它字段省略...
)    
默认情况下,Hibernate 会将持久类以匹配的名称映射到表和字段中。例如,下例中,若不用注解,则会映射到如下一表中:
CREATE TABLE MODELPLANE
(
    ID long,
    NAME varchar
    其它字段省略...
)
[3]
一对多注解:
1.
在一对多注解中,会用到:
"一"方:
@OneToMany --> mappedBy:"多"方的关联属性(被控方)
"多"方:
@ManyToOne --> @JoinColumn,"多"方定义的外键字段.
如数据表定义外键如下:
FOREIGN KEY (classid) REFERENCES classes(id)
则:
@JoinColumn(name="classid")
2.
在双向关联中,有且仅有一端作为主体(owner)端存在:主体端负责维护联接列(即更新),对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向另一主体的关联属性。例子中,mappedBy的值为classes。
附加说明:
mappedBy相当于过去的inverse="true".
inverse=false的side(side其实是指inverse=false所位于的class元素)端有责任维护关系,而inverse=true端无须维护这些关系。
3.
cascade与fetch使用说明:
Cascade
CascadeType.PERSIST (级联新建)
CascadeType.REMOVE (级联删除)
CascadeType.REFRESH (级联刷新)
CascadeType.MERGE   (级联更新)中选择一个或多个。
CascadeType.ALL
fetch属性:
关联关系获取方式,即是否采用延时加载。
LAZY(默认值)采用延时加载,查询数据时,不一起查询关联对象的数据。而是当访问关联对象时(如:getStudnets()时)才触发相应的查询操作,获取关联对象数据。
EAGER:是在查询数据时,也直接一起获取关联对象的数据。
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();        
     }
   }
}
[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定义的字段,就是当前类的主键.
@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();        
     }
   }
}

 

分享到:
评论

相关推荐

    hibernate annotation hibernate3

    在Java开发领域,Hibernate作为一种强大的对象关系映射(ORM)框架,极大地简化了数据库操作。本篇将深入探讨Hibernate 3版本中的注解使用,帮助开发者理解如何利用注解进行数据持久化,提高开发效率。 一、...

    hibernate annotation 中文文档

    Hibernate Annotation提供了一系列预定义的注解,如@Entity、@Table、@Id等,它们用于标记实体类、映射表以及主键。例如,`@Entity`表示该类为一个数据库实体,`@Table`指定对应的数据库表名,`@Id`则标识类中的...

    Hibernate Annotation 中文文档

    Hibernate Annotation是Hibernate框架的一个扩展,它允许开发者直接在Java类和属性上使用注解(Annotations),来定义实体类与数据库表之间的映射关系。相比于XML配置,注解提供了一种更加内聚和直接的方式,使得...

    最全的Hibernate Annotation API文档

    在Hibernate中,注解(Annotation)是一种声明式的方法,用于配置实体类、属性以及它们与数据库表之间的映射关系。本文将深入探讨“最全的Hibernate Annotation API文档”中的关键知识点。 一、实体类(Entity) 在...

    Hibernate Annotation库

    总之,Hibernate Annotation库是Java开发中不可或缺的工具,它通过注解的方式简化了ORM的过程,使得开发者能更专注于业务逻辑,而不是底层的数据操作细节。通过理解并熟练使用这些注解,可以有效地提升开发效率和...

    Hibernate Annotation入门

    而Hibernate Annotation是Hibernate的一个重要特性,它通过在Java类和字段上添加注解来简化数据库表和实体类之间的映射配置。这篇博文将带你了解如何使用Hibernate Annotation进行开发。 首先,我们需要理解Java...

    Hibernate Annotation 学习笔记

    本文将通过一个实际操作的实例,逐步介绍Hibernate Annotation的基础知识。 一、开始实践 1. 项目准备:首先,我们需要准备JDK 5.0或更高版本,以及Hibernate 3.2.2.ga、hibernate-annotations-3.2.1.GA和ejb3-...

    sping hibernate Annotation(注释配置) demo(例子)

    在 Hibernate 中,实体类可以通过注解进行配置,如 `@Entity` 表示该类对应数据库中的表,`@Table` 定义表名,`@Id` 定义主键,`@GeneratedValue` 用于自动生成主键值。另外,`@Column`、`@ManyToOne`、`@OneToMany`...

    hibernate annotation api chm文件

    Hibernate是一个流行的Java持久化框架,它简化了数据库操作,使得开发者可以更专注于业务逻辑而不是底层的数据访问细节。在Hibernate 3.3版本中,引入了Annotation API,这是一种更加直观、简洁的方式来声明对象-...

    Hibernate Annotation 笔记 总结 注解

    【描述】:本文将全面介绍Hibernate Annotation的使用,包括事务管理和声明式事务处理,以及如何通过注解简化数据库持久化操作。 【标签】:Hibernate, Annotation, 笔记, 总结, 注解 【正文】: Hibernate ...

    HibernateAnnotation

    其中,HibernateAnnotation技术是指在Java类上使用注解来替代传统的XML配置文件,这不仅简化了配置过程,还提高了代码的可读性和维护性。 ### 核心知识点详解 #### 1. `@Entity` 注解 `@Entity` 是用于标记一个...

    Hibernate distribution and annotation

    标题“Hibernate distribution and annotation”涉及到的是Hibernate ORM框架的一个特定版本及其相关的注解功能。Hibernate是一个流行的Java对象关系映射(ORM)工具,它允许开发者使用面向对象的编程模型来操作...

    Hibernate Annotation 唯一外键一对一双向关联

    通过阅读《Hibernate_annotation_1to1_foreignKey》文档或博客,你可以更详细地了解如何配置和使用这种关联,包括示例代码、注意事项以及可能遇到的问题和解决方案。理解并熟练运用这些知识,能帮助你在使用...

    hibernate-annotation

    Hibernate作为Java领域中的一款强大持久化框架,极大地简化了数据库操作。而Hibernate注解则是其在ORM(对象关系映射)领域的进一步进化,它允许开发者将元数据直接嵌入到Java类和属性的声明中,从而避免了XML配置...

    hibernate-Annotation.jar

    Hibernate是一个开源的对象...综上所述,Hibernate Annotation使得Java开发者能够更高效地管理数据库操作,减少XML配置,提高代码可读性和可维护性。在实际开发中,熟练掌握Hibernate的注解映射是提升开发效率的关键。

    Hibernate中文文档+hibernate annotation +distribution

    本文将深入探讨Hibernate的核心概念,结合提供的中文文档,以及hibernate-annotation-3.4.0GA和hibernate-distribution-3.3.2.GA的相关资料,为开发者提供详尽的学习资源。 首先,Hibernate中文文档是理解框架基础...

    hibernate annotation jar

    Hibernate是一个广泛使用的Java库,它允许开发人员将数据库操作与应用程序的业务逻辑解耦,使得数据库管理更加灵活和高效。在3.3版本中,Hibernate引入了对Java注解的支持,这极大地简化了配置过程,减少了XML文件的...

    hibernate annotation 3.40

    Hibernate Annotation是Hibernate 3.x引入的新特性,它允许开发者通过在Java类和类属性上使用特定的注解,来定义对象和数据库表之间的映射关系。这使得开发者可以脱离XML配置文件,直接在源代码中管理ORM配置。 2....

    hibernate 中文文档 and _annotation.chm

    《Hibernate中文文档与Annotation》 Hibernate是一款开源的对象关系映射(ORM)框架,它极大地简化了Java应用程序对数据库的操作。Hibernate允许开发人员将Java对象模型与数据库表进行映射,从而避免了传统的JDBC...

Global site tag (gtag.js) - Google Analytics