hibernate学习笔记之一（上）-阿里云开发者社区

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JavaEE架构中取代CMP，完成数据持久化的重任。----百度百科

了解完Hibernate是什么后，我们正式开始Hibernate。

Hibernate ORM

先来说说什么是jdbc

JDBC 代表 Java Database Connectivity ，它是提供了一组 Java API 来访问关系数据库的 Java 程序。这些 Java APIs 可以使 Java 应用程序执行 SQL 语句，能够与任何符合 SQL 规范的数据库进行交互。

JDBC 提供了一个灵活的框架来编写操作数据库的独立的应用程序，该程序能够运行在不同的平台上且不需修改，能够与不同的 DBMS 进行交互。

jdbc的优缺点

JDBC 的优点	JDBC 的缺点
干净整洁的 SQL 处理	大项目中使用很复杂
大数据下有良好的性能	很大的编程成本
对于小应用非常好	没有封装
易学的简易语法	难以实现 MVC 的概念
	查询需要指定 DBMS

为什么是对象关系映射（ORM）？

我们先看一个实体类以及对应的数据库表

@Setter
@Getter
@NoArgsConstructor
public class User {
    private String id;
    private String name;
    private String password;
    private Date createTime;
    private Date expireTime;
    public User(String name,String password,Date createTime,Date expireTime){
        this.name = name;
        this.password = password;
        this.createTime = createTime;
        this.expireTime = expireTime;
    }
}

create table `user` (
  `id` varchar (765),
  `name` varchar (765),
  `password` varchar (765),
  `createTime` datetime ,
  `expireTime` datetime ,
    PRIMARY KEY (`id`)
);

我们发现实体类与表的关系一旦确定那么，就能难在进行改变了。

如果在开发中，我们写了大半，却要修改数据库到的设计怎么办？

在关系型数据库中加载和存储对象时我们要面临以下五个不匹配的问题，怎么解决？

ORM就能够很好的解决。

什么是ORM

ORM 表示 Object-Relational Mapping (ORM)，是一个方便在关系数据库和类似于 Java， C# 等面向对象的编程语言中转换数据的技术。一个 ORM 系统相比于普通的 JDBC 有以下的优点。

ORM解决方案由一下四个实体组成

hibernate 简介

Hibernate 是传统 Java 对象和数据库服务器之间的桥梁，用来处理基于 O/R 映射机制和模式的那些对象

Hibernate 优势

Hibernate 使用 XML 文件来处理映射 Java 类别到数据库表格中，并且不用编写任何代码。
为在数据库中直接储存和检索 Java 对象提供简单的 APIs。
如果在数据库中或任何其它表格中出现变化，那么仅需要改变 XML 文件属性。
抽象不熟悉的 SQL 类型，并为我们提供工作中所熟悉的 Java 对象。
Hibernate 不需要应用程序服务器来操作。
操控你数据库中对象复杂的关联。
最小化与访问数据库的智能提取策略。
提供简单的数据询问。

Hibernate 架构

Hibernate 架构是分层的，作为数据访问层，你不必知道底层 API 。Hibernate 利用数据库以及配置数据来为应用程序提供持续性服务（以及持续性对象）。

详细的 Hibernate 应用程序体系结构视图以及一些重要的类

Hibernate 使用不同的现存 Java API，比如 JDBC，Java 事务 API（JTA），以及 Java 命名和目录界面（JNDI）。JDBC 提供了一个基本的抽象级别的通用关系数据库的功能， Hibernate 支持几乎所有带有 JDBC 驱动的数据库。JNDI 和 JTA 允许 Hibernate 与 J2EE 应用程序服务器相集成。

配置对象

配置对象是你在任何 Hibernate 应用程序中创造的第一个 Hibernate 对象，并且经常只在应用程序初始化期间创造。它代表了 Hibernate 所需一个配置或属性文件。配置对象提供了两种基础组件。

数据库连接：由 Hibernate 支持的一个或多个配置文件处理。这些文件是 hibernate.properties 和 hibernate.cfg.xml。
类映射设置：这个组件创造了 Java 类和数据库表格之间的联系。

SessionFactory 对象

配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。

SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以如果你使用多种数据库那么你要创造多种 SessionFactory 对象。

Session 对象

一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。

Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

Transaction 对象

一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。

这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

Query 对象

Query 对象使用 SQL 或者 Hibernate 查询语言（HQL）字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

Criteria 对象

Criteria 对象被用于创造和执行面向规则查询的对象来检索对象。

Hibernate 配置

Hibernate 需要事先知道在哪里找到映射信息，这些映射信息定义了 Java 类怎样关联到数据库表。Hibernate 也需要一套相关数据库和其它相关参数的配置设置。所有这些信息通常是作为一个标准的 Java 属性文件提供的，名叫 hibernate.properties。又或者是作为 XML 文件提供的，名叫 hibernate.cfg.xml。

Hibernate属性

重要主属性列表

S.N.	属性和描述
1	hibernate.dialect 这个属性使 Hibernate 应用为被选择的数据库生成适当的 SQL。
2	hibernate.connection.driver_class JDBC 驱动程序类。

3	hibernate.connection.url 数据库实例的 JDBC URL。
4	hibernate.connection.username 数据库用户名。
5	hibernate.connection.password 数据库密码。

6	hibernate.connection.pool_size 限制在 Hibernate 应用数据库连接池中连接的数量。
7	hibernate.connection.autocommit 允许在 JDBC 连接中使用自动提交模式。

Hibernate会话

会话

Session 用于获取与数据库的物理连接。 Session 对象是轻量级的，并且设计为在每次需要与数据库进行交互时被实例化。持久态对象被保存，并通过 Session 对象检索找回。

Hibernation 映射文件

这里直接使用上面的表与实体类

基于这两个实体之上，我们可以定义下列映射文件来指示 Hibernate 如何将已定义的类或类组与数据库表匹配。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.hibernate.User">
 <id name="id">
   <generator class="uuid"/> 
   </id>
   <property name="name"/> 
   <property name="password"/> 
   <property name="createTime"/> 
   <property name="expireTime"/> 
 </class>
</hibernate-mapping>

需要以格式 <classname>.hbm.xml保存映射文件。我们保存映射文件在 User.hbm.xml 中。

标签的使用:

映射文件是一个以 <hibernate-mapping> 为根元素的 XML 文件，里面包含所有<class>标签。

<class> 标签是用来定义从一个 Java 类到数据库表的特定映射。Java 的类名使用 name 属性来表示，数据库表明用 table 属性来表示。

<id> 标签将类中独一无二的 ID 属性与数据库表中的主键关联起来。id 元素中的 name 属性引用类的性质，column 属性引用数据库表名的列。type 属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。

在 id 元素中的 <generator> 标签用来自动生成主键值。设置 generator 标签中的 class 属性可以设置 native 使 Hibernate 可以使用 identity, sequence 或 hilo 算法根据底层数据库的情况来创建主键。

<property> 标签用来将 Java 类的属性与数据库表的列匹配。标签中 name 属性引用的是类的性质，column 属性引用的是数据库表的列。type 属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。

映射类型

介绍完上面的知识，我们就可以开始Hibernate的第一个安利了

第一个Hibernate程序

本人创建的是maven项目

目录结构

pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>hibernate</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>hibernate Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.20</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-c3p0</artifactId>
      <version>4.3.5.Final</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <!-- 添加Hibernate依赖 -->
  <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-annotations</artifactId>
    <version>3.2.1.ga</version>
  </dependency>
  <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>3.2.1.ga</version>
  </dependency>
<!--    SLF4J-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.32</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>1.7.2</version>
    </dependency>
    <!-- 添加javassist -->
    <dependency>
      <groupId>javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.12.0.GA</version>
    </dependency>
    <!-- mysql数据库的驱动包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>
  </dependencies>
  <build>
    <!--配置Maven 对resource文件 过滤 -->
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
          <include>**/*.xls</include>
          <include>**/*.xlsx</include>
        </includes>
        <filtering>true</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
      </resource>
    </resources>
  </build>
</project>

编写一个实体类

@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String id;
    private String name;
    private String password;
    private Date createTime;
    private Date expireTime;
    public User(String name,String password,Date createTime,Date expireTime){
        this.name = name;
        this.password = password;
        this.createTime = createTime;
        this.expireTime = expireTime;
    }
}

由于 Hibernate 默认访问的是各个属性的 getter 和 setter 方法，所以为了实现类的封装性，建议为持久化类的各个属性添加 getter 和 setter 方法。

通常持久化类的编写应该遵循一些规则，具体如下。

提供一个无参数的 public 访问控制符的构造器。

持久化类中所有属性使用 private 修饰。

所有属性提供 public 修饰的 setter 和 getter 方法。

提供一个标识属性 OID，映射数据表主键字段，例如 User 表的 id 属性。

标识属性应尽量使用基本数据类型的包装类型，目的是为了与数据库表的字段默认值 null 一致。

不要用 final 修饰持久化类，否则无法生成代理对象。

编写映射文件`User.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">
<hibernate-mapping>
    <!-- name代表的是类名 ，table代表表名，table="user"可不写-->
    <class name="com.hibernate.User"  table="user">
        <!-- name代表的是User类中的id属性，column代表的是user表中的主键id， column="id"可不写-->
        <id name="id" column="id">
            <!-- 主键生成策略 -->
            <generator class="increment"/>
        </id>
        <!-- 其他属性使用property标签映射 -->
        <property name="name"/>
        <property name="password"/>
        <property name="createTime"/>
        <property name="expireTime"/>
    </class>
</hibernate-mapping>

上述代码展示了实体类 User 与数据表 user 的映射关系。在上述映射文件中：

节点用于配置实体类的映射信息，其中 name 属性表示实体类的完整类名，table 属性表示数据表的名称。

节点用于定义实体类的唯一标识（对应数据表的主键），是节点下的必须节点，其 name 属性对应实体类的属性，用于对应数据库表中的列，这里即为表的主键，子节点用于指定主键的生成策略。

节点用于映射普通属性，其 name 属性对应实体中的属性，column 属性对应数据库表中的字段，type 属性表示其属性的类型。

编写核心配置文件 hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
      "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
      "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   <session-factory>
      <!-- 链接数据库url -->
      <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernatelearn</property>
      <!-- 数据库驱动 -->
      <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</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="format_sql">true</property>
      <property name="hibernate.hbm2ddl.auto">update</property>
      <!-- 映射文件配置 -->
      <mapping resource="com/hibernate/User.hbm.xml"/>
   </session-factory>
</hibernate-configuration>

hibernate.hbm2ddl.auto参数的作用主要用于：自动创建|更新|验证数据库表结构。如果不是此方面的需求建议set value=“none”。

create：

每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，这就是导致数据库表数据丢失的一个重要原因。

create-drop ：

每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。

update：

最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，**即使表结构改变了但表中的行仍然存在不会删除以前的行。**要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。

validate ：

每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

数据操作：

    @Test
    public void test(){
// 1.创建Configuration对象并加载hibernate.cfg.xml配置文件
        Configuration config = new Configuration().configure();
        // 2.获取SessionFactory
        SessionFactory sessionFactory = config.buildSessionFactory();
        // 3.得到一个Session
        Session session = sessionFactory.openSession();
        // 4.开启事务
        Transaction transaction = session.beginTransaction();
        // 5.执行持久化操作
        User user = new User();
        user.setName("zhangsan");
        user.setPassword("12345");
        user.setCreateTime(new Date());
        user.setExpireTime(new Date());
        // 将对象保存到表中
        session.save(user);
/*
        // 更新数据
        session.update(user);
        //查询操作
        Object o = session.get(User.class, 1);
        //删除操作
        User user2 = (User) session.get(User.class, 1);
        session.delete(user2);
*/
        // 6.提交事务
        transaction.commit();
        // 7.关闭资源
        session.close();
        sessionFactory.close();
    }

截图

Hibernate 运行流程

运行时的执行流程

图所示的 Hibernate 的执行流程过程具体如下。

1）创建 Configuration 实例，加载 Hibernate 核心配置文件和映射文件信息到 Configuration 对象中。

2）创建 SessionFactory 实例。通过 Configuration 对象读取到的配置文件信息创建 SessionFactory 对象，该对象中保存了当前数据库的配置信息和所有映射关系等信息。

3）创建 Session 实例，建立数据库连接。Session 主要负责执行持久化对象的增、删、改、查操作，创建一个 Session 就相当于创建一个新的数据库连接。

4）创建 Transaction 实例，开启一个事务。Transaction 用于事务管理，一个 Transaction 对象对应的事务可以包含多个操作。在使用 Hibernate 进行增、删、改操作时，必须先创建 Transaction 对象。需要注意的是，Hibernate 的事务默认是关闭的，需要手动开启事务和关闭事务。

5）利用 Session 接口通过的各种方法进行持久化操作。

6）提交事务，对实体对象持久化操作后，必须提交事务。

7）关闭 Session 与 SessionFactory，断开与数据库的连接。

Hibernate 映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!--映射文件的dtd约束信息-->
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- name代表的是完整类名（包含的类名），table代表的是表名 -->
    <class name="className" table="tableName">
        <!-- name代表的是className类中的唯一标识属性，column代表的是tableName表中的主键id -->
        <id name="id" column="id">
            <!-- 主键生成策略 -->
            <generator class="native" />
        </id>
        <!-- name表示className的普通属性 column表示tableName表的普通字段 type 表示字段类型-->
        <property name="attrName" column="fieIdName" type="string" />
    </class>
</hibernate-mapping>

首先进行了 xml 声明，然后定义了映射文件的 dtd 信息，此 dtd 信息读者不需要去手写，可以在项目的 Web App Libraries 目录（或 Referenced Libraries 目录）中，找到

`<hibernate-mapping>`元素

`<class>` 元素

用于指定持久化类和数据表的映射关系，它是 XML 配置文件中的主要配置内容。

属性名	是否必须	说明
name	否	持久化类或接口的全限定名。如果未定义该属性，则 Hibernate 将该映射视为非 POJO 实体的映射
table	否	持久化类对应的数据库表名，默认为持久化类的非限定类名

catalog	否	数据库 catalog 名称，如果指定该属性，则会覆盖 hibernate-mapping 元素中指定的 catalog 属性值
lazy	否	指定是否使用延迟加载

`<id>`元素

元素内包含了一个元素，该属性用于设定持久化类的 OID（Object identifier，对象标识符）和表的主键的映射

主键生成策略

1，自然主键

把具有业务含义的字段作为主键，称为自然主键

2，代理主键

把不具备业务含义的字段作为主键，称为代理主键

Hibernate中内置的主键生成策略

`<property>`元素

<class>元素内可以包含多个 <property>子元素，它用于表示持久化类的其他属性和数据表中非主键字段的映射关系

属性名	说明
name	持久化类属性的名称，以小写字母开头
column	数据表字段名
type	数据表的字段类型

length	数据表字段定义的长度
lazy	指定当持久化类的实例首次被访问时，是否对该属性使用延迟加载，其默认值是 false
unique	是否对映射列产生一个唯一性约束。常在产生 DDL 语句或创建数据库对象时使用
not-null	是否允许映射列为空

hibernate学习笔记之一（上）

Hibernate ORM

什么是ORM

hibernate 简介

Hibernate 优势

Hibernate 架构

配置对象

Hibernate 配置

Hibernate属性

Hibernate会话

Hibernation 映射文件

映射类型

第一个Hibernate程序

目录结构

编写映射文件`User.hbm.xml`

编写核心配置文件 hibernate.cfg.xml

Hibernate 运行流程

Hibernate 映射文件

`<hibernate-mapping>`元素

`<class>` 元素

`<id>`元素

`<property>`元素

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

hibernate学习笔记之一（上）

Hibernate ORM

什么是ORM

hibernate 简介

Hibernate 优势

Hibernate 架构

配置对象

Hibernate 配置

Hibernate属性

Hibernate会话

Hibernation 映射文件

映射类型

第一个Hibernate程序

目录结构

编写映射文件User.hbm.xml

编写核心配置文件 hibernate.cfg.xml

Hibernate 运行流程

Hibernate 映射文件

<hibernate-mapping>元素

<class> 元素

<id>元素

<property>元素

热门文章

最新文章

相关电子书

编写映射文件`User.hbm.xml`

`<hibernate-mapping>`元素

`<class>` 元素

`<id>`元素

`<property>`元素