• Home
• com.arsframework
• ars-database
• 2.0.0
• source code
• DetachedCriteriaQuery.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

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.Match;
import ars.util.Conditions.Condition;
import ars.database.repository.Query;
import ars.database.repository.Repositories;

/**
 * Hibernate离线查询实现
 *
 * @param  数据模型
 * @author wuyongqiang
 */
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("SessionFactory must not be null");
        }
        if (model == null) {
            throw new IllegalArgumentException("Model must not be null");
        }
        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 (session == null) {
            throw new IllegalArgumentException("Session must not be null");
        }
        if (this.subquery) {
            String primary = Repositories.getPrimary(this.getModel());
            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 joinType 外键关联类型
     * @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 wuyongqiang
     */
    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