Hibernate 教程（五）[Criteria使用]

Criteria

Criteria 只支持查询，而且很难用
但是Hibernate推荐这么做（一万省略字脏话）

Criteria 查询数据

package query.Criteria;

import java.util.Arrays;
import java.util.List;

import javax.persistence.Tuple;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.jupiter.api.Test;

import orm.entity.Datas;
import orm.entity.Event;
import util.SessionUtil;

/**
 * QBC查询
 * @author LiHan
 *
 */
public class CriteriaQueryTest {
	
	private Session session = SessionUtil.getSession();

	private Transaction transaction = session.beginTransaction();
	
	
	/**
	 * 查询所有
	 */
	@Test
	public void test00() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 传入Event，查询的结果就是Event对象
		CriteriaQuery<Event> criteriaQuery = criteriaBuilder.createQuery(Event.class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 查询对象
		criteriaQuery.select(root);
		System.out.println(session.createQuery(criteriaQuery).getResultList());
		transaction.commit();
	}
	
	/**
	 * 条件查询
	 */
	@Test
	public void test01() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 传入Event，查询的结果就是Event对象
		CriteriaQuery<Event> criteriaQuery = criteriaBuilder.createQuery(Event.class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 查询对象
		criteriaQuery.select(root);
		// 构建查询条件
		criteriaQuery.where(criteriaBuilder.equal(root.get("title"), "标题一"));
		System.out.println(session.createQuery(criteriaQuery).getResultList());
		transaction.commit();
	}
	
	/**
	 * 选择字段查询
	 */
	@Test
	public void test02() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 预期结果是String类型
		CriteriaQuery<String> criteriaQuery = criteriaBuilder.createQuery(String.class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 查询对象
		criteriaQuery.select(root.get("title"));
		// 构建查询条件
		criteriaQuery.where(criteriaBuilder.equal(root.get("title"), "标题一"));
		System.out.println(session.createQuery(criteriaQuery).getResultList());
		transaction.commit();
	}
	
	/**
	 * 选择多个字段
	 */
	@Test
	public void test03() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 预期结果是String类型
		CriteriaQuery<Object[]> criteriaQuery = criteriaBuilder.createQuery(Object[].class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 选择字段
		Path<Long> idPath = root.get("id");
		Path<String> titlePath = root.get("title");
		criteriaQuery.select(criteriaBuilder.array(idPath, titlePath));
		// 构建查询条件
		criteriaQuery.where(criteriaBuilder.equal(root.get("title"), "标题一"));
		// 获取结果
		List<Object[]> objs = session.createQuery(criteriaQuery).getResultList();
		// 输出结果
		for (int i = 0; i < objs.size(); i++) {
			Object[] objArray = objs.get(i);
			System.out.println(Arrays.toString(objArray));
		}
		transaction.commit();
	}
	
	
	/**
	 * 选择多个字段
	 */
	@Test
	public void test04() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 预期结果是String类型
		CriteriaQuery<Object[]> criteriaQuery = criteriaBuilder.createQuery(Object[].class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 选择字段
		Path<Long> idPath = root.get("id");
		Path<String> titlePath = root.get("title");
		criteriaQuery.multiselect(idPath, titlePath);
		// or
		// criteriaQuery.multiselect(root.get("id"), root.get("title"));
	
		// 构建查询条件
		criteriaQuery.where(criteriaBuilder.equal(root.get("title"), "标题一"));
		// 获取结果
		List<Object[]> objs = session.createQuery(criteriaQuery).getResultList();
		// 输出结果
		for (int i = 0; i < objs.size(); i++) {
			Object[] objArray = objs.get(i);
			System.out.println(Arrays.toString(objArray));
		}
		transaction.commit();
	}
	
	/**
	 * 选择多个字段
	 */
	@Test
	public void test05() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		// 预期结果是String类型
		CriteriaQuery<Tuple> criteriaQuery = criteriaBuilder.createQuery(Tuple.class);
		// 选择根实体
		Root<Event> root = criteriaQuery.from(Event.class);
		// 选择字段
		Path<Long> idPath = root.get("id");
		Path<String> titlePath = root.get("title");
		criteriaQuery.multiselect(idPath, titlePath);
		// or
		// criteriaQuery.multiselect(root.get("id"), root.get("title"));
	
		// 构建查询条件
		criteriaQuery.where(criteriaBuilder.equal(root.get("title"), "标题一"));
		// 获取结果
		List<Tuple> tuples = session.createQuery(criteriaQuery).getResultList();
		// 输出结果
		for (Tuple tuple : tuples) {
			Long id = tuple.get(idPath);
			String title = tuple.get(titlePath);
			System.out.println(id);
			System.out.println(title);
		}
		// or 
		for ( Tuple tuple : tuples ) {
			Long id = (Long) tuple.get( 0 );
			String title = (String) tuple.get( 1 );
			System.out.println(id);
			System.out.println(title);
		}
		transaction.commit();
	}
	
	/**
	 * 多表查询
	 */
	@Test
	public void test06() {
		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();

		CriteriaQuery<Tuple> criteria = criteriaBuilder.createQuery( Tuple.class );

		Root<Event> personRoot = criteria.from( Event.class );
		Root<Datas> partnerRoot = criteria.from( Datas.class );
		criteria.multiselect( personRoot, partnerRoot );
		List<Tuple> tuples  = session.createQuery( criteria ).getResultList();
		for (Tuple tuple : tuples ) {
			System.out.println(tuple.toArray());
		}
	}
	
	/**
	 * 使用参数
	 */
	@Test
	public void test07() {
		// 查询返回结果为Object数组不能用对象，不然会报错
		// CriteriaQuery<Event> criteriaQuery = criteriaBuilder.createQuery(Event.class);

		CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
		CriteriaQuery<Object[]> criteriaQuery = criteriaBuilder.createQuery(Object[].class);
		Root<Event> root = criteriaQuery.from(Event.class);
		
		// 类.属性名
		criteriaQuery.multiselect(root.get("title"), root.get("date"));
		
		ParameterExpression<String> String1 = criteriaBuilder.parameter(String.class); // 为String类型
		ParameterExpression<Long> String2 = criteriaBuilder.parameter(Long.class); // 为String类型
		// 用比较条件生成对象
		Predicate predicate1 = criteriaBuilder.equal(root.get("title"), String1);
		Predicate predicate2 = criteriaBuilder.equal(root.get("id"), String2);
		// 放入where中
		criteriaQuery.where(predicate1, predicate2);
		TypedQuery<Object[]> query = session.createQuery(criteriaQuery);
		query.setParameter(String1, "标题二");
		query.setParameter(String2, Long.valueOf("2"));
		// Object[],先获取结果集scroll， 再输出
		List<Object[]> objs = query.getResultList();
		for (Object[] row : objs) {
			System.out.println(row[0]+"--"+row[1]);
		}
	}	
}