顶级架构师学习——第十八阶段：数据库管家Hibernate

短命女 2021-09-28 06:14 325阅读 0赞

Hello，今天要学习的是Hibernate，我把它称之为数据库管家，嘿嘿ヾ(≧O≦)〃嗷~

**目录**

一、Hibernate简介

二、Hibernate入门

三、Hibernate的API详解

四、Hibernate进阶

--------------------

# 一、Hibernate简介 #

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

我们通过一张图来展示一下什么是Hibernate框架吧！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70][]

简单的说，Hibernate就是帮我们从繁琐的sql操作当中解放出来的~~

我们为什么要使用Hibernate呢？

我们使用传统的jdbc进行开发应用系统时，如果是小型系统，并不会觉得有什么麻烦。然而当我们开发大型应用系统时，jdbc就会显得有些力不从心。比如说对于几十甚至上百张表进行操作时，编写的sql语句不仅长而且繁琐，容易出错且工作量巨大。为了提高数据访问层的变成效率，一种流行的ORM架构应运而生，这就是我们的Hibernate框架。

ORM指的时Object Relation Mapping（对象关系映射），它共分为四级，Hibernate属于第四级的ORM架构，它完全面向对象操作数据库。开发人员仅需关注一段的映射，其他的数据库操作均由Hibernate框架负责解决，极大的减少了代码数量，并且优化了内存，加快了运行效率。同时它也具有极强的可扩展性，有很多开源的代码可以直接使用来实现各种不同的附加功能，当然，你自己也可以编写相应的扩展代码来实现自己的业务需求。

# 二、Hibernate入门 #

1、框架搭建

我们从官网下载最新的Hibernate压缩包，解压后的目录情况如下：

![20190228210902526.png][]

我们在javaee工程中引入Hibernate的jar包以及mysql的数据库驱动包，导入相应的dtd约束（hibernate-configuration-3.0.dtd和hibernate-mapping-3.0.dtd）。

OK！

2、创建数据库及示例表

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 1][]

3、修改配置文件

1.orm元数据（Customer.hbm.xml）

<hibernate-mapping package="cn.itheima.domain" >
    
    
    
    
    <class name="Customer" table="cst_customer" >
    
    
    
    
    <id name="cust_id"  >
    
    
    
    <property name="cust_name" column="cust_name" >

2.Hibernate主要配置（hibernate.cfg.xml 文件的名字不要改！！！默认的文件名）

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
     
    <property name="hibernate.connection.url">jdbc:mysql:///hibernate_32</property>
     
    <property name="hibernate.connection.username">root</property>
     
    <property name="hibernate.connection.password">1234</property>
    
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    
    
    
    <property name="hibernate.show_sql">true</property>
    
    <property name="hibernate.format_sql">true</property>
    
    <property name="hibernate.hbm2ddl.auto">update</property>
    
    
    
    <mapping resource="cn/itheima/domain/Customer.hbm.xml" />

4、Demo

这个Demo我们尝试保存一个新用户到我们的表当中。

import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.Test;
    
    import cn.itheima.domain.Customer;
    
    //测试Hibernate框架
    public class Demo {
    
    	@Test
    	//保存客户
    	public void fun1(){
    		Configuration conf = new Configuration().configure();
    		
    		SessionFactory sessionFactory = conf.buildSessionFactory();
    		
    		Session session = sessionFactory.openSession();
    	
    		Transaction tx = session.beginTransaction();
    		//----------------------------------------------
    		Customer c = new Customer();
    		c.setCust_name("google公司");
    		
    		session.save(c);//执行保存
    		
    		//----------------------------------------------
    		tx.commit();
    		session.close();
    		sessionFactory.close();
    	}
    }

# 三、Hibernate的API详解 #

我们以上面的API为引，展示了如何使用Hibernate框架快速的操作数据库，接下来我们详细的介绍一下Hibernate的API。

1、Configuration

// 1 创建,调用空参构造
    Configuration conf = new Configuration();
    
    // 2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
    conf.configure();
    
    // 3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
    //conf.addResource(resourceName);
    //conf.addClass(persistentClass);
    
    // 4 根据配置信息,创建 SessionFactory对象
    SessionFactory sf = conf.buildSessionFactory();

2、SessionFactory

// SessionFactory功能: 用于创建操作数据库核心对象session对象的工厂.
    //					 简单说功能就一个---创建session对象
    // 注意:1.sessionfactory 负责保存和使用所有配置信息.消耗内存资源非常大.
    //	  2.sessionFactory属于线程安全的对象设计.
    // 结论: 保证在web项目中,只创建一个sessionFactory.
    
    // 4 根据配置信息,创建 SessionFactory对象
    SessionFactory sf = conf.buildSessionFactory();
    
    // 5 获得session
    // 打开一个新的session对象
    sf.openSession();
    
    // 6 获得一个与线程绑定的session对象
    sf.getCurrentSession();

3、Session

// 学习Session对象
    // session对象功能: 表达hibernate框架与数据库之间的连接(会话).session类似于
    //				JDBC年代的connection对象. 还可以完成对数据库中数据的增删改查操作.
    //				session是hibernate操作数据库的核心对象
    
    // 1 创建,调用空参构造
    Configuration conf = new Configuration().configure();
    
    // 2 根据配置信息,创建 SessionFactory对象
    SessionFactory sf = conf.buildSessionFactory();
    
    // 3 获得session
    Session session = sf.openSession();
    
    // 4 session获得操作事务的Transaction对象
    // 获得操作事务的tx对象
    // Transaction tx = session.getTransaction();
    // 开启事务并获得操作事务的tx对象(建议使用)
    Transaction tx2 = session.beginTransaction();
    
    // 增删改查操作
    // 增
    Customer c = new Customer();
    c.setCust_name("传智播客");
    session.save(c);
    // 查
    Customer customer = session.get(Customer.class, 1l);
    // 改
    Customer c = session.get(Customer.class, 1l);
    c.setCust_name("黑马程序员");
    session.update(c);
    // 删
    Customer c = session.get(Customer.class, 1l);
    session.delete(c);
    
    tx2.commit();//提交事务
    tx2.rollback();//回滚事务
    session.close();//释放资源
    sf.close();//释放资源

4、Transaction

//获得操作事务的tx对象
    //Transaction tx = session.getTransaction();
    //开启事务并获得操作事务的tx对象(建议使用)
    Transaction tx2 = session.beginTransaction();

# 四、Hibernate进阶 #

1、实体规则

1.实体类创建的注意事项

**·** 持久化类提供无参构造

**·** 成员变量私有，提供公有get/set方法访问，称为**属性**

**    ·** 持久化类中的属性，应尽量使用包装类型

**    ·** 持久化类中需提供与数据库中主键对应的id

**    ·** 不要使用final修饰class

2.主键类型

**·** 自然主键：这个在业务当中比较少见，它要求业务本身具有至少一个唯一且与业务相关的属性

**·** 代理主键：我们人为的创建的一种必须有且不重复的特征

3.主键生成策略

**·** sequence：Oracle数据库使用的一种主键生成策略

**·** hilo：采用高低位算法实现主键自增，也是由hibernate维护的，开发当中一般不使用

**·** identity：由数据库本身维护的一种主键自增

**·** native：自动从前面所说的三种策略中根据数据库本身选择其中一种

**·** uuid：生成随机字符串作为主键，主键类型必须为String类型

**·** increment：hibernate维护的一种主键自增，每次插入前会查询表内最大的id值，自增1后作为新的主键值插入

**·** assigned：自然主键生成策略，由开发人员手动输入

2、对象状态

对象分为三种状态：瞬时状态（无id，不在session缓存中），持久化状态（有id，在session缓存中），游离状态（有id，不在session缓存当中）

我们使用Hibernate的其中一个目的便是将对象转化为**持久化状态**！

三种状态的转换关系如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 2][]

3、一级缓存

与我们电脑使用缓存的目的相似——提高操作数据库效率！

使用缓存有两种方式：

1.提高查询效率

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 3][]

2.减少不必要的修改语句发送（快照）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 4][]

4、事务

Hibernate中的事务与数据库的事务相同，同样具备ACID特性，有着同样的事务隔离级别。

我们在hibernate的配置文件当中对事务的隔离级别进行配置：

<property name="hibernate.connection.isolation">4</property>

我们如何在项目当中管理事务呢？

我们在dao层和service层都在使用session对象完成对数据库的操作，因此，为了保证我们能够获取到同一个session，我们在开发当中仅需要调用sessionFactory.getCurrentSession()方法即可获得与当前线程绑定的session对象。我们通过这个方法获得的session在事务提交之后会自动关闭，而不要我们手动关闭。

5、批量查询

Hibernate中的批量查询有三种方法：HQL查询、Criteria查询、原生SQL查询。下面我们来一一介绍：

1.HQL查询

从名字当中我们也可以猜出来，HQL查询是Hibernate独家的查询语言，属于面向对象的查询语言，它适用于不很复杂的多表查询。

// 1 获得session
    Session session = HibernateUtils.openSession();
    // 2 控制事务
    Transaction tx = session.beginTransaction();
    // 3 执行操作
    //-------------------------------------------
    
    // 基本查询
    // 1> 书写HQL语句
    //		String hql = " from cn.itheima.domain.Customer ";
    String hql = " from Customer "; // 查询所有Customer对象
    // 2> 根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    // 3> 根据查询对象获得查询结果
    List<Customer> list = query.list();	// 返回list结果
    // query.uniqueResult();//接收唯一的查询结果
    
    // 条件查询
    //1> 书写HQL语句
    String hql = " from Customer where cust_id = 1 "; // 查询所有Customer对象
    //2> 根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    //3> 根据查询对象获得查询结果
    Customer c = (Customer) query.uniqueResult();
    
    // 带占位符的条件查询
    //1> 书写HQL语句
    String hql = " from Customer where cust_id = ? "; // 查询所有Customer对象
    //2> 根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    //设置参数
    //query.setLong(0, 1l);
    query.setParameter(0, 1l);
    //3> 根据查询对象获得查询结果
    Customer c = (Customer) query.uniqueResult();
    
    // 分页查询
    //1> 书写HQL语句
    String hql = " from Customer  "; // 查询所有Customer对象
    //2> 根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    //设置分页信息 limit ?,?
    query.setFirstResult(1);
    query.setMaxResults(1);
    //3> 根据查询对象获得查询结果
    List<Customer> list =  query.list();
    
    //-------------------------------------------
    //4提交事务.关闭资源
    tx.commit();
    session.close();// 游离|托管 状态, 有id , 没有关联

2.Criteria查询

Criteria是Hibernate自创的一种无语句面向对象查询。

// 基本查询
    //查询所有的Customer对象
    Criteria criteria = session.createCriteria(Customer.class);
    List<Customer> list = criteria.list();
    
    // 条件查询
    //创建criteria查询对象
    Criteria criteria = session.createCriteria(Customer.class);
    //添加查询参数 => 查询cust_id为1的Customer对象
    criteria.add(Restrictions.eq("cust_id", 1l));
    //执行查询获得结果
    Customer c = (Customer) criteria.uniqueResult();
    System.out.println(c);
    
    // 分页查询
    //创建criteria查询对象
    Criteria criteria = session.createCriteria(Customer.class);
    //设置分页信息 limit ?,?
    criteria.setFirstResult(1);
    criteria.setMaxResults(2);
    //执行查询
    List<Customer> list = criteria.list();
    System.out.println(list);
    
    // 查询总记录数
    //创建criteria查询对象
    Criteria criteria = session.createCriteria(Customer.class);
    //设置查询的聚合函数 => 总行数
    criteria.setProjection(Projections.rowCount());
    //执行查询
    Long count = (Long) criteria.uniqueResult();
    System.out.println(count);

3.原生SQL查询

//1 获得session
    Session session = HibernateUtils.openSession();
    //2 控制事务
    Transaction tx = session.beginTransaction();
    //3执行操作
    //-------------------------------------------
    
    // 基本查询
    //1 书写sql语句
    String sql = "select * from cst_customer";
    //2 创建sql查询对象
    SQLQuery query = session.createSQLQuery(sql);
    //3 调用方法查询结果
    // 返回数组List
    List<Object[]> list = query.list();
    //指定将结果集封装到哪个对象中
    query.addEntity(Customer.class);
    // 返回对象List
    List<Customer> list = query.list();
    System.out.println(list);
    
    // 条件查询
    //1 书写sql语句
    String sql = "select * from cst_customer where cust_id = ? ";
    //2 创建sql查询对象
    SQLQuery query = session.createSQLQuery(sql);
    query.setParameter(0, 1l);
    //指定将结果集封装到哪个对象中
    query.addEntity(Customer.class);
    //3 调用方法查询结果
    List<Customer> list = query.list();
    System.out.println(list);
    
    // 分页查询
    //1 书写sql语句
    String sql = "select * from cst_customer  limit ?,? ";
    //2 创建sql查询对象
    SQLQuery query = session.createSQLQuery(sql);
    query.setParameter(0, 0);
    query.setParameter(1, 1);
    //指定将结果集封装到哪个对象中
    query.addEntity(Customer.class);
    //3 调用方法查询结果
    List<Customer> list = query.list();
    System.out.println(list);
    
    //-------------------------------------------
    //4提交事务.关闭资源
    tx.commit();
    session.close();// 游离|托管 状态, 有id , 没有关联

6、数据表的一对一&多对一&多对多

数据库中表的三种关系由下图给出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 5][]

实体表之间的映射关系在数据库当中是由外键来描述的。

一对多的建表原则：在多的一方创建外键指向一的一方的主键。

多对多的建表原则：创建一个中间表，中间表至少两个字段作为外键分别指向两张表的主键。

一对一的建表原则：唯一外键对应（同一对多，但外键唯一）或主键对应（一方的主键作为另一方的主键）。

相应的xml文件配置如下：

<set name="linkMens" inverse="true" cascade="delete"  >
    	<key column="lkm_cust_id" ></key>
    	<one-to-many class="LinkMan" />
    </set>
    
    
    
    <many-to-one name="customer" column="lkm_cust_id" class="Customer"  >
    </many-to-one>

--------------------

今天的内容就到这里~~~

我是小昶，明天见啦o(\*^＠^\*)o

日常推一推我们的公众号：落饼枫林，有需要相关代码的请在后台留言呢~~

![20190228230417125.jpg][]

[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E6%8C%81%E4%B9%85%E5%8C%96/5777076
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70]: /images/20210923/b1001e41db634293831199a479818d78.png
[20190228210902526.png]: /images/20210923/0d5b294421c146819ccaf87f7cd9364b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 1]: /images/20210923/3abf328b7ed349e89739e04a2866fee4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 2]: /images/20210923/fcd78a1d308942529cdd24ee357c5c77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 3]: /images/20210923/b699aa4e142d4c40ab7bb589b141a70f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 4]: /images/20210923/f1c5c42779bd43d79bba84d19e368292.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 5]: /images/20210923/2819fc6f32f8478c9f9f323b7fe473bf.png
[20190228230417125.jpg]: /images/20210923/9c4877acd1cf4b3b8cc3b49892785474.png