Hibernate中持久化类与持久化对象

1、JavaBean类

JavaBean类是实体类，必须一下属性，private修饰的成员属性，public修饰的getter与setter访问方法，public修饰的空参构造器，实现Serializable接口。

2、持久化类的概念

持久化类就是建立了映射关系的JavaBean类，持久化类 = JavaBean类 + JavaBean类对应的映射配置文件。

编写持久化类时，有几点需要注意：

private修饰的成员属性尽量使用基本数据类型对应的包装类，包装类型更合理，例如年龄不存在时，基本类型int默认值为0，而包装类型Integer默认值为null
public修饰的空参构造器，底层需要进行反射
提供一个标识属性，映射表的主键字段
创建表时应尽量使用代理主键而不是自然主键

3、主键生成策略

increment：Hibernate提供的一种自动增长机制，适用与short、int、long类型作为主键的字段，使用时需要先从数据库查询出主键最大值，再将最大值加1进行插入。
identity：适用于short、int、long类型的主键，必须使用在有自动增长机制的数据库中，采用的是数据库底层的自动增长机制。如MySQL数据库的auto_increment。
sequence：适用于short、int、long类型的主键，底层使用的是序列的增长方式。Oracle使用序列实现自动增长。
uuid：使用与char、varchar类型的主键，使用随机的字符串最为主键
native：本地策略，根据底层数据库类型的不同，自动选择适用于该数据库的主键生成策略（short、int、long）。如果底层是MySQL，相当于identity，如果是Oracle，相当于sequence。
assigned：不适用hibernate维护主键，必须手动设置主键。

4、持久化对象的状态

Hibernate为了管理持久化类，将持久化对象分为三个状态。

瞬时态：Transient Object，没有持久化标识OID，没有被Session对象管理
持久态：Persistent Object，有持久化标识OID，被Session对象管理
托管态：Detached Object，有持久化标识OID，没有被Session对象管理

5、持久化对象之间的转换

以实体类User为例，User user = new User();

瞬时态-->持久态：save()/saveOrUpdate()
瞬时态-->托管态：user.setId(1);
持久态-->瞬时态：delete()
持久态-->托管态：调用evict()/close()/clear()
托管态-->持久态：upodate()/saveOrUpdate()/lock()
托管态-->瞬时态:user.setId(null)

6、hibernate开发环境搭建、编写映射配置文件、编写核心配置文件、编写代码实现数据库交互演示

Person类（JavaBean类，主键String类型演示主键生成策略uuid用）

 1 package com.alphajuns.domain;
 2 
 3 public class Person {
 4     
 5     private String pid;
 6     private String pname;
 7     
 8     public String getPid() {
 9         return pid;
10     }
11     public void setPid(String pid) {
12         this.pid = pid;
13     }
14     public String getPname() {
15         return pname;
16     }
17     public void setPname(String pname) {
18         this.pname = pname;
19     }
20     @Override
21     public String toString() {
22         return "Person [pid=" + pid + ", pname=" + pname + "]";
23     }
24     
25 }

Person类映射配置文件Person.hbm.xml（配置文件位于实体包下，命名为实体类类名.hbm.xml）

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5     
 6 <hibernate-mapping>
 7     <!-- 配置JavaBean类与表的映射 -->
 8     <class name="com.alphajuns.domain.Person" table="person">
 9         <!-- 配置id -->
10         <id name="pid" column="pid">
11             <!-- 主键生成策略 -->
12             <generator class="uuid"></generator>
13         </id>
14         
15         <!-- 其他配置项 -->
16         <property name="pname" column="pname"></property>
17         
18     </class>
19 </hibernate-mapping>

User类（JavaBean类，演示开发环境搭建，代码编写步骤用，测试用）

 1 package com.alphajuns.domain;
 2 
 3 public class User {
 4     
 5     private Integer id;
 6     private String name;
 7     private Integer age;
 8     
 9     public Integer getId() {
10         return id;
11     }
12     public void setId(Integer id) {
13         this.id = id;
14     }
15     public String getName() {
16         return name;
17     }
18     public void setName(String name) {
19         this.name = name;
20     }
21     public Integer getAge() {
22         return age;
23     }
24     public void setAge(Integer age) {
25         this.age = age;
26     }
27     
28     @Override
29     public String toString() {
30         return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
31     }
32     
33 }

User类映射配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5     
 6 <hibernate-mapping>
 7     <!-- 配置类和表结构的映射 name:全包名 table:表名 -->
 8     <class name="com.alphajuns.domain.User" table="user">
 9     
10         <!-- 配置id name:JavaBean中的属性 column:数据库表的主键 -->
11         <id name="id" column="id">
12             <!-- 主键生成策略 native代表本地的，会根据数据库自动选择 -->
13             <generator class="native"></generator>
14         </id>
15         
16         <!-- 配置其他属性 -->
17         <property name="name" column="name"></property>
18         <property name="age" column="age"></property>
19         
20     </class>
21     
22 </hibernate-mapping>

