JavaEE框架---Hibernate第二部分

1.1 持久化类的编写规则

1.1.1 什么是持久化类：

       Hibernate 是持久层的ORM映射框架，专注于数据的持久化工作。所谓持久化，就是将内存中的数据永久的存储到关系型数据库中。那么知道了什么是持久化，那么什么是持久化类呢？其实就所谓的持久化类指的是一个Java类与数据库表建立了映射关系，那么这个类就是持久化类。其实你可以简单的理解为持久化类就是一个java类有了一个映射文件与数据库的表建立了关系。那么我们在编写持久化类的时候有哪些要求的？接下来我们看一下：

1.1.2 持久化类的编写规则：      

1.2 主键生成策略

1.2.1 主键的分类

1.2.1.1 自然主键
*自然主键：主键的本身就是 表中的一个字段（实体中的一个属性）
    *创建一个人员表，人员都会有一个身份证号（唯一的不可重复的），使用了身份证作为主键，这种主键称之为自然主键。
1.2.1.2 代理主键
*代理主键：主键的本身不是表中必须的一个字段（不是实体中的某个具体的属性）
    *创建一个人员表，没有使用人员中的身份证号，用了一个与这个表不不相关的字段ID,（PNO）。这种主键称之为代理主键。
*在实际开发中，尽量使用代理主键
    *一旦自然主键参与到业务逻辑中，后期可能需要修改源代码。
    *好的程序设计满足OCP原则：对程序的扩展是OPEN的。对修改源码是CLOSE的。

1.2.2 主键的生成策略

1.2.2.1 Hibernate的主键生成策略

    在实际开发中一般不允许用户手动设置主键，一般将主键交给数据，手动编写程序进行设置。在Hibernat为了减少程序的编写，提供了多种主键生成策略。

 

1.3持久化类的三种状态
Hibernate是持久层框架，通过持久化类完成ORM操作。Hibernate为了更好的管理持久化类，将持久化类分为3中状态。

持久化类=java类+映射。    

1.3.1 瞬时态

*这种对象没有唯一的表示OID，没有被Session管理，称为持久态对象。

1.3.2持久态

*这种对象有唯一的表示OID，被Session管理，称为持久态对象。
        *持久化类的持久态的对象，可以自动更新数据库。

1.3.3脱管态

这种对象有唯一的标识，没有被session管理，称为脱管态对象。

区分对象的三种状态，代码实例：

	@Test
	public void Demo1() {
		Session session=HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer=new Customer();//瞬时态对象：没有唯一表示的OID，没有被session管理
		customer.setCust_name("李四");
		Serializable id = session.save(customer);//持久态对象：有唯一的标识OID，被session管理
		session.get(Customer.class, id);
		
		transaction.commit();
		session.close();
		
		System.out.println(customer.getCust_name());//托管态对象：有持久化标识的OID，没有被session管理
	}

1.4 持久化类三种状态的相互转换

1.4.1三种状态的转换图

1.4.2瞬时态对象

    *获得
        *Customer customer=new Customer();
    *状态转换
        *瞬时->持久
            *save(Object obj) ,saveOrUpdate(Object obj)
        *瞬时->托管 
            *customer.setCust_id(1)
            
1.4.3持久态对象

    *获得
        *get(),load(),find(),iterate(),
        *Customer customer=session.get(Customer.class,1)
    *状态转换
        *持久->瞬时
            *delete()
        *持久->托管
            *close(),clear(),evict(Object obj),

1.4.4脱管态对象

    *获得
        *Customer customer=new Customer();
        *customer.setCust_id(1);
    *状态转换
        *托管->持久
            *update(),saveOrUpdate(Object obj);
        *托管->瞬时
            *customer.setCust_id(null);

1.5 持久态对象特性

1.5.1持久化类持久态对象自动更新数据库

	@Test
	public void Demo2() {
		Session session=HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer = session.get(Customer.class, 1l);
		customer.setCust_name("王五");
//		session.update(customer);//无需写update语句
		
		transaction.commit();
		session.close();
		
		System.out.println(customer.getCust_name());//托管态对象：有持久化标识的OID，没有被session管理
	}

1.6 Hibernate的一级缓存

1.6.1什么是缓存
缓存：是一种优化的方式，将数据存入到内存中，使用时直接从内存中获取，不用通过存储源

1.6.2 Hibernate 的缓存

1.6.2.1 Hibernate的一级缓存

Hibernate框架中提供了优化的手段，缓存，抓取策略。Hibernate中提供了两种缓存机制，一级缓存、二级缓存。
Hibernate的一级缓存：称为是Session级别的缓存，一级缓存的生命周期与Session一致（一级缓存是由session中一系列的java集合构成）。一级缓存是自带不可卸载的。（Hibernate的二级缓存是SessionFactory级别的缓存，需要配置的缓存）。

1.6.2.2 证明一级缓存的存在

	public void Demo3() {
		Session session=HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer1 = session.get(Customer.class, 1l);//发送sql语句
		System.out.println(customer1);
		Customer customer2 = session.get(Customer.class, 1l);//不发送sql语句
		System.out.println(customer2);

		Customer customer=new Customer();
		customer.setCust_name("凤姐");
		session.save(customer);
		
		Customer customer3 = session.get(Customer.class, 1l);//不发送sql语句
		System.out.println(customer3);
		
		transaction.commit();
		session.close();
	}

1.6.3 HIbernate一级缓存的结构

1.6.3.1 一级缓存中特殊区域：快照区

session.clear()是清空所有一级缓存

session.evict()是清空一个缓存

1.7 Hibernate的事务控制

1.7.1什么是事务

1.7.2 事务特性

事务有严格的定义，需要同时满足四个特性，既原子性、一致性、隔离性、持久性。这四个特性通常称之为ACID特性，具体如下：

1.7.3 如果不考虑隔离理性，会引发安全问题（事务的并发问题）

1.7.4事务的隔离级别

1.7.5 Hiberate中的事务管理

1.7.6事务的应用场景

事务的控制应该是在service层实现的，而不是在DAO层实现的，并且在Service中调用一个DAO实现一个业务逻辑的操作。.

在hibernate.cfg,xml中进行如下操作：

		 <!-- 指定session与当前线程绑定 -->
		 <property name="hibernate.current_session_context_class">thread</property>

Hibernate提供sessionFactory.getCurrentSession()创建一个session和ThreadLocal绑定的方法。

在HibernateUtil工具类更改getCurrentSession方法：

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();
	}
	public static Session getCurrentSession(){
		return sf.getCurrentSession();
	}
}

1.8 HIbernate 的其他API

1.8.1 Query

//Query
	@Test
	public void demo01() {
		
		Session session=HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询全部
//		String hql="from Customer";
		//模糊查询、条件查询     cust_name是属性名
//		String hql="from Customer where cust_name like ?";
		//分页查询
		String hql="from Customer";
		Query query=session.createQuery(hql);//通过session获得query接口
		//设置条件
//		query.setParameter(0, "王%");
		//设置分页
		query.setFirstResult(3);
		query.setMaxResults(3);
		
		List<Customer> list = query.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		transaction.commit();
	}

1.8.2 Criteria

//Criteria
	@Test
	public void demo2() {
		
		Session session=HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		//查询所有
//		Criteria criteria = session.createCriteria(Customer.class);
//		List<Customer> list = criteria.list();
		
		//条件查询
//		Criteria criteria = session.createCriteria(Customer.class);
//		criteria.add(Restrictions.like("cust_name", "李%"));
//		List<Customer> list = criteria.list();
		
		Criteria criteria = session.createCriteria(Customer.class);
		criteria.setFirstResult(0);
		criteria.setMaxResults(3); 
		List<Customer> list = criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		transaction.commit();
	}

1.8.3 SQLQuery

SQLQuery用于接受SQL语句，特背复杂的情况下使用。

	//SQlQuery
	@Test
	public void demo4() {
		Session session=HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		/*String sql="select * from cst_customer";
		SQLQuery createSQLQuery = session.createSQLQuery(sql);
		List<Object[]> list = createSQLQuery.list();
		
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		String sql="select * from cst_customer";
		SQLQuery createSQLQuery = session.createSQLQuery(sql);
		//封装到对象中
		createSQLQuery.addEntity(Customer.class);
		List<Customer> list = createSQLQuery.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		transaction.commit();
	}