hibernate day02
本节内容
1.实体类的编写规则
2. hibernate主键生成策略
3 实体类操作
4 hibernate的一级缓存
5 hibernate的事务操作
6 hibernate其他的api（查询）
一、实体类编写规则
持久化类：hibernate是一个持久层的ORM映射框架，专注于数据的持久化工作。所谓的持久化，就是将内存中的数据永久性的存储到关系型数据库中。那么什么是持久化类：持久化类指的是一个java类与数据库表建立了映射关系，那么这个类称为持久化类。
持久化类的编写规则：
1.持久化类需要提供无参数的构造方法。因为hibernate底层需要使用反射生成类的实例
2.持久类中的属性需要私有化，对私有属性提供get与set方法。因为在hibernate底层会将查询到的数据进行封装
3.持久化类的属性尽量使用包装类的类型。因为基本类型和包装类型的默认值不同，包装类的类型语义更清晰而基本数据类型不容易描述。
4.持久化类要有一个唯一标识OID与表的主键对应
5.持久化类尽量不要使用final修饰.
二、hibernate主键生成策略
主键：
自然主键：把具有业务含义的字段设置为主键，称为自然主键：比如用户信息表中有一个用户姓名，使用姓名作为主键。
代理主键：把不具备业务含义的字段作为主键，称为代理主键，例如id，通常为整数类型。
hibernate要求实体类里面有一个属性作为唯一值，对应表主键，主键可以不同生成策略
hibernate提供了几个内置的主键生成策略
三、实体类操作
对实体类进行CRUD操作
添加操作：
使用session中的save方法：
// 添加操作 Shop shop = new Shop (); shop.setS_name ("面条"); shop.setS_describe ("意大利面"); shop.setS_stock (123); shop.setS_price (10.0); session.save (shop);
根据id查询：
// 第一个参数：实体类的class 第二个参数：id值 Shop shop1 = session.get (Shop.class,1);
修改操作：
1.首先根据id查询，然后修改
// 修改操作 // 第一个参数：实体类的class 第二个参数：id值 Shop shop1 = session.get (Shop.class,1); // 修改查询到的数据 shop1.setS_name ("披萨"); // 进行修改：到shop1对象中找到id根据id进行修改 session.update (shop1);
删除操作;
先查询后删除：
// 删除操作 Shop shop2 = session.get (Shop.class,1); session.delete (shop2);
实体类对象状态：
hibernate为了更好的来管理持久化类，特将持久化类分为了三中状态：瞬时态、持久态、脱管态。
1.瞬时态：
瞬时态称为：临时态或者自由态，瞬时态的实例是由new命令创建的，开辟内存空间的对象，不存在主键值，没有与hibernate Session关联，在数据库也没有记录，与数据库没有关系。
2.持久态
持久态的对象存在id主键值，并且相关联的session没有关闭，在数据库中有对应的记录，没条记录只对应唯一的持久化对象，持久态对象是在事务没有提交之前变成的持久态。
3.脱管态
托管态也称为离线态或者游离态，当某个持久化状态的实例与session的关联被关闭时，就变成了托管态，托管态的对象存在id主键值，并与数据库的数据存在关联，但是没有了session关联。发生改变hibernate不能检测。
四、Hibernate的一级缓存
1.什么是缓存
缓存是计算机领域非常通用的一个概念。它介于应用程序与永久性数据存储源（如磁盘文件或者数据库）之间，其作用就是降低应用程序直接读写永久性数据存储源的频率，从而提高应用的运行性能。缓存中的数据是从数据源存储中数据拷贝。缓存的物理介质通常是内存。
hibernate的缓存分为一级缓存和二级缓存，hibernate的这两级缓存都位于持久化层，存储的都是数据库的备份。其中一级缓存为Hibernate的内置缓存，不能被卸载。
2.什么是hibernate的一级缓存
hibernate的一级缓存就是指Session缓存，Session缓存就是一块内存空间，用来存放相互管理的Java对象，在使用hibernate查询对象的时候，会首先使用对象属性的OID 值在，hibernate的一级缓存中进行查找，如果找到匹配的IOD值对象，就直接将该对象返回，不会再查询数据库，如果没有找到相同的OID值的对象，则会去数据库查询，当从数据库中查到后，将该数据信息保存到一级缓存中。hibernate的一级缓存的作用高就是为了减少对数据库的访问次数。
hibernate一级缓存的特点：
当应用程序调用Session接口中的save、update、saveOrUpdae时，如果缓存中没有相应的对象，Hibernate就会 自动把数据库查询的相应的对象保存到一级缓存中。
当调用Session接口的load、get方法，一级Query中的list、iterator方法时，会判断缓存中是否存在该对象，有则返回，不会查询数据库，如果缓存中没有要查询的对象，再去数据库中查询对应的对象，并保存到一级缓存中。
当调用session中的close方法时，Session缓存会被清空。
测试一级缓存：
// 测试一级缓存 @Test public void test1(){ //1.加载配置文件 //自动在src下查找hibernate.cfg.xml文件 Configuration configuration = new Configuration ().configure (); //2.创建一个SessionFactory SessionFactory sessionFactory = configuration.buildSessionFactory (); //3.创建一个session对象 session对象类似于connection Session session = sessionFactory.openSession (); //4.开启事务 Transaction transaction = session.beginTransaction (); // 马上发送一条sql语句查询数据库，并将数据添加到一级缓存 Shop shop1 = session.get (Shop.class,1); //没有发送SQL语句，从一级缓存中获取 System.out.println (shop1); Shop shop2 = session.get (Shop.class,1); System.out.println (shop2); // 缓存缓存的是对象的地址 System.out.println (shop1==shop2); transaction.commit (); session.close (); }
运行结果：
Hibernate: select shop0_.s_id as s_id1_0_0_, shop0_.s_name as s_name2_0_0_, shop0_.s_describe as s_descri3_0_0_, shop0_.s_stock as s_stock4_0_0_, shop0_.s_price as s_price5_0_0_ from shop shop0_ where shop0_.s_id=? com.hibernate.pojo.Shop@72fe8a4f com.hibernate.pojo.Shop@72fe8a4f true
从以上代码的运行结果上可以看出，执行第一次查询时，发送了一条sql语句，当执行第2次查询时，发现没有发送sql，直返返回了对象。第二次直接从缓存中获取的数据。
我们知道hibernate的持久态对象可以自动更新数据库，其实就是依赖于一级缓存，那么一级缓存为什么可以去更新数据库，是因为一级缓存的一块特殊区域就是快照区
一级缓存的内部结构（快照区）
hibernate向一级缓存中存放数据时，同时会复制一份数据放入到Hibernate快照区中，当使用 commit方法提交事务时，同时会清理Session的一级缓存，这时会使用OID判断一级缓存中的对象和快照区中的对象是否一致
五、hibernate的事务操作
Hibernate是对JDBC的轻量级封装，其主要功能是操作数据库，在操作数据库过程中，经常会遇到事务处理的问题，那么我们接下来就学习Hibernate的事务管理。
1.什么是事务
事务：由一条或者多条操作数据库的SQL语句组成的一个不可分割的工作单元。当事务中的所有操作都正常完成时，整个事务才能被提交到数据库，如果有一项操作没有完成，则整个事务会被回滚。
总结：一条或者一组sql语句要么全部执行成功，要么全部失败。
2.事务的四大特性（ACID）
原子性：（Atomic）表示将事务中所做的操作捆绑成一个不可分割的单元，即事务所进行的数据修改等操作。要么全部执行，要么全部不执行。
一致性：（Consistency）：表示事务完成时，必须使所有的数据都保持一致状态。
隔离性：（Isolation）：指一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性：（Durability）：持久性也称为永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。提交后的其他操作或者故障不会对其有任何影响。
3.事务的并发问题：
在实际使用事务的过程中，数据库数据要被多个用户所共同访问的，在多个事务同时使用相同的数据时，可能会发生并发的问题：
脏读：一个事务读取到另一个事务未提交的数据。
不可重复读：一个事务读到了另一个事务已经提交的update的数据，导致在同一个事务中的多次查询结果不一致。
虚读/幻读：一个事务读取到了另一个事务已经提交的insert的数据，导致在同一个事务中的多次多次查询结果不一致。
4.事务的隔离级别
为了避免事务并发问题的发生，在标准SQL规范中，定义了4个事务隔离级别，不同的隔离级别对事务的处理不同。
读未提交：（Read Uncommitted 1）一个事务在执行过程中，即可以访问其他事务未提交的新插入的数据，又可以访问未提交的修改数据。如果一个事务已经开始写数据，则另外一个事务不允许同时进行写操作，但允许其他事务读此数据。防止丢失更新
已提交读：（Read Committed 2）一个事务在执行过程中，即可以访问其他事务成功提交，新插入的数据，又可以访问成功修改的数据，读取数据的事务允许其他事务继续访问该数据，但是未提交事务将会禁止其他事务访问该行数据，有效防止脏读
可重复读：（Repeatable Read 4）一个事务在执行过程中，可以访问其他事务成功提交的数据，但是不可以访问成功修改的数据，读数据的事务将会禁止写事务(允许读)，写事务则禁止任何其他事务，防止不可重复读和脏读
序列化/串行化：（Serializable 8）提供严格的事务隔离。它要求事务序列化执行。事务只能一个接一个的执行，但不能并发执行。次隔离级别可有效防止脏读，不可重复读，或者幻读。
事务隔离级别，是由数据库提供的，并不是所有数据库都支持四种隔离级别。
在使用数据库时候，隔离级别越高，安全性越高，性能越低。实际开发中，不会选择最高或者最低隔离级别。一般选择默认的级别Oracle(Read Committed) mysql(Repeatable Read)
5.hibernate中的事务管理
在Hibernate中可以通过代码来操作管理事务，如通过：Transaction tx = session.beginTransaction 开启一个事务，持久化操作后，通过 tx.commit 提交事务，如果事务出现异常，通过 tx.rollback 操作来撤销事务（事务回滚）
除了在代码中对事务开启，提交和回滚操作外，还可以在Hibernate的配置文件中对事务进行配置。配置文件中，可以设置事务的隔离级别，在hibernate.cfg.xml文件中的<session-factory>标签中进行。
<!--设置事务的隔离级别--> <property name="hibernate.connection.isolation">4</property>
设置事务的隔离级别，那么我们的事务一般不使用在dao层，而是使用在service层中，在一个service中调用多个dao中的方法来实现一个逻辑操作。
那么我们需要保证的是在service中开启事务时，使用的Session对象和Dao中多个操作使用的是同一个session对象。
有2种方式可以实现：
1 可以在业务层获取到Session，并将Session作为参数传递给Dao
2可以使用 ThreadLocal 将业务层获取到的，Session绑定到当前线程中，然后在dao层获取Session的时候，从当前线程中获取。
一般我们都使用第二种，具体的实现不需要我们来完成，hibernate内部已经做好了，我们只需要完成一段配置即可。
Hibernate5自身提供了3种管理Session对象的方法。
Session对象的生命周期与本地线程绑定。
Session对象的生命周期与JTA事务绑定
Hibernate委托程序管理 Session对象的生命周期。
在Hibernate的配置文件中，通过hibernate.current_session_context_class来指定Session的管理方式：
thread:Session对象的生命周期与本地线程绑定
jta：session对象的生命周期与JTA事务绑定
managed:Hibernate委托程序管理Session对象的生命周期。
在hibernate中配置：
<property name="hibernate.current_session_context_class">thread</property>
hibernate提供sessionFactory.getCurrentSession() 创建一个 session和ThreadLocal绑定方法。
package com.hibernate.util; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtil { private static SessionFactory sessionFactory; static { Configuration configuration = new Configuration ().configure (); sessionFactory = configuration.buildSessionFactory (); } // 获取当前线程绑定的会话 public static Session getCurrentSession(){ return sessionFactory.getCurrentSession (); } }
hibernate中提供的这个与线程绑定的Session可以不用关闭，当线程执行结束后，就会自动关闭。
六、Hibernate的其他API（查询）
1.Query
query代表面向对象的一个Hibernate查询操作，在hibernate中通常使用createQuery方法接收一个HQL语句，然后调用Query的list方法或者uniqueResult 方法执行查询。
HQL：Hibernate Query Language 缩写 语法很像sql，但是他是完全面向对象的。sql操作的是表，HQL操作的是实体类。
Hibernate中使用Query对象的步骤：
1.获取Hibernate的session对象
2.编写HQL语句
3.调用createQuery创建查询对象
4.如果HQL语句包含参数，则使用Query的setXXX方法设置参数
5.调用Query的list方法或者uniqueResult 方法执行查询
Session session = HibernateUtil.getCurrentSession (); Transaction transaction = session.beginTransaction (); //查询所有 // Query query = session.createQuery ("from Shop"); // List<Shop> list = query.list (); // // list.forEach ( shop ->{ // System.out.println (shop.getS_name ()); // }); // //条件查询 // Query query1 = session.createQuery ("from Shop where s_id=?0"); // // query1.setParameter (0,1); //分页查询 Query query = session.createQuery ("from Shop "); query.setFirstResult (1); query.setMaxResults (10); List<Shop> list = query.list (); list.forEach ( shop ->{ System.out.println (shop.getS_name ()); }); transaction.commit (); session.close (); }
2.Criteria
Criteria是一个完全面向对象，可扩展的条件查询API，它不用考虑数据库底层的实现，以及SQL如何编写，它是Hibernate框架的核心查询对象，Criteria查询又称为“QBC”查询，他是Hibernate的另一种对象检索方式。由于它的API比较多，使用比较繁琐，所以在我们的开发中很少有人使用。
使用步骤;
1.创建查询：CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
2.设置查询语句信息 ：criteriaBuilder.createQuery
3.定义查询的From子句中能出现的类型,也可以用root.get()获取具体的某个属性：
Root root = criteriaQuery.from (Shop.class);
4.设置条件
criteriaQuery.where
5.创建Query对象并获取结果集list
Query query = session.createQuery (criteriaQuery);
List<Shop> list = query.list ();
@Test public void test4(){ Session session = HibernateUtil.getCurrentSession (); Transaction transaction = session.beginTransaction (); CriteriaBuilder criteriaBuilder =session.getCriteriaBuilder (); CriteriaQuery criteriaQuery = criteriaBuilder.createQuery (Shop.class); Root root = criteriaQuery.from (Shop.class); criteriaQuery.select (root); Path<Integer> path = root.get("s_id"); Path<String> path1 =root.get ("s_name"); //多条件查询 Predicate predicate =criteriaBuilder.or (criteriaBuilder.equal (path,1),criteriaBuilder.equal (path1,"面条")); Predicate predicate1 =criteriaBuilder.or (criteriaBuilder.equal (path,2)); // criteriaQuery.where (criteriaBuilder.equal (root.get ("s_id"),1),criteriaBuilder.equal (root.get ("s_name"),"面条")); criteriaQuery.where (predicate,predicate1); Query query = session.createQuery (criteriaQuery); List<Shop> list = query.list (); list.forEach (shop ->{ System.out.println (shop.getS_price ()); }); }
3.SQLQuery
SQLQuery这个就比较简单了，这个借口用于接收一个sql语句进行查询，然后调用list或者uniqueResult方法进行查询，但是sql语句不会直接封装到实体对象中，需要我们手动写代码才可以封装到实体中
@Test public void test5(){ Session session = HibernateUtil.getCurrentSession (); Transaction transaction = session.beginTransaction (); //全查询 // String sql = "select * from shop"; // NativeQuery nativeQuery =session.createNativeQuery (sql,Shop.class); // // List<Shop> list = nativeQuery.getResultList (); //分页查询 String sql = "select * from shop"; NativeQuery nativeQuery = session.createNativeQuery (sql,Shop.class).setFirstResult (1) .setMaxResults (10); List<Shop> list = nativeQuery.getResultList (); transaction.commit (); list.forEach (shop ->{ System.out.println (shop.getS_name ()); }); }
