Hibernate入门系列（一）

hibernate是什么

• 一个框架
• 一个 Java 领域的持久化框架
• 一个 ORM 框架

对象的持久化

狭义的理解，“持久化”仅仅指把对象永久保存到数据库中
广义的理解，“持久化”包括和数据库相关的各种操作：

• 保存：把对象永久保存到数据库中。
• 更新：更新数据库中对象(记录)的状态。
• 删除：从数据库中删除一个对象。
• 查询：根据特定的查询条件，把符合查询条件的一个或多个对象从数据库加载到内存中。
• 加载：根据特定的OID，把一个对象从数据库加载到内存中。
  注:OID,为了在系统中能够找到所需对象，需要为每一个对象分配一个唯一的标识号。在关系数据库中称之为主键，而在对象术语中，则叫做对象标识(Object identifier-OID).

ORM

ORM(Object/Relation Mapping): 对象/关系映射

• ORM 主要解决对象-关系的映射
  
  
  
  
  
  
  

  面向对象的概念	面向关系的概念
  类	表
  对象	表的行（记录）
  属性	表的列（字段）

• ORM的思想：将关系数据库中表中的记录映射成为对象，以对象的形式展现，程序员可以把对数据库的操作转化为对对象的操作。
• ORM 采用元数据来描述对象-关系映射细节, 元数据通常采用 XML 格式, 并且存放在专门的对象-关系映射文件中.
  

流行的ORM框架

Hibernate:

• 非常优秀、成熟的 ORM 框架。
  完成对象的持久化操作
• Hibernate 允许开发者采用面向对象的方式来操作关系数据库。
• 消除那些针对特定数据库厂商的 SQL 代码

myBatis：

• 相比 Hibernate 灵活高，运行速度快
• 开发速度慢，不支持纯粹的面向对象操作，需熟悉sql语句，并且熟练使用sql语句优化功能

TopLink

OJB

Hibernate 与 Jdbc 代码对比

hibernate的helloworld

准备环境，导入相应的jar包

创建hibernate基本配置文件

<?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>
    <session-factory>
    <!-- 配置连接数据库的基本信息 -->
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">zhang1997</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>

    <!-- 配置hibernate的基本信息 -->
    <!--  hibernate所使用的数据库方言-->
    <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

    <!--  执行操作时是否在控制台打印SQL-->
    <property name="show_sql">true</property>
    <!--  是否对SQL进行格式化-->
    <property name="format_sql">true</property>
    <!--  指定自动生成数据表的策略-->
    <property name="hbm2ddl.auto">update</property>
    <!--  指定关联的 .hbm.xml文件位置-->
    <mapping resource="io/hibernate/helloworld/News.hbm.xml"/>
    </session-factory>
    </hibernate-configuration>

特别提醒：数据库方言org.hibernate.dialect.MySQLInnoDBDialect和org.hibernate.dialect.MySQLDialect 两个方言的区别，MySQLDialect是兼容性方言，MySQLInnoDBDialect支持事务的方言版。但是如果数据库版本是5.5以下，就可以直接用，如果是5.5版本及以上，需要改成MySQL5InnoDBDialect。
我的开始就是因为使用了MySQLInnoDBDialect方言而导致一直报找不到表的错误。

创建一个实体类

package io.hibernate.helloworld;

import java.sql.Date;

public class News {

    private Integer Id;
    private String title;
    private String author;
    private Date date;
    public Integer getId() {
        return Id;
    }
    public void setId(Integer id) {
        Id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }

    public News(String title, String author, Date date) {
        super();
        this.title = title;
        this.author = author;
        this.date = date;
    }

    public News() {
        //super();
    }
    @Override
    public String toString() {
        return "News [Id=" + Id + ", title=" + title + ", author=" + author + ", date=" + date + "]";
    }

​
}

