JavaWeb 之 Hibernate 配置及接口

Posted on Edited on In

Hibernate 配置文件与接口方法。

映射配置文件

映射文件，即类与表的映射配置文件，假设是 Customer.hbm.xml

<class>标签

<class> 标签 用来将类与数据库表建立映射关系
name 类的全路径
table 表名.(类名与表名一致,那么table属性也可以省略)
catalog 数据库的名称，基本上都会省略不写

<id>标签

<id> 标签 用来将类中的属性与表中的主键建立映射，id 标签就是用来配置主键的
name 类中属性名
column 表中的字段名。（如果类中的属性名与表中的字段名一致,那么 column 可以省略。）
length 字段的程度，如果数据库已经创建好了，那么 length 可以不写。如果没有创建好，生成表结构时，length 最好指定。

<property>标签

<property> 标签 用来将类中的普通属性与表中的字段建立映射
name 类中属性名
column 表中的字段名（如果类中的属性名与表中的字段名一致,那么column可以省略。）
length 数据长度
type 数据类型（一般都不需要编写，如果写需要按着规则来编写）
Hibernate 的数据类型 type=”string”
Java 的数据类型 type=”java.lang.String”
数据库字段的数据类型 <column name=”name” sql-type=”varchar”/>

注： 配置不需要那么麻烦，一般默认的就可以了。

核心配置文件

核心配置文件的两种方式

属性文件

第一种方式是属性文件的形式，即 properties 的配置文件

hibernate.properties 里面的编写规则如下：（key=value）

1
hibernate.connection.driver_class=com.mysql.jdbc.Driver

缺点：不能加载映射的配置文件，需要手动编写代码去加载

xml 文件（★）

第二种方式是 XML 文件的形式，开发基本都会选择这种方式（★）

hibernate.cfg.xml

1
<property name="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</property>

优点

  • 格式比较清晰
  • 编写有提示
  • 可以在该配置文件中加载映射的配置文件（最主要的）

hibernate.cfg.xml 的配置文件详解

必须有的配置

  • 数据库连接信息:
1
2
3
4
hibernate.connection.driver_class       -- 连接数据库驱动程序
hibernate.connection.url        -- 连接数据库 URL
hibernate.connection.username       -- 数据库用户名
hibernate.connection.password       -- 数据库密码
  • 方言:
1
hibernate.dialect       -- 操作数据库方言

可选的配置

1
2
3
4
5
6
7
8
* hibernate.show_sql        -- 显示 SQL，控制台输出 SQL 语句
* hibernate.format_sql      -- 格式化控制台输出的 SQL 语句

* hibernate.hbm2ddl.auto        -- 通过映射转成DDL语句
    * create            -- 每次都会创建一个新的表。 ---测试的时候使用
    * create-drop       -- 每次都会创建一个新的表，当执行结束之后，将创建的这个表删除。   ---测试的时候使用
    * update★            -- 如果有表，使用原来的表。没有表，创建一个新的表。同时更新表结构。
    * validate          -- 如果有表，使用原来的表。同时校验映射文件与表中字段是否一致如果不一致就会报错。

加载映射

  • 如果是 XML 方式：
1
<mapping resource="com/renkaigis/domain/Customer.hbm.xml"/>

单表最基本的 Hibernate 配置文件

hibernate.cfg.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?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 个，4 大参数和数据库的方言-->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate_01</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <!--数据库的方言-->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!--可选配置-->
        <!--控制台显示 SQL 语句-->
        <property name="show_sql">true</property>
        <!--格式化显示的 SQL 语句-->
        <property name="format_sql">true</property>
        <!--生成数据库表结构-->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!--映射配置文件，需要引入映射的配置文件-->
        <mapping resource="com/renkaigis/domain/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Hibernate 常用的接口和类

Configuration 类和作用

Configuration类

  • Configuration 对象用于配置并且启动 Hibernate。

  • Hibernate 应用通过该对象来获得 对象-关系映射 文件中的元数据，以及动态配置 Hibernate 的属性，然后创建 SessionFactory 对象。

简而言之：加载 Hibernate 的配置文件，可以获取 SessionFactory 对象。

Configuration类的其他应用（了解）

加载配置文件的种类，Hibernate 支持 xml 和 properties 类型的配置文件，在开发中基本都使用 XML 配置文件的方式。

  • 如果采用的是 properties 的配置文件，那么通过下面语句可以加载配置文件
1
Configuration configuration = new Configuration();

但是需要自己手动加载映射文件

例如：

1
config.addResource("cn/itcast/domain/Student.hbm.xml");
  • 如果采用的 XML 的配置文件，通过下面语句可直接加载配置文件和映射文件。
1
Configuration configuration = new Configuration().configure();

SessionFactory 类 ★

SessionFactory 是工厂类，负责初始化 Hibernate，充当数据存储源，并负责创建 Session 对象。

SessionFactory 类的特点

  • 由Configuration 通过加载配置文件创建该对象。

  • SessionFactory 对象中保存了当前的数据库配置信息和所有映射关系以及预定义的 SQL 语句。同时，SessionFactory 还负责维护 Hibernate 的二级缓存。

    • 预定义 SQL 语句
      • 使用 Configuration 类创建了 SessionFactory 对象时，已经在 SessionFacotry 对象中缓存了一些 SQL 语句；
      • 常见的SQL语句是增删改查（通过主键来查询）；
      • 这样做的目的是效率更高。

  • 一个 SessionFactory 实例对应一个数据库，应用从该对象中获得 Session 实例。

  • SessionFactory 是 线程安全 的，意味着它的一个实例可以被应用的多个线程共享。

  • SessionFactory 是 重量级 的，意味着不能随意创建或销毁它的实例。如果只访问一个数据库，只需要创建一个 SessionFactory 实例，且在应用初始化的时候完成。

  • SessionFactory 需要一个较大的缓存，用来存放预定义的SQL语句及实体的映射信息。另外可以配置一个缓存插件，这个插件被称之为 Hibernate 的二级缓存，被多线程所共享。

总之，一般应用使用一个 SessionFactory，最好是应用启动时就完成初始化。

编写 HibernateUtils 的工具类

简化获取 Session 的方法，在服务器启动时就完成了初始化，加载了配置文件和映射文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class HibernateUtils {
    private static final Configuration cfg;
    private static final SessionFactory factory;
    static{
        // 给常量赋值 
        // 加载配置文件
        cfg = new Configuration().configure();
        // 生成factory对象
        factory = cfg.buildSessionFactory();
    }
    // 获取Session对象
    public static Session openSession(){
        return factory.openSession();
    }
}

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 测试工具类
 */
@Test
public void testSave2() {
    // 通过工具类获取 session 对象
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();
    Customer c=new Customer();
    c.setCust_name("小明");
    session.save(c);

    tr.commit();
    session.close();
}

Session 接口

概述

  • Session 是在 Hibernate 中使用最频繁的接口。也被称之为 持久化管理器。它提供了和持久化有关的操作，比如添加、修改、删除、加载和查询实体对象；
  • Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心；
  • Session 是线程不安全的；
  • 所有持久化对象必须在 session 的管理下才可以进行持久化操作；
  • Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久化操作的数据都缓存在 session 对象处；
  • 持久化类与 Session 关联起来后就具有了持久化的能力。

特点

  • 不是线程安全 的。应避免多个线程使用同一个 Session 实例；
  • Session 是 轻量级 的，它的创建和销毁不会消耗太多的资源。应为每次客户请求分配独立的 Session 实例；
  • Session 有一个缓存，被称之为 Hibernate 的一级缓存。每个 Session 实例都有自己的缓存。

常用的方法

  • save(obj)
  • delete(obj)
  • get(Class,id)
  • update(obj)
  • saveOrUpdate(obj) – 保存或者修改（如果没有数据，保存数据。如果有，修改数据）
  • createQuery() – HQL语句的查询的方式

get(Class,id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 测试 get() 方法，获取查询，通过主键来查询一条记录
 */
@Test
public void testGet() {
    // 通过工具类获取 session 对象
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();

    // 两个参数：JavaBean 的 class 对象，主键的值
    Customer c = session.get(Customer.class, 94L);
    System.out.println(c);

    tr.commit();
    session.close();
}

输出结果：

1
Customer{cust_id=94, cust_name='测试', cust_user_id=null, cust_create_id=null, cust_source='null', cust_industry='null', cust_level='2', cust_linkman='null', cust_phone='110', cust_mobile='null'}

delete(obj)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 测试 delete() 方法
 * 注意：删除或者修改，都要先查询在删除或者修改
 */
@Test
public void testDel() {
    // 通过工具类获取 session 对象
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();

    Customer c = session.get(Customer.class, 94L);
    // 删除客户
    session.delete(c);

    tr.commit();
    session.close();
}

输出 SQL 语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Hibernate: 
    select
        customer0_.cust_id as cust_id1_0_0_,
        customer0_.cust_name as cust_nam2_0_0_,
        customer0_.cust_user_id as cust_use3_0_0_,
        customer0_.cust_create_id as cust_cre4_0_0_,
        customer0_.cust_source as cust_sou5_0_0_,
        customer0_.cust_industry as cust_ind6_0_0_,
        customer0_.cust_level as cust_lev7_0_0_,
        customer0_.cust_linkman as cust_lin8_0_0_,
        customer0_.cust_phone as cust_pho9_0_0_,
        customer0_.cust_mobile as cust_mo10_0_0_ 
    from
        cst_customer customer0_ 
    where
        customer0_.cust_id=?
Hibernate: 
    delete 
    from
        cst_customer 
    where
        cust_id=?

update(obj)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 测试 update() 方法
 */
@Test
public void testUpdate() {
    // 通过工具类获取 session 对象
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();
    // 查询客户
    Customer c = session.get(Customer.class, 1L);
    // 设置客户信息
    c.setCust_level("中级");
    c.setCust_name("小徐");
    // 修改
    session.update(c);

    tr.commit();
    session.close();
}

saveOrUpdate(obj)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 测试 SaveOrUpdate() 方法
 */
@Test
public void testSaveOrUpdate() {
    // 通过工具类获取 session 对象
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();
    // 查询客户
    Customer c = session.get(Customer.class, 1L);
    // 设置客户信息
    // c.setCust_id(7L); // 千万不能修改 id 值
    c.setCust_name("小天");
    // 修改
    session.saveOrUpdate(c);

    tr.commit();
    session.close();
}

createQuery()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 测试 creatQuery() 方法
 */
@Test
public void testSel() {
    Session session = HibernateUtils.getSession();
    Transaction tr = session.beginTransaction();
    // 创建查询的接口
    Query query = session.createQuery("from Customer");
    // 查询所有的数据 select * from 表
    List<Customer> list = query.list();
    for (Customer customer :
            list) {
        System.out.println(customer);
    }

    tr.commit();
    session.close();
}

Transaction 接口

Transaction 是事务的接口。

常用的方法

  • commit() – 提交事务
  • rollback() – 回滚事务

特点

  • Hibernate 框架默认情况下事务不自动提交.需要手动提交事务
  • 如果没有开启事务，那么每个 Session 的操作，都相当于一个独立的事务

测试事务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 测试事务
 */
@Test
public void testSave3() {
    Session session = null;
    Transaction tr = null;
    try {
        session = HibernateUtils.getSession();
        // 开启事务
        tr = session.beginTransaction();
        Customer c = new Customer();
        // int a=10/0;
        c.setCust_name("嘿嘿");
        session.save(c);
        tr.commit();
    } catch (Exception e) {
        // 回滚事务
        tr.rollback();
        e.printStackTrace();
    } finally {
        // 释放资源
        session.close();
    }
}