基于HIBERNATE的全自动查询框架（三）

本篇讲解“标准条件处理器”，此处理器实现了IConditionBuilder接口，此接口只有一个方法

//参数分别是属性名，属性值，POJO类，查询时的别名
public Criterion parseToCriterion(Object key, Object value, Class pojoClass, String alias);

如果要完整重写条件处理器，请实现此接口，另外下面的类的说明中还把另一种扩展方法写出来了。

标准条件得理器的完整代码

package com.esc.common.util.conditionbuilder;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Expression;
import org.hibernate.property.ChainedPropertyAccessor;
import org.hibernate.property.PropertyAccessor;
import org.hibernate.property.PropertyAccessorFactory;

import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;

import com.esc.common.exception.BusinessException;
import com.esc.common.util.CollectionUtils;
import com.esc.common.util.Condition;
import com.esc.common.util.DetachedCriteriaUtil;
import com.esc.common.util.Operator;
import com.esc.common.util.StringUtil;
import com.esc.common.util.conditionbuilder.valuehandler.BigDecimalValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.BooleanValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.DateValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.DoubleValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.FloatValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.IValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.IntegerValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.LongValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.StringValueHandler;
import com.esc.common.util.conditionbuilder.valuehandler.TimeStampValueHandler;

/**
 * 标准的条件处理器，功能：把零散的条件属性组装成HIBERNATE能识别的Criterion对象 输入：属性名，属性值，所属性的pojo类，和别名
 * 输出：Criterion 
 * 扩展时：
 * 1、如果完整实现，只需要实现接口IConditionBuilder就行。
 * 2、如果只想另外处理某些类型的条件，如整数型条件处理器，则模仿IntegerValueHandler类再实现一个，
 *    然后通过addCustomerConditionHandlers或setCustomerConditionHandlers方法设进来就行
 * @author lgdlgd
 * 
 */
@SuppressWarnings("unchecked")
public class StandardConditionBuilder implements IConditionBuilder {
	/** 默认的各类型的条件处理器集合 */
	private Set<IValueHandler> conditionHandlers = new HashSet<IValueHandler>( 10);
	/** 用户自定义的条件处理器集合，如果默认列表中有相同类型的条件处理类，将被此集合中相同类覆盖 */
	private Set<IValueHandler> customerConditionHandlers;
	
	/** 缓存POJO类的属性访问器 */
	private Map<String, PropertyAccessor> propertyAccessors = new LinkedHashMap<String, PropertyAccessor>();

	/**
	 * 初始化的时候，把各种类型的处理器全部设入
	 * 
	 * @author lgdlgd 2009-10-13
	 */
	public StandardConditionBuilder() {
		conditionHandlers.add(StringValueHandler.getInstance());
		conditionHandlers.add(DoubleValueHandler.getInstance());
		conditionHandlers.add(LongValueHandler.getInstance());
		conditionHandlers.add(IntegerValueHandler.getInstance());
		conditionHandlers.add(BigDecimalValueHandler.getInstance());
		conditionHandlers.add(DateValueHandler.getInstance());
		conditionHandlers.add(TimeStampValueHandler.getInstance());
		conditionHandlers.add(FloatValueHandler.getInstance());
		conditionHandlers.add(BooleanValueHandler.getInstance());
	}

