Hibernate框架学习笔记

Hibernate框架

Hibernate框架的概述

什么是框架

框架：指的是软件的半成品，已经完成了部分功能

EE的经典三层结构

Hibernate的概述

什么是Hibernate

Hibernate：Hibernate是一个持久层的ORM框架

什么是ORM

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

为什么要学习Hibernate

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

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

Hibernate的入门

下载Hibernate的开发环境

Hibernate3.x Hibernate4.x Hibernate5.x

https://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/

解压Hibernate

• documentation ：Hibernate开发文档
• lib：Hibernate开发包
  • required：Hibernate开发的必须的依赖包
  • optional：Hibernate开发的可选的jar包
• project：Hibernate提供的项目

创建一个项目，引入jar包

• 数据库驱动包
• Hibernate开发的必须的jar包
• Hibernate引入日记记录包

创建表

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_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类

public class Customer {
	private Long cust_id;
	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_phone;
	private String cust_mobile;
}

创建映射（****）

映射需要通过XML的配置文件来完成，这个配置文件可以任意命名。尽量统一命名规范（类名.hbm.xml）

创建一个Hibernate的核心配置文件（*********）

Hibernate的核心配置文件的名称：hibernate.cfg.xml

编写测试类

package com.hibernate.demo01;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class HibernateDemo1 {
	@Test
	public void demo1() {
		//1、加载Hibernate的核心配置文件
		Configuration configuration = new Configuration().configure();
		//手动加载映射
		//configuration.addResource("com/hibernate/demo01/Customer.hbm.xml");
		//2、创建一个SessionFactory对象：类似JDBC中的连接池
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		//3、通过SessionFactory获取到Session对象：类似JDBC中Connection
		Session session = sessionFactory.openSession();
		//4、手动开启事务
		Transaction transaction = session.beginTransaction();
		//5、编写代码
		
		Customer cust = new Customer();
		cust.setCust_name("李四");
		
		session.save(cust);
		
		//6、事务提交
		transaction.commit();
		//7、释放资源
		session.close();
	}
}

Hibernate的常见配置

配置xml提示问题

Hibernate的映射的配置

映射的配置

• 【class标签的配置】
  • 标签用来建立类与表的映射关系
  • 属性：
    • name：类的全路径
    • table：表名（类名与表名一致，table可以省略）
    • catalog：数据库名
• 【id标签的配置】
  • 标签用来建立类中的属性与表中的主键对应关系
  • 属性：
    • name：类中的属性名
    • column：表中的字段名（类中的属性名与表中的字段名如果一致，column可以省略）
    • length：长度
    • type：类型
• 【property标签的配置】
  • 标签用来建立类中的普通属性与表的字段的对应关系
  • 属性：
    • name：类中的属性名
    • column：表中的字段名
    • length：长度
    • type：类型
    • not-null：设置非空
    • unique：设唯一

Hibernate的核心配置

Hibernate的核心配置方式 ###、

• 一种方式：属性文件的方式
  • hibernate.properties
    • hibernate.connection.driver_class=com.mysql.jdbc.Driver
    • …
    • hibernate.show_sql=true
  • 属性文件的方式不能引入映射文件（手动编写代码加载映射文件）
• 二种方式：
  • hibernate.cfg.xml

核心的配置

• 必须的配置

  • 连接数据库的基本的参数
    • 驱动类
    • url路径
    • 用户名
    • 密码
  • 方言

• 可选的配置

  • 显示SQL：hibernate.show_sql
  • 格式化SQL：hibernate.format_sql
  • 自动建表：hibernate.hbm2ddl.auto
    • none：不使用hibernate的自动建表
    • create：如果数据库中已经有表，删除原有表，重新创建，如果没有表，新建表（测试）
    • create-drop：如果数据库中已经有表，删除原有表，执行操作，再删除这个表。如果没有表，新建一个，使用完了删除该表。（测试）
    • update：如果数据库中有表，使用原有表，如果没有表，创建新表（更新表结构）
    • validate：如果没有表，不会创建表。只会使用数据库中原有的表。（校验映射和表结构）。

• 映射文件的引入

  • 引入映射文件的位置

  

Hibernate的核心API

Configuration：Hibernate的配置对象

• 作用：

  • 加载核心配置文件

    • hibernate.properties

      Configuration cfg = new Configuration();

    • hibernate.cfg.xml

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

  • 加载映射文件

      //手动加载映射
      configuration.addResource("com/itheima/hibernate/demo1/Customer.hbm.xml");
    

SessionFactory：Session工厂

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

• 配置连接池

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

• 抽取工具类

    package com.hibernate.utils;
    /*
     * Hibernate的工具类
     */
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    
    public class HibernateUtils {
    	public static final Configuration cfg;
    	public static final SessionFactory sf;
    	
    	static {
    		cfg = new Configuration().configure();
    		sf = cfg.buildSessionFactory();
    	}
    	
    	public static Session openSession() {
    		return sf.openSession();
    	}
    }
  

Session：类似Connection对象是连接对象

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

• Session中的API

  • 保存方法

    • Serializable save（Object obj）

        @Test
        //保存客户
        public void demo1() {
        	Session session = HibernateUtils.openSession();
        	Transaction tx = session.beginTransaction();
        	
        	Customer customer = new Customer();
        	customer.setCust_name("赵六");
        	Serializable id = session.save(customer);
        	System.out.println(id);
        	
        	tx.commit();
        	session.close();
        	
        }
      

  • 查询方法

    • T get(Class c,Serializable id);

    • T load(Class c,Serializable id);

    • get方法和load方法的区别？

        @Test
        //查询
        /*
         * get方法与load方法的区别
         */
        public void demo2() {
        	Session session = HibernateUtils.openSession();
        	Transaction tx = session.beginTransaction();
        	
        	/*
        	 * get方法
        	 * 	*  采用的是立即加载，执行到这行代码的时候，就会马上发送SQL语句去查询
        	 * 	*  查询返回的是真实对象本身
        	 * 	*  查询一个找不到的对象的时候，返回null
        	 * 
        	 * load方法
        	 * 	*  采用的是延迟加载（lazy懒加载），执行到这行代码的时候，怒会发送SQL语句，当真正使用这个对象的时候才会发送SQL语句
        	 * 	*  查询后返回的是代理对象 javassist-3.18.1-GA.jar 利用javassist技术产生的代理
        	 * 	*  查询一个找不到的对象的时候，返回ObjectNotFoundException
        	 */
        	
        	//使用get方法查询
        	
        	 Customer customer = session.get(Customer.class, 1l);
        	 System.out.println(customer);
        	
        	
        	//使用load方法查询
        	/*
        	 * Customer customer = session.load(Customer.class, 2l);
        	 * System.out.println(customer);
        	 */
        	
        	tx.commit();
        	session.close();
        }
      

  • 修改方法

    • void update(Object obj);

        @Test
        //修改操作
        public void demo3() {
        	Session session = HibernateUtils.openSession();
        	Transaction tx = session.beginTransaction();
        	
        	//直接创建对象，进行修改
        	/*
        	 * Customer customer = new Customer(); 
        	 * customer.setCust_id(1l);
        	 * customer.setCust_name("老王"); 
        	 * session.update(customer);
        	 */
        	
        	//先查询，再修改
        	Customer customer = session.get(Customer.class, 1l);
        	customer.setCust_name("哈哈");
        	session.update(customer);
        	
        	tx.commit();
        	session.close();
        }	
      

  • 删除方法

    • void delete(Object obj);

        @Test
        //删除操作
        public void demo4() {
        	Session session = HibernateUtils.openSession();
        	Transaction tx = session.beginTransaction();
        	
        	//直接创建对象，删除
        	/*
        	 * Customer customer = new Customer(); 
        	 * customer.setCust_id(9l);
        	 * session.delete(customer);
        	 */
        	
        	//先查询，再删除 - -级联删除
        	Customer customer = session.get(Customer.class, 8l);
        	session.delete(customer);
        	
        	tx.commit();
        	session.close();
        	
        }
      

  • 保存或更新

    • void saveOrUpdate(Object obj)

        @Test
        //保存或更新
        public void demo5() {
        	Session session = HibernateUtils.openSession();
        	Transaction tx = session.beginTransaction();
        	
        	/*
        	 * Customer customer = new Customer();
        	 * customer.setCust_name("李云龙");
        	 * session.saveOrUpdate(customer);
        	 */
        	
        	Customer customer = new Customer();
        	customer.setCust_id(10l);
        	customer.setCust_name("意大利炮");
        	session.saveOrUpdate(customer);
        	
        	tx.commit();
        	session.close();
        }
      

  • 查询所有

      @Test
      //查询所有
      public void demo6() {
      	Session session = HibernateUtils.openSession();
      	Transaction tx = session.beginTransaction();
      	
      	//接受HQL：Hibernate Query Language 面向对象的查询语言
      	/*
      	 * Query query = session.createQuery("from Customer"); 
      	 * List<Customer> list = query.list();
      	 * for (Customer customer : list) 
      	 * { 
      	 * 		System.out.println(customer);
      	 * }
      	 */
      	
      	//接收SQL
      	SQLQuery query = session.createSQLQuery("select * from cst_customer");
      	List<Object[]> list = query.list();
      	for (Object[] objects : list) {
      		System.out.println(Arrays.toString(objects));
      	}
      	
      	tx.commit();
      	session.close();
      }
    

Transaction：事务对象

Hibernate中管理事务的对象

• commit();
• rollback();

来源：CSDN

作者：sytem_a

链接：https://blog.csdn.net/sytem_a/article/details/104174595