Hibernate框架的入门
一、Hibernate的简介
1.什么是HIbernate框架？
Hibernate是一种ORM框架，全称为 Object Relative Mapping，是一个高性能的对象关系型持久化存储和查询的服务，不仅关注于从 Java 类到数据库表的映射，也有 Java 数据类型到 SQL 数据类型的映射，另外也提供了数据查询和检索服务。
2.什么是框架?
指的是软件的半成品，已经完成了部分功能。
3 .为什么要学习Hibernate框架？
- Hibernate对JDBC访问数据库的代码做了
轻量级的封装，大大的简化了数据访问层繁琐的重复性代码，并且减少了内存消耗，加快了运行效率 - Hibernate是一个
基于JDBC的主流持久层框架，是一个优秀的ORM实现，它很大程度的简化了DAO（Data Access Object，数据访问对象）层编码工作。 - Hibernate的
性能非常好，映射的灵活性很出色，它支持很多关系型数据库，从一对一到多对多的各种复杂关系。 可扩展性强，由于源代码的开放以及API的开放，当本身功能不够用时，可以自行编码进行扩展。
4 . hibernate的优势
- hibernate使用XML文件来处理映射Java类到数据库表格中，不用编写任何代码。
- 在数据库中直接存储和检索Java对象提供简单的API
- 如果数据库中或者其他任何表格出现变化，那么仅需要改变XML文件属性。
- 抽象不熟悉的SQL类型，并为我们提供工作中所熟悉的java对象。
5.相关概念
-
持久化：将我们想要保存的数据保存到硬盘上，也就是我们电脑的磁盘上，为什么叫持久化呢，就是数据能够保存的很久，所以叫持久化，现在对持久化的实现过程大多通过各种关系型数据库完成，所以我们常说的，将数据保存到数据库中，其实是数据库帮我们帮数据保存到硬盘中了。 -
持久层：把数据库看成是内存的一部分，我们就当做将数据保存到数据库中，就像保存到了硬盘中一样，所以在操作数据库的或者跟数据库打交道的那一层就是就持久层。 -
ORM：Object Relational Mapping，对象关系映射，这个是一个思想，模型，或者说是规范。关系数据库中的记录映射成为程序语言中的对象实例，然后通过操作对象，来达到操作数据库的这样一种思想。如果没有ORM思想，我们之前就是直接操作数据库中的记录字段，来达到存储数据的目的。 -
持久化类：持久化类就是可以将类保存到数据库中，并还可以从数据库中拿到该类，这就叫持久化类。 -
持久化对象：持久化类的实例对象，能保存到数据库中，也能从数据库中取出来。
二、hibernate的入门
1.下载Hibernate的开发环境
http://www.hibernate.org/downloads
2.解压目录介绍
- documentation–>hibernate开发的文档
- lib
required–>开发的必须依赖包
optional–>开发的可选的jar包 - project–> 提供的项目包
3.安装环境
- 创建一个Java项目，导入jar包
数据库驱动包- hibernate开发的必须jar包
- hibernate的日志记录包
4.创建数据库表
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;
5.创建实体类
package com.hibernate.demo1;
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;
public Long getCust_id() {
return cust_id;
}
public void setCust_id(Long cust_id) {
this.cust_id = cust_id;
}
public String getCust_name() {
return cust_name;
}
public void setCust_name(String cust_name) {
this.cust_name = cust_name;
}
public String getCust_source() {
return cust_source;
}
public void setCust_source(String cust_source) {
this.cust_source = cust_source;
}
public String getCust_industry() {
return cust_industry;
}
public void setCust_industry(String cust_industry) {
this.cust_industry = cust_industry;
}
public String getCust_level() {
return cust_level;
}
public void setCust_level(String cust_level) {
this.cust_level = cust_level;
}
public String getCust_phone() {
return cust_phone;
}
public void setCust_phone(String cust_phone) {
this.cust_phone = cust_phone;
}
public String getCust_mobile() {
return cust_mobile;
}
public void setCust_mobile(String cust_mobile) {
this.cust_mobile = cust_mobile;
}
}
6.创建映射
映射需要通过XML的配置文件来完成，这个配置文件可以任意命名，但尽量统一命名规范(类名.hbm.xml)
<hibernate-mapping>
<class name="com.hibernate.demo1.Customer" table="cst_customer">
<id name="cust_id" column="cust_id">
<generator class="native">generator>
id>
<property name="cust_name" column="cust_name" length="32" />
<property name="cust_source" column="cust_source" length="32" />
<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" />
class>
hibernate-mapping>
7.创建一个hibernate的核心配置文件–>hibernate.cfg.xml
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate01property>
<property name="hibernate.connection.username">rootproperty>
<property name="hibernate.connection.password">123property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty>
<property name="hibernate.show_sql">trueproperty>
<property name="hibernate.format_sql">trueproperty>
<mapping resource="com/hibernate/demo1/Customer.hbm.xml">mapping>
session-factory>
hibernate-configuration>
8.编写测试代码
package com.hibernate.demo1;
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();
//2.创建一个SessionFactory对象，类似于JDBC中的连接池
SessionFactory sessionFactory = configuration.buildSessionFactory();
//3.通过SessionFactory获取到Session对象，类似于JDBC中的Connection
Session session = sessionFactory.openSession();
//4.手动开启事务
Transaction transaction = session.beginTransaction();
//5.编写代码
Customer customer = new Customer();
customer.setCust_name("里斯本");
session.save(customer);
//6.事务提交
transaction.commit();
//7. 资源释放
session.close();
}
}
9.映射文件配置信息
-
class标签的配置- class标签用来建立类与表的映射关系
- 属性：
name: 类的全路径
table: 表名（类名与表名一致，table可以省略）
catalog: 数据库名 -
id标签的配置- 标签用来建立类中的属性与表中的主键的对应关系
- 属性：
name: 类中的属性名
column: 表中的字段名（类中的属性名和表中的字段名如果一致可省略）
length: 长度
type: 类型 -
generator标签用来自动生成主键值1、
increment：主键自动增长、由hibernate来管理
注意：如果数据库也设置了自动增长，就会发生主键冲突问题
2、identity：由底层数据库来管理生成，不由hibernate管理,也就是说底层数据库怎么设置的主键就怎么来
注意：mysql、sql server可以，oracle不可以
3、sequence：标识符生成器，就是底层数据库来管理生成，利用底层数据库提供的序列来生成标识符，不由hibernate管理
注意：mysql不支持序列 oracle支持
4、native：由底层数据库自己来决定使用什么策略，hibernate不管
注意：mysql自动选择identity、oracle自动选择sequence
5、uuid：随机生成32位不相同的字符串。 -
property标签的配置- 此标签用来建立类中的普通属性与表的字段的对应关系
- 属性：
name: 类中的属性名
column :表中的字段名
length: 长度
type :类型
not-null :设置非空
unique :设置唯一
10.hibernate的核心配置
-
配置方式有两种
第一种文件名：hibernate.properties
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql:///hibernate
hibernate.connection.username=root
hibernate.connection.password=123
属性配置文件不能引入映射文件，需要手动引入。第二种文件名：XML文件的方式
文件名：hibernate.cfg.xml -
必须的配置- 连接数据库的基本参数
驱动类 ：com.mysql.jdbc.Driver
url路径
用户名
密码
数据库的方言 -
可选的配置选项
>显示SQL ： hibernate.show_sql
>格式化 ：hibernate.format_sql
> 自动建表 ： hibernate.hbm2ddl.auto
>none : 不使用hibernate的自动建表
>create : 如果数据库中已经有表，删除原有的表，重新创建，如果没有，则新建表（用于测试）
>create-drop : 如果数据库已经有表，删除原有的表，执行操作，删除这个表，如果没有，则新建表，使用完毕后删除该表（用于测试）
>update : 如果数据库中有表，使用原有表，如果没有则创建（更新表结构）
>validate : 如果没有表，不会创建表，只有使用数据库原有的表（校验映射和表结构）。
* 映射文件的映入
> 引入映射文件的位置(路径换成斜杠)
\11.hibernate的核心API详解
-
configurationConfiguration 类的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时所遇到的第一个对象。
-
加载核心配置文件
1.如果是hibernate.properties文件
Configuration cfg =new Configuration();
2.如果是hibernate.cfg.xml文件
Configuration cfg =new Configuration().configure();
加载映射文件
手动加载
configuration.addResource(“hibernate01/demo1/hibernate.hbm.xml”);
SessionFactory
该接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
它是线程安全的，同一个实例可以被应用中的多个线程共享。
内部维护连接池，配置C3P0，自定义工具类。
Session接口
1.从
SessionFactory中可以获得Session实例。
2.Session接口是Hibernate应用中使用最广泛的接口，它是持久化管理器，提供添加、更新、删除、加载、查询对象。
常用方法：
save(Object obj)
get()/load()
update()
delete()
saveOrUpdate()
3.Session不是线程安全的，所以应避免多个线程共享同一个Session实例。
4.Session是轻量级对象，它的创建和销毁不需要太多资源，这意味着在应用中可以经常创建和销毁Session对象。
5.Session有一个缓存，称之为Hibernate的一级缓存，它存放当前工作单元加载的持久化对象，每个Session都有自己的缓存，缓存中的对象只能被当前工作单元访问。
Transaction接口
Transaction是Hibernate的数据库事务接口，它对底层事务接口进行了封装。
开启事务：
Transaction tx = session.beginTransaction();
事务提交和回滚方法：
tx.commit();
tx.rollback();
事务四个特性：原子性、一致性、隔离性、持久性
11. Query和Criteria接口
这两个是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。
Query实例包装了一个HQL(Hibernate Query Language)来查询。Criteria接口完全封装了基于字符串形式的查询语句，比Query更面向对象，Criteria更擅长执行动态查询。
- hibernate中抽取工具类
package hibernate.utils;
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();
}
}
- 配置C3P0
<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProviderproperty>
<property name="c3p0.min_size">5property>
<property name="c3p0.max_size">20property>
<property name="c3p0.timeout">120property>
<property name="c3p0.idle_test_period">3000property>
- 代码块
package com.hibernate.demo1;
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import hibernate.utils.HibernateUtils;
public class HibernateDemo2 {
@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();
}
@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方法查询 // 发送SQL语句
Customer customer = session.get(Customer.class, 100l);
System.out.println(customer);
// 使用load方法查询
Customer customer = session.load(Customer.class, 200l);
System.out.println(customer);
tx.commit();
session.close();
}
@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();
}
@Test
// 删除操作
public void demo4(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
// 直接创建对象，删除
Customer customer = new Customer();
customer.setCust_id(1l);
session.delete(customer);
// 先查询再删除(推荐)--级联删除
Customer customer = session.get(Customer.class, 2l);
session.delete(customer);
tx.commit();
session.close();
}
@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(3l);
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();
}
}