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