ch02 Hibernate基础操作讲义

本章任务

1、理解hibernate
1:为什么使用hibernate
答：开发效率高，让开发变的更加简单，专注于写业务。
2:什么是持久化
答:
3:什么是ORM与一对一，一对多，多对多
答:

2、hibernate的三态

1、HIBERNATE 中持久化类实例的三种状态
1.1 临时状态(transientInstance)
	特征：
a.不存在于session实例的缓存中，不与任何session实例相关联
		b.在数据库中没有民之相对应的记录
	促使持久化类实例进入临时状态的情况如下：
		a.通过new语句创建新的持久化类实例。
		b.通过执行delete()方法删除持久化类实例。
1.2 持久化状态(persistentInstance)
	特征：
a.存在于session实例的缓存中，与session实例相关联。
		b.在数据库中有与这相对应的记录。
		c.session实例在清理缓存时会根据持久化类实例属性的变化更新数据库。
促使持久化类实例进入持久化状态的情况如下：
	a.通过执行save()或saveOrUpdate()方法使临时对象转变为持久化对象。
	b.通过执行update()或saveOrUdate()方法使游离对象转变为持久化对象。
	c.通过执行load()或get()方法返回的持久化实例都是持久化类对象。
	d.通过执行find()方法返回的list集合中的持久化实例都是持久化类对象。
e.在允许级联保存的情况下，session实例在清理缓存时会把与持久化对象关联的临时对象转变为持久化对象。

1.3 游离状态(detachedInstance)
	特征：
a.不存在于session实例的缓存中，不与任何session实例相关联
b.在数据库中有与之相对应的记录（前提条件是没有其他session实例删除该记录）.
	促使持久化类实例进入临时状态的情况如下：
a.通过执行evict()方法，可以从session实例的缓存中删除一个持久化类实例，使之转变为游离对象。
b.通过执行clear()方法，可以清空session实例的缓存，使缓存中的所有持久化类实例转变为游离状态
c.通过执行close()方法，可以销毁session实例，从而清空session实例的缓存。

三种状态之间的转换

代码	                                       对象的生命周期状态	对象的状态
Users users=new Users();	               开始生命周期	        开始生命周期
Session session=sessionFactory.openSessin();
Transaction tx=session.beginTransaction();     在生命周期中	        临时状态
Session.save(users);	                       在生命周期中	        转变为持久化状态
Tx.commit();	                               在生命周期中	        持久化状态
Session.close();	                       在生命周期中	        转变为游离状态
System.out.println(users.getName());	       在生命周期中	        游离状态
Users=null;	                               结束生命周期	        结束生命周期


3、Hibernate的CRUD

HQL系列-------->Query

3-1：单个属性查询,list集合里的数据就不是一条条实体对象，而是一个个Object类型的

		 * 方法一,查询所有
		 */
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("From UserInfo");
//		List<UserInfo> list = query.list();
//		for (UserInfo userInfo : list) {
//			System.out.println(userInfo.getUserInfoDetails().size());
//		}
//		System.out.println(list.size());
//        session.close();
		
		 /**
		 * 方法一,单个属性查询
		 */
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("select loginName From  UserInfo");
//		List<Object> list = query.list();//在这里list集合里的数据就不是一条条UserInfo实体对象，而是一个个Object类型的loginName		
//		for (Object object : list) {
//			System.out.println(object);
//		}
//		System.out.println(list.size());
//        session.close();

3-2：多个属性查询,list集合里的数据就不是一条条实体对象，而是一个个Object[]类型的

		 /**
		 * 方法一,多个属性查询
		 */
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("select u.loginName,u.loginPass From  UserInfo u");
//		List<Object[]> list = query.list();//在这里list集合里的数据就不是一条条UserInfo实体对象，而是一个个String类型的loginName
//		for (Object[] objects : list) {
//			for(int i=0;i<objects.length;i++){
//				System.out.println(objects[i]);
//			}
//		}		
//		System.out.println(list.size());
//        session.close();

		 /**
		 * 方法一,分组与排序
		 */
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("select count(u.userId) as count, u.userId,u.loginName,u.loginPass From  UserInfo u group by u.loginName,u.loginPass,u.userId order by u.userId desc");
//		List<Object[]> list = query.list();//在这里list集合里的数据就不是一条条UserInfo实体对象，而是一个个String类型的loginName
//		for (Object[] objects : list) {
//			for(int i=0;i<objects.length;i++){
//				System.out.println(objects[i]);
//			}
//		}		
//		System.out.println(list.size());
//        session.close();


3-3：联合查询,没有fetch,则得到的list集合里面每一个元素就是一个对象数组，其包括一个主对象和一个主对象相对应的从对象

		 * 方法一,联合查询,没有fetch
		 */
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("from UserInfo as u join u.userInfoDetails");
//		List<Object[]> list = query.list();//没有声明fetch，则得到的list集合里面每一个元素就是一个对象数组，其包括一个UserInfo对象和一个UserInfo相对应的userInfoDetails对象。
//		for (Object[] objects : list) {
//			System.out.println(objects);
//		}
//		System.out.println(list.size());
//        session.close();

		
		 /**
		 * 方法一,联合查询,左连接:没有fetch
		 */
//		long beginTime = System.currentTimeMillis();
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("from UserInfo as u left  join  u.userInfoDetails ");
//		List<Object[]> list = query.list();//没有声明fetch，则得到的list集合里面每一个元素就是一个对象数组，其包括一个UserInfo对象和一个UserInfo相对应的userInfoDetails对象。
//		for (Object[] objects : list) {
//			System.out.println(objects);
//		}
//		long endTime = System.currentTimeMillis();
//		System.out.println("time:"+(endTime-beginTime));
//		System.out.println(list.size());
//        session.close(); 
        
		 /**
		 * 方法一,联合查询,右连接:没有fetch
		 */
//		long beginTime = System.currentTimeMillis();
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("from UserInfo as u right  join  u.userInfoDetails ");
//		List<Object[]> list = query.list();//没有声明fetch，则得到的list集合里面每一个元素就是一个对象数组，其包括一个UserInfo对象和一个UserInfo相对应的userInfoDetails对象。
//		for (Object[] objects : list) {
//			System.out.println(objects);
//		}
//		long endTime = System.currentTimeMillis();
//		System.out.println("time:"+(endTime-beginTime));
//		System.out.println(list.size());
//        session.close(); 
		


3-4：联合查询,加fetch后,当主对象被加载时就立即填充主对象里的从对象集合

//		 /**
//		 * 方法一,联合查询,加fetch后,当UserInfo对象被加载时就立即填充UserInfo里的userInfoDetails集合
//		 */
//		long beginTime = System.currentTimeMillis();
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("from UserInfo as u inner join fetch u.userInfoDetails ");
//		List<UserInfo> list = query.list();
//		for (UserInfo userInfo : list) {
//			System.out.println(userInfo.getUserInfoDetails().size());
//		}	
//		long endTime = System.currentTimeMillis();
//		System.out.println("time:"+(endTime-beginTime));
//		System.out.println(list.size());
//      session.close();        

		 /**
		 * 方法一,子查询
		 */
//		long beginTime = System.currentTimeMillis();
//		Session session = HibernateSessionFactory.getSession();
//		Query query = session.createQuery("from UserInfo u where (select count(*) from u.userInfoDetails)>1)");
//		List<UserInfo> list = query.list();//在这里list集合里的数据就不是一条条UserInfo实体对象，而是一个个String类型的loginName
//		for (UserInfo userInfo : list) {
//			System.out.println(userInfo.getUserInfoDetails().size());
//		}	
//		long endTime = System.currentTimeMillis();
//		System.out.println("time:"+(endTime-beginTime));
//		System.out.println(list.size());
//      session.close(); 	


3-5： 分页

query.setFirstResult(firstResultIndex);query.setMaxResults(pageSize);


QBC系列-------->Criteria与DetachedCriteria

//限制条件 Restrictions

//匹配模式 MatchMode

//分组查询 Projection
criteria.setProjection(Projections.projectionList()   
.add(Projections.groupProperty("userId"))   
.add(Projections.sum("userId")))

//排序 Order


		/** *********************Criteria系列************************** */
		 /**
		 * 方法八，查询所有
		 */
//		 Session session = HibernateSessionFactory.getSession();
//		 Transaction tx = session.getTransaction();
//		 tx.begin();
//		 List list = session.createCriteria(UserInfo.class).list();
//		 tx.commit();
//		 session.close();
//		 System.out.println(list.size());
		
		
		 /**
		 * 方法九（分页查询）
		 */
		 //第几页
//		 int pageNo = 2;
//		 //当前页的数量
//		 int pageSize = 2;
//		 //从第几条记录开始
//		 int firstResultIndex = pageSize*(pageNo-1);
//		 Session session = HibernateSessionFactory.getSession();
//		 Transaction tx = session.getTransaction();
//		 tx.begin();
//		 Criteria criteria = session.createCriteria(UserInfo.class);
//		 criteria.setFirstResult(firstResultIndex);
//		 criteria.setMaxResults(pageSize);
//				
//		 List list = criteria.list();
//		 tx.commit();
//		 session.close();
//		 System.out.println(list.size());
		
//		 /**
//		 * 方法十,模糊查询
//		 */
//		 Session session = HibernateSessionFactory.getSession();
//		 Criteria criteria = session.createCriteria(UserInfo.class);
//		 
//		 Transaction tx = session.getTransaction();
//		 tx.begin();
//		 //模拟一个要查询的用户对象
//		 UserInfo userInfo = new UserInfo();
//		 userInfo.setLoginName("d");
//		 userInfo.setIds("1,2,3");
//		 userInfo.setUserId(2);
//
//		 //模糊匹配用户名
//		if(userInfo.getLoginName()!=null)
//			criteria.add(Restrictions.like("loginName",userInfo.getLoginName(), MatchMode.ANYWHERE));
//		//匹配用户编号
//		if(userInfo.getUserId()!=null)
//			criteria.add(Restrictions.idEq(userInfo.getUserId()));
//		//批量匹配用户编号
//		if(userInfo.getIds()!=null){
//			Integer[] ints = {1,2,3};
//			
//			criteria.add(Restrictions.in("userId",ints));	
//		}
//		//分组查询
//		criteria.setProjection(Projections.projectionList()   
//                .add(Projections.groupProperty("userId"))   
//                .add(Projections.sum("userId")));   
//          
//	
//		criteria.addOrder(Order.asc("userId"));
//		System.out.println(criteria.toString());
//		List list = criteria.list();
//		 tx.commit();
//		 System.out.println(list.size());
	}


	public static void testCriteria(Session session){
		DetachedCriteria dcrit=DetachedCriteria.forClass(Customer.class);
		dcrit.addOrder(Order.asc("age"));
		Criteria crit=dcrit.getExecutableCriteria(session);
//		Criteria crit=session.createCriteria(Customer.class);
//		crit.addOrder(Order.asc("age"));
//		crit.add(Expression.eq("age",new Integer(10)));
		List<Customer> list=crit.list();
		for (Customer customer : list) {
			
			Set<Buy> buies=customer.getBuies();
			
			for (Buy buy : buies) {
				System.out.println(buy.getBuyName()+" "+buy.getBuyId());
			}
		}
	}


4、Hibernate的级联CRUD

4-1：inverse,维持两个实体的关系
inverse="false|true"
true:先select两个实体,再delete两个实体
false:update 实体外键 为null，如果外键设置为不为空则会出错。

4-2:cascade,级联的程度
none,只是维持两者的关系。
sava-update,级联保存更新。
all,级联保存更新删除

5、get()与load()

5-1:get方法，hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，还没有就查询数据库，数据库中没有就返回null

5-2:load方法，load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)

若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。 

若为false,就跟get方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。 
本章目标
1:理解hibernate
2:理解hibernate的三个状态
3:掌握Hibernate的CRUD
4:掌握Hibernate的级联CRUD
5:掌握Hibernate的get()与load()方法的区别