4、创建表（关系型数据库）
create database hibernate3_day01;
use hibernate3_day01;
create table customer(
id int primary key auto_increment,
name varchar(20),
age int
);
5、创建实体类（面向对象）
/**
* 实体类对象
*
* @author WYC
*
*/
public class Customer {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
6、创建ORM的映射
映射文件只要是XML格式文件就可以，名字可以任意。
通常情况下映射文件与实体类在同包下。
名称规范：
实体类名称.hbm.xml
在XML文件中引入约束：
在hibernate3.jar/org.hibernate.hibernate-mapping-3.0.dtd
示例代码：
----------------------------------------------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入hibernate约束 -->
<hibernate-mapping>
<!-- 建立类与表的映射 -->
<!-- class标签：用于映射类和表的关系，name表示类的完整路径，table表示表名 -->
<class name="com.wyc.hibernate3.demo1.Customer" table="Customer">
<!-- 建立类中属性与表中的字段映射关系 -->
<!-- 主键 -->
<!-- 使用id的标签配置唯一属性 -->
<!-- 在<id>标签中配置主键的生成策略 -->
<id name="id" column="id">
<generator class="native"></generator>
</id>
<!-- 普通属性 -->
<!-- property标签：映射类中的普通属性，name表示类中的属性名称，column表示字段名称 -->
<!--
type的三种写法
* Java类型：java.lang.String
* Hibernate类型：string
* SQL类型：不能直接使用type属性，需要使用子标签<column>
> <property name=""><column name="" sql-type="varchar(20)"/></property>
通常使用Hibernate类型。
可以不写type，Hibernate会自动完成类型转换
-->
<property name="name" column="name" type="string" length="20"/>
<property name="age" column="age" />
</class>
</hibernate-mapping>
----------------------------------------------------------------------------------------------------------------------------
7、创建Hibernate的核心配置文件
配置Hibernate连接的数据库等信息。
在src下创建一个配置文件：
hibernate.cfg.xml
在XML文件中引入约束：
Hibernate核心包下：/org/hibernate/hibernate-configuration-3.0.dtd
示例代码：
----------------------------------------------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<hibernate-configuration>
<!-- 相当于连接池，可以提供多个连接 -->
<session-factory>
<!-- Hibernate中必须配置的属性 -->
<!-- 配置数据库连接的基本信息 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate3_day01</property>
<property name="hibernate.connection.username">root</property>
<property name=hibernate.connection.password">Admin123</property>
<!-- Hibernate的方言 -->
<!-- 不同数据库底层生成的SQL语句不同 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 可选属性 -->
<!-- 在控制台打印生成的SQL -->
<property name="hibernate.show_sql">true</property>
<!-- 默认打印在一行，可以格式化SQL -->
<property name="hibernate.format_sql">true</property>
<!-- 设置是否自动提交 -->
<property name="hibernate.connection.autocommit">false</property>
<!-- 通过映射自动创建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 通知Hibernate加载哪些配置文件 -->
<!-- 可以通过拖拽形式自动生成 -->
<mapping resource="com/wyc/hibernate3/demo1/Customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>
----------------------------------------------------------------------------------------------------------------------------
8、编写测试
向数据库中插入一条记录。
session.save(Object obj);
示例代码：
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
/**
* Hibernate入门案例测试
* @author WYC
*
*/
public class HibernateDemo1 {
@Test
public void fun(){
/*
* 1、使用Hibernate框架加载核心配置文件，获取连接信息。
*/
Configuration config = new Configuration().configure();
/*
* 2、创建连接池SessionFactory，可以获得Session（相当于Connection）
*/
SessionFactory factory = config.buildSessionFactory();
/*
* 3、获得Session对象
*/
Session session = factory.openSession();
/*
* 4、默认情况下事务是不会自动提交的
*/
// 开启事务
Transaction tx = session.beginTransaction();
/*
* 5、业务逻辑操作
*/
// 向数据库中插入一条记录
Customer customer = new Customer();
customer.setName("张三");
customer.setAge(20);
session.save(customer);
/*
* 7、提交事务
*/
tx.commit();
/*
* 8、释放资源
*/
session.close();
factory.close();
}
}
9、Java - Hibernate - SQL类型对应关系
——Hibernate的CRUD操作
1、插入数据
session.save(customer);
2、根据主键进行查询：
Customer customer = (Customer)session.get(Customer.class, 1);
Customer customer = (Customer)session.load(Customer.class, 1);
示例代码：
public void fun2(){
/*
* 1、加载Hibernate配置文件
* 2、创建SessionFactory
* 3、通过工厂创建Session对象
* 4、开启事务
* 5、逻辑操作
* 6、提交事务
* 7、释放资源
*/
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
/*
* 根据id进行查询
*/
// get()方法
Customer customer = (Customer)session.get(Customer.class, 1);
// load()方法
// Customer customer = (Customer)session.load(Customer.class, 1);
// System.out.println(customer);
tx.commit();
session.close();
factory.close();
}
get()方法和load()方法的区别：
1）发送SQL的时间不同
* load()方法采用了一个延时加载的技术（懒加载），load()方法在调用时并没有发送SQL语句，而是在使用对象属性时才会发送一条SQL语句。
* get()方法采用的是立即检索，当执行session.get()方法的时候立即发送SQL语句。
* load()更优化
2）返回的对象不同
* load()方法返回的是一个代理对象（javassist包生成），可以通过断点查看。
* get()方法返回的是真实对象本身。
3）当查询数据不存在时
* load()方法会抛出ObjectNotFoundException异常。
* get()方法会返回null，如果调用方法会出现空指针异常。
3、修改操作
session.update(Object obj)
修改有两种方式：
* 手动创建对象修改
* 先查询再修改
// 修改记录
public void fun3(){
/*
* 1、加载核心配置文件
* 2、创建Session工厂
* 3、通过工厂创建Session对象
* 4、开启事务
* 5、逻辑操作
* 6、提交事务
* 7、释放资源
*/
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
/*
* 有两种方式可以进行修改
* * 手动创建对象的方式
* * 先查询再修改的方式
*/
// Customer customer = new Customer();
// customer.setId(2);
// customer.setName("李四");
/*
* 当被修改对象不设置age等属性时，则会采用默认值的形式：0
* 所以在定义属性时不要使用基本数据类型，因为基本数据类型的默认值是0
* 而是使用包装类，因为包装类的默认值是null
*/
// session.update(customer);
/*
* 先查询再修改的方式
*/
Customer customer = (Customer)session.get(Customer.class, 2);
customer.setName("王五");
session.update(customer);
tx.commit();
session.close();
factory.close();
}
4、删除记录
session.delete(Object obj)
删除有两种方式：
* 手动创建对象删除
* 先查询再删除
如果想要进行级联删除，则必须先查询再删除。
// 删除操作
public void fun4(){
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
/*
* 有两种删除方式：
* * 手动创建对象的方式
* * 先查询再删除的方式
*/
// Customer customer = new Customer();
// customer.setId(3);
//
// session.delete(customer);
Customer customer = (Customer)session.get(Customer.class, 6);
session.delete(customer);
tx.commit();
session.close();
factory.close();
}
——查询操作
1、HQL查询
Hibernate Query Language。
Hibernate的查询语言，只能用于面向对象的查询。
// HQL查询操作
public void fun5(){
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
// 查询所有客户
// Customer表示一个类，可以不写表名，因为在配置文件中已经完成了映射
// Query query = session.createQuery("from com.wyc.hibernate3.demo1.Customer");
// List<Customer> list = query.list();
// 根据姓名查询客户
// Query query = session.createQuery("from Customer where name = ?");
// setParameter()方法可以不设置值的类型
// query.setParameter(0, "张三");
// List<Customer> list = query.list();
// 为参数起别名
Query query = session.createQuery("from Customer where name = :name");
query.setParameter("name", "张三");
List<Customer> list = query.list();
for(Customer c : list){
System.out.println(c);
}
tx.commit();
session.close();
factory.close();
}
2、QBC查询
Query By Criteria，条件查询。
示例代码：
public void fun6(){
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
/*
* 使用QBC查询
*/
// Criteria criteria = session.createCriteria(Customer.class);
// List<Customer> list = criteria.list();
/*
* 使用QBC进行条件查询
*/
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("name", "张三"));
List<Customer> list = criteria.list();
for(Customer c : list){
System.out.println(c);
}
tx.commit();
session.close();
factory.close();
}
3、SQL查询
public void fun7(){
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
/*
* 使用SQL进行查询
*/
// 查询所有记录
// SQLQuery query = session.createSQLQuery("select * from customer");
// // 一个数组表示一条记录
// List<Object[]> list = query.list();
//
// for(Object[] o : list){
// System.out.println(Arrays.toString(o));
// }
SQLQuery query = session.createSQLQuery("select * from customer");
// 指定封装对象
query.addEntity(Customer.class);
List<Customer> list = query.list();
for(Customer c : list){
System.out.println(c);
}
tx.commit();
session.close();
factory.close();
}
——Hibernate常用配置
1、核心配置
有两种方式进行配置
1）属性文件的配置
hibernate.properties
格式：
key=value
hibernate.connection.driver_class=com.mysql.jdbc.Driver
注意：在属性配置文件中无法完成加载映射文件，只能通过手动编码的方式进行加载。
2）XML格式文件配置
hibernate.cfg.xml
2、配置属性
1）必须属性：
连接数据库的4个基本参数
* hibernate.connection.driver_class：数据库驱动程序
* hibernate.connection.url：数据库URL
* hibernate.connection.username：数据库用户名
* hibernate.connection.password：数据库密码
Hibernate方言：
* hibernate.dialect：操作数据库方言
2）可选属性：
hibernate.show_sql：true，会在控制台上输出SQL语句
hibernate.format_sql：true，格式化控制台输出的SQL语句
hibernate.connection.autocommit：true，事务是否自动提交
hibernate.hbm2ddl.auto：
* create：每次执行时，都会创建一个新的表（如果这个表已经存在，那么将删除该表然后重新创建），一般用于测试。
* create-drop：每次执行时，都会创建一个新的表，程序执行结束后会将该表删除，一般用于测试，当SessionFactory close()之后才会执行drop操作。
* update：如果数据库中没有表，则会创建一个新的表，如果该表已存在，会直接使用这个表，当指定字段不存在时，会更新表结构，新添加字段的值默认为null
* validate：使用原有的表，并且完成校验，校验映射文件中与表配置的字段是否一致，如果不一致，则会报错。
3）映射文件配置
* 在核心配置文件中配置映射文件：
<mapping resource="com/wyc/hibernate3/demo1/Customer.hbm.xml" />
* 需要使用手动编码的方式加载
2、映射文件的配置
主要配置的是ORM，对象和关系表的映射。
1）配置类与表的映射
<class name="com.wyc.hibernate3.demo1.Customer" table="Customer"></class>
* name：类的完整路径
* table：表名（可以省略，默认使用类名，不区分大小写，但是类名不能与数据库关键字冲突）
2）配置普通属性与字段的映射
* <property name="name" column="name" type="string" length="20" />
* 如果不写length，默认255。
* type的三个值：
> Java类型：java.lang.String
> Hibernate类型：string
> SQL类型：不能直接使用type属性，需要使用子标签<column>
<column name="name" sql-type="varchar(20)" />
3）配置唯一标识与主键映射
* 一个表中只有一个主键
<id name="类中属性名" column="表中字段名" />
> 生成策略
* 复合主键
必须实现序列化接口
<composite-id> </composite-id>
4）关联关系
5）命名SQL
使用的是HQL：
<query name="findAll">
from Customer
</query>
使用SQL：
<sql-query name="sqlFindAll">
select * from Customer
</sql-query>
——Hibernate核心API
1、Configuration
1）负责管理Hibernate的配置信息，包括如下内容：
* 加载hibernate.properties和hibernate.cfg.xml
* 持久化类与数据表的映射关系（*.hbm.xml）
2）创建Configuration的两种方式：
* 属性文件（hibernate.properties）
Configuration config = new Configration(); // 手动加载hbm
* XML文件（hibernate.cfg.xml）
ConfigURation config = new Configration().configure();
configure()方法源代码：configure("/hibernate.cfg.xml");
可以手动指定要加载的XML文件：configure(XML文件名称);
3）加载映射文件
* 第一种写法：
configuration.addResource("com/wyc/hibernate3/demo1/Customer.hbm.xml");
* 第二种写法（要求：映射文件名称要规范，类与映射文件要在同一个包下）
configuration.addClass(Customer.class);
通常会将映射文件配置在核心配置文件中，如果要使用properties配置文件，则必须使用这种方法。
2、SessionFactory工厂类
Configuration对象根据当前的配置信息生成SessionFactory对象。
SessionFactory对象中保存了当前数据库配置信息和所有映射关系以及预定义的SQL语句。
SessionFactory对象是线程安全的。
SessionFactory还负责维护Hibernate的二级缓存（Session是一级缓存）。
SessionFactory对象根据数据库信息，维护连接池，创建Session（相当于Connection）对象。
构造SessionFactory很耗费资源，一般情况下一个应用只初始化一个SessionFactory对象。
练习：抽取一个HibernateUtils工具类来提供Session对象。
示例代码：
/**
* Hibernate工具类
* @author WYC
*
*/
public class HibernateUtils {
private static Configuration config;
private static SessionFactory factory;
static {
config = new Configuration().configure();
factory = config.buildSessionFactory();
}
public static Session openSession(){
return factory.openSession();
}
}
当openSession()方法调用时，就会通过实体类来创建映射的表，前提是在核心配置文件中进行了配置。
3、Session接口
1）相当于JDBC的Connection
2）Session是应用程序与数据库之间交互操作的一个单线程对象，是Hibernate的运作中心。
3）Session是线程不安全的。
4）所有持久化对象必须在Session的管理下才可以进行持久化操作。
5）Session对象有一个一级缓存，显示执行flush之前，所有的持久化操作的数据都换存在Session对象中。
6）持久化类与Session关联起来后就具有了持久化的能力。
7）常用方法：
* save()、persist()：增加
> persist()方法是JPA提供的方法
* update()：修改对象
* saveOrUpdate()：添加或修改对象
> 当对象存在时执行修改操作，对象不存在时执行添加操作
* delete()：删除对象
* get()、load()：根据主键查询对象。
* createQuery()：创建一个Query接口，编写HQL语句
* createSQLQuery()：创建一个SQLQuery接口，编写SQL语句
* createCriteria()：条件查询，会返回一个Criteria接口。
4、Transaction接口
1）代表数据库操作的事务对象
Transaction transaction = session.beginTransaction();
2）提供事务管理的方法
* commit()：提交相关联的Session实例
* rollback()：撤销事务操作
* wasCommitted()：检察事务是否提交
如果没有开启事务，那么每个Session的操作都相当于一个独立的事务。
5、Query接口
1）Query代表面向对象的一个Hibernate查询操作。
2）session.createQuery()接收的是一个HQL语句。
3）HQL是Hibernate Query Language的缩写，语法很像SQL语法，但是完全面向对象的。
4）使用Query对象步骤：
* 获得Hibernate Session对象
* 编写HQL语句
* 调用session.createQuery()方法创建查询对象
* 如果HQL语句包含查询条件参数，则调用Query对象的setXxx()方法设置参数
* 调用Query对象的list()方法，或uniqueResult()方法执行查询
5）Query还包含两个方法，用于控制返回结果
* setFirstResult(int firstResult)：设置返回结果从第几条开始
* setMaxResults(int maxResults)：设置本次返回结果记录数
* 可以使用这两个方法进行分页查询。
HQL入门举例：
* 以from开头的HQL语句：
调用list()方法返回List<Customer>，from Customer表示查询Customer表的所有数据。
* 使用Select关键字：（查询部分对象属性）
> select name from Customer，返回List<String>
> select name, age from Customer，返回List<Object[]>
> select c.name from Customer as c，为Customer实例起别名
* 使用Where添加条件：
> from Customer as c where c.age > :age：其中:age是参数
> from Customer as c where c.age > ?：其中?是参数
6、Criteria接口
1）Criteria接口是Hibernate提供的用于条件查询接口
2）Criteria criteria = session.createCriteria(Customer.class);
3）使用Criteria对象步骤：
* 获得Hibernate的Session对象
* 通过Session获得Criteria对象
* 使用Restrictions的静态方法创建Criteria条件对象
* 向Criteria对象中添加Criteria查询条件
* 执行Criteria的list()或uniqueResult()获得结果
——在Hibernate中使用C3P0连接池
1、导入C3P0的jar包
2、在核心配置文件中添加一段配置：
<!-- C3P0连接池设定-->
<!-- 使用c3po连接池 配置连接池提供的供应商-->
<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>
——Hibernate持久化对象的配置和操作
1、Hibernate采用普通、传统的Java对象（POJO类），作为持久化类，与数据表进行映射。
2、编写规则：
* 提供一个public的无参构造方法。
* 提供一个标识属性，映射数据表主键字段。
* 所有属性提供public访问控制符的set()/get()方法。
* 标识属性应尽量使用基本数据类型的包装类。
* 不要用final修饰（不能被继承，无法生成代理对象进行优化）
当无法生成代理对象时，load()方法不会延时加载，会即时打印SQL语句。
3、持久化对象的唯一标识：OID
* Java根据地址区分同一个类的不同对象。
* 关系数据库根据主键区分是否同一条记录
* Hibernate使用OID来建立内存中的对象和数据库记录的对应关系。
* 对象的OID和数据库的表的主键对应，为保证OID的唯一性，应该让Hibernate来为OID赋值。
4、自然主键和代理主键
1）自然主键
创建一个用户表，用户表中某条记录想要被唯一确定，可以使用身份证号作为主键，身份证号本身就是一个用户的属性，这就叫自然主键。
2）代理主键
创建一个用户表，用户表中某条记录想要被唯一确定，但没有使用身份证号作为主键，使用一个与用户的任何信息都不相关，只具备标识的作用，这就是代理主键。
尽量使用代理主键。
5、尽量让Hibernate自己维护主键
涉及到主键的生成策略。
——主键的生成策略
1、increment
自动增长，适用于数值类型，而不能使用字符串。
不是使用数据库的自动增长机制，而是使用Hibernate框架提供的自动增长方式。
* 首先会检查主键的最大值：select max(id) from table
* 然后在最大值的基础上+1
容易出现多线程的问题，不能在集群下使用。
2、identity
自动增长，适用于数值类型，而不能使用字符串。
采用数据库的自动增长的机制。
不适用于Oracle数据库，因为Oracle数据库没有自动增长。
3、sequence
序列，适用于数值类型，而不能使用字符串。
可以应用在Oracle中，MySQL中不能使用。
4、uuid
使用与字符串类型的主键。
使用随机字符串作为主键。
5、native
本地策略。
根据底层数据库自动选择使用identity还是sequence。
6、assigned
Hihernate框架不维护主键，由程序自动生成。
7、foreign
主键来自外表主键。
应用在一对一的关系表中。
——练习
1、搭建Hibernate环境
> 核心配置文件
> 映射文件
2、抽取Hibernate工具类
3、CRUD操作
——总结
1、Hibernate框架概述
* 是一个持久层的ORM框架
* ORM：Object Relational Mapping
> 对象关系映射，将Java中实体对象与关系型数据库中的表建立一种关系，Hibernate中可以通过操作对象的方式，从而操作数据库中的表。
* 常见持久层框架
> Hibernate
> MyBatis
> JPA
2、Hibernate入门
1）下载Hibernate开发包
2）Hibernate开发包目录结构
* 文档
* 开发包
> 操作字节码
> 必须包
> 可选包
> JPA
3）创建一个Java项目，导入相应jar包
4）创建数据库表
5）创建一个实体类
6）映射配置文件
7）核心配置文件
8）测试程序
3、Hibernate的CRUD
1）save()
2）update()
3）delete()
4）get() / load()
* 区别：
> get：采用立即检索，马上发送SQL语句。返回的是真实对象。当检索不到数据时会抛出NullPointerException
> load：采用延迟加载的技术，当真正使用对象的时候，才会发送SQL语句。返回的是代理对象。抛出ObjectNotFoundException
4、Hibernate的配置
* 核心配置
> 属性文件(properties)
在src下创建一个hibernate.properties文件
必须手动加载
> XML文件
在src下创建一个hibernate.cfg.xml文件
必须的配置：
数据库连接信息
Hibernate方言
可选配置：
显示SQL
格式化SQL
hbm2ddl.auto
create/create-drop/update/validate
映射文件：
<mapping resource="" />
* 映射配置
> <class>建立类与表的映射
name：类的全路径
table：表名称
> id
> property
name
column
type
length
5、Hibernate核心API
* Configuration
> 属性文件：
直接创建
> XML文件
new Configuration().configure();
* SessionFactory
> 维护二级缓存，线程安全的对象
> 抽取工具类
* Session
> 维护一级缓存，线程不安全的对象
* Transaction
> 控制事务
> 在Hibernate中默认事务不自动提交，每个Session都是一个独立的事务
* Query
* Criteria
6、Hibernate的持久化类的编写
* 无参构造
* 属性提供set() / get()方法
* 属性尽量使用包装类
* 类不要使用final
* 提供唯一标识OID
7、自然主键和代理主键
8、Hibernate主键的生成策略
* increment：线程不安全，不能用于集群
* identity：使用数据库自动增长机制
* sequence：支持序列的数据库，比如Oracle
* uuid
* native：本地策略，根据本地数据库自动选择主键生成策略
