Hibernate Annotation笔记

 

来源：http://shenzhenchufa.blog.51cto.com/730213/291787

 

HibernateAnnotation笔记

(1)
简介：
在过去几年里，Hibernate不断发展，几乎成为Java数据库持久性的事实标准。它非常强大、灵活，而且具备了优异的性能。在本文中，我们将了解如何使用Java5注释来简化Hibernate代码，并使持久层的编码过程变得更为轻松。
　　传统上，Hibernate的配置依赖于外部XML文件：数据库映射被定义为一组XML映射文件，并且在启动时进行加载。
在最近发布的几个Hibernate版本中，出现了一种基于Java5注释的更为巧妙的新方法。借助新的HibernateAnnotation库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的Java类中，并提供一种强大及灵活的方法来声明持久性映射。

即利用hibernate注解后，可不用定义持久化类对应的*.hbm.xml文件，直接以注解方式写入在持久化类中来实现。

Hibernateannotation使用了ejbJPA的注解,所以，下面安装配置hibernateannotation环境时，需要导入ejb的包。许多网上的资料都是jpahibernateannotation方面的资料。

(2)
安装HibernateAnnotation
第一步，
环境与jar包：
　　要使用HibernateAnnotation，您至少需要具备Hibernate3.2和Java5。可以从Hibernate站点下载Hibernate3.2和HibernateAnnotation库。除了标准的HibernateJAR和依赖项之外，您还需要HibernateAnnotations.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会话工厂。尽管无需惊天的修改，但这一工作与使用HibernateAnnotations有所不同。您需要使用AnnotationConfiguration类来建立会话工厂：
sessionFactory=newAnnotationConfiguration().buildSessionFactory();
第三步，
尽管通常使用<mapping>元素来声明持久性类，您还是需要在Hibernate配置文件（通常是hibernate.cfg.xml）中声明持久性类：
<!DOCTYPEhibernate-configurationPUBLIC
"-//Hibernate/HibernateConfigurationDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<mappingclass="com.onjava.modelplanes.domain.PlaneType"/>
<mappingclass="com.onjava.modelplanes.domain.ModelPlane"/>
</session-factory>
</hibernate-configuration>
　　近期的许多Java项目都使用了轻量级的应用框架，例如Spring。如果您正在使用Spring框架，可以使用

AnnotationSessionFactoryBean类轻松建立一个基于注释的Hibernate会话工厂，如下所示：
<!--Hibernatesessionfactory-->
<beanid="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<propertyname="dataSource">
<refbean="dataSource"/>
</property>
<propertyname="hibernateProperties">
<props>
<propkey="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
<propkey="hibernate.hbm2ddl.auto">create</prop>
...
</props>
</property>
<propertyname="annotatedClasses">
<list>
<value>com.onjava.modelplanes.domain.PlaneType</value>
<value>com.onjava.modelplanes.domain.ModelPlane</value>
...
</list>
</property>
</bean>

(3)
hibernateAnnotation标签的使用:

[1]
1.带注释的持久性类也是普通POJO,它们只是具备了持久性注释的普通POJO。

2.事实上，您既可以保持字段的持久性（注释写在成员变量之上），也可以保持属性（注释写在getter方法之上）的持久性。

3.常用的hibernateannotation标签如下:

@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/EBJ3注释也可以为主键的自动生成提供丰富的支持，允许实现各种策略。
其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法,JPA提供四种标准用法,由@GeneratedValue的源代码可以明显看出.
JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO.
TABLE：使用一个特定的数据库表格来保存主键。
SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
IDENTITY：主键由数据库自动生成（主要是自动增长型）
AUTO：主键由程序控制。

在指定主键时，如果不指定主键生成策略，默认为AUTO。
@Id

相当于

@Id
@GeneratedValue(strategy=GenerationType.AUTO)

 

identity:

使用SQLServer和MySQL的自增字段，这个方法不能放到Oracle中，Oracle不支持自增字段，要设定sequence（MySQL和SQLServer中很常用）。

Oracle就要采用sequence了.

 

同时,也可采用uuid,native等其它策略.(相关用法,上网查询)

[2]

第一个持久性类

@Entity
@Table(name="T_MODEL_PLANE")
publicclassModelPlaneimplementsSerializable{
@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.
*/
privateLongid;

privateStringname;//注解写于getter方法之上.请见下.

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

//显示0隐藏1
publicstaticenumDisplayType{显示,隐藏}
@Enumerated(value=EnumType.ORDINAL)//ORDINAL序数
privateDisplayTypedisplayType=DisplayType.显示;

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

//注解于方法中
@Column(name="PLANE_ID",length=80,nullable=true)//较详细定义
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
其它的setter,getter省略......
}

该内容将映射到下表中：
CREATETABLET_MODEL_PLANE
(
PLANE_IDlong,
PLANE_NAMEvarchar
其它字段省略...
)

