Hibernate Annotation笔记 Hibernate Annotation笔记
Hibernate Annotation笔记

2010-04-06 22:20:51 　标签： java 笔记 Hibernate Annotation 　　　[ 推送到技术圈 ]

(1)

简介：

在过去几年里，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 文件添加相应的依赖项即可，如下所示：

...

<groupId>org.hibernate</groupId>

<artifactId>hibernate</artifactId>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-annotations</artifactId>

</dependency>

<groupId>javax.persistence</groupId>

<artifactId>persistence-api</artifactId>

</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>

</session-factory>

</hibernate-configuration>

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

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

</property>

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>

<prop key="hibernate.hbm2ddl.auto">create</prop>

...

</props>

</property>

<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)[email protected]是类一级的注解,定义在@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) //注解于属性中

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.*;

@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 {

public static void main(String[] args) throws SQLException

{

try

{

SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();

Session session=sf.openSession();

Transaction tx=session.beginTransaction();

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(); // 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);

}

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笔记 Hibernate Annotation笔记

Hibernate Annotation笔记 Hibernate Annotation笔记
Hibernate Annotation笔记

继续阅读

报错：'mysql' 不是内部或外部命令，也不是可运行的程序或批处理文件。

Small tricks

Could not determine type for: String

Linxu常用命令技巧汇总

ERROR 1 (HY000): Can't create/write to file '/tmp/#sql_4188_1.MYI' (Errcode: 28)

艰难安装LDAP,SSL认证

《Linux命令行与Shell脚本编程大全第2版.布卢姆》pdf

MySQL的4种隔离级别？出现问题

XX系统实施过程问题总结

无组件上传图片到数据库中，最完整解决方案

【MySQL数据库】数据库索引事务1.索引2.事务

neo4j之cypher使用文档

NOSQL安全攻击

mybatis_入门程序Mybatis入门

登录plsql 报错 the account is locked --用户被锁

SequoiaDB巨杉数据库C++驱动概述