核心配置文件（位于src下）

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 5     
 6 <hibernate-configuration>
 7     <!-- 先配置SessionFactory，一个数据库对应一个SessionFactory -->
 8     <session-factory>
 9         <!-- 必须配置项：5个，包括数据库驱动、url、用户名、密码、数据库的方言 -->
10         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
11         <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day02</property>
12         <property name="hibernate.connection.username">root</property>
13         <property name="hibernate.connection.password">root</property>
14         <!-- 数据库的方言，指明为某种数据库所特有 -->
15         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
16         
17         <!-- 可选配置项 -->
18         <!-- 在控制台显示sql语句 -->
19         <property name="hibernate.show_sql">true</property>
20         <!-- 格式化sql语句 -->
21         <property name="hibernate.format_sql">true</property>
22         <!-- 生成数据库的表结构 -->
23         <property name="hibernate.hbm2ddl.auto">update</property>
24         <!-- 开启绑定本地的session -->
25         <property name="hibernate.current_session_context_class">thread</property>
26         <!-- 设置数据库的隔离级别，就使用默认值就OK 
27         <property name="hibernate.connection.isolation">4</property>
28         -->
29         
30         <!-- 引入映射配置文件 update：没有表时，创建表，表存在时，更新表 -->
31         <mapping resource="com/alphajuns/domain/User.hbm.xml" />
32         <mapping resource="com/alphajuns/domain/Person.hbm.xml" />
33         
34     </session-factory>
35 </hibernate-configuration>

HibernateUtisl工具类

 1 package com.alphajuns.utils;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.cfg.Configuration;
 6 
 7 /*
 8  * Hibernate工具类
 9  */
10 public class HibernateUtils {
11     
12     private static final Configuration CONFIG;
13     private static final SessionFactory FACTORY;
14     
15     // 静态代码块
16     static {
17         // 加载配置文件
18         CONFIG = new Configuration().configure();
19         // 创建SessionFactory对象
20         FACTORY = CONFIG.buildSessionFactory();
21     }
22     
23     // 由SessionFactory对象创建Session对象
24     public static Session getSession() {
25         return FACTORY.openSession();
26     }
27     
28     // 从ThreadLocal中获得Session
29     public static Session getCurrentSession() {
30         return FACTORY.getCurrentSession();
31     }
32     
33 }

测试代码

 1 package com.alphajuns.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8 
 9 import com.alphajuns.domain.Person;
10 import com.alphajuns.domain.User;
11 import com.alphajuns.utils.HibernateUtils;
12 
13 public class Demo1 {
14     
15     @Test
16     public void run4() {
17         // 创建Session对象
18         Session session = HibernateUtils.getSession();
19         // 开启事务
20         Transaction tr = session.beginTransaction();
21         User user = new User();
22         user.setName("小华");
23         user.setAge(24);
24         // 此时user是瞬时态，没有oid，没有被session对象管理
25         
26         // 保存操作
27         session.save(user);
28         // 此时user是持久态，有oid，被session对象管理
29         
30         // 提交事务
31         tr.commit();
32         // 释放资源
33         session.close();
34         // session对象销毁，此时user是托管态，有oid，没有被session管理
35     }
36     
37     @Test
38     public void run3() {
39         // 创建Session对象
40         Session session = HibernateUtils.getSession();
41         // 开启事务
42         Transaction tr = session.beginTransaction();
43         // 操作数据
44         Person p = new Person();
45         p.setPname("小明");
46         // 保存操作
47         session.save(p);
48         // 提交事务
49         tr.commit();
50         // 关闭资源
51         session.close();
52     }
53     
54     @Test
55     public void run2() {
56         // 创建Session对象
57         Session session = HibernateUtils.getSession();
58         // 开启事务
59         Transaction tr = session.beginTransaction();
60         // 操作数据
61         User user = new User();
62         user.setName("韩梅梅");
63         user.setAge(20);
64         // 保存操作
65         session.save(user);
66         // 提交事务
67         tr.commit();
68         // 关闭资源
69         session.close();
70     }
71     
72     @Test
73     public void run1() {
74         // 1、加载配置文件
75         Configuration config = new Configuration();
76         config.configure();
77         // 2、创建SessionFactory对象
78         SessionFactory factory = config.buildSessionFactory();
79         // 3、由SessionFactory对象创建Session对象
80         Session session = factory.openSession();
81         // 4、开启事务
82         Transaction tr = session.beginTransaction();
83         // 5、编写操作db代码
84         User user = new User();
85         user.setName("李雷");
86         user.setAge(18);
87         // 保存对象
88         session.save(user);
89         // 6、提交事务
90         tr.commit();
91         // 7、释放资源
92         session.close();
93         factory.close();
94     }
95     
96 }