	/**
	 * 把字符串条件解析成condition对象，再解析成Criterion对象 此方法不支持POJO中子集合为MAP类型的查询 2008-10-16
	 * 
	 * @author lgdlgd
	 * @param key
	 * @param value
	 * @param pojoClass
	 */
	@Override
	public Criterion parseToCriterion(Object key, Object value,
			Class pojoClass, String alias) {
		try {
			return getCriterion(key.toString(), value, getPropertyType(
					pojoClass, key.toString().trim()), alias);
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}

	// ////////////以下三个方法用于递归取得POJO类中的属性的类型////////////////////////
	private Type getPropertyGenericReturnType(Class rootClass,
			String propertyName) {
		PropertyAccessor propertyAccessor = propertyAccessors.get(rootClass
				.getName());
		if (propertyAccessor == null) {
			propertyAccessor = new ChainedPropertyAccessor(
					new PropertyAccessor[] {
							PropertyAccessorFactory.getPropertyAccessor(
									rootClass, null),
							PropertyAccessorFactory
									.getPropertyAccessor("field") });
			propertyAccessors.put(rootClass.getName(), propertyAccessor);
		}
		return propertyAccessor.getGetter(rootClass, propertyName).getMethod()
				.getGenericReturnType();
	}

	private Class getPropertyType(Class rootClass, String propertyName)
			throws SecurityException, NoSuchFieldException {
		Type result = null;
		if (propertyName.contains(".")) {
			result = getPropertyType(rootClass, propertyName.split("\\."), 0);
		} else {
			result = getPropertyGenericReturnType(rootClass, propertyName);
		}
		if (result instanceof ParameterizedTypeImpl) {
			throw new BusinessException("属性" + propertyName
					+ "未明确指定集合中元素的属性名，无法进行拼装条件");
		}

		if (!(result instanceof Class)) {
			throw new BusinessException("属性" + propertyName + "为不合法的类型:"
					+ result + "，无法进行拼装条件");
		}

		return (Class) result;
	}

	private Class getPropertyType(Class rootClass, String[] propertyNames,
			int index) throws SecurityException, NoSuchFieldException {
		Class result = null;
		if (index < propertyNames.length - 1) {
			Type genericType = getPropertyGenericReturnType(rootClass,
					propertyNames[index]);
			if (genericType instanceof ParameterizedTypeImpl) {
				result = getPropertyType(
						(Class) ((ParameterizedTypeImpl) genericType)
								.getActualTypeArguments()[0], propertyNames,
						++index);
			} else {
				result = getPropertyType((Class) genericType, propertyNames,
						++index);
			}
		} else {
			result = (Class) getPropertyGenericReturnType(rootClass,
					propertyNames[index]);
		}
		return result;
	}

	// ////////////以上三个方法用于递归取得POJO类中的属性的类型////////////////////////

	/**
	 * 把字符串条件解析成condition对象，再解析成Criterion对象
	 * 
	 * @author lgdlgd 2009-1-3
	 * @param key
	 *            属性名
	 * @param value
	 *            属性值，包含操作符的值
	 * @param valueType
	 *            属性类型
	 * @param alias
	 *            别名
	 * @return Criterion 条件对象
	 */
	protected Criterion getCriterion(String key, Object value, Class valueType,
			String alias) {
		if (value == null)
			return null;
		List<Condition> conditios = null;
		// 1、先将字符串转换成一个或多个Condition对象
		if (valueType.isAssignableFrom(String.class)) {// 属性为字符串
			// 直接创建一个LIKE的条件
			conditios = new ArrayList<Condition>(1);
			Condition condition = new Condition(key, value.toString(),
					Operator.LIKE);
			conditios.add(condition);
		} else {// 属性为其它
			// 这里有可能会返回两个Condition
			conditios = parseStringToCondition(key, value.toString());
		}
		if (CollectionUtils.isEmpty(conditios))
			return null;
		// 2、 取得所有类型条件处理器,通过它将Condition对象集合转换成Criterion对象
		Set<IValueHandler> temp = getConditionHandlers();
		for (IValueHandler handler : temp) {
			if (valueType.isAssignableFrom(handler.getDealType())) {
				// 最终通过此方法返回一个HIBERNATE的Criterion对象
				return assembleToOne(handler.getConditions(conditios, alias));
			}
		}
		throw new BusinessException("找不到匹配的条件处理类，无法过滤此属性，请定义此类型的条件处理类，条件类型："
				+ valueType.getName());
	}

	/**
	 * 把多个条件用and组成一个
	 * 
	 * @author lgdlgd 2009-1-2
	 * @param criterions
	 * @return
	 */
	private Criterion assembleToOne(List<Criterion> criterions) {
		if (criterions == null)
			return null;
		Criterion result = null;
		for (Criterion criterion : criterions) {
			if (result == null) {
				result = criterion;
			} else {
				result = Expression.and(result, criterion);
			}
		}
		return result;
	}

	/**
	 * 字符串中只允许有<和<=号 2008-10-15 把字符串条件解析成CONDITION对象
	 * 
	 * @author lgdlgd
	 * @param key
	 * @param value
	 * @return
	 */
	private static List<Condition> parseStringToCondition(String key,
			String value) {
		if (StringUtil.isEmpty(value))
			return null;

		List<Condition> conditions = new ArrayList<Condition>(5);
		String valueTemp = value.trim();
		int srcLength = value.length();
		int trimLength = valueTemp.length();

		if (trimLength != srcLength) {// 前或者有空格，要进一步检查是否有 aaa <= x <= 或者 <= x
										// <= aaa的情况
			if (trimLength == 0) {
				return null;
			}
			if (valueTemp.substring(0, 1).equals("<")) {// 属 <= x <= aaa的情况
				// 把前面截断
				value = value.substring(value
						.indexOf(DetachedCriteriaUtil.MIDDLE_SEPRATOR_CHAR),
						srcLength);
			} else if (valueTemp.substring(trimLength - 1, trimLength).equals(
					"<")
					|| valueTemp.substring(trimLength - 1, trimLength).equals(
							"=")) {// 属 aaa <= x <= 的情况
				// 把后面截断
				value = value.substring(0, value.indexOf(DetachedCriteriaUtil.MIDDLE_SEPRATOR_CHAR) + 1);
			}
		}

		if (value.trim().indexOf(DetachedCriteriaUtil.SEPARATOR_TWO_SPACE) != -1) {// 多条件，也可能是有操作符的单条件
			String[] split = value.trim().split(
					DetachedCriteriaUtil.SEPARATOR_TWO_SPACE);
			if (split.length == 3) {// 类似于 值 <= x 或 x <= 值的表达式
				boolean xPosition = split[0]
						.equalsIgnoreCase(DetachedCriteriaUtil.MIDDLE_SEPRATOR_CHAR);
				if (xPosition) {// x <= 值
					Condition condition = new Condition(key, split[2], split[1]);
					conditions.add(condition);
				} else { // 值 <= x
					if (split[1].equals("<")) {// 小于
						Condition condition = new Condition(key, split[0],
								Operator.GT);
						conditions.add(condition);
					} else {// 小于等于
						Condition condition = new Condition(key, split[0],
								Operator.GE);
						conditions.add(condition);
					}
				}

			} else if (split.length == 5) {// 类似于 值1 <= x <= 值2 的表达式
				// 把 值1 <= x 这部份拼成条件
				if (split[1].equals("<")) {
					Condition condition = new Condition(key, split[0],
							Operator.GT);
					conditions.add(condition);
				} else {
					Condition condition = new Condition(key, split[0],
							Operator.GE);
					conditions.add(condition);
				}
				// 把 x <= 值2 这部份拼成条件
				Condition condition = new Condition(key, split[4], split[3]);
				conditions.add(condition);
			}
		} else {// 单条件，无操作符
			Condition condition = new Condition(key, value);
			conditions.add(condition);
		}

		return conditions;
	}

	/**
	 * 获得所有条件组合器
	 * 
	 * @author lgdlgd 2009-1-3
	 * @return
	 */
	protected Set<IValueHandler> getConditionHandlers() {
		if (CollectionUtils.hasNotNullElement(customerConditionHandlers)) {
			conditionHandlers.addAll(customerConditionHandlers);
		}
		return conditionHandlers;
	}

	////////////////////下面两个方法是预留给用扩展某些类型的条件处理器用的///////////////
	/**
	 * 单个增加条件得处器集合
	 * @author lgdlgd
	 * 2009-10-13
	 * @param handler
	 */
	public void addCustomerConditionHandlers(IValueHandler handler) {
		if(handler==null){
			throw new BusinessException("传入条件处理器为空。");
		}
		if(customerConditionHandlers==null){
			customerConditionHandlers = new HashSet<IValueHandler>(1);;
		}
		customerConditionHandlers.add(handler);
	}

	/**
	 * 传入用户自定义条件处理器集合
	 * @author lgdlgd
	 * 2009-10-13
	 * @param customerConditionDealers
	 */
	public void setCustomerConditionHandlers(
			Set<IValueHandler> customerConditionDealers) {
		this.customerConditionHandlers = customerConditionDealers;
	}
	////////////////////上面两个方法是预留给用户扩展某些类型的条件处理器用的///////////////
}

本类构造函数中初始化所有默认的基本类型的值处理器，所有类型的条件最终是通过它们拼装成Criterion对象的，下一篇讲解这些具体类型处理器类。