默认情况下，Hibernate会将持久类以匹配的名称映射到表和字段中。例如，下例中，若不用注解，则会映射到如下一表中：
CREATETABLEMODELPLANE
(
IDlong,
NAMEvarchar

其它字段省略...
)

[3]
一对多注解:

1.

在一对多注解中,会用到:

"一"方：
@OneToMany-->mappedBy:"多"方的关联属性(被控方)
"多"方：
@ManyToOne-->@JoinColumn，"多"方定义的外键字段.

如数据表定义外键如下:

FOREIGNKEY(classid)REFERENCESclasses(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：是在查询数据时，也直接一起获取关联对象的数据。

packageoneToMany;
importjava.util.Set;
importjavax.persistence.*;
/*
注意导入时，是导入：importjavax.persistence.*;
非导入org.hibernate的相关类：importorg.hibernate.annotations.Entity;
*/
@Entity
@Table(name="classes")
publicclassClassesimplementsSerializable{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
privateintid;
privateStringname;

@OneToMany(cascade=CascadeType.ALL,mappedBy="classes")
privateSet<Student>students;
//getter,setter省略
}


packageoneToMany;
importjavax.persistence.*;
@Entity
@Table(name="student")
publicclassStudentimplementsSerializable{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
privateintsid;

privateStringsname;

//若有多个cascade，可以是：{CascadeType.PERSIST,CascadeType.MERGE}
@ManyToOne(cascade={CascadeType.ALL})
@JoinColumn(name="classid")//student类中对应外键的属性：classid
privateClassesclasses;
//getter,setter省略
}


publicclassTestOneToMany{
/*
CREATETABLEstudent(--要定义外键!!!!!!!
`sid`doubleNOTNULLauto_increment,
`classid`doubleNULL,
`sname`varchar(255)NOTNULL,
PRIMARYKEY(sid),
INDEXpar_ind(classid),
FOREIGNKEY(classid)REFERENCESclasses(id)ONDELETECASCADEONUPDATECASCADE
)ENGINE=InnoDB
*/
publicstaticvoidmain(String[]args)throwsSQLException
{
try
{
SessionFactorysf=newAnnotationConfiguration().configure().buildSessionFactory();
Sessionsession=sf.openSession();
Transactiontx=session.beginTransaction();

/*

因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以,

1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据;

2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student.

*/
Classesclasses=newClasses();
classes.setName("access");

Studentst1=newStudent();
st1.setSname("jason");
st1.setClasses(classes);
session.save(st1);

Studentst2=newStudent();
st2.setSname("hwj");
st2.setClasses(classes);
session.save(st2);
tx.commit();

/*

输出如下:

Hibernate:insertintoclasses(name)values(?)
Hibernate:insertintostudent(classid,sname)values(?,?)
Hibernate:insertintostudent(classid,sname)values(?,?)

*/

/*

因为一端维护关系另一端不维护关系的原因，我们必须注意避免在应用中用不维护关系的类(class)建立关系，因为这样建立的关系是不会在数据库中存储的。

如上的代码倒过来,则插入时,student的外键值为空.如下:

*/

//Studentst1=newStudent();
//st1.setSname("jason");
//session.save(st1);
//
//Studentst2=newStudent();
//st2.setSname("hwj");
//session.save(st2);
//
//Set<Student>students=newHashSet<Student>();
//students.add(st1);
//students.add(st2);
//
//Classesclasses=newClasses();
//classes.setName("access");
//classes.setStudents(students);
//session.save(classes);

/*

输出如下:
Hibernate:insertintostudent(classid,sname)values(?,?)
Hibernate:insertintostudent(classid,sname)values(?,?)

Hibernate:insertintoclasses(name)values(?)

*/
}
catch(HibernateExceptione)
{
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")
publicclassJcourse{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
privateintcid;
privateStringcname;

@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY,mappedBy="courses")
privateSet<Jstudent>students;
//setter,getter省略....
}


@Entity
@Table(name="jstudent")
publicclassJstudent{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
privateintsid;

privateStringsname;

@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")})
privateSet<Jcourse>courses;
//setter,getter省略....
}


publicclassTest{
publicstaticvoidmain(String[]args){
try
{
SessionFactorysf=newAnnotationConfiguration().configure().buildSessionFactory();
Sessionsession=sf.openSession();
Transactiontx=session.beginTransaction();

Jcoursecourse=newJcourse();
course.setCname("jason-english");
session.save(course);//先各自保存.

Jcoursecourse2=newJcourse();
course2.setCname("herry-english");
session.save(course2);

Set<Jcourse>courses=newHashSet<Jcourse>();
courses.add(course);
courses.add(course2);

Jstudentstudent=newJstudent();
student.setSname("jason");
student.setCourses(courses);

session.save(student);//要用非mapby定义的类(studet)来作为主者(会控制级联关系),一对多,多对一也一样道理.
//可以尝试反过来.
tx.commit();
}
catch(HibernateExceptione)
{
e.printStackTrace();
}
}
}