Hibernate框架（二）

关于ORM映射文件

           1）类和表映射

           2）主键映射【对象和行记录标示】

           3）属性映射

关于主键的几种管理方式（还有几种没有列出，可自己查阅，关于Hibernate的配置文件节点<generator class="identity" />）

   1，identity自增长(Mysql，SQLServer数据库，它的特点是数据库主键时自增长方式)

   2，sequence序列（Oracle数据库，他的主键式以序列化的形式存在）

   3,native根据数据库的支持方式做选择（建议使用这种方式，当数据库更换时，不会有什么影响）

   4，UUID（是以字符串的形式存在，前边的三种，主键的类型为short int  long）   

关于Hql语句的说明（最重要的一点，思想与SQL一样，但字段以及表名均换为pojo对象，即实体类中的对象，）

      关于hql有一个索引占位符和命名占位符这两个问题

     关于检索的方式有立即检索和延迟检索这两种形式（即在配置文件中有一个关于lazy的属性，默认情况下为true）

关于pojo的三种状态，分别为瞬时态，持久太，游离态

      瞬时态：没有与数据库关联，没有主键

      持久态： 和数据库关联，有主键

      游离态：没有和数据库关联，有主键，即在session关闭的时候

注意一点：在不用本地线程工具类获取session对象的情况下，查找不需要使用事务

关于缓存问题（有一级缓存和二级缓存及查询缓存 ）

    对于检索与缓存会出现的一些问题，在下边的代码中做出了相应的解释

作用：为了提升性能

一级缓存：同一个session中的数据共享，是session级别的缓存，而sessionfactory是二级缓存   

注意：在利用反向工程生成类及配置文件的时候，如果有关联表问题，将会在主表中产生一个set集合，在子表中有一个外键的地方是以主表的类名为属性名的

    在配置文件中，或出现many-to-one  与  one-to-many  或者是在多对多的关系中，会有many-to-many这样的节点  

  //hql的模糊查询
      public void likeFind(String bookName){
    	  Session session = Hibernate.getSession();	  
    	  String hql="from BookInfo where bookName like ?";
    	  //模糊查询语句的写法，在like的后边没有等号
    	  Query<BookInfo> query = session.createQuery(hql, BookInfo.class);
    	  Query<BookInfo> setParameter = query.setParameter(0, "%"+bookName+"%");
    	  List<BookInfo> list = setParameter.getResultList();
    	  for (BookInfo bookInfo : list) {
			System.out.println(bookInfo.getBookPublish());
		}
    	  session.close(); 
      }

   

    public void findByName(String name){
    	  //根据条件查找
    	  Session session = Hibernate.getSession();
    	  Transaction transaction = session.beginTransaction();   	  
    	String hql="from BookInfo where bookName=?";
    	Query<BookInfo> query = session.createQuery(hql, BookInfo.class);
    	Query<BookInfo> parameter = query.setParameter(0, name);
    	transaction.commit();    	
        List<BookInfo> list = parameter.getResultList();
        for (BookInfo bookInfo : list) {
			System.out.println(bookInfo);
		}  	
      }

	public void upBookIfHql(long bookId, String string) {
		 Session session = Hibernate.getSession();
   	  Transaction transaction = session.beginTransaction();
   	  String hql="update BookInfo  set bookPublish=:bookPublish where bookId=:bookId";
   	  Query<BookInfo> query = session.createQuery(hql);
   	 //此处不该添加BookInfo.class 会报错。关于框架底层的写法	  
   	  query.setParameter("bookPublish", string);
   	  query.setParameter("bookId", bookId);
   	  query.executeUpdate();
   	  //此处容易忘记的点，不加query.executeUpdate();  
   	  transaction.commit();
   	  session.close();
	}

public void findBookByManyID(long l) {
		// TODO Auto-generated method stub
		Session session = Hibernate.getSession();
		String hql="select book.bookName,book.bookData  from BookInfo book where book.bookType.typeId=:typeId";
		Query<Object[]> query = session.createQuery(hql,Object[].class);//此处的泛型，最为重要
		Query parameter = query.setParameter("typeId", l);
		List<Object[]> list = query.getResultList();
		//利用debug模式可以看出取出的值是以Object数组的形式存在的，所以要利用下标的形式去查询里边的内容
	for (Object[] objects : list) {
		System.out.println(objects[0]+"\t"+objects[1]);
	}
		//当查询表中的部分字段时，需要注意的几个关键点		
		session.close();
	}

	//聚合函数查询数据总条数
	public void findCount(){
		Session session = Hibernate.getSession();
		String hql="select count(bookId) from BookInfo";
		Query query = session.createQuery(hql);
		Long long1= (Long)query.uniqueResult();
		//关于聚合函数，应该要注意的是这一个点query.uniqueResult();和有关这个的类型
		session.close();
		System.out.println(long1);		
	}

//连接查询
	public void findSearch(){
		Session session = Hibernate.getSession();
		//from BookInfo book inner join book.bookType
	//	String hql="from BookInfo book inner join   book.bookType";
		String hql="from BookInfo book inner join   book.bookType";
		//利用内连接去查询的时候只能写成这种形式，不能有其他形式的改变
		Query query = session.createQuery(hql);
		List list =query.getResultList();
	 for (int i = 0; i < list.size(); i++) {
		Object[] object = (Object[]) list.get(i);
		BookInfo bookInfo= (BookInfo) object[0];
		BookType bookType= (BookType) object[1];		
		System.out.println(bookInfo.getBookData());
		System.out.println(bookType.getTypeName());
	}		
		session.close();
	}

//迫切左外链接查询
	//多了一个关键字fetch,可以直接获得POJO对象
	public void findFetchSearch(){
		
		Session session = Hibernate.getSession();
		String hql="from BookInfo book right join fetch book.bookType";
		//String hql="from BookInfo book right join book.bookType";//当用它时会报错
		//利用右迫切连接查询的方法，按BookType的顺序打印，当在BookInfo中有数据的时候，
		//就打印BookInfo中的数据
		/*String hql="from  book right join fetch book.bookId";*/	
		 Query<BookInfo> query = session.createQuery(hql,BookInfo.class);
		 List<BookInfo> list = query.getResultList();
		 for (BookInfo bookInfo : list) {
			 System.out.println(bookInfo);
		//	System.out.println(bookInfo.getBookName()+"\t"+bookInfo.getBookType().getTypeName());
		}
		session.close();
	}

	//二级缓存的测试
	//关于get和load，前提是在有这一行数据的情况下，如果是get，则其结果是NULL，但是load报异常
	public void findTwo(){
		//二级缓存不能解决关联表问题
		//此表与主表相关联，不能利用二级缓存方式加载
		Session session = Hibernate.getSession();
		BookInfo bookInfo = session.get(BookInfo.class, 8L);
		System.out.println(bookInfo.getBookName()+"这是第一次查询");
		session.close();
		Session session2 = Hibernate.getSession();
		BookInfo bookInfo2 = session2.get(BookInfo.class, 8L);
		System.out.println(bookInfo2.getBookName()+"这是第二次查询");
		session2.close();
		ArrayList< String> list= new ArrayList<String>();		
	}

	//关于查询缓存的实验
	public void findSearchD(){ 
		//查询缓存是不是就解决了关联表不能使用二级缓存的问题
		Session session = Hibernate.getSession();
		String hql="from BookInfo  where bookId=:bookId ";		
		//<property name="hibernate.cache.use_query_cache">true</property>
		//使用查询缓存的时候，Hibernate中的配置的写法	
		 Query<BookInfo> query = session.createQuery(hql,BookInfo.class);
		query.setCacheable(true);
		Query<BookInfo> parameter = query.setParameter("bookId", 7L);		
		List<BookInfo> list = parameter.getResultList();
		for (Object object : list) {
			System.out.println(object);
		}
		session.close();		
		Session session2 = Hibernate.getSession();
		String hql2="from BookInfo  where bookId=:bookId ";
		Query<BookInfo> query2 = session2.createQuery(hql2,BookInfo.class);
		query2.setCacheable(true);
		Query<BookInfo> parameter2 = query2.setParameter("bookId", 7L);
		List<BookInfo> list2 = parameter2.getResultList();
		for (Object object : list2) {
			System.out.println(object);
		}
		session2.close();	
	}