Hibernate（开放源代码的对象关系映射框架）

1.简介

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

2.ORM

ORM：Object Relational Mapping（对象关系映射）。指将一个Java中的对象与关系型数据库中的表建立一种映射关系，从而通过操作对象就可以操作数据库中的表。

3.Hibernate特点

4.Hibernate入门

4.1 Hibernate目录结构

• documentation Hibernate开发文档

• lib Hibernate开发包

  • required Hibernate开发必须的依赖包
  • optional Hibernate开发可选jar包

• project Hibernate提供的项目

4.2Hibernate项目的创建（eclipse）

4.2.1创建数据表(数据库中创建)

1CREATE TABLE `cst_customer` (
2  `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
3  `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
4  `cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
5  `cust_industry` VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
6  `cust_level` VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
7  `cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
8  `cust_mobile` VARCHAR(16) DEFAULT NULL COMMENT '移动电话',
9  PRIMARY KEY (`cust_id`)
10) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

4.2.2创建实体类(与要连接的表相对应)

1public class Customer {
2	private Long cust_id;
3	private String cust_name;
4	private String cust_source;
5	private String cust_industry;
6	private String cust_level;
7	private String cust_phone;
8	private String cust_mobile;
9	public Customer() {
10		super();
11		// TODO Auto-generated constructor stub
12	}
13}

4.2.3创建映射

在与实体类相同的包下创建映射文件Customer.hbm.xml

1<?xml version="1.0" encoding="UTF-8" ?>
2<!DOCTYPE hibernate-mapping PUBLIC
3        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5<hibernate-mapping>
6    <!-- 建立类与表的映射 -->
7    <class name="Demo01.Customer" table="cst_customer">
8        <id name="cust_id" column="cust_id">
9            <!-- 设置主键的生成策略：native--自增 -->
10            <generator class="native"/>
11        </id>
12        <property name="cust_name" column="cust_name"/>
13        <property name="cust_source" column="cust_source"/>
14        <property name="cust_industry" column="cust_industry"/>
15        <property name="cust_level" column="cust_level"/>
16        <property name="cust_phone" column="cust_phone"/>
17        <property name="cust_mobile" column="cust_mobile"/>
18    </class>
19</hibernate-mapping>

4.2.4创建核心配置文件

在src目录下创建hibernate.cfg.xml

1<?xml version='1.0' encoding='utf-8'?>
2<!DOCTYPE hibernate-configuration PUBLIC
3        "-//Hibernate/Hibernate Configuration DTD//EN"
4        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
5<hibernate-configuration>
6    <session-factory>
7        <property name="connection.url" >jdbc:mysql:///hibernate01</property>
8        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
9        <property name="connection.username">root</property>
10        <property name="connection.password">123456</property>
11
12        <!-- DB schema will be updated if needed -->
13        <!-- <property name="hbm2ddl.auto">update</property>-->
14       <!-- 配置数据库方言-->
15        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
16        <!--映射文件路径-->
17        <mapping resource="Demo01/Customer.hbm.xml"/>
18    </session-factory>
19</hibernate-configuration>

4.2.5测试代码

1import org.hibernate.Session;
2import org.hibernate.SessionFactory;
3import org.hibernate.Transaction;
4import org.hibernate.cfg.Configuration;
5import org.junit.jupiter.api.Test;
6
7public class HibernateDemo01 {
8    @Test
9    public void demo1(){
10        //加载hibernate核心配置文件
11        Configuration configuration = new Configuration().configure();
12        //创建一个session工厂类似于jdbc的连接池
13        SessionFactory sessionFactory = configuration.buildSessionFactory();
14        //通过sessionFactory获取session对象
15        Session session = sessionFactory.openSession();
16        //开启事务
17        Transaction transaction = session.beginTransaction();
18        //编写代码
19        Customer customer = new Customer();
20        customer.setCust_name("gx");
21        //保存
22        session.save(customer);
23        //提交事务
24        transaction.commit();
25        //释放资源
26        session.close();
27    }
28}

5.Hibernate的常见配置

5.1Hibernate映射配置

文件Customer.hbm.xml

• class标签属性配置

  • 该标签用来建立类与表的映射关系

  • 属性

    • name：类的全路径
    • table ：表名（类名和表名如果一致那么table可以省略）
    • ctatlog：数据库名
    <class name="Demo01.Customer" table="cst_customer">

• id标签配置

  • 标签用来建立类中属性与表中主键的对应关系

  • 属性

    • name：类中的属性
    • column：表中的字段名（类中属性名和表中字段名如果一致那么column可以省略）
    • length：长度
    • type：类型
    <id name="cust_id" column="cust_id"> <!-- 设置主键的生成策略：native--自增 --> <generator class="native"/> </id>

• property

  • 标签用来建立类中普通属性与表字段之间的对应关系

  • 属性

    • name：类中的属性
    • column：表中的字段名
    • length：长度（Hibernate如果在运行前没有建立定义的表，那么在运行时就会自动建表，这时表中对应字段的长度就是此处设置的长度）
    • type：类型
    • not-noll：设置非空
    • unique：是否唯一
    <property name="cust_name" column="cust_name"/> <property name="cust_source" column="cust_source"/> <property name="cust_industry" column="cust_industry"/> <property name="cust_level" column="cust_level"/> <property name="cust_phone" column="cust_phone"/> <property name="cust_mobile" column="cust_mobile"/>

5.2Hibernate核心配置

两种方式：

1.属性文件配置

hibernate.properties

键值对配置

注意：该方式不能引入配置文件，若想引入需要通过代码配置需要手动编写代码加载映射文件。

2.XMl文件配置

hibernate.cfg.xml

• 必须的配置

  • 连接数据库的基本参数

    • 驱动类
    • url路径
    • 用户名
    • 密码

    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql:///hibernate01</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：hibernate.show_sql

  • 格式化sql：hibernate.format_sql

  • 自动建表：hibernate.hbm2ddl.auto

    • none：不使用Hibernate自动建表
    • create：如果数据库中已经有表，先删除原来的表，在创建新表。如果没有表就新建表
    • create-drop；如果数据库中已经有表，先删除原来的表，在创建新表。如果没有表就新建表。使用完成后删除该表
    • update：如果数据库中有表，就使用原来的表，若没有就新建表。如果映射文件中表字段与数据库中的对应表不一致，那么就会新建对应字段。（即更改表结构）
    • validate：如果没有表，不会创建表，只会使用原有表，作用：校验映射与表结构
    <!-- 打印SQL -->

    <property name="hibernate.show_sql">true</property>

    <!-- 格式化SQL -->

    <property name="hibernate.format_sql">true</property>

    <!-- 自动创建表 -->

    <property name="hibernate.hbm2ddl.auto">create</property>

• 映射文件的引入

  • 配置映射文件位置（使用mapping标签）

    <mapping resource="hibernate/Demo1/Custmoer.hbm.xml"/>

  ​

6.Hibernate的核心API

6.1 Configuration：Hibernate的配置对象

​ Configuration 类的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时所遇到的第一个对象。

6.1.1作用

6.1.1.1加载核心配置文件

1. hibernate.properties

Configuration configuration = new Configuration();

1. hibernate.cfg.xml

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

6.1.1.1.2加载映射文件

配置属性文件时无法加载映射文件故映射文件只能手动加载，xml文件也可以使用该方法加载

configuration.addResource("hibernate/Demo1/Custmoer.hbm.xml");

6.2 SessionFactory:session工厂

SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。

SessionFactory内部维护了Hibernate的连接池和Hibernate的二级缓存。是对象安全对象，一个项目创建一个对象即可

6.2.1 配置数据库连接池

1<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
2<!--在连接池中可用的数据库连接的最少数目 -->
3<property name="c3p0.min_size">5</property>
4<!--在连接池中所有数据库连接的最大数目  -->
5<property name="c3p0.max_size">20</property>
6<!--设定数据库连接的过期时间,以秒为单位,如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
7<property name="c3p0.timeout">120</property>
8<!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
9<property name="c3p0.idle_test_period">3000</property>

6.2.2 抽取工具类

1import org.hibernate.Session;
2import org.hibernate.SessionFactory;
3import org.hibernate.cfg.Configuration;
4
5public class HibernateUtils {
6	
7	public static final Configuration cfg;
8	public static final SessionFactory sf;
9	
10	static {
11		cfg=new Configuration().configure();
12		sf=cfg.buildSessionFactory();
13	}
14	
15	public static Session openSession() {
16		return sf.openSession();
17	}
18}

6.3 Session:类似Connection对象是连接对象

​ Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。

Session代表Hibernate与数据库连接池的连接对象。线程不安全，与数据库交互的桥梁

6.3.1 Session中的api

6.3.1.1保存方法

Serialzable save(Object o);

1public void demo6() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		
5		Customer c = new Customer();
6		c.setCust_name("gfws");
7		session.save(c);
8		
9		transaction.commit();
10		session.close();
11	}

6.3.1.2 查询方法

T get(Class c,Serializable id);

T load(Class c,Serializable id);

1public void demo1() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		
5		/**
6		 * get方法
7		 * 	* 采用的是立即加载，执行到这行代码的时候，就会马上发送SQL语句去查询。
8		 *  * 查询后返回是真实对象本身。
9		 * 	* 查询一个找不到的对象的时候，返回null
10		 * 
11		 * load方法
12		 * 	* 采用的是延迟加载（lazy懒加载），执行到这行代码的时候，不会发送SQL语句，当真正使用这个对象的时候才会发送SQL语句。
13		 *  * 查询后返回的是代理对象。javassist-3.18.1-GA.jar 利用javassist技术产生的代理。
14		 *  * 查询一个找不到的对象的时候，返回ObjectNotFoundException
15		 */
16		/*Customer customer = session.get(Customer.class, 1l);
17		System.out.println(customer);*/
18		
19		Customer customer = session.load(Customer.class, 2l);
20		System.out.println(customer);
21		
22		transaction.commit();
23		session.close();
24	}

查询所有

1public void demo5() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		
5		//通过HQL：Hibernate Query Language面向对象查询语言
6		/*Query query = session.createQuery("from Customer");
7		List<Customer> list = query.list();
8		for (Customer customer : list) {
9			System.out.println(customer);
10		}*/
11		//使用普通SQL语句查询
12		SQLQuery sql = session.createSQLQuery("select * from cst_customer");
13		List<Object[]> list = sql.list();
14		for (Object[] object : list) {
15			System.out.println(Arrays.toString(object));
16		}
17		
18		transaction.commit();
19		session.close();
20	}

6.3.1.3 修改方法

void update(Object o);

1public void demo2() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		//直接创建对象进行修改
5		/*Customer c = new Customer();
6		c.setCust_name("hh");
7		c.setCust_id(1l);*/
8		
9		//先查询后修改（推荐）
10		Customer c = session.get(Customer.class, 2l);
11		c.setCust_name("gx");
12		session.update(c);
13		
14		transaction.commit();
15		session.close();
16	}

6.3.1.4 删除方法

void delete(Object o);

1public void demo3() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		//直接创建对象进行删除
5		/*Customer c = new Customer();
6		c.setCust_id(4l);*/
7		
8		//先查询后删除（推荐）--级联删除
9		Customer c = session.get(Customer.class, 1l);		
10		session.delete(c);
11		
12		transaction.commit();
13		session.close();
14	}

6.3.1.5 保存或更新

void saveOrUpdate(Object o);

1public void demo4() {
2		Session session = HibernateUtils.openSession();
3		Transaction transaction = session.beginTransaction();
4		//如果要删除或保存对象的属性与现有数据库中的都不相同就保存，如有相同就对有相同的那一列修改
5		Customer c = new Customer();
6		/*c.setCust_name("wf");*/
7		c.setCust_id(2l);
8		c.setCust_name("fx");
9		session.saveOrUpdate(c);
10		transaction.commit();
11		session.close();
12	}

6.4 Transaction ：事务对象

Hibernate中管理事务的对象

commit();

rollback();