ars.database.hibernate.DetachedCriteriaQuery Maven / Gradle / Ivy

Go to download
package ars.database.hibernate;

import java.util.Map;
import java.util.List;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Collection;

import org.hibernate.Session;
import org.hibernate.Criteria;
import org.hibernate.type.Type;
import org.hibernate.sql.JoinType;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Subqueries;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.metadata.ClassMetadata;

import ars.util.Beans;
import ars.util.Strings;
import ars.util.Conditions;
import ars.util.Conditions.Or;
import ars.util.Conditions.And;
import ars.util.Conditions.Logic;
import ars.util.Conditions.Condition;
import ars.database.repository.Query;
import ars.database.hibernate.Hibernates;
import ars.database.repository.Repositories;

/**
 * Hibernate离线查询实现
 * 
 * @author yongqiangwu
 * 
 * @param 
 *            数据模型
 */
public class DetachedCriteriaQuery implements Query {
	private int page; // 分页页码
	private int size; // 分页数量
	private T object; // 单个实例
	private List stats; // 统计数据列表
	private List objects; // 实例列表
	private Integer count; // 实例数量
	private Class model; // 数据模型
	private boolean loaded; // 数据是否已加载
	private boolean subquery; // 是否需要子查询
	private DetachedCriteria criteria; // 离线查询对象
	private SessionFactory sessionFactory; // 会话工厂对象
	private List orders = new LinkedList();
	private ProjectionList projections = Projections.projectionList();
	private Map aliases = new HashMap();

	public DetachedCriteriaQuery(SessionFactory sessionFactory, Class model) {
		if (sessionFactory == null) {
			throw new IllegalArgumentException("Illegal sessionFactory:" + sessionFactory);
		}
		if (model == null) {
			throw new IllegalArgumentException("Illegal model:" + model);
		}
		this.model = model;
		this.sessionFactory = sessionFactory;
		this.criteria = DetachedCriteria.forClass(model);
	}

	public SessionFactory getSessionFactory() {
		return this.sessionFactory;
	}

	public DetachedCriteria getDetachedCriteria() {
		return this.criteria;
	}

	/**
	 * 获取在线查询对象
	 * 
	 * @param session
	 *            持久化会话对象
	 * @return 在线查询对象
	 */
	protected Criteria getExecutableCriteria(Session session) {
		if (this.subquery) {
			String primary = Repositories.getRepository(this.getModel()).getPrimary();
			this.criteria = DetachedCriteria.forClass(this.getModel())
					.add(Subqueries.propertyIn(primary, this.criteria.setProjection(Property.forName(primary))));
			this.aliases.clear();
		}
		for (String property : this.orders) {
			boolean asc = property.charAt(0) == '+';
			String alias = this.getCriteriaAlias(property.substring(1), JoinType.LEFT_OUTER_JOIN);
			if (asc) {
				this.criteria.addOrder(Order.asc(alias));
			} else {
				this.criteria.addOrder(Order.desc(alias));
			}
		}
		Criteria criteria = this.criteria.getExecutableCriteria(session)
				.setResultTransformer(DetachedCriteria.ROOT_ENTITY);
		int index = (this.page - 1) * this.size;
		if (index > 0) {
			criteria.setFirstResult(index);
		}
		if (this.size > 0) {
			criteria.setMaxResults(this.size);
		}
		return criteria;
	}

	/**
	 * 获取属性查询描述
	 * 
	 * @param property
	 *            属性名称，可使用“.”号隔开
	 * @param 外键关联类型
	 * @return 描述名称
	 */
	private String _getCriteriaAlias(String property, JoinType joinType) {
		String alias = this.aliases.get(property);
		if (alias == null) {
			int index = property.lastIndexOf('.');
			if (index <= 0) {
				alias = property + this.aliases.size();
				this.criteria.createAlias(property, alias, joinType);
			} else {
				alias = property.substring(index + 1) + this.aliases.size();
				this.criteria.createAlias(
						this._getCriteriaAlias(property.substring(0, index), joinType) + property.substring(index),
						alias);
			}
			this.aliases.put(property, alias);
		}
		return alias;
	}

	/**
	 * 获取属性查询描述
	 * 
	 * @param property
	 *            属性名称，可使用“.”号隔开
	 * @return 描述名称
	 */
	protected String getCriteriaAlias(String property) {
		return this.getCriteriaAlias(property, JoinType.LEFT_OUTER_JOIN);
	}

	/**
	 * 获取属性查询描述
	 * 
	 * @param property
	 *            属性名称，可使用“.”号隔开
	 * @param joinType
	 *            外键关联类型
	 * @return 描述名称
	 */
	protected String getCriteriaAlias(String property, JoinType joinType) {
		int index = property.lastIndexOf('.');
		if (index <= 0) {
			return property;
		}
		return this._getCriteriaAlias(property.substring(0, index), joinType) + property.substring(index);
	}

	/**
	 * 条件包装对象
	 * 
	 * @author yongqiangwu
	 * 
	 */
	class ConditionWrapper {
		private String property; // 条件名称
		private Object value; // 条件值

		public ConditionWrapper(String property, Object value) {
			this.property = property;
			this.value = value;
		}

		public String getProperty() {
			return property;
		}

		public Object getValue() {
			return value;
		}

	}

	/**
	 * 获取条件包装对象
	 * 
	 * @param property
	 *            属性名称
	 * @param value
	 *            属性值
	 * @return 条件包装对象实例
	 */
	protected ConditionWrapper getConditionWrapper(String property, Object value) {
		if (!this.subquery) {
			int sign = property.indexOf('.');
			this.subquery = Hibernates
					.getPropertyType(this.sessionFactory, this.model, sign > 0 ? property.substring(0, sign) : property)
					.isCollectionType();
		}
		Type type = Hibernates.getPropertyType(this.sessionFactory, this.model, property);
		Class meta = Hibernates.getPropertyTypeClass(this.sessionFactory, type);
		if (type.isEntityType() || type.isCollectionType()) {
			ClassMetadata metadata = Hibernates.getClassMetadata(this.sessionFactory, meta);
			Class primaryType = metadata.getIdentifierType().getReturnedClass();
			property = new StringBuilder(property).append('.').append(metadata.getIdentifierPropertyName()).toString();
			if (value instanceof Collection || value instanceof Object[]) {
				Collection values = value instanceof Collection ? (Collection) value
						: Arrays.asList((Object[]) value);
				List