`
sun4love
  • 浏览: 233124 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

比springside PropertyFilter增强灵活的FieldFilter,

    博客分类:
  • orm
阅读更多

 完整代码附件内

 

 SpringSide PropertyFilter 的缺点:

 

1,不能A or B or C

 

2, 不能( A or B) and c

 

3, 不能包含between

 

4,不能属性间比较 field2 >field2

 

5,很难看的下划线 EQS_compId EQS_userName GES_recTime

 

6,即使已经知道具体类型,但也要转换成字符串

 

if (recForm.getBeginTime() != null && recForm.getEndTime() != null) {
			filters.add(new PropertyFilter("GES_recTime", DateFormatUtils
					.format(recForm.getBeginTime(), "HH:mm:ss")));
			filters.add(new PropertyFilter("LES_recTime", DateFormatUtils
					.format(recForm.getEndTime(), "HH:mm:ss")));
		}

7,功能有限的like

 

增强后的PropertyFilter

 

 

package com.sun4love.common.orm;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.beanutils.ConvertUtils;
import org.springframework.util.Assert;

/**
 * 属性过滤器
 * 
 * @author sun4love
 */
public class PropertyFilter {
	private String fieldName;
	private String otherField;
	private MatchType matchType;
	private boolean or;
	private boolean and;
	private boolean roundOr;
	private boolean roundAnd;
	private Object[] values;
	private List<PropertyFilter> filters = new ArrayList<PropertyFilter>();

	/**
	 * values为具体类型值的构造函数
	 * 
	 * @param fieldName
	 *            属性名
	 * @param matchType
	 *            匹配类型 {@link MatchType}
	 * @param values
	 *            值数组,MatchType为BETWEEN类型时,长度必须是2,其他为1,值必须是具体类型的值,
	 *            如果是字符串需要转换类型,见另一个构造函数
	 *            {@link #PropertyFilter(String, MatchType, FieldType, Object...)}
	 */
	public PropertyFilter(final String fieldName, MatchType matchType,
			Object... values) {
		this.fieldName = fieldName;
		this.matchType = matchType;
		if (this.matchType == MatchType.BETWEEN
				&& (values == null || values.length != 2)) {
			throw new IllegalArgumentException(String.format(
					"%s属性选择MatchType.BETWEEN类型时,values参数长度必须为2", fieldName));
		}
		this.values = values;
		filters.add(this);
	}

	/**
	 * 
	 * values值需要转换类型的构造函数
	 * 
	 * @param fieldName
	 *            属性名
	 * @param matchType
	 *            匹配类型 {@link MatchType}
	 * @param fieldType
	 *            属性的类型,value将被转换到此类型
	 * @param values
	 *            值数组,BETWEEN类型时,长度必须是2,其他为1,值必须是具体类型的值, 如果是字符串需要转换类型,见另一个构造函数
	 *            {@link #FieldFilter(String, MatchType, FieldType, Object...)}
	 */
	public PropertyFilter(final String fieldName, MatchType matchType,
			FieldType fieldType, Object... values) {
		this.fieldName = fieldName;
		this.matchType = matchType;
		Assert.notEmpty(values);
		if (this.matchType == MatchType.BETWEEN
				&& (values == null || values.length != 2)) {
			throw new IllegalArgumentException(String.format(
					"%s属性选择MatchType.BETWEEN类型时,values参数长度必须为2", fieldName));
		}
		for (int i = 0; i < values.length; i++) {
			this.values[i] = ConvertUtils.convert(values[i],
					fieldType.getValue());
		}
		filters.add(this);
	}

	/**
	 * 属性比较构造函数
	 * 
	 * @param fieldName
	 *            属性名
	 * @param matchType
	 *            条件类型
	 * @param otherField
	 *            其他属性
	 */
	public PropertyFilter(final String fieldName, String otherField,
			MatchType matchType) {
		this.fieldName = fieldName;
		this.matchType = matchType;
		this.otherField = otherField;
		filters.add(this);
	}

	/**
	 * 获取属性名
	 * 
	 * @return
	 */
	public String getFieldName() {
		return fieldName;
	}

	/**
	 * 向当前filter添加一个or联合过滤条件
	 * 
	 * @param filter
	 * @return
	 */
	public PropertyFilter addOrFilter(PropertyFilter filter) {
		filter.or = true;
		filters.add(filter);
		return this;
	}

	/**
	 * 向当前filter添加一个or联合过滤条件,
	 * <p>
	 * 过滤条件将作为一个整体,即将所有条件放入括号内
	 * 
	 * @param filter
	 * @return
	 */
	public PropertyFilter addRoundOrFilter(PropertyFilter filter) {
		Assert.isTrue(filter == this, "PropertyFilter不允许添加自身");
		filter.roundOr = true;
		filters.add(filter);
		return this;
	}

	/**
	 * 向当前filter添加一个and联合过滤条件,
	 * 
	 * @param filter
	 * @return
	 */
	public PropertyFilter addAndFilter(PropertyFilter filter) {
		Assert.isTrue(filter == this, "PropertyFilter不允许添加自身");
		filter.and = true;
		filters.add(filter);
		return this;
	}

	/**
	 * 
	 * 向当前filter添加一个and联合过滤条件,
	 * <p>
	 * 过滤条件将作为一个整体,即将所有条件放入括号内
	 * 
	 * @param filter
	 * @return
	 */
	public PropertyFilter addRoundAndFilter(PropertyFilter filter) {
		Assert.isTrue(filter == this, "PropertyFilter不允许添加自身");
		filter.roundAnd = true;
		filters.add(filter);
		return this;
	}

	/**
	 * 判断该filter是否是一个or联合过滤,见{@link #addOrFilter(PropertyFilter)}
	 * 
	 * @return
	 */
	public boolean isOr() {
		return or;
	}

	/**
	 * 判断该filter是否是一个and联合过滤,见{@link #addAndFilter(PropertyFilter)}
	 * 
	 * @return
	 */
	public boolean isAnd() {
		return and;
	}

	/**
	 * 判断该filter是否是一个or联合过滤, 见 {@link #addRoundOrFilter(PropertyFilter)}
	 * 
	 * @return
	 */
	public boolean isRoundOr() {
		return roundOr;
	}

	/**
	 * 判断该filter是否是一个and联合过滤, 见 {@link #addRoundAndFilter(PropertyFilter)}
	 * 
	 * @return
	 */
	public boolean isRoundAnd() {
		return roundAnd;
	}
	/**
	 * 判断该filter是否是一个联合过滤
	 * @return
	 */
	public boolean isMulti() {
		return !filters.isEmpty();
	}
	/**
	 * 获取属性的比较类型
	 * @return
	 */
	public MatchType getMatchType() {
		return matchType;
	}
	/**
	 * 获取属性比较参数值集合
	 * @return
	 */
	public Object[] getValues() {
		return values;
	}

	/**
	 * 联合filter迭代器
	 * <p>
	 * 不支持删除操作
	 * 
	 * @return
	 */
	public Iterator<PropertyFilter> iterator() {
		return new Iterator<PropertyFilter>() {
			private Iterator<PropertyFilter> it = filters.iterator();

			public boolean hasNext() {
				return it.hasNext();
			}

			public PropertyFilter next() {
				return it.next();
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	/**
	 * 联合filter作为一个过滤条件
	 * 
	 * @param filter
	 * @return
	 */
	public PropertyFilter joinFilter(PropertyFilter filter) {
		Assert.isTrue(filter == this, "PropertyFilter不允许添加自身");
		filters.add(filter);
		return this;
	}
	/**
	 * 其他field,两个属性比较时
	 * 
	 * @return
	 */
	public String getOtherField() {
		return otherField;
	}
	/**
	 * 属性类型
	 * @author sun4love
	 *
	 */
	public enum FieldType {
		String(String.class), Date(Date.class), Integer(Integer.class), Double(
				Double.class), Long(Long.class), Boolean(Boolean.class);
		private Class<?> clazz;

		private FieldType(Class<?> clazz) {
			this.clazz = clazz;
		}

		public Class<?> getValue() {
			return clazz;
		}
	}

	/** 属性比较类型. */
	public enum MatchType {
		/**
		 * 等于
		 * */
		EQ,
		/**
		 * 等于另一属性
		 * */
		EQF,
		/**
		 * like 'value'
		 * */
		LIKE,
		/**
		 * like '%value'
		 * */
		LIKE_START,
		/**
		 * like 'value%'
		 * */
		LIKE_END,
		/**
		 * like '%value%'
		 * */
		LIKE_ANYWHERE,
		/**
		 * 小于
		 * */
		LT,
		/**
		 * 小于另一属性
		 * */
		LTF,
		/**
		 * 大于
		 * */
		GT,
		/**
		 * 大于另一属性
		 * */
		GTF,
		/**
		 * 小于等于
		 * */
		LE,
		/**
		 * 小于等于另一属性
		 * */
		LEF,
		/**
		 * 大于等于
		 */
		GE,
		/**
		 * 大于等于另一属性
		 */
		GEF,
		/**
		 * 
		 * 在两者之间
		 * 
		 */
		BETWEEN,
		/**
		 * 
		 * 不等于
		 * 
		 */
		NE,
		/**
		 * 
		 * 不等于另一属性
		 * 
		 */
		NEF
	}

}
 

 

 

 当然HibernateDao也需要修改

 

package com.sun4love.common.orm.hibernate;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.transform.ResultTransformer;
import org.springframework.util.Assert;

import com.sun4love.common.reflection.ReflectionUtils;
import com.sun4love.common.orm.Page;
import com.sun4love.common.orm.PropertyFilter;
import com.sun4love.common.orm.PropertyFilter.MatchType;

/**
 * 封装SpringSide扩展功能的Hibernat DAO泛型基类.
 * 
 * 扩展功能包括分页查询,按属性过滤条件列表查询. 可在Service层直接使用,也可以扩展泛型DAO子类使用,见两个构造函数的注释.
 * 
 * @param <T>
 *            DAO操作的对象类型
 * @param <PK>
 *            主键类型
 * 
 * @author calvin
 */
public class HibernateDao<T, PK extends Serializable> extends
		SimpleHibernateDao<T, PK> {
	/**
	 * 用于Dao层子类使用的构造函数. 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends
	 * HibernateDao<User, Long>{ }
	 */
	public HibernateDao() {
		super();
	}

	/**
	 * 用于省略Dao层, Service层直接使用通用HibernateDao的构造函数. 在构造函数中定义对象类型Class. eg.
	 * HibernateDao<User, Long> userDao = new HibernateDao<User,
	 * Long>(sessionFactory, User.class);
	 */
	public HibernateDao(final SessionFactory sessionFactory,
			final Class<T> entityClass) {
		super(sessionFactory, entityClass);
	}

	// -- 分页查询函数 --//
	/**
	 * 分页获取全部对象.
	 */
	public Page<T> getAll(final Page<T> page) {
		return findPage(page);
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            分页参数.不支持其中的orderBy参数.
	 * @param hql
	 *            hql语句.
	 * @param values
	 *            数量可变的查询参数,按顺序绑定.
	 * 
	 * @return 分页查询结果, 附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<T> findPage(final Page<T> page, final String hql,
			final Object... values) {
		Assert.notNull(page, "page不能为空");

		Query q = createQuery(hql, values);

		if (page.isAutoCount()) {
			long totalCount = countHqlResult(hql, values);
			page.setTotalCount(totalCount);
		}

		setPageParameter(q, page);
		List result = q.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            分页参数.
	 * @param hql
	 *            hql语句.
	 * @param values
	 *            命名参数,按名称绑定.
	 * 
	 * @return 分页查询结果, 附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<T> findPage(final Page<T> page, final String hql,
			final Map<String, ?> values) {
		Assert.notNull(page, "page不能为空");

		Query q = createQuery(hql, values);

		if (page.isAutoCount()) {
			long totalCount = countHqlResult(hql, values);
			page.setTotalCount(totalCount);
		}

		setPageParameter(q, page);

		List result = q.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 按Criteria分页查询.
	 * 
	 * @param page
	 *            分页参数.
	 * @param criterions
	 *            数量可变的Criterion.
	 * 
	 * @return 分页查询结果.附带结果列表及所有查询时的参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<T> findPage(final Page<T> page, final Criterion... criterions) {
		Assert.notNull(page, "page不能为空");

		Criteria c = createCriteria(criterions);

		if (page.isAutoCount()) {
			int totalCount = countCriteriaResult(c);
			page.setTotalCount(totalCount);
		}

		setPageParameter(c, page);
		List result = c.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 设置分页参数到Query对象,辅助函数.
	 */
	protected Query setPageParameter(final Query q, final Page<T> page) {
		// hibernate的firstResult的序号从0开始
		q.setFirstResult(page.getFirst() - 1);
		q.setMaxResults(page.getPageSize());
		return q;
	}

	/**
	 * 设置分页参数到Criteria对象,辅助函数.
	 */
	protected Criteria setPageParameter(final Criteria c, final Page<T> page) {
		// hibernate的firstResult的序号从0开始
		c.setFirstResult(page.getFirst() - 1);
		c.setMaxResults(page.getPageSize());

		if (page.isOrderBySetted()) {
			String[] orderByArray = StringUtils.split(page.getOrderBy(), ',');
			String[] orderArray = StringUtils.split(page.getOrder(), ',');

			Assert.isTrue(orderByArray.length == orderArray.length,
					"分页多重排序参数中,排序字段与排序方向的个数不相等");

			for (int i = 0; i < orderByArray.length; i++) {
				if (Page.ASC.equals(orderArray[i])) {
					c.addOrder(Order.asc(orderByArray[i]));
				} else {
					c.addOrder(Order.desc(orderByArray[i]));
				}
			}
		}
		return c;
	}

	/**
	 * 执行count查询获得本次Hql查询所能获得的对象总数.
	 * 
	 * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
	 */
	protected long countHqlResult(final String hql, final Object... values) {
		String fromHql = hql;
		// select子句与order by子句会影响count查询,进行简单的排除.
		fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
		fromHql = StringUtils.substringBefore(fromHql, "order by");

		String countHql = "select count(*) " + fromHql;

		try {
			Long count = findUnique(countHql, values);
			return count;
		} catch (Exception e) {
			throw new RuntimeException("hql can't be auto count, hql is:"
					+ countHql, e);
		}
	}

	/**
	 * 执行count查询获得本次Hql查询所能获得的对象总数.
	 * 
	 * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
	 */
	protected long countHqlResult(final String hql, final Map<String, ?> values) {
		String fromHql = hql;
		// select子句与order by子句会影响count查询,进行简单的排除.
		fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
		fromHql = StringUtils.substringBefore(fromHql, "order by");

		String countHql = "select count(*) " + fromHql;

		try {
			Long count = findUnique(countHql, values);
			return count;
		} catch (Exception e) {
			throw new RuntimeException("hql can't be auto count, hql is:"
					+ countHql, e);
		}
	}

	/**
	 * 执行count查询获得本次Criteria查询所能获得的对象总数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	protected int countCriteriaResult(final Criteria c) {
		CriteriaImpl impl = (CriteriaImpl) c;

		// 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作
		Projection projection = impl.getProjection();
		ResultTransformer transformer = impl.getResultTransformer();

		List<CriteriaImpl.OrderEntry> orderEntries = null;
		try {
			orderEntries = (List) ReflectionUtils.getFieldValue(impl,
					"orderEntries");
			ReflectionUtils
					.setFieldValue(impl, "orderEntries", new ArrayList());
		} catch (Exception e) {
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}

		// 执行Count查询
		int totalCount = ((Long) c.setProjection(Projections.rowCount())
				.uniqueResult()).intValue();

		// 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
		c.setProjection(projection);

		if (projection == null) {
			c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		}
		if (transformer != null) {
			c.setResultTransformer(transformer);
		}
		try {
			ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
		} catch (Exception e) {
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}

		return totalCount;
	}

	// -- 属性过滤条件(FieldFilter)查询函数 --//

	/**
	 * 按属性查找对象列表,支持多种匹配方式.
	 * 
	 * @param matchType
	 *            匹配方式,目前支持的取值见FieldFilter的MatcheType enum.
	 */
	public List<T> findBy(final String fieldName, final Object value,
			final MatchType matchType) {
		Criterion criterion = buildFieldFilterCriterion(fieldName,
				new Object[] { value }, null, matchType);
		return find(criterion);
	}

	/**
	 * 按属性过滤条件列表查找对象列表.
	 */
	public List<T> find(List<PropertyFilter> filters) {
		Criterion[] criterions = buildFieldFilterCriterions(filters);
		return find(criterions);
	}

	/**
	 * 按属性过滤条件列表分页查找对象.
	 */
	public Page<T> findPage(final Page<T> page,
			final List<PropertyFilter> filters) {
		Criterion[] criterions = buildFieldFilterCriterions(filters);
		return findPage(page, criterions);
	}

	/**
	 * 按属性条件列表创建Criterion数组,辅助函数.
	 */
	protected Criterion[] buildFieldFilterCriterions(
			final List<PropertyFilter> filters) {
		List<Criterion> criterionList = new ArrayList<Criterion>();
		for (PropertyFilter filter : filters) {
			if (!filter.isMulti()) {
				criterionList.add(buildFieldFilterCriterion(
						filter.getFieldName(), filter.getValues(),
						filter.getOtherField(), filter.getMatchType()));
			} else {
				criterionList.add(buildMultiFieldFilter(filter));
			}
		}
		return criterionList.toArray(new Criterion[criterionList.size()]);
	}

	protected Criterion buildMultiFieldFilter(PropertyFilter filter) {
		Criterion last = null;
		for (Iterator<PropertyFilter> it = filter.iterator(); it.hasNext();) {
			PropertyFilter ff = it.next();
			Criterion c = buildFieldFilterCriterion(ff);
			if (ff.isAnd()) {
				last = new SimpleLogicalExpression(last, c, "and");
			} else if (ff.isOr()) {
				last = new SimpleLogicalExpression(last, c, "or");
			} else if (ff.isRoundAnd()) {
				last = Restrictions.and(last, c);
			} else if (ff.isRoundOr()) {
				last = Restrictions.or(last, c);
			} else {
				last = c;
			}
		}
		return last;
	}

	/**
	 * 按属性条件参数创建Criterion,辅助函数.
	 */
	protected Criterion buildFieldFilterCriterion(final String fieldName,
			final Object[] fieldValues, String otherField,
			final MatchType matchType) {
		Assert.hasText(fieldName, "fieldName不能为空");
		Criterion criterion = null;
		try {
			// 根据MatchType构造criterion
			if (MatchType.EQ.equals(matchType)) {
				criterion = Restrictions.eq(fieldName, fieldValues[0]);
			} else if (MatchType.LE.equals(matchType)) {
				criterion = Restrictions.le(fieldName, fieldValues[0]);
			} else if (MatchType.LT.equals(matchType)) {
				criterion = Restrictions.lt(fieldName, fieldValues[0]);
			} else if (MatchType.GE.equals(matchType)) {
				criterion = Restrictions.ge(fieldName, fieldValues[0]);
			} else if (MatchType.GT.equals(matchType)) {
				criterion = Restrictions.gt(fieldName, fieldValues[0]);
			} else if (MatchType.NE.equals(matchType)) {
				criterion = Restrictions.ne(fieldName, fieldValues[0]);
			} else if (MatchType.EQF.equals(matchType)) {
				criterion = Restrictions.eqProperty(fieldName, otherField);
			} else if (MatchType.LEF.equals(matchType)) {
				criterion = Restrictions.leProperty(fieldName, otherField);
			} else if (MatchType.LTF.equals(matchType)) {
				criterion = Restrictions.ltProperty(fieldName, otherField);
			} else if (MatchType.GEF.equals(matchType)) {
				criterion = Restrictions.geProperty(fieldName, otherField);
			} else if (MatchType.GTF.equals(matchType)) {
				criterion = Restrictions.gtProperty(fieldName, otherField);
			} else if (MatchType.NEF.equals(matchType)) {
				criterion = Restrictions.neProperty(fieldName, otherField);
			} else if (MatchType.LIKE.equals(matchType)) {
				criterion = Restrictions.like(fieldName,
						(String) fieldValues[0], MatchMode.EXACT);
			} else if (MatchType.LIKE_START.equals(matchType)) {
				criterion = Restrictions.like(fieldName,
						(String) fieldValues[0], MatchMode.START);
			} else if (MatchType.LIKE_END.equals(matchType)) {
				criterion = Restrictions.like(fieldName,
						(String) fieldValues[0], MatchMode.END);
			} else if (MatchType.LIKE_ANYWHERE.equals(matchType)) {
				criterion = Restrictions.like(fieldName,
						(String) fieldValues[0], MatchMode.ANYWHERE);
			} else if (MatchType.BETWEEN.equals(matchType)) {
				criterion = Restrictions.between(fieldName, fieldValues[0],
						fieldValues[1]);
			}
		} catch (Exception e) {
			throw ReflectionUtils.convertReflectionExceptionToUnchecked(e);
		}
		return criterion;
	}

	/**
	 * 按属性条件参数创建Criterion,辅助函数.
	 */
	protected Criterion buildFieldFilterCriterion(PropertyFilter filter) {
		return buildFieldFilterCriterion(filter.getFieldName(),
				filter.getValues(), filter.getOtherField(),
				filter.getMatchType());
	}

	/**
	 * 判断对象的属性值在数据库内是否唯一.
	 * 
	 * 在修改对象的情景下,如果属性新修改的值(value)等于属性原来的值(orgValue)则不作比较.
	 */
	public boolean isFieldUnique(final String fieldName, final Object newValue,
			final Object oldValue) {
		if (newValue == null || newValue.equals(oldValue)) {
			return true;
		}
		Object object = findUniqueBy(fieldName, newValue);
		return (object == null);
	}
}
 

 

 事例:

 

public Setting getSetting(String key) {
		List<FieldFilter> filters = new ArrayList<FieldFilter>();
		FieldFilter ff1 = new FieldFilter("keyField", "data", MatchType.EQF);
		FieldFilter ff2 = new FieldFilter("data", MatchType.BETWEEN, "3", "6");
		FieldFilter ff3 = new FieldFilter("data", MatchType.BETWEEN, "4", "8");
		ff1.addRoundAndFilter(ff2);
		ff2.addOrFilter(ff3);
		filters.add(ff1);
		settingDao.find(filters);
		return null;
	}

 

 

 

 

 生成sql

 

   select
        this_.keyField as keyField0_0_,
        this_.version as version0_0_,
        this_.data as data0_0_,
        this_.description as descript4_0_0_,
        this_.orderby as orderby0_0_
    from
        setting this_
    where
        (
            this_.keyField=this_.data
            and this_.data between ? and ?
        )
        or this_.data between ? and ?

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

6
5
分享到:
评论
2 楼 hljxpf 2012-03-10  
源码引用的包,给得不全啊
1 楼 wzjsyj 2011-09-21  
你好,能不能给个完整的例子,非常感谢,253436278@qq.com

相关推荐

    SpringSide3的PropertyFilter条件过滤应用小结

    标题“SpringSide3的PropertyFilter条件过滤应用小结”指的是对SpringSide项目中PropertyFilter类的一个功能总结,这个类主要用于实现基于属性的条件过滤。在Java Web开发中,尤其是在使用Spring框架时,我们经常...

    Springside-core-4.1.0/Springside-core-4.1.0

    《SpringSide核心库4.1.0深度解析》 SpringSide是Java开发中的一款轻量级框架,它基于Spring框架,旨在简化企业级应用的开发流程。本文将深入探讨SpringSide-core-4.1.0的核心特性,以及其在实际项目中的应用。 一...

    springside开发全面讲解

    《springside开发全面讲解》是一份旨在帮助开发者深入了解并掌握springside框架的详尽教程。springside是一款基于Spring框架的轻量级开发工具集,它为Java开发提供了简洁、高效的解决方案,尤其适合中大型项目的开发...

    springside-3.2.2源码

    《SpringSide 3.2.2 源码解析与技术深度探讨》 SpringSide 是一个基于 Spring Framework 的 Java 开发工具集,旨在简化 Spring 应用程序的开发过程,提供一套快速、现代且规范的开发实践。SpringSide 3.2.2 版本是...

    springside-core-4.2.2.GA(含关联的test.jar)

    pom.xml配置 ...mvn install:install-file -DgroupId=org.springside -DartifactId=springside-core -Dversion=4.2.2.GA -Dfile=./springside-core-4.2.2.GA.jar -Dpackaging=jar -DgeneratePom=true

    SpringSide4 参考手册

    SpringSide4参考手册是一份详尽的文档,涵盖了使用SpringSide4.0版本开发应用时可能会用到的各种技术组件和模块。SpringSide是一个开源的Java开发平台,它集成了Spring框架和大量实用的组件,以方便开发人员构建复杂...

    有springside4.2.3-GA.jar 包

    在Java开发领域,SpringSide框架以其高效、灵活和强大的特性深受开发者喜爱。本文将围绕springside4.2.3-GA.jar这个核心组件,探讨其在Java应用中的重要作用以及如何利用它提升开发效率。 首先,我们需要理解什么是...

    springside3.0.zip

    9. **日志管理**:SpringSide 3.0 使用Log4j或Logback作为日志框架,提供了灵活的日志配置和丰富的日志记录功能。 10. **持续集成**:SpringSide 3.0 考虑到持续集成的重要性,推荐使用Hudson或Jenkins进行持续构建...

    springside

    《SpringSide:全面解析与应用》 SpringSide项目是一个基于Java的开源软件开发框架,它以Spring Framework为核心,旨在提供一套简洁、规范的项目构建和开发实践。在深入理解SpringSide之前,我们首先需要了解Spring...

    springside-4.0.0.GA.zip

    《SpringSide 4.0.0.GA:JavaEE世界的春天之光》 ...无论是对于新手还是资深开发者,SpringSide都是一个不可多得的学习和参考资料库,它不仅展示了技术的实用性和灵活性,还体现了JavaEE开发的艺术与智慧。

    SpringSide3.3.4安装部署

    SpringSide3.3.4 安装部署详解 SpringSide3.3.4 安装部署是指在计算机上安装和部署 SpringSide3.3.4 软件的过程。在这个过程中,我们需要使用 Maven 工具来生成项目模板,安装 mini-web 应用程序,并配置相应的...

    springside-core-4.1.0.GA.jar

    5. **AOP(面向切面编程)支持**: Springside提供了对Spring AOP的集成,允许开发者定义切面,实现如日志记录、事务管理等功能,增强了代码的可复用性。 6. **单元测试**:Springside鼓励并简化了单元测试的编写,...

    springside的jar包

    6. **安全控制**:Springside提供了基于Spring Security的安全控制模块,可以快速实现用户认证与授权功能,增强了应用的安全性。 7. **日志管理**:集成了Logback作为日志系统,提供了灵活的日志级别控制和输出格式...

    springside3.3完整版

    《SpringSide 3.3 完整版:深入解析与实战指南》 SpringSide 是一个开源的Java项目,旨在提供一套简洁、规范的Spring应用开发模板,帮助开发者快速上手Spring框架。本版本,即“springside3.3”,是专为MyEclipse...

    springside3.3.4 使用方法

    ### springside3.3.4使用方法与SSH整合详解 #### 一、Springside简介 Springside项目是基于Spring框架的一个应用架构示例,它提供了一套完整的开发模式来构建企业级Java Web应用程序。Springside 3.3.4版本作为一...

    springside.jar

    《springside.jar在Java应用中的使用详解》 在Java开发领域,springside.jar是一个备受推崇的开源项目,它为开发者提供了丰富的工具和最佳实践,以简化Spring框架的使用。本文将深入探讨springside.jar的核心功能,...

    springside4(showcase)

    在SpringSide 4的showcase中,我们可以期待看到如何有效地利用Spring MVC来构建高效、灵活的Web服务。 首先,Spring MVC的核心组件包括DispatcherServlet、Controller、Model、View和ViewResolver。...

    springside4-4.1.0.GA

    《SpringSide 4.1.0.GA:深入探索企业级Java开发的得力助手》 SpringSide项目,作为一个开源的Java开发框架,是许多开发者在进行企业级应用开发时的首选工具。SpringSide 4.1.0.GA版本是该项目的一个稳定版本,它在...

    springside-core-4.2.2.GA相关jar包

    《SpringSide核心库4.2.2.GA详解》 SpringSide是一款基于Spring框架的开源项目,它旨在为Java开发者提供一个快速、整洁且高效的开发环境。SpringSide Core 4.2.2.GA是该项目的核心库,包含了丰富的功能和最佳实践,...

Global site tag (gtag.js) - Google Analytics