1.Hibernate中的实体规则
(1)实体类创建的注意事项
- 持久化类需要提供无参的构造方法(因为在Hibernate底层需要使用反射生成类的实例)
- 属性私有,并提供get、set方法
- 持久化类中的属性,应尽量使用包装类型(补充:八大基本类型都有对应的包装类型。实体类尽量使用包装类型;包装类型比基本类型的好处:可以表示null;装箱就是自动将基本数据类型转换为包装类型;拆箱就是自动将包装类型转换为基本数据类型)
- 持久化类需要提供oid.与数据库中的主键列对应
- 不要用final修饰实体的class(hibernate使用cglib代理生成代理对象.代理对象是继承被代理对象.如果被final修饰.将无法生成代理.)
(2)主键类型
(2.1)自然主键(少见)
表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用.(例如身份证号)
(2.2)代理主键(常见)
表的业务列中,没有某业务列符合,必须有,并且不重复的特征时,创建一个没有业务意义的列作为主键
(3)主键生成策略
(3.1)代理主键生成策略
sequence、identity、increment(了解)、hilo(了解)、native、uuid
(3.2)自然主键生成策略
assigned
详细介绍:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itheima.domain" >
<class name="Customer" table="cst_customer" >
<id name="cust_id" >
<!-- generator:主键生成策略.就是每条记录录入时,主键的生成规则.(7个)
identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.
sequence: Oracle中的主键生成策略.
increment(了解): 主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值.
hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时不使用.
native:hilo+sequence+identity 自动三选一策略.
uuid: 产生随机字符串作为主键. 主键类型必须为string 类型.
assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.
-->
<generator class="increment"></generator>
</id>
<property name="cust_name" column="cust_name" ></property>
<property name="cust_source" column="cust_source" ></property>
<property name="cust_industry" column="cust_industry" ></property>
<property name="cust_level" column="cust_level" ></property>
<property name="cust_linkman" column="cust_linkman" ></property>
<property name="cust_phone" column="cust_phone" ></property>
<property name="cust_mobile" column="cust_mobile" ></property>
</class>
</hibernate-mapping>
2.Hibernate中的对象状态
Hibernate中对象分为三种状态:瞬时状态(没有id,没有在session缓存中)、持久化状态(有id,在session缓存中)、游离/托管状态(有id,没在session缓存中)
三种状态的转换图:(save、updat、get方法真正目的是把对象持久化,持久化的对象会在事务提交时自动同步到数据库。delete是把对象的持久化状态转为瞬时状态)
代码示例:
package cn.itheima.b_state;
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;
import cn.itheima.utils.HibernateUtils;
//测试对象的三种状态
public class Demo {
@Test
//查看三种状态
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer(); // 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想"); // 瞬时状态
session.save(c); // 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
//save方法: 其实不能理解成保存.理解成将瞬时状态转换成持久状态的方法
//主键自增 : 执行save方法时,为了将对象转换为持久化状态.必须生成id值.所以需要执行insert语句生成.
//increment: 执行save方法,为了生成id.会执行查询id最大值的sql语句.
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = new Customer(); // 没有id, 没有与session关联 => 瞬时状态
c.setCust_name("联想"); // 瞬时状态
session.save(c); // 持久化状态, 有id,有关联
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//三种状态特点
// 持久化状态特点: 持久化状态对象的任何变化都会自动同步到数据库中.
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c = session.get(Customer.class, 1l);//持久化状态对象
c.setCust_name("微软公司");//不调用session.save()就已经保存了。
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
3.Hibernate进阶:一级缓存:提高查询效率,减少语句发送
缓存:介于程序和永久性数据存储源之间,目的是提高效率。hibernate中的一级缓存也是为了提高操作数据库的效率.(在事务提交之前进行检查,事务提交之后才确定要不要访问数据库)
(1)提高效率手段1:提高查询效率(session缓存)
原理图和代码:
package cn.itheima.c_cache;
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;
import cn.itheima.utils.HibernateUtils;
//测试一级缓存
public class Demo {
@Test
//证明一级缓存存在
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = session.get(Customer.class, 1l);
Customer c2 = session.get(Customer.class, 1l);
Customer c3 = session.get(Customer.class, 1l);
Customer c4 = session.get(Customer.class, 1l);
Customer c5 = session.get(Customer.class, 1l);
//获得的都是同一个对象(第一次获得是从数据库查询的,然后放到session缓存中,第二次开始都是优先从session缓存中获取的)
System.out.println(c3==c5);//true
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
(2)提高效率手段2:减少不必要的修改语句发送(一级缓存的内部结构:快照,快照的作用是确保一级缓存中的数据和数据库中的数据一致)
原理图和代码:
package cn.itheima.c_cache;
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;
import cn.itheima.utils.HibernateUtils;
//测试一级缓存和快照
public class Demo {
@Test
//快照
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = session.get(Customer.class, 1l);
//数据库中的数据是传智播客,此处只执行一个select语句,不执行update语句。
//因为在事务提交之前,程序取对象的时候先从缓存中找。找到了就直接返回,没找到再去数据库,从数据库中返回的内容组装成了两个对象,一个放入缓存,一个放入快照。
//事务提交之前,程序修改对象的时候,Hibernate会将这个修改过的缓存中的对象与快照里修改前的对象比较,如果有变化会同步到数据库,没有变化就不修改数据库里的对象。以此减少修改语句
c1.setCust_name("哈哈");
c1.setCust_name("传智播客");
//如果去掉c1.setCust_name("传智播客");,会执行select语句和update语句。
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//持久化状态对象其实就是放入session缓存中的对象
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
Customer c1 = new Customer();
c1.setCust_id(1l);//托管|游离
session.update(c1);//c1被放入session缓存了
Customer c2 = session.get(Customer.class, 1l);//拿的是缓存中的,不是查询数据库获得的
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
4.Hibernate中的事务
(1)事务复习
事务特性:A(原子性)C(一致性)I(隔离性)D(持久性)
事务并发问题:1.脏读、2.不可重复读、3.幻读/虚读
事务的隔离级别:读未提交(哪个都不能解决),读已提交(解决1),可重复读(解决12,mysql默认),串行化(解决123)
(2)在Hibernate中指定事务的隔离级别(在主配置中配置)(properties里面有例子)
<!-- 指定hibernate操作数据库时的隔离级别
#hibernate.connection.isolation 1|2|4|8
0001 1 读未提交
0010 2 读已提交
0100 4 可重复读
1000 8 串行化
-->
<property name="hibernate.connection.isolation">4</property>
(3)在Hibernate项目中管理事务
业务开始之前打开事务,业务执行之后提交事务. 执行过程中出现异常.回滚事务.
在dao层操作数据库需要用到session对象.在service控制事务也是使用session对象完成. 我们要确保dao层和service层使用的使用同一个session对象。
在hibernate中,确保使用同一个session的问题,hibernate已经帮我们解决了. 开发人员只需要调用sf.getCurrentSession()方法即可获得与当前线程绑定的session对象。
注意1: 调用getCurrentSession方法必须配合主配置中的一段配置
<!-- 指定session与当前线程绑定 -->
<property name="hibernate.current_session_context_class">thread</property>
注意2:通过getCurrentSession方法获得的session对象.当事务提交时,session会自动关闭.不要手动调用close关闭.
对昨天的CRM项目优化 事务管理,部分代码:
public class CustomerDao {
//dao层
public void save(Customer customer) {
//把事务控制放在service层
Session session = HibernateUtils.getCurrentSession();//获得当前线程绑定的session
session.save(customer);
}
}
public class CustomerService {
//service层
public void save(Customer customer) {
CustomerDao dao=new CustomerDao();
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();//开启事务
dao.save(customer);
tx.commit();//Hibernate中,事务提交,session会自动关闭,不能手动关闭
}
}
5.Hibernate中的批量查询
(1)HQL查询-hibernate Query Language(适用于多表查询,但不复杂时使用)
Hibernate独家查询语言,属于面向对象的语句查询语言
基本查询,条件查询,问号占位符,命名占位符,分页查询
(uniqueResult()用于返回一条记录,list用于返回多条记录)
package cn.itheima.e_hql;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试HQL语句
public class Demo {
@Test
//基本查询
public void fun1(){
//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();//接收唯一的查询结果
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = 1 "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//条件查询
//问号占位符
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//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();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//条件查询
//命名占位符
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer where cust_id = :cust_id "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数
query.setParameter("cust_id", 1l);
//3> 根据查询对象获得查询结果
Customer c = (Customer) query.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//分页查询
public void fun5(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1> 书写HQL语句
String hql = " from Customer "; // 查询所有Customer对象
//2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置分页信息 limit ?,?
query.setFirstResult(1);//索引从0开始(mysql语句是从1开始)
query.setMaxResults(1);//查询条数
//3> 根据查询对象获得查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
(2)Criteria查询(适用于单表条件查询)
Hibernate自创的无语句面向对象查询。面向对象的无语句查询
基本查询,条件查询,分页查询
package cn.itheima.f_criteria;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试Criteria查询
public class Demo {
@Test
//基本查询
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//查询所有的Customer对象
Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
System.out.println(list);
// Customer c = (Customer) criteria.uniqueResult();
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//条件查询
//HQL语句中,不可能出现任何数据库相关的信息的
// > gt
// >= ge
// < lt
// <= le
// == eq
// != ne
// in in
// between and between
// like like
// is not null isNotNull
// is null isNull
// or or
// and and
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//添加查询参数 => 查询cust_id为1的Customer对象
criteria.add(Restrictions.eq("cust_id", 1l));// == eq
//执行查询获得结果
Customer c = (Customer) criteria.uniqueResult();
System.out.println(c);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//分页查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置分页信息 limit ?,?
criteria.setFirstResult(1);
criteria.setMaxResults(2);
//执行查询
List<Customer> list = criteria.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//查询总记录数
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//创建criteria查询对象
Criteria criteria = session.createCriteria(Customer.class);
//设置查询的聚合函数 => 总行数
criteria.setProjection(Projections.rowCount());
//执行查询
Long count = (Long) criteria.uniqueResult();
System.out.println(count);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
}
(3)原生sql查询(适用于复杂业务的查询)
package cn.itheima.g_sql;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
import cn.itheima.domain.Customer;
import cn.itheima.utils.HibernateUtils;
//测试原生SQL查询
public class Demo {
@Test
//基本查询
public void fun1(){
//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<Object[]> list = query.list();
//query.uniqueResult();
for(Object[] objs : list){
System.out.println(Arrays.toString(objs));
}
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//基本查询
public void fun2(){
//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);
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//条件查询
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer where cust_id = ? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 1l);//Hibernate中所有占位符索引从0开始,mysql是从1开始
//指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
//3 调用方法查询结果
List<Customer> list = query.list();
System.out.println(list);
//-------------------------------------------
//4提交事务.关闭资源
tx.commit();
session.close();// 游离|托管 状态, 有id , 没有关联
}
@Test
//分页查询
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 控制事务
Transaction tx = session.beginTransaction();
//3执行操作
//-------------------------------------------
//1 书写sql语句
String sql = "select * from cst_customer limit ?,? ";
//2 创建sql查询对象
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 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 , 没有关联
}
}