Hibernate中的用hql语句完成查询，以及hibernate当中的三种缓存方式的不同和用法

//查询持久化数据
Users users = session.get(Users.class, 2);
System.out.println(users.getUname());

//查询users表中的所有数据
String hql="select u from Users u";
	Query query = session.createQuery(hql);
	List<Users> list = query.list();
		for (Users users : list) {
		System.out.println(users.getUname());
	}

//查询非持久态数据查询某个特定的内容
		String hql="select u.uid,u.uname from Users u";
		Query query = session.createQuery(hql);
		//用一个数组类的list集合来接收
		List<Object[]> list = query.list();
		for (Object[] objects : list) {
			System.out.println(objects[0]+"\t"+objects[1]);
		}

//查询持久态的数据要求要有相对应得构造方法用new 对象来接收
		String hql="select new Users(u.uid,u.uname) from Users u";
		Query query = session.createQuery(hql);
		List<Users> list = query.list();
		for (Users users : list) {
			System.out.println(users.getUname()+"\t"+users.getUid());
		}

//修改
	String hql="update Users u set u.uname='哈哈'";
	Query query = session.createQuery(hql);
	int row = query.executeUpdate();
	System.out.println(row);

	//删除
		String hql="delete from Users u where u.uname like '%哈%'";
		Query query = session.createQuery(hql);
		int row = query.executeUpdate();
		System.out.println(row);

//		查询函数
		String hql="select count(p.pid) from Product p";
		Query query = session.createQuery(hql);
		//获取唯一的结果
		long i = (Long) query.uniqueResult();
		System.out.println(i);


		String hql="select max(p.pid) from Product p";
		Query query = session.createQuery(hql);
		Integer  max = (Integer) query.uniqueResult();
		System.out.println(max);

//占位符的使用
		String hql="select p from Product p where p.pname like ?0";
		Query query = session.createQuery(hql).setParameter(0, "%奥%");
		List<Product> list = query.list();
		for (Product product : list) {
			System.out.println(product.getPname());
		}

	//指定占位符的方式
		String hql="select p from Product p where p.pname like:pname";
		Query query = session.createQuery(hql).setParameter("pname", "%奥%");
		List<Product> list = query.list();
		for (Product product : list) {
			System.out.println(product.getPname());
		}

//集合的方式
		String hql="delete from Product p where p.pid in :fw";
		List<Integer> list=new ArrayList<Integer>();
		list.add(5);
		list.add(6);
				//集合值
		Query query = session.createQuery(hql).setParameterList("fw", list);
		int i = query.executeUpdate();
		System.out.println(i);

//分页查询
		String hql="select p from Product p";
		int pagenum=1;
		int pagesize=4;
		Query query = session.createQuery(hql)
				//获取最大位置的结果值
		.setMaxResults(pagesize)
		       //获取第一个位置的值
		.setFirstResult((pagenum-1)*pagenum);
		List<Product> list = query.list();
		for (Product product : list) {
			System.out.println(product.getPname());
		}

//查询用户名称带d的所有商品
		String hql="select p from Product p left join Users u on p.users.uid=u.uid where u.uname like:uname ";
		Query query = session.createQuery(hql)
		.setParameter("uname", "%d%");
		List<Product> list = query.list();
		for (Product product : list) {
			System.out.println(product.getPname());
		}

//查询买了商品的用户
		String hql="select u from Users u where u.products.size>0";
		Query query = session.createQuery(hql);
		List<Users> list = query.list();
		for (Users users : list) {
			System.out.println(users.getUname());
		}

//查询买了商品带h的所有用户
		String hql="select u from Users u where u.uid in(select p.users.uid from Product p where p.pname like:pname)";
		Query query = session.createQuery(hql).setParameter("pname", "%h%");
		List<Object> list = query.list();
		for (Object object : list) {
			Users users=(Users)object;
			System.out.println(users.getUname());
		}

对于hibernate当中的三种缓存
一级缓存：session缓存，不缓存集合

//用相同的代码，他会只查询一次，结果出现两次
Users users = session.get(Users.class, 10);
		System.out.println(users.getUname());
		Users users1 = session.get(Users.class, 10);
		System.out.println(users1.getUname());

接下来我们把session关闭来看一下会是什么结果

Users users = session.get(Users.class, 10);
		System.out.println(users.getUname());
		session.close();
		session=factory.openSession();
		Users users1 = session.get(Users.class, 10);
		System.out.println(users1.getUname());

我们接下来再来看一下对于集合来说一级缓存有没有用
写两个相同的list集合来查询看看一级缓存是否能缓存

List<Users> list = session.createQuery("select u from Users u").list();
		for (Users users : list) {
			System.out.println(users.getUname());
		}
		List<Users> list1 = session.createQuery("select u from Users u").list();
		for (Users users : list1) {
			System.out.println(users.getUname());
		}

因此得到的结论便是一级查询只针对于session查询，是一个对象缓存，不能缓存集合

二级查询 是一个session仓库缓存
只不过要想完成二级缓存首先要去hibernate文件当中去打开二级缓存然后需要自己配置 需要Ehcache （后期工作使用redis）因为二级缓存在hibernate当中不是默认存在的需要自己去打开

然后再重复以上查询动作看会有什么不同的结果

//把session关闭看会不会与一级缓存不同之处
Users users = session.get(Users.class, 10);
		System.out.println(users.getUname());
		session.close();
		session = factory.openSession();
    	Users users1 = session.get(Users.class, 10);
		System.out.println(users1.getUname());

我们再来看一下集合

List<Users> list = session.createQuery("select u from Users u").list();
		for (Users users : list) {
			System.out.println(users.getUname());
		}
		List<Users> list1 = session.createQuery("select u from Users u").list();
		for (Users users : list1) {
			System.out.println(users.getUname());
		}

因此得到的结论是二级缓存是session仓库级缓存，只能是对象缓存不能是集合缓存

最后一个便是查询缓存了
查询缓存了：缓存的是当前对象的缓存

		Query query = session.createQuery("from Users u where u.uid=10");
		//手动开启查询缓存
		query.setCacheable(true);
		Users a=(Users) query.uniqueResult();
		System.out.println(a.getUname());
		System.out.println("-------------------------------");
		Query query1 = session.createQuery("from Users u where u.uid=10");
		//手动开启查询缓存
		query1.setCacheable(true);
		Users a1=(Users) query1.uniqueResult();
		System.out.println(a1.getUname());

Query query1=session.createQuery("from Users");
		query1.setCacheable(true);
		List<Users> list=query1.list();
		for (Users a : list) {
			System.out.println(a.getUname());
		}
		
		Query query2=session.createQuery("from Users");
		query2.setCacheable(true);
		List<Users> list1=query2.list();
		for (Users a : list1) {
			System.out.println(a.getUname());
		}

、
因此得到了一个结论就是
查询缓存缓存的是当前对象的缓存