`

hibernate Annotations 实例

阅读更多
从 hbm.xml 到 Annotations
任何获得Matrix授权的网站,转载请保留以下作者信息和链接:
作者:icess(作者的blog:http://blog.matrix.org.cn/page/icess)
关键字:Hibernate Validator

下面让我们先看一个通常用 hbm.xml 映射文件的例子. 有3个类 .HibernateUtil.java 也就是 Hibernate文档中推荐的工具类,Person.java 一个持久化的类, Test.java 测试用的类.都在test.hibernate 包中. 每个类的代码如下:

01 package test.hibernate;
02
03 import org.hibernate.HibernateException;
04 import org.hibernate.Session;
05 import org.hibernate.SessionFactory;
06 import org.hibernate.cfg.Configuration;
07
08 public class HibernateUtil {
09   public static final SessionFactory sessionFactory;
10  
11   static {
12     try {
13       sessionFactory = new Configuration()
14               .configure()
15               .buildSessionFactory();
16     } catch (HibernateException e) {
17       // TODO Auto-generated catch block
18      
19       e.printStackTrace();
20       throw new ExceptionInInitializerError(e);
21     }
22   }
23  
24   public static final ThreadLocal<Session> session = new ThreadLocal<Session>();
25  
26   public static Session currentSession() throws HibernateException {
27     Session s = session.get();
28    
29     if(s == null) {
30       s = sessionFactory.openSession();
31       session.set(s);
32     }
33    
34     return s;
35   }
36  
37   public static void closeSession() throws HibernateException {
38     Session s = session.get();
39     if(s != null) {
40       s.close();
41     }
42     session.set(null);
43   }
44 }

 

01 package test.hibernate;
02
03 import java.util.LinkedList;
04 import java.util.List;
05
06 /**
07  *
08  */
09
10 @SuppressWarnings("serial")
11 public class Person implements java.io.Serializable {
12
13   // Fields
14
15   private Integer id;
16
17   private String name;
18
19   private String sex;
20
21   private Integer age;
22
23   private List list = new LinkedList();
24
25   // Collection accessors
26
27   public List getList() {
28     return list;
29   }
30
31   public void setList(List list) {
32     this.list = list;
33   }
34
35   /** default constructor */
36   public Person() {
37   }
38
39   /** constructor with id */
40   public Person(Integer id) {
41     this.id = id;
42   }
43
44   // Property accessors
45
46   public Integer getId() {
47     return this.id;
48   }
49
50   public void setId(Integer id) {
51     this.id = id;
52   }
53
54   public String getName() {
55     return this.name;
56   }
57
58   public void setName(String name) {
59     this.name = name;
60   }
61
62   public String getSex() {
63     return this.sex;
64   }
65
66   public void setSex(String sex) {
67     this.sex = sex;
68   }
69
70   public Integer getAge() {
71     return this.age;
72   }
73
74   public void setAge(Integer age) {
75     this.age = age;
76   }
77
78 }

 

01 /*
02  * Created on
03  * @author
04  */
05 package test.hibernate;
06
07 import java.sql.SQLException;
08
09 import org.hibernate.FlushMode;
10 import org.hibernate.HibernateException;
11 import org.hibernate.Session;
12 import org.hibernate.Transaction;
13
14 public class Test {
15  
16   public static void main(String [] args) {
17     Session s = HibernateUtil.currentSession();
18    
19     Transaction tx = s.beginTransaction();   
20    
21 //    Person p = (Person) s.load(Person.class, 1);
22 //    System.out.println(p.getName());
23     Person p = new Person();
24    
25     p.setAge(19);
26     p.setName("icerain");
27     p.setSex("male");
28     s.save(p);
29     s.flush();
30     /*
31     Person p2 = (Person) s.get(Person.class, new Integer(1));
32     System.out.println(p2.getName());
33     p2.setName("ice..");
34     s.saveOrUpdate(p2);
35     s.flush();
36     Person p3 = (Person) s.get(Person.class, new Integer(2));
37     System.out.println(p3.getName());
38     s.delete(p3);
39     */
40    
41     tx.commit(); 
42     try {
43       System.out.println(p.getName());
44     } catch (Exception e) {
45       // TODO Auto-generated catch block
46       e.printStackTrace();
47     }
48    
49     HibernateUtil.closeSession();
50   }
51 }

hibernate.cfg.xml 配置文件如下,利用mysql 数据库.

<?

<!





<

xml version="1.0" encoding="UTF-8"?>DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">hibernate-configuration>


<session-factory>


<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>


<property name="hibernate.connection.password">你的数据库密码</property>


<property name="hibernate.connection.url">jdbc:mysql://localhost/数据库名</property>


<property name="hibernate.connection.username">用户名</property>


<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>


<property name="show_sql">true</property>


<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>


<property name="hibernate.transaction.auto_close_session">false</property>
<property name="hibernate.hbm2ddl.auto">update</property>





<mapping resource="test/hibernate/annotation/Person.hbm.xml"/>


</

其中 配置了<property name="hibernate.hbm2ddl.auto">update</property>属性 自动导入数据库ddl.生产的ddl sql语句如下

create table person (id integer not null auto_increment, name varchar(255), sex varchar(255), age integer, person integer, primary key (id))

alter table person add index FKC4E39B5511C4A5C2 (person), add constraint FKC4E39B5511C4A5C2 foreign key (person) references person (id)

而Person.hbm.xml 文件如下:

<?

<!

xml version="1.0"?>DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"

<

>hibernate-mapping>
<class name="test.hibernate.Person" table="person">



<id name="id" type="integer">


<column name="id" />


<generator class="native"></generator>


</id>


<property name="name" type="string">


<column name="name" />


</property>


<property name="sex" type="string">


<column name="sex" />


</property>


<property name="age" type="integer">


<column name="age" />


</property>




<bag name="list" cascade="all">


<key column="person"></key>


<one-to-many class="test.hibernate.Person"/>


</bag>


</

</class>hibernate-mapping>
下面让我们看看利用 Hibernate Annotations 如何做,只要三个类 不再需要 hbm.xml配置文件:

还要把用到的两个jar文件 放入的类路径中. 具体如何做,请参考  Hibernate Annotations 中文文档

http://hb.6644.net

HibernateUtil.java 也就是 Hibernate文档中推荐的工具类,Person.java 一个持久化的类, Test.java 测试用的类.都在test.hibernate.annotation 包中. 每个类的代码如下:

01 package test.hibernate.annotation;
02
03 import org.hibernate.HibernateException;
04 import org.hibernate.Session;
05 import org.hibernate.SessionFactory;
06 import org.hibernate.cfg.AnnotationConfiguration;
07 import org.hibernate.cfg.Configuration;
08
09 public class HibernateUtil {
10   public static final SessionFactory sessionFactory;
11  
12   static {
13     try {
14       sessionFactory = new AnnotationConfiguration()   //注意: 建立 SessionFactory于前面的不同
15                 .addPackage("test.hibernate.annotation")
16                 .addAnnotatedClass(Person.class)
17                
18                 .configure()
19                 .buildSessionFactory();
20         //new Configuration().configure().buildSessionFactory();
21     } catch (HibernateException e) {
22       // TODO Auto-generated catch block
23      
24       e.printStackTrace();
25       throw new ExceptionInInitializerError(e);
26     }
27   }
28  
29   public static final ThreadLocal<Session> session = new ThreadLocal<Session>();
30  
31   public static Session currentSession() throws HibernateException {
32     Session s = session.get();
33    
34     if(s == null) {
35       s = sessionFactory.openSession();
36       session.set(s);
37     }
38    
39     return s;
40   }
41  
42   public static void closeSession() throws HibernateException {
43     Session s = session.get();
44     if(s != null) {
45       s.close();
46     }
47     session.set(null);
48   }
49 }

 

01 package test.hibernate.annotation;
02
03 import java.util.LinkedList;
04 import java.util.List;
05
06 import javax.persistence.AccessType;
07 import javax.persistence.Basic;
08 import javax.persistence.Entity;
09 import javax.persistence.GeneratorType;
10 import javax.persistence.Id;
11 import javax.persistence.OneToMany;
12 import javax.persistence.Table;
13 import javax.persistence.Transient;
14
15 /**
16  *
17  */
18
19 @SuppressWarnings("serial")
20 @Entity(access = AccessType.PROPERTY) //定义该类为实体类
21 @Table   //映射表
22 public class Person implements java.io.Serializable {
23
24   // Fields
25
26   private Integer id;
27
28   private String name;
29
30   private String sex;
31
32   private Integer age;
33
34   private List list = new LinkedList();
35
36   // Constructors
37   /** default constructor */
38   public Person() {
39   }
40
41   /** constructor with id */
42   public Person(Integer id) {
43     this.id = id;
44   }
45
46   // Property accessors
47   @Id
48   public Integer getId() {
49     return this.id;
50   }
51
52   public void setId(Integer id) {
53     this.id = id;
54   }
55
56   @Basic
57   public String getName() {
58     return this.name;
59   }
60
61   public void setName(String name) {
62     this.name = name;
63   }
64
65   @Basic
66   public String getSex() {
67     return this.sex;
68   }
69
70   public void setSex(String sex) {
71     this.sex = sex;
72   }
73
74   @Basic
75   public Integer getAge() {
76     return this.age;
77   }
78
79   public void setAge(Integer age) {
80     this.age = age;
81   }
82   @Transient  //由于本例不打算演示集合映射 所有声明该属性为 Transient 
83   public List getList() {
84     return list;
85   }
86
87   public void setList(List list) {
88     this.list = list;
89   }
90
91 }

注意该实体类中的属性都使用了默认值.

Test.java 代码同上

不需要了 hbm.xml 映射文件, 是不是简单了一些 .给人认为简化了一些不是主要目的.主要是可以了解一下 EJB3 的持久化机制 ,提高一下开发效率才是重要的.

好了 .本例就完了 . 感觉怎么样了 .欢迎你来批批.

PS:

生成的数据库表 和 程序执行后的 数据库情况如下

mysql> describe person;
+--------+--------------+------+-----+---------+----------------+
|  Field  | Type          | Null  | Key | Default |          Extra |
+--------+--------------+------+-----+---------+----------------+
| id        | int(11)       | NO   | PRI | NULL    | auto_increment |
| name  | varchar(255) | YES  |     | NULL    |                |
| sex    | varchar(255) | YES  |     | NULL    |                |
| age    | int(11)      | YES  |     | NULL    |                |
| person | int(11)      | YES  | MUL | NULL    |                |
+--------+--------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

mysql> select * from person;
+----+---------+------+------+--------+
| id | name    |  sex |  age | person |
+----+---------+------+------+--------+
|  1 | icerain | male |   19 |   NULL |
+----+---------+------+------+--------+
1 row in set (0.03 sec)
分享到:
评论

相关推荐

    hibernate annotations

    **标题:“Hibernate Annotations”** **概述** Hibernate是一个流行的Java对象关系映射(ORM)框架,它简化了在Java应用程序中处理数据库的过程。Hibernate Annotations是Hibernate框架的一个重要组成部分,它...

    hibernate 和hibernate_annotations(中文API).pdf帮助文档

    1. 实体(Entity):在Hibernate中,实体代表数据库表中的记录,是Java类的实例。通过@Entity注解标记一个Java类作为实体。 2. 表映射(Table Mapping):Hibernate将Java类映射到数据库表,通过配置文件或注解来...

    Hibernate Annotations Reference 中文参考手册HTML版

    **Hibernate Annotations 参考手册中文版** Hibernate 是一个流行的开源对象关系映射(ORM)框架,它允许开发者使用面向对象的编程模型来处理数据库操作。Hibernate Annotations 是 Hibernate 的一个重要组成部分,...

    hibernate-annotations 相关jar包

    4. 创建SessionFactory:根据配置文件创建SessionFactory实例,它是Hibernate的核心,用于生成Session。 5. 操作数据库:通过SessionFactory获取Session,进行CRUD操作。 **四、优势** 1. 简化配置:通过注解方式...

    hibernate-annotations-3.4.0.jar

    《Hibernate核心组件:hibernate-annotations-3.4.0.jar详解》 在Java世界里,ORM(Object-Relational Mapping)框架是连接数据库的重要工具,其中Hibernate作为一款广泛应用的ORM框架,大大简化了数据库操作。而`...

    Hibernate annotations大全

    《Hibernate Annotations 全解》 Hibernate 是一个广受欢迎的Java持久化框架,它极大地简化了数据库操作,使得开发者可以专注于业务逻辑而不是繁琐的SQL语句。在Hibernate 3.2及以后的版本中,引入了Annotations...

    hibernate-annotations-3.4.0.GA and hibernate-entitymanager-3.4.0.GA

    本篇将详细探讨`hibernate-annotations-3.4.0.GA`和`hibernate-entitymanager-3.4.0.GA`这两个版本中的核心知识点,尤其是它们在注释和枚举映射方面的应用。 首先,`hibernate-annotations`是Hibernate提供的一套...

    hibernate-annotations-3.2.1.GA

    《Hibernate Annotations 3.2.1.GA:深入解析企业级Java开发的持久化利器》 Hibernate,作为Java领域中最著名的对象关系映射(ORM)框架之一,极大地简化了数据库与Java对象之间的交互。其中,Hibernate ...

    hibernate-annotations-3.4.0.GA与slf4j-1.5.8.zip

    《深入理解Hibernate Annotations 3.4.0.GA与SLF4J 1.5.8》 在Java世界中,Hibernate作为一款优秀的对象关系映射(ORM)框架,极大地简化了数据库操作。而Hibernate Annotations是Hibernate框架的一个扩展,允许...

    hibernate annotations详解

    对于没有使用注解的属性,默认情况下,Hibernate 将尝试映射所有实例变量。 **2.2.3 映射标识符属性** 使用 `@Id` 注解来指定实体的唯一标识符。 **2.2.4 映射继承** **2.2.4.1 表每类策略** 每种子类都有自己...

    Hibernate core+annotations+entitymanager 指南小集合

    本指南小集合将详细探讨Hibernate的核心(Core)、注解(Annotations)以及实体管理器(EntityManager)这三个关键组件。 **一、Hibernate Core** Hibernate Core是Hibernate框架的基础部分,它提供了基本的ORM功能...

    hibernate xml annotations

    在"hibernate xml annotations 代码的例子"中,我们可能会看到以下两种实例: 1. **纯XML映射**:在这种情况下,所有的实体类映射信息都存在于单独的XML文件中。例如,一个名为`User.hbm.xml`的文件可能包含如下...

    hibernate-annotations-3.4.0.GA.rar

    《Hibernate注解3.4.0.GA版详解》 Hibernate作为Java领域中的一款主流对象关系映射(ORM)框架,极大地简化了数据库操作。在3.4.0.GA版本中,它引入了注解功能,使得Java实体类与数据库表之间的映射变得更加简洁、...

    基于注解的struts2+spring+hibernate 实例

    总的来说,这个SSH2+Annotations实例展示了如何在Java Web开发中有效地利用注解来提高开发效率和代码可读性。通过这种方式,开发者可以更专注于业务逻辑,而非繁琐的框架配置。在实际项目中,这样的实践对于快速开发...

    hibernate映射枚举类型

    import org.hibernate.annotations.Type; import org.hibernate.type.EnumType; public enum Status { ACTIVE("A"), INACTIVE("I"); private String code; // 构造器,getters和setters } @Entity public class...

    hibernate-annotations-3.1beta6

    - `@Embeddable` 和 `@Embedded`:用于嵌入式复杂类型,将一个类的实例作为另一个类的一个属性来处理。 - `@Cascade`:定义级联操作,如删除父对象时同时删除所有子对象。 - `@PrePersist`、`@PostPersist`、`@...

    hibernate-3.3.2.GA-jar包集合

    这个集合可能包括hibernate3.jar、hibernate-annotations.jar、hibernate-commons-annotations.jar、hibernate-jpa-2.0-api.jar等,以及数据库驱动相关的jar文件。通过这些jar文件,开发者可以在项目中集成和使用...

    Hibernate_

    【描述】"hibernate api 中文参考文档,Annotations注解文档" 提到的是Hibernate的API中文参考文档和关于Hibernate中Annotations的注解文档。Hibernate API文档提供了全面的API接口和类的介绍,帮助开发者理解如何...

    Hibernate注释大全收藏

    Hibernate 提供了与其自身特性相吻合的注解,如`@org.hibernate.annotations.Entity`、`@org.hibernate.annotations.GenericGenerator`等。 例如,使用`@NaturalId`注解标识自然ID,使用`@Formula`注解进行计算,...

    Hibernate实例

    10. **实体关系映射(JPA annotations)**: Hibernate支持多种关系映射,如一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)和多对多(@ManyToMany)。通过注解,我们可以定义这些关系并处理关联...

Global site tag (gtag.js) - Google Analytics