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用）

 package com.alphajuns.domain;

 public class Person {

     private String pid;
     private String pname;

     public String getPid() {
         return pid;
     }
     public void setPid(String pid) {
         this.pid = pid;
     }
     public String getPname() {
         return pname;
     }
     public void setPname(String pname) {
         this.pname = pname;
     }
     @Override
     public String toString() {
         return "Person [pid=" + pid + ", pname=" + pname + "]";
     }

 }

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

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping>
     <!-- 配置JavaBean类与表的映射 -->
     <class name="com.alphajuns.domain.Person" table="person">
         <!-- 配置id -->
         <id name="pid" column="pid">
             <!-- 主键生成策略 -->
             <generator class="uuid"></generator>
         </id>

         <!-- 其他配置项 -->
         <property name="pname" column="pname"></property>

     </class>
 </hibernate-mapping>

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

 package com.alphajuns.domain;

 public class User {

     private Integer id;
     private String name;
     private Integer age;

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }

     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
     }

 }

User类映射配置文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping>
     <!-- 配置类和表结构的映射 name:全包名 table:表名 -->
     <class name="com.alphajuns.domain.User" table="user">

         <!-- 配置id name:JavaBean中的属性 column:数据库表的主键 -->
         <id name="id" column="id">
             <!-- 主键生成策略 native代表本地的，会根据数据库自动选择 -->
             <generator class="native"></generator>
         </id>

         <!-- 配置其他属性 -->
         <property name="name" column="name"></property>
         <property name="age" column="age"></property>

     </class>

 </hibernate-mapping>

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

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

 <hibernate-configuration>
     <!-- 先配置SessionFactory，一个数据库对应一个SessionFactory -->
     <session-factory>
         <!-- 必须配置项：5个，包括数据库驱动、url、用户名、密码、数据库的方言 -->
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day02</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">root</property>
         <!-- 数据库的方言，指明为某种数据库所特有 -->
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

         <!-- 可选配置项 -->
         <!-- 在控制台显示sql语句 -->
         <property name="hibernate.show_sql">true</property>
         <!-- 格式化sql语句 -->
         <property name="hibernate.format_sql">true</property>
         <!-- 生成数据库的表结构 -->
         <property name="hibernate.hbm2ddl.auto">update</property>
         <!-- 开启绑定本地的session -->
         <property name="hibernate.current_session_context_class">thread</property>
         <!-- 设置数据库的隔离级别，就使用默认值就OK
         <property name="hibernate.connection.isolation">4</property>
         -->

         <!-- 引入映射配置文件 update：没有表时，创建表，表存在时，更新表 -->
         <mapping resource="com/alphajuns/domain/User.hbm.xml" />
         <mapping resource="com/alphajuns/domain/Person.hbm.xml" />

     </session-factory>
 </hibernate-configuration>

HibernateUtisl工具类

 package com.alphajuns.utils;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;

 /*
  * Hibernate工具类
  */
 public class HibernateUtils {

     private static final Configuration CONFIG;
     private static final SessionFactory FACTORY;

     // 静态代码块
     static {
         // 加载配置文件
         CONFIG = new Configuration().configure();
         // 创建SessionFactory对象
         FACTORY = CONFIG.buildSessionFactory();
     }

     // 由SessionFactory对象创建Session对象
     public static Session getSession() {
         return FACTORY.openSession();
     }

     // 从ThreadLocal中获得Session
     public static Session getCurrentSession() {
         return FACTORY.getCurrentSession();
     }

 }

测试代码

 package com.alphajuns.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.alphajuns.domain.Person;
 import com.alphajuns.domain.User;
 import com.alphajuns.utils.HibernateUtils;

 public class Demo1 {

     @Test
     public void run4() {
         // 创建Session对象
         Session session = HibernateUtils.getSession();
         // 开启事务
         Transaction tr = session.beginTransaction();
         User user = new User();
         user.setName("小华");
         user.setAge(24);
         // 此时user是瞬时态，没有oid，没有被session对象管理

         // 保存操作
         session.save(user);
         // 此时user是持久态，有oid，被session对象管理

         // 提交事务
         tr.commit();
         // 释放资源
         session.close();
         // session对象销毁，此时user是托管态，有oid，没有被session管理
     }

     @Test
     public void run3() {
         // 创建Session对象
         Session session = HibernateUtils.getSession();
         // 开启事务
         Transaction tr = session.beginTransaction();
         // 操作数据
         Person p = new Person();
         p.setPname("小明");
         // 保存操作
         session.save(p);
         // 提交事务
         tr.commit();
         // 关闭资源
         session.close();
     }

     @Test
     public void run2() {
         // 创建Session对象
         Session session = HibernateUtils.getSession();
         // 开启事务
         Transaction tr = session.beginTransaction();
         // 操作数据
         User user = new User();
         user.setName("韩梅梅");
         user.setAge(20);
         // 保存操作
         session.save(user);
         // 提交事务
         tr.commit();
         // 关闭资源
         session.close();
     }

     @Test
     public void run1() {
         // 1、加载配置文件
         Configuration config = new Configuration();
         config.configure();
         // 2、创建SessionFactory对象
         SessionFactory factory = config.buildSessionFactory();
         // 3、由SessionFactory对象创建Session对象
         Session session = factory.openSession();
         // 4、开启事务
         Transaction tr = session.beginTransaction();
         // 5、编写操作db代码
         User user = new User();
         user.setName("李雷");
         user.setAge(18);
         // 保存对象
         session.save(user);
         // 6、提交事务
         tr.commit();
         // 7、释放资源
         session.close();
         factory.close();
     }

 }