Hibernate(一)

1. Hibernate和ORM的概念

1.1 Hibrenate概述

它是一个轻量级，企业级，开源的ORM持久层框架。是可以操作数据库的框架。

• 框架：它就是一个架构。
• 通常情况下，软件工程的持久层解决方案，一个为主一个为辅。两者并存（写SQL语句的和不写SQL语句的
• 轻量级：指的是使用时依赖的资源很少。（目前我们使用的阶段，只依赖log4j，c3p0连接池）
• 企业级：指的是在企业级应用中使用的比较多
• 开源的：开放源代码。
• ORM的操作方式：建立对象关系映射，实现操作实体类就相当于操作数据库表。

Hibernate框架是当今主流的Java持久层框架之一，由于它具有简单易学、灵活性强、扩展性强等特点，能够大大地简化程序的代码量，提高工作效率，因此受到广大开发人员的喜爱。

Hibernate是一个开放源代码的ORM框架，它对JDBC进行了轻量级的对象封装，使得Java开发人员可以使用面向对象的编程思想来操作数据库。

1.2 ORM

Object Relational Mapping

• 对象关系映射
• 就是建立实体类和数据库表的对应关系。
• 实现操作实体类对象就相当于操作数据库表

Object Relation Mapping 对象关系映射。

对象-关系映射（OBJECT/RELATIONALMAPPING，简称ORM），是随着面向对象的软件开发方法发展而产生的。用来把对象模型表示的对象映射到基于S Q L 的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的 SQ L 语句打交道，只需简单的操作实体对象的属性和方法[2] 。O R M 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转化[1] 。

简单的说就是把我们程序中的实体类和数据库表建立起来对应关系。

1.3 为什么要学习Hibernate

与其它操作数据库的技术相比，Hibernate具有以下几点优势：

• Hibernate对JDBC访问数据库的代码做了轻量级封装，大大简化了数据访问层繁琐的重复性代码，并且减少了内存消耗，加快了运行效率。
• Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现，它很大程度的简化了DAO（Data Access Object，数据访问对象）层编码工作。
• Hibernate的性能非常好，映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系。
• 可扩展性强，由于源代码的开源以及API的开放，当本身功能不够用时，可以自行编码进行扩展。

明确：

​ 操作实体类就相当于操作数据库表

使用传统的JDBC开发应用系统时，如果是小型应用系统，并不觉得有什么麻烦，但是对于大型应用系统的开发，使用JDBC就会显得力不从心。例如对几十、几百张包含几十个字段的表进行插入操作时，编写的SQL语句不但很长，而且繁琐，容易出错；在读取数据时，需要写多条getXxx语句从结果集中取出各个字段的信息，不但枯燥重复，并且工作量非常大。为了提高数据访问层的编程效率，Gavin King开发出了一个当今最流行的的ORM框架，它就是Hibernate框架。

所谓的ORM就是利用描述对象和数据库表之间映射的元数据，自动把Java应用程序中的对象，持久化到关系型数据库的表中。通过操作Java对象，就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带，开发人员只需要关注纽带一端映射的对象即可。ORM原理如图所示。

2. CRM

CRM：客户关系管理系统

CRM（Customer Relationship Management）客户关系管理，是利用相应的信息技术以及互联网技术来协调企业与顾客间在销售、营销和服务上的交互，向客户提供创新式的个性化的客户交互和服务的过程。

其最终目标是将面向客户的各项信息和活动集成起来，组建一个以客户为中心的企业，实现对面向客户的活动的全面管理。

3. Hibernate快速入门

3.1 需求介绍

保存一个客户到数据库的客户表中。

3.2 搭建Hibernate开发环境

3.2.1 第一步：拷贝必备的jar包到开发目录

数据库驱动包，如下图：

Hibernate/lib/required/*.jar，如下图：

日志记录的包，如下图:

3.2.2 第二步：创建数据库和实体类

持久化类是应用程序中的业务实体类，这里的持久化是指类的对象能够被持久化保存到数据库中。Hibernate使用普通Java对象（Plain Old Java Object），即POJO的编程模式来进行持久化。POJO类中包含的是与数据库表相对应的各个属性，这些属性通过getter和setter方法来访问，对外部隐藏了内部的实现细节。下面就来编写Customer持久化类。

在项目src目录下，创建cn.wgy.domain包，并在包中创建实体类Customer（对应数据库表cst_customer），Customer类包含与cst_customer数据表字段对应的属性，以及相应的getXxx ()和setXxx ()方法。

/*创建客户表*/
CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_address` varchar(128) DEFAULT NULL COMMENT '客户联系地址',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '客户联系电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;

/**
 * 客户实体类
 *
 * @author wgy
 */
public class Customer implements Serializable {
    private Long custId;
    private String custName;
    private String custSource;
    private String custIndustry;
    private String custLevel;
    private String custAddress;
    private String custPhone;
    ...
}

3.2.3 第三步：编写映射配置文件（xml）

实体类Customer目前还不具备持久化操作的能力，而Hibernate需要知道实体类Customer映射到数据库Hibernate中的哪个表，以及类中的哪个属性对应数据库表中的哪个字段，这些都需要在映射文件中配置。

在实体类Customer所在的包中，创建一个名称为Customer.hbm.xml的映射文件，在该文件中定义了实体类Customer的属性是如何映射到cst_customer表的列上的。

<?xml version="1.0" encoding="UTF-8"?>
<!-- 在实体类所在的包下，创建一个xml文件。该文件建议名称为：实体类名称+.hbm+.xml -->

<!-- 导入约束:dtd约束
        位置：在Hibernate的核心jar包中名称为hibernate-mapping-3.0.dtd
        明确该文件中的内容：
            实体类和表的对应关系
            实体类中属性和表的字段的对应关系
-->
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- package属性用于设定包的名称，接下来该配置文件中凡是用到此包中的对象时都可以省略包名 -->
<hibernate-mapping package="com.wgy.domain">
    
	<!-- class标签
                作用：建立实体类和表的对应关系
                属性：
                    name：指定实体类的名称
                    table：指定数据库表的名称
	 -->
	<class name="Customer" table="cst_customer">
		
                <!-- id标签
                        作用：用于映射主键
                        属性：
                            name：指定的是属性名称。也就是get/set方法后面的部分，并且首字母要转小写。
                            column:指定的是数据库表的字段名称
		-->
		<id name="custId" column="cust_id">
            
                        <!-- generator标签：
                                作用：配置主键的生成策略。
                                属性：
                                    class:指定生成方式的取值。
                                    取值之一：native。使用本地数据库的自动增长能力。
                                    mysql数据库的自动增长能力是让某一列自动+1。但是不是所有数据库都支持这种方式。
                        -->
			<generator class="native"></generator>
		</id>
        
		<!-- property标签：
                        作用：映射其他字段
                        属性：
                            name：指定属性的名称。和id标签的name属性含义一致
                            column：指定数据库表的字段名称
		-->
		<property name="custName" column="cust_name"></property>
		<property name="custLevel" column="cust_level"></property>
		<property name="custSource" column="cust_source"></property>
		<property name="custIndustry" column="cust_industry"></property>
		<property name="custAddress" column="cust_address"></property>
		<property name="custPhone" column="cust_phone"></property>
	</class>
</hibernate-mapping>

3.2.4 第四步：编写主配置文件（hibernate.cfg.xml）

Hibernate的映射文件反映了持久化类和数据库表的映射信息，而Hibernate的配置文件则主要用来配置数据库连接以及Hibernate运行时所需要的各个属性的值。在项目的src下创建一个名称为hibernate.cfg.xml的文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- 在类的根路径下创建名称为hibernate.cfg.xml的配置文件 -->

<!-- 导入dtd约束：
        位置：在核心jar包中的名称为hibernate-configuration-3.0.dtd中
-->
<!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对象的。
                Session对象就是hibernate中操作数据库的核心对象。
		此处的配置不要求背，但是要求记住创建SessionFactory必须的三部分信息
                    第一部分：
                        连接数据库的信息
                    第二部分：
                        hibernate的可选配置
                    第三部分：
                        映射文件的位置
	-->
	<session-factory>
		<!-- 第一部分：连接数据库的信息 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
                <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate01</property>
                <property name="hibernate.connection.username">root</property>
                <property name="hibernate.connection.password">root</property>
		<!-- 数据库的方言 -->
                <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

		<!-- 第二部分：hibernate的可选配置 -->
                <!-- 是否显示hibernate生成的SQL语句 -->
                <property name="hibernate.show_sql">true</property>
                <!-- 是否使用格式化输出sql语句到控制台 -->
                <property name="hibernate.format_sql">false</property>
		<!-- 是否让hibernate根据表结构的变化来生成DDL语句
			 DDL:数据定义语言
			 hibernate可以根据映射文件来为我们生成数据库的表结构。但是他不能生成数据库。
                         hbm2ddl.auto的取值
                            * none:不用Hibernate自动生成表.
                            * create:每次都会创建一个新的表.(测试)
                            * create-drop:每次都会创建一个新的表，执行程序结束后删除这个表.(测试)
                            * update:如果数据库中有表，使用原来的表，如果没有表，创建一个新表.可以更新表结构。
                            * validate:只会使用原有的表.对映射关系进行校验.
		-->
		<property name="hibernate.hbm2ddl.auto">update</property>

		<!-- 第三部分：映射配置文件的位置 -->
                <mapping resource="com/wgy/domain/Customer.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

3.4 实现保存操作

在项目中新建一个名称为cn.wgy.test的包，然后在包中建立一个名为HibernateDemo1Test.java的文件，该文件是用来测试的类文件。

/**
 * hibernate的入门案例
 * 需求：
 * 实现保存一个客户到数据库
 *
 * @author wgy
 */
public class HibernateDemo1Test {
    /**
     * 步骤分析
     * 1、解析主配置文件
     * 2、根据配置文件创建SessionFactory
     * 3、根据SessionFactory创建Session
     * 4、开启事务
     * 5、执行操作（保存）
     * 6、提交事务
     * 7、释放资源
     */
    @Test
    public void test1() {
        Customer customer = new Customer();
        customer.setCustName("测试1");
        
        // 1、解析主配置文件
        Configuration configuration = new Configuration();
        configuration.configure();

        // 2、根据配置文件创建SessionFactory
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        // 3、根据SessionFactory创建Session
        Session session = sessionFactory.openSession();

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

        // 5、执行操作（保存）
        session.save(customer);

        // 6、提交事务
        transaction.commit();

        // 7、释放资源
        session.close();
        sessionFactory.close();
    }
}

3.5 入门案例的执行过程

首先创建Configuration类的实例，并通过它来读取并解析配置文件hibernate.cfg.xml。然后创建SessionFactory读取解析映射文件信息，并将Configuration对象中的所有配置信息拷贝到SessionFactory内存中。接下来，打开Session，让SessionFactory提供连接，并开启一个事务，之后创建对象，向对象中添加数据，通过session.save()方法完成向数据库中保存数据的操作。最后提交事务，并关闭资源。

4. Hibernate中API介绍

4.1 Configuration对象

4.1.1 作用

在使用Hibernate时，首先要创建Configuration实例，Configuration实例主要用于启动、加载、管理hibernate的配置文件信息。在启动Hibernate的过程中，Configuration实例首先确定Hibernate配置文件的位置，然后读取相关配置，最后创建一个唯一的SessionFactory实例。Configuration对象只存在于系统的初始化阶段，它将SessionFactory创建完成后，就完成了自己的使命。

Hibernate通常使用Configuration config = new Configuration().configure();的方式创建实例，此种方式默认会去src下读取 hibernate.cfg.xml配置文件。如果不想使用默认的hibernate.cfg.xml配置文件，而是使用指定目录下（或自定义）的配置文件，则需要向configure()方法中传递一个文件路径的参数，其代码写法如下：

Configuration config = new Configuration().configure("xml文件位置");

此种写法hibernate会去指定位置查找配置文件，例如，想要使用src下config包中的 hibernate.cfg.xml文件，只需将文件位置加入configure()中即可，其代码如下所示：

Configuration config = new Configuration().configure("/config/hibernate.cfg.xml");

【加载映射文件】

Hibernate除了可以使用Configuration对象加载核心配置文件以外，还可以利用该对象加载映射文件。因为如何使用properties文件作为Hibernate的核心配置文件，其他的属性可以使用key=value的格式来设置，但是映射没有办法加载。这时这个对象就有了用武之地。可以在手动编写代码的时候去加载映射文件。

Configuration configuration = new Configuration().configure("xml文件位置");

configuration.addResource("cn/wgy/domain/Customer.hbm.xml");

4.1.2 常用方法

默认构造函数：
        它只能加载类的根路径下，名称为hibernate.properties的配置文件。不能加载xml
configure()：
        它用于加载类的根路径下，名称为hibernate.cfg.xml的配置文件。
        configuration.configure();
buildSessionFactory()：
        根据配置文件，构建SessionFactory
        SessionFactory sessionFactory = configuration.buildSessionFactory();
addResource(String url);
        指定映射文件的位置
        configuration.addResource("com/itheima/domain/Customer.hbm.xml");
addClass(Class clazz);
        指定实体类的字节码
        configuration.addClass(Customer.class);

4.2 SessionFactory

4.2.1 作用

SessionFactory接口负责Hibernate的初始化和建立Session对象。它在Hibernate中起到一个缓冲区作用，Hibernate可以将自动生成的SQL语句、映射数据以及某些可重复利用的的数据放在这个缓冲区中。同时它还保存了对数据库配置的所有映射关系，维护了当前的二级缓存。

SessionFactory 实例是通过Configuration对象获取的，其获取方法如下所示。

SessionFactory sessionFactory = config.buildSessionFactory();

4.2.2 常用方法

openSession()：每次都是生成一个新的Session

4.2.3 细节

该对象维护了很多信息：

• 连接数据库的信息
• hibernate的基本配置
• 映射文件的位置，以及映射文件中的配置
• 一些预定义的SQL语句（这些语句都是通用的） 比如：全字段保存，根据id的全字段更新，根据id的全字段查询，根据id的删除等等。
• hibernate的二级缓存（了解）

同时，它是一个线程安全的对象，所有由该工厂生产的Session都共享工厂中维护的数据。

4.2.4 使用原则

由于SessionFactory维护了很多信息同时又是线程安全的，一般情况下，一个项目中只需要一个SessionFactory，只有当应用中存在多个数据源时，才为每个数据源建立一个SessionFactory实例。因此，不应该反复的创建和销毁。

原则：一个应用应该只有一个SessionFactory。在应用加载时创建，应用卸载时销毁。

4.2.5 在hibernate中使用数据源(连接池)

SessionFactory内部还维护了一个连接池，如果我们需要使用第三方的连接池如C3P0，那么需要我们自己手动进行配置

配置C3P0步骤如下：

• 导入连接池的jar包

  

• 在hibernate主配置文件中配置

  <!-- 配置数据源的提供商 -->
  <property name="hibernate.connection.provider_class">
  	org.hibernate.connection.C3P0ConnectionProvider
  </property>

4.3 Session

4.3.1 作用

Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心，它的主要功能是为持久化对象提供创建、读取和删除的能力，所有持久化对象必须在session的管理下才可以进行持久化操作。

创建SessionFactory实例后，就可以通过它获取Session实例。获取Session实例有两种方式，一种是通过openSession()方法，另一种是通过getCurrentSession()方法。两种方法获取session的代码如下所示：

//采用openSession方法创建session
Session session = sessionFactory.openSession();

//采用getCurrentSession()方法创建session
Session session = sessionFactory.getCurrentSession();

以上两种获取session实例方式的主要区别是，采用openSession方法获取Session实例时，SessionFactory直接创建一个新的Session实例，并且在使用完成后需要调用close方法进行手动关闭。而getCurrentSession方法创建的Session实例会被绑定到当前线程中，它在提交或回滚操作时会自动关闭。

4.3.2 常用方法

save(Object entity);  ：保存一个实体到数据库

update(Object entity);：更新一个实体

delete(Object entity);：删除一个实体

get(Class clazz,Serializable id);：根据id查询一个实体。参数的含义：Class表示要查询的实体类字节码。Serializable就是查询的条件。

beginTransaction();：开启事务，并返回事务对象

4.3.3 细节

由于SessionFactory已经维护了很多数据，所以Session就维护较少的内容。

它是一个轻量级对象。并且：它不是线程安全的！！！！！！！

它维护了hibernate的一级缓存。

它的反复创建销毁不会消耗太多资源。

4.3.4 使用原则

每个线程都只有一个Session对象。

4.4 Transaction

4.4.1 作用

Transaction接口主要用于管理事务，它是Hibernate的数据库事务接口，且对底层的事务接口进行了封装。Transaction接口的事务对象是通过Session对象开启的，其开启方式如下所示。

Transaction transaction = session.beginTransaction();

4.4.2 常用方法

commit()：提交事务

rollback()：回滚事务

Session执行完数据库操作后，要使用Transaction接口的commit()方法进行事务提交，才能真正的将数据操作同步到数据库中。发生异常时，需要使用rollback()方法进行事务回滚，以避免数据发生错误。因此，在持久化操作后，必须调用Transaction接口的commit()方法和rollback()方法。如果没有开启事务，那么每个Session的操作，都相当于一个独立的操作。

@Test
public void testSave1() {
    Customer c = new Customer();
    c.setCustName("测试保存功能");
    Transaction tx = null;
    Session s = null;
    try {
        s = HibernateUtil.openSession();
        tx = s.beginTransaction();
        //保存客户
        s.save(c);
        tx.commit();
    } catch (Exception e) {
    	tx.rollback();
    } finally {
    	s.close();
    }
}

5. 抽取HibernateUtil工具类

/**
 * hibernate的工具类
 * 	用于生产一个Session对象
 *
 * @author wgy
 */
public class HibernateUtil {

	private static SessionFactory factory;
	
	static{
            try {
                Configuration cfg = new Configuration();
                cfg.configure();
                factory = cfg.buildSessionFactory();
            } catch (Exception e) {
                //e.printStackTrace();
                throw new ExceptionInInitializerError("初始化SessionFactory失败");
            }
	}
	
	/**
	 * 获取一个新的Session对象
	 * @return
	 */
	public static Session openSession(){
            return factory.openSession();
	}
}

6. 案例：使用Hibernate实现CRUD

6.1 保存操作

@Test
public void testAdd(){
    Customer c = new Customer();
    c.setCustName("测试保存功能");

    //1.使用工具类获取一个Session
    Session session = HibernateUtil.openSession();
    //2.开启事务
    //Transaction tx = session.beginTransaction();
    //3.保存客户
    session.save(c);
    //4.提交事务
    //tx.commit();
    //5.释放资源
    session.close();
}

6.2 查询一个实体

@Test
public void testFindOne(){
    //1.使用工具类获取一个Session
    Session session = HibernateUtil.openSession();
    //2.开启事务
    Transaction tx = session.beginTransaction();
    //3.查询id为2的客户
    Customer c = session.get(Customer.class, 2L);
    System.out.println(c);
    //4.提交事务
    tx.commit();
    //5.释放资源
    session.close();
}

6.3 修改操作

@Test
public void testUpdate(){
    //1.使用工具类获取一个Session
    Session session = HibernateUtil.openSession();
    //2.开启事务
    Transaction tx = session.beginTransaction();
    //3.查询id为2的客户
    Customer c = session.get(Customer.class, 2L);
    //修改客户的地址为：湖北省
    c.setCustAddress("湖北省");
    //执行更新
    session.update(c);
    //4.提交事务
    tx.commit();
    //5.释放资源
    session.close();
}

6.4 删除操作

@Test
public void testDelete(){
    //1.使用工具类获取一个Session
    Session session = HibernateUtil.openSession();
    //2.开启事务
    Transaction tx = session.beginTransaction();
    //3.查询id为1的客户
    Customer c = session.get(Customer.class, 1L);
    //删除实体
    session.delete(c);//delete from cst_customer where cust_id = ?
    //4.提交事务
    tx.commit();
    //5.释放资源
    session.close();
}

6.5 实体查询get和load方法

6.5.1 实体查询的概念

所谓实体查询即OID查询，就是使用主键作为条件来查询一个实体。其中涉及的方法是Session对象get方法和load方法。

6.5.2 方法的说明

get方法：

/**
 * 根据id查询一个实体
 * @param entityType 指的是要查询的实体类字节码对象
 * @param id 查询的条件，即主键的值。
 * @return 返回的是实体类对象
 */
<T> T get(Class<T> entityType, Serializable id);

@Test
public void testGet(){
    Session s = HibernateUtil.openSession();
    Transaction tx = s.beginTransaction();
    Customer c = s.get(Customer.class, 2L);
    System.out.println("get : "+c.toString());
    tx.commit();
}

load方法：

/**
 * 根据id查询一个实体
 * @param theClass 指的是要查询的实体类字节码
 * @param id查询的条件，即主键的值。
 * @return 返回的是实体类对象或者是实体类对象的代理对象
 */
<T> T load(Class<T> theClass, Serializable id);

@Test
public void testLoad(){
    Session s = HibernateUtil.openSession();
    Transaction tx = s.beginTransaction();
    Customer c = s.load(Customer.class, 2L);
    System.out.println("load : "+c.toString());
    tx.commit();
}

6.5.3 get和load的区别

• 查询的时机不一样。

  get的查询时机：每次调用get方法时，马上发起查询。 立即加载

  load的查询时机：每次真正使用的时候，发起查询。 延迟加载 懒加载 惰性加载

• 返回的结果不一样。

  get方法返回的对象是实体类类型

  load方法返回的对象是实体类类型的代理对象

load方法默认情况下是延迟，可以通过配置的方式改为立即加载。

<!-- 由于load方法是hibernate的方法所以只有XML的方式：-->
<class name="Customer" table="cst_customer" lazy="false">

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： Hibernate(一)
本文链接： https://wgy1993.gitee.io/archives/ef455019.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝

微信