Hibernate学习笔记01

建立 Hibernate 工程步骤

首先得导入 Hibernate 相关 jar 包，也可以使用 Maven 创建工程，再配置 POM.xml

1. 创建 Hibernate 配置文档 hibernate.cfg.xml

<?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="connection.username">root</property>
        <!--对应的用户密码 -->
        <property name="connection.password">root</property>
        <!--数据库驱动  -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!--数据库连接字段 -->
        <property name="connection.url">jdbc:mysql:///hibernate?useUnicode=true&amp;characterEncoding=UTF-8</property>
        <!--数据库方言-->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!--设置对数据库的操作模式-->
        <!--update只更新相应数据 -->
        <!--create无论表是否存在执行操作都要删除原表创建新表 -->
        <property name="hbm2ddl.auto">update</property>
        <!--在控制台显示sql语句  -->
        <property name="show_sql">true</property>
        <!--设置格式输出sql语句  -->
        <property name="format_sql">true</property>
        <!--设置映射的文件-->
        <mapping resource="Students.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

2. 创建持久化类

规范：遵循JavaBeans规范，必须满足
1. 公有类
2. 有无参构造方法
3. 私有的属性变量
4. 每个属性对应的getter/setter方法

一个持久化类对应数据库中的一张表，一个属性对应表中的一个字段，一个该类的实例对应表中的一条记录

3. 创建对象关系映射文件

Students类对应的文件：Students.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">
<!-- Generated 2017-6-27 19:21:06 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.lyon.Hibernate_003">
    <class name="Students" table="STUDENTS">
        <id name="sid" type="int">
            <column name="SID" />
            <generator class="native" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>
        <property name="gender" type="java.lang.String">
            <column name="GENDER" />
        </property>
        <property name="birthday" type="java.util.Date">
            <column name="BIRTHDAY" />
        </property>
        <!--
        <property name="address" type="java.lang.String">
            <column name="ADDRESS" />
        </property>
        -->
        <property name="picture" type="java.sql.Blob">
            <column name="PICTURE" />
        </property>

        <!-- 组件属性 -->
        <component name="address" class="Address">
            <property name="postcode" column="POSTCODE"></property>
            <property name="phone" column="PHONE"></property>
            <property name="address" column="ADDRESS"></property>
        </component>
    </class>
</hibernate-mapping>

知识点：

1. 根标签<hibernate-mapping> 中的package属性设置对应的持久化类所在的包

   <id></id> 标签指定该表对应的主键， 其中 <generator/>子标签class指定主键的方式：如 assigned为Java代码指定主键值；native指定主键值自增

2. 如果持久化类中某一属性的类型为 自定义类的引用类型（如上述代码中的 address 属性 ，它包含自身的属性信息，这样的属性在Hibernate中称为组件属性），它的内部属性在数据库中为多个不同的字段

   注意点：需将该属性信息用<component></component>标签包围，name属性为持久化类中的属性名，class属性指定该引用类型的类名（由于在根标签属性中指定了包名，所以这里只需要给出类名）

3. <property></property 标签中type属性的设置（即数据库对应字段的类型）

   有三种设置 分别为：Hibernate自带的类型，Java自带的类型，SQL语言自带类型（一般用前两种）
   以下为属性对照表

   

4. 通过 Hibernate API 编写访问数据库的的代码

步骤:

1. 创建Configuration（配置）对象
2. 创建ServiceRegistry（服务注册)对象
3. 创建SessionFactory（会话工厂）对象
4. 创建Session（会话）对象
5. 开启Transaction（事务）对象

代码示例：

//1
Configuration config = new Configuration().configure();
//2
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).builderServiceRegistry();
//3
SessionFactory sessionFactory = config.buildSessionFactory();
//4
Session session= sessionFactory.openSession();
//5
Transaction transaction = session.beginTransaction();

对应访问完成后需要的操作：

//提交事务
transaction.commit();
//关闭会话
session.close();
//关闭会话工厂
sessionFactory.close()

知识点：

1. Session 相当于 JDBC 中的 Connection 对象，一个 Session 对象在访问数据库时对应一个 Connection 对象。一个 Connection 对象可以被多个 Session 对象复用。

2. 创建 Session 对象有两种方法：

   • openSession(); 开启一个新的会话，对应 Connection 连接池中一个新的连接对象，必须手动关闭，若过多使用而未关闭会导致连接池溢出

   • getCurrentSession(); 使用当前会话，在事务提交或回滚时会自动释放连接，达到多个Session复用连接的目的。使用该该方法需在hibernate.cfg.xml中进行配置

     • 使用本地事务（JDBC事务）：
       <property name="hibernate.current_session_context_class">thread</property>

     • 使用全局事务（JTA事务）：
       <property name="hibernate.current_session_context_class">jta</property>

   • 调用 Session 对象的 doWork()方法 可以对其对应的 Connection对象 进行相应的设置，如自动提交，获取 Connection 的信息等。

   • Transaction对象：hibernate对数据的操作都是封装在事务里的，并且默认是非自动提交，在使用session对象保存对象时，如果不开启事务并提交事务，对象不会真正保存在数据库中

Hibernate单表操作

代码示例：

package com.lyon.Hibernate_004;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
//测试类
public class StudentsTest {

    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Before
    public void init(){
        //创建配置对象
        Configuration config = new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory(serviceRegistry);
        //会话对象
        session = sessionFactory.openSession();
        //开启事务
        transaction = session.beginTransaction();
    }

    @After
    public void destory(){
        transaction.commit();//提交事务
        session.close();//关闭会话
        sessionFactory.close();//关闭会话工厂
    }

    @Test
    public void testSaveStudents(){
        //由于配置文档中设置为主键自增，无需设置sid属性
        Students stu = new Students();
        stu.setSname("张三");
        stu.setGender("男");
        stu.setBirthday(new Date());
        Address ad = new Address("324378","123466551","杭州市");
        stu.setAddress(ad);
        //session的save方法保存数据
        session.save(stu);
    }

    @Test
    public void testGetStudents(){
        //session的get方法查询数据
        Students s = (Students) session.get(Students.class, 1);
        System.out.println(s);

    }

    @Test
    public void testLoadStudents(){
        //session 的 load 方法查询数据
        Students s = (Students) session.load(Students.class, 1);
        System.out.println(s);
    }

    @Test
    public void testUpdateStudents(){
        //先获取到需要修改的数据
        Students s = (Students) session.get(Students.class, 1);
        //修改相应字段
        s.setGender("女");
        //session的update方法修改数据
        session.update(s);
    }

    @Test
    public void testDeleteStudents(){
        Students s = (Students) session.get(Students.class, 1);
        //session的delete方法删除数据
        session.delete(s);
    }
}

上述代码使用Junit单元测试工具测试代码，其中：
- @ Before 注解下的方法为执行测试方法之前执行的方法（这里使用 Hibernate API 进行访问前的初始化工作）
- @ After 注解下的方法为执行测试方法之后执行的方法 （这里对事务提交及关闭相应的连接）
- @ Test 注解下的方法为测试方法（这里测试了使用session进行简单的增删改查）

知识点：
load 方法 和 get 方法的区别：load 方法在需要用到查询数据时才开始建立连接并查询，而 get 方法则在方法执行时就建立连接并查询。