生成对应的对象关系映射.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 2018-7-13 21:10:20 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="io.hibernate.helloworld.News" table="NEWS">
        <id name="Id" type="java.lang.Integer">
            <column name="ID" />
            <!-- 指定主键的生成方式  native：使用数据库本地方式 -->
            <generator class="native" />
        </id>
        <property name="title" type="java.lang.String">
            <column name="TITLE" />
        </property>
        <property name="author" type="java.lang.String">
            <column name="AUTHOR" />
        </property>
        <property name="date" type="java.sql.Date">
            <column name="DATE" />
        </property>
    </class>
</hibernate-mapping>

测试

    public class HibernateTest {

        @Test
        public void test(){

    //        1.创建一个SessionFactory对象
            SessionFactory sessionFactory=null;
    //        1.1创建configuration对象：对应hibernate的基本配置信息和对象关系映射信息
            Configuration configuration=new Configuration().configure();
            //4.0以前这样创建
    //        sessionFactory=configuration.buildSessionFactory();
    //        1.2创建一个serviceRegistry对象 hibernate 4.x新添加的对象
            //hibernate的任何配置和服务都需要在该对象中注册才能有效
            ServiceRegistry serviceRegistry=
                    new             ServiceRegistryBuilder    ().applySettings    (configuration.getProperties    ()).buildServiceRegistry();
    //        1.3
                    sessionFactory=configuration.buil    dSessionFactory(serviceRegistry);

    //        2.创建一个Session对象 
            Session session=sessionFactory.openSession();

    //        3.开启事务
            Transaction transaction=session.beginTransaction();

    //        4.执行保存操作
            News news=new News("Java","haha",new Date(new java.util.Date().getTime()));
            session.save(news);
    //        5.提交事务
            transaction.commit();

    //        6.关闭Session
            session.close();

    //        7.关闭SessionFactory对象
            sessionFactory.close();
        }
    }

查看数据库出现了一个新表News，并且新插入了一条记录

在进行测试前，数据库应存在名为hibernate的库

mysql> use hibernate;
Database changed

mysql> show tables;
+---------------------+
| Tables_in_hibernate |
+---------------------+
| news                |
+---------------------+
1 row in set (0.00 sec)

mysql> desc news;
+--------+--------------+------+-----+---------+----------------+
| Field  | Type         | Null | Key | Default | Extra          |
+--------+--------------+------+-----+---------+----------------+
| ID     | int(11)      | NO   | PRI | NULL    | auto_increment |
| TITLE  | varchar(255) | YES  |     | NULL    |                |
| AUTHOR | varchar(255) | YES  |     | NULL    |                |
| DATE   | date         | YES  |     | NULL    |                |
+--------+--------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

​
mysql> select * from news;
+—-+——-+——–+————+
| ID | TITLE | AUTHOR | DATE |
+—-+——-+——–+————+
| 1 | Java | haha | 2018-07-13 |
+—-+——-+——–+————+
1 row in set (0.00 sec)

mysql>

hibernate的helloworld配置简介

hibernate环境的准备

导入 Hibernate 必须的 jar 包:

      <dependency>
              <groupId>antlr</groupId>
              <artifactId>antlr</artifactId>
              <version>2.7.6</version>
      </dependency>

      <dependency>
              <groupId>dom4j</groupId>
              <artifactId>dom4j</artifactId>
              <version>1.6.1</version>
      </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate.common/hibernate-commons-annotations -->
    <dependency>
     <groupId>org.hibernate.common</groupId>
        <artifactId>hibernate-commons-annotations</artifactId>
        <version>4.0.2.Final</version>
    </dependency>

          <dependency>
              <groupId>org.hibernate</groupId>
              <artifactId>hibernate-core</artifactId>
              <version>4.2.4.Final</version>
          </dependency>

      <dependency>
          <groupId>org.hibernate.javax.pers istence</groupId>
              <artifactId>hibernate-jpa-2.0-api</artifactId>
              <version>1.0.1.Final</version>
          </dependency>

      <dependency>
              <groupId>javassist</groupId>
              <artifactId>javassist</artifactId>
              <version>3.11.0.GA</version>
      </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss.logging/jboss-logging -->
    <dependency>
        <groupId>org.jboss.logging</groupId>
        <artifactId>jboss-logging</artifactId>
        <version>3.1.0.GA</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss.spec.javax.transaction/jboss-transaction-api_1.1_spec -->
    <dependency>              <groupId>org.jboss.spec.javax.transaction</groupId>
        <artifactId>jboss-transaction-api_1.1_spec</artifactId>
        <version>1.0.1.Final</version>
    </dependency>

导入数据库驱动和Junit测试包：

    <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.37</version>
      </dependency>
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
      </dependency>

创建 Hibernate 配置文件

Hibernate 从其配置文件hibernate.cfg.xml中读取和数据库连接的有关信息, 这个文件应该位于应用的 classpath 下.

<?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>
    <session-factory>
    <!-- 配置连接数据库的基本信息 -->
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">zhang1997</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>

    <!-- 配置hibernate的基本信息 -->
    <!--  hibernate所使用的数据库方言-->
    <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

    <!--  执行操作时是否在控制台打印SQL-->
    <property name="show_sql">true</property>
    <!--  是否对SQL进行格式化-->
    <property name="format_sql">true</property>
    <!--  指定自动生成数据表的策略-->
    <property name="hbm2ddl.auto">update</property>
    <!--  指定关联的 .hbm.xml文件位置-->
    <mapping resource="io/hibernate/helloworld/News.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Hibernate 配置文件的两个配置项:

hbm2ddl.auto：该属性可帮助程序员实现正向工程, 即由 java 代码生成数据库脚本, 进而生成具体的表结构。取值 create | update | create-drop | validate

• create : 会根据 .hbm.xml 文件来生成数据表, 但是每次运行都会删除上一次的表 ,重新生成表, 哪怕二次没有任何改变
  
• create-drop : 会根据 .hbm.xml 文件生成表,但是SessionFactory一关闭, 表就自动删除
  
• update : 最常用的属性值，也会根据 .hbm.xml 文件生成表, 但若 .hbm.xml 文件和数据库中对应的数据表的表结构不同, Hiberante 将更新数据表结构，但不会删除已有的行和列
  
• validate : 会和数据库中的表进行比较, 若 .hbm.xml 文件中的列在数据表中不存在，则抛出异常
  

format_sql：是否将 SQL 转化为格式良好的 SQL . 取值 true | false

创建持久化 Java 类

Hibernate 不要求持久化类继承任何父类或实现接口，这可以保证代码不被污染。这就是Hibernate被称为低侵入式设计的原因
持久化类的几个要求：

• 提供一个无参的构造器:使Hibernate可以使用Constructor.newInstance() 来实例化持久化类
• 提供一个标识属性(identifier property): 通常映射为数据库表的主键字段. 如果没有该属性，一些功能将不起作用，如：Session.saveOrUpdate()
• 为类的持久化类字段声明访问方法(get/set): Hibernate对JavaBeans 风格的属性实行持久化。
• 使用非 final 类: 在运行时生成代理是 Hibernate 的一个重要的功能. 如果持久化类没有实现任何接口, Hibnernate 使用 CGLIB - 生成代理. 如果使用的是 final 类, 则无法生成 CGLIB 代理.
• 重写 eqauls 和 hashCode 方法: 如果需要把持久化类的实例放到 Set 中(当需要进行关联映射时), 则应该重写这两个方法

创建对象-关系映射文件

Hibernate 采用 XML 格式的文件来指定对象和关系数据之间的映射. 在运行时 Hibernate 将根据这个映射文件来生成各种 SQL 语句
映射文件的扩展名为 .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 2018-7-13 21:10:20 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="io.hibernate.helloworld.News" table="NEWS">
        <id name="Id" type="java.lang.Integer">
            <column name="ID" />
            <!-- 指定主键的生成方式  native：使用数据库本地方式 -->
            <generator class="native" />
        </id>
        <property name="title" type="java.lang.String">
            <column name="TITLE" />
        </property>
        <property name="author" type="java.lang.String">
            <column name="AUTHOR" />
        </property>
        <property name="date" type="java.sql.Date">
            <column name="DATE" />
        </property>
    </class>
</hibernate-mapping>

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

测试代码：

@Test
        public void test(){
            SessionFactory sessionFactory=null;
            Configuration configuration=new Configuration().configure();
            ServiceRegistry serviceRegistry=
                    new             ServiceRegistryBuilder    ().applySettings    (configuration.getProperties    ()).buildServiceRegistry();
                    sessionFactory=configuration.buil    dSessionFactory(serviceRegistry);
            Session session=sessionFactory.openSession();
            Transaction transaction=session.beginTransaction();
            News news=new News("Java","haha",new Date(new java.util.Date().getTime()));
            session.save(news);
            transaction.commit();
            session.close();
            sessionFactory.close();
        }

下面讲解一下测试里面用到的类和接口：

一、Configuration 类

Configuration 类负责管理 Hibernate 的配置信息。

包括如下内容：

• Hibernate 运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect,数据库连接池等（对应 hibernate.cfg.xml 文件）。
  
• 持久化类与数据表的映射关系（*.hbm.xml 文件）
  

创建 Configuration 的两种方式：

1.属性文件（hibernate.properties）

Configuration cfg = new Configuration();

2.Xml文件（hibernate.cfg.xml）(常用)

Configuration cfg = new Configuration().configure();

3.Configuration 的 configure 方法还支持带参数的访问：

File file = new File(“simpleit.xml”);

Configuration cfg = new Configuration().configure(file);

二、SessionFactory 接口

• 针对单个数据库映射关系经过编译后的内存镜像，是线程安全的。
• SessionFactory 对象一旦构造完毕，即被赋予特定的配置信息
• SessionFactory是生成Session的工厂
• 构造 SessionFactory 很消耗资源，一般情况下一个应用中只初始化一个 SessionFactory 对象。
• Hibernate4 新增了一个 ServiceRegistry 接口，所有基于 Hibernate 的配置或者服务都必须统一向这个 ServiceRegistry 注册后才能生效
• Hibernate4 中创建 SessionFactory 的步骤
  -
  Configuration configuration=new Configuration().configure();
  // sessionFactory=configuration.buildSessionFactory();
  // 创建一个serviceRegistry对象 hibernate 4.x新添加的对象

        //hibernate的任何配置和服务都需要在该对象中注册才能有效
        ServiceRegistry serviceRegistry=
                new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
        sessionFactory=configuration.buildSessionFactory(serviceRegistry);
  

三、Session 接口
Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心，所有持久化对象必须在 session 的管理下才可以进行持久化操作。此对象的生命周期很短。Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久层操作的数据都缓存在 session 对象处。相当于 JDBC 中的 Connection。

持久化类与 Session 关联起来后就具有了持久化的能力。

Session 类的方法：

• 取得持久化对象的方法： get() load()
• 持久化对象都得保存，更新和删除：save(),update(),saveOrUpdate(),delete()
• 开启事务: beginTransaction().
• 管理 Session 的方法：isOpen(),flush(), clear(), evict(), close()等

四、Transaction(事务)

一次事务代表一次原子操作，它具有数据库事务的概念。所有持久层都应该在事务管理下进行，即使是只读操作。

Transaction tx = session.beginTransaction();

常用方法:

• commit():提交相关联的session实例
• rollback():撤销事务操作
• wasCommitted():检查事务是否提交

注：使用 Hibernate 进行数据持久化操作，通常有如下步骤：

• 编写持久化类： POJO + 映射文件
• 获取 Configuration 对象
• 获取 SessionFactory 对象
• 获取 Session，打开事务
• 用面向对象的方式操作数据库
• 关闭事务，关闭 Session

小结

hibernate的helloworld很简单，很容易上手。以上就是hibernate的简单的操作和介绍，主要的问题可能会出在数据库方言和数据库的映射关系上。
附录：
方言大全

赏

你的鼓励，是使我前进的力量

微信