为了简化分页查询的条件参数，写了一个工具类。
前提是，页面的参数命名必须按照一定规则，这个规则是f_dataType_property以及s_sortType_property。
f_前缀代表这是一个过滤器(filter)，s_前缀代表这是一个排序器(Sort)。
dataType是数据类型，可以写一个枚举来定义这些类型，sortType是排序类型，也可以写一个枚举来定义。
接下来，页面提交到类里面的时候，需要用一个类的静态方法来处理并解析提交的参数。
Map<String, String> parametersMap = org.springframework.web.util.WebUtils.getParametersStartingWith(request, prefix);
prefix就是前缀，根据f_前缀以及s_前缀，就可以拿到过滤器以及排序器的Map集合
然后，
SimpleFilter simpleFilter = new SimpleFilter();
for (Map.Entry<String, String> entry : parametersMap.entrySet()) {
// 添加过滤器，这行添加过滤器仅作为一个例子，实际上并不正确，还需要根据dataType来转换value的值类型
// 并且key也有可能需要添加级联处理
simpleFilter.addFilter(entry.getKey(), entry.getValue(), MatchType.EQ);
}
最后，只需要xxxDao.findCount(simpleFilter); Collection<xxx> items = xxxDao.find(simpleFilter);
这样就可以得到结果集的数目以及结果集数组
然后可以方便的在页面展示出来。
仅将SimpleFilter的代码贴出来：
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Restrictions;
/**
* 属性过滤器
*
*/
public class SimpleFilter {
private List<Filter> filters = new ArrayList<Filter>();
private Set<String> alias = new HashSet<String>(); // 防止重复添加alias用
public boolean hasFilters() {
return filters.size() > 0;
}
public void addFilter(final String property, final Object value, final MatchType matchType) {
if (matchType == MatchType.OR || matchType == MatchType.BETWEEN) {
throw new RuntimeException("匹配模式不正确");
} else {
filters.add(new Filter(property, value, matchType));
}
}
public void addFilter(final String property, final Object value) {
filters.add(new Filter(property, value));
}
public void addFilter(final String property, final Object lo, final Object hi) {
filters.add(new Filter(property, lo, hi));
}
public void addFilter(final Set<OrClausePair> set) {
filters.add(new Filter(set));
}
/**
* 清理过滤器
* 在具有级联条件的查询中，alias不能重复添加，只允许添加一次
* 在执行完一次count(*)查询后，之前添加的criteria全部失效
* 重新添加criteria的时候，需要清空alias的Set集合
* 以便正确执行createAlias语句
*
*/
public void clearFilter() {
alias.clear();
}
/**
* 构建当前filter的Criteria对象
*/
public Criteria buildCriteria(final Criteria criteria) {
for (Filter filter : filters) {
if (filter.getMatchType() == MatchType.BETWEEN) {
buildCriteria(criteria, filter.getProperty(), filter.getLo(), filter.getHi());
} else if (filter.getMatchType() == MatchType.OR) {
builCriteria(criteria, filter.getSet());
} else {
buildCriteria(criteria, filter.getProperty(), filter.getValue(), filter.getMatchType());
}
}
return criteria;
}
/**
* 根据多个属性名、值和匹配类型构建Hibernate的Criteria的OR对象
*/
private Criteria builCriteria(final Criteria criteria, final Set<OrClausePair> set) {
Disjunction disjunction = Restrictions.disjunction();
for (OrClausePair pair : set) {
String alias = createAlias(criteria, pair.getProperty());
if (StringUtils.isNotBlank(alias)) {
MatchType matchType = pair.getMatchType();
if (matchType == MatchType.BETWEEN) {
if (pair.getLo() != null && pair.getHi() != null) {
disjunction.add(Restrictions.between(alias, pair.getLo(), pair.getHi()));
}
} else {
switch (matchType) {
case NULL:
disjunction.add(Restrictions.isNull(alias));
break;
case NOTNULL:
disjunction.add(Restrictions.isNotNull(alias));
break;
case EMPTY:
disjunction.add(Restrictions.isEmpty(alias));
break;
case NOTEMPTY:
disjunction.add(Restrictions.isNotEmpty(alias));
break;
}
Object value = pair.getValue();
if (value != null) {
switch (matchType) {
case EQ:
disjunction.add(Restrictions.eq(alias, value));
break;
case LIKE:
disjunction.add(Restrictions.like(alias, (String) value, MatchMode.ANYWHERE));
break;
case LIKESTART:
disjunction.add(Restrictions.like(alias, (String) value, MatchMode.START));
break;
case LIKEND:
disjunction.add(Restrictions.like(alias, (String) value, MatchMode.END));
break;
case LE:
disjunction.add(Restrictions.le(alias, value));
break;
case LT:
disjunction.add(Restrictions.lt(alias, value));
break;
case GE:
disjunction.add(Restrictions.ge(alias, value));
break;
case GT:
disjunction.add(Restrictions.gt(alias, value));
break;
case NE:
disjunction.add(Restrictions.ne(alias, value));
break;
}
}
}
}
}
criteria.add(disjunction);
return criteria;
}
/**
* 根据属性名、值和匹配类型构建Hibernate的Criteria对象
*/
private Criteria buildCriteria(final Criteria criteria, final String property, final Object value,
final MatchType matchType) {
String alias = createAlias(criteria, property);
if (StringUtils.isNotBlank(alias)) {
switch (matchType) {
case NULL:
Restrictions.isNull(alias);
return criteria;
case NOTNULL:
Restrictions.isNotNull(alias);
return criteria;
case EMPTY:
Restrictions.isEmpty(alias);
return criteria;
case NOTEMPTY:
Restrictions.isNotEmpty(alias);
return criteria;
}
if (value != null) {
switch (matchType) {
case EQ:
criteria.add(Restrictions.eq(alias, value));
break;
case LIKE:
criteria.add(Restrictions.like(alias, (String) value, MatchMode.ANYWHERE));
break;
case LIKESTART:
criteria.add(Restrictions.like(alias, (String) value, MatchMode.START));
break;
case LIKEND:
criteria.add(Restrictions.like(alias, (String) value, MatchMode.END));
break;
case LE:
criteria.add(Restrictions.le(alias, value));
break;
case LT:
criteria.add(Restrictions.lt(alias, value));
break;
case GE:
criteria.add(Restrictions.ge(alias, value));
break;
case GT:
criteria.add(Restrictions.gt(alias, value));
break;
case NE:
criteria.add(Restrictions.ne(alias, value));
break;
}
}
}
return criteria;
}
/**
* 创建BETWEEN匹配类型的Criteria对象
*/
private Criteria buildCriteria(final Criteria criteria, final String property, final Object lo, final Object hi) {
String alias = createAlias(criteria, property);
if (StringUtils.isNotBlank(alias) && lo != null && hi != null) {
criteria.add(Restrictions.between(alias, lo, hi));
}
return criteria;
}
/**
* 为Criteria对象添加别名
* 最多支持2级级联，例如animal.pet.cat
* @param criteria Criteria对象
* @param property 属性
* @return 别名
*/
private String createAlias(final Criteria criteria, final String property) {
String[] names = StringUtils.split(property, ".");
if (names != null && names.length == 2) {
if (alias.add(names[0])) {
criteria.createAlias(names[0], names[0]);
}
return names[0] + "." + names[1];
} else if (names != null && names.length == 3) {
if (alias.add(names[0])) {
criteria.createAlias(names[0], names[0]);
}
if (alias.add(names[0] + "." + names[1])) {
criteria.createAlias(names[0] + "." + names[1], names[1]);
}
return names[1] + "." + names[2];
} else {
return property;
}
}
/**
* 过滤器
* 两个参数的构造方法，默认查询条件为LIKE
*/
private static class Filter {
private String property;
private Object value;
private Object lo;
private Object hi;
private Set<OrClausePair> set;
private MatchType matchType;
/**
* 构造一个OR条件的过滤器，使用disjunction进行连接
* @param set OR条件参数集合
*/
public Filter(Set<OrClausePair> set) {
this.set = set;
this.matchType = MatchType.OR;
}
/**
* 构造LIKE类型查询
* @param property 属性
* @param value 值
*/
public Filter(String property, Object value) {
this.property = property;
this.value = value;
this.matchType = MatchType.LIKE;
}
/**
* 构造MatchType类型的查询
* @param property 属性
* @param value 值
* @param matchType 匹配类型
*/
public Filter(String property, Object value, MatchType matchType) {
this.property = property;
this.value = value;
this.matchType = matchType;
}
/**
* 构造Between类型的查询
* @param property 属性
* @param lo lowValue
* @param hi hiValue
*/
public Filter(String property, Object lo, Object hi) {
this.property = property;
this.lo = lo;
this.hi = hi;
this.matchType = MatchType.BETWEEN;
}
public String getProperty() {
return property;
}
public Object getValue() {
return value;
}
public Object getLo() {
return lo;
}
public Object getHi() {
return hi;
}
public Set<OrClausePair> getSet() {
return set;
}
public MatchType getMatchType() {
return matchType;
}
}
}
上述过滤器参考自Jmesa源码的一个过滤器，有兴趣的同学可以研究一下Jmesa的源码。Jmesa的TableFacade.getLimit().getSortSet().getSorts()可以拿到页面的所有排序集合，而TableFacade.getLimit().getFilterSet().getFilters()则取得所有过滤对象。
接下来，使用SimpleFilter，并配合通用Hibernate泛型DAO，就可以很方便的处理页面表格了。
补充两个类：
public enum MatchType {
EQ, LIKE, LIKESTART, LIKEND, LT, GT, LE, GE, BETWEEN, NE, OR, NULL, NOTNULL, EMPTY, NOTEMPTY;
}
import org.hibernate.criterion.Criterion;
/**
* 用于为SimpleFilter添加OR过滤条件
*
*/
public class OrClausePair {
private String property;
private Object value;
private Object lo;
private Object hi;
private MatchType matchType;
private Criterion criterion;
public OrClausePair(String property, Object value, MatchType matchType) {
if (matchType == MatchType.BETWEEN) {
throw new RuntimeException("匹配模式不正确");
} else {
this.property = property;
this.value = value;
this.matchType = matchType;
}
}
public OrClausePair(String property, Object lo, Object hi) {
this.property = property;
this.lo = lo;
this.hi = hi;
this.matchType = MatchType.BETWEEN;
}
public OrClausePair(Criterion criterion) {
this.criterion = criterion;
}
public String getProperty() {
return property;
}
public Object getValue() {
return value;
}
public Object getLo() {
return lo;
}
public Object getHi() {
return hi;
}
public MatchType getMatchType() {
return matchType;
}
public Criterion getCriterion() {
return criterion;
}
}
分享到：
相关推荐
这里面包含了大部分hibernate大部分常用的工具类和判断是否为空的工具类还有是否分页和hiberntae的hql通用分页
搭建Hibernate需要的东西都在这里，包括jar包，持久化类的配置，核心文件的配置，dtd文件，以及一些hibernate的资料
HibernateUtil工具类，封装了Hibernate的事务，增，删，改，查，以及分页的方法!
hibernate开发的工具类，封装的sessionFactory，session等
超好用的hibernate查询工具类
使用Hibernate工具生成实体类..........
一个工具类实现了增删改查 util comm.util beanutils 方便了获取session和sessionFactory
官网hibernate5类包！！！！！！！！！！！！！！！！！！！！！！！
纯干货，什么方法都有jdbctemp/hibernateTempl全部都有
NULL 博文链接：https://zhaoshijie.iteye.com/blog/1060576
HibernateSessionFactory.java
hibernate lib
1. Hibernate工具包。 2. JDBC数据库连接驱动。以mysql为例，mysql-connector-java-3.1.×-bin.jar。 3. 配置文件。 1) Hibernate全局配置文件，hibernate.properties或者hibernate.cfg.xml.。一般使用XML文件。...
调用这个工具类的方法，根据方法对应的参数，传入要生成XML的实体类名点class和自定义一个表名，可以单个、也可以一对一、一对多的关系。
Session s= HibernateSessionFactory.getSession(); 就是Hibernate的工具java类
J2EE常用工具类—Hibernate操作 J2EE常用工具类—Cookie操作 J2EE常用工具类—数组操作 J2EE常用工具类—时间处理工具类 J2EE常用工具类—文件打包解包处理类 J2EE常用工具类——文件操作类 J2EE常用工具类...
java util帮助类，包括日期工具类、字符串处理工具类、上传工具类、http请求工具类、hibernate工具类、MD5工具类、分页工具类等。 CodeStringUtil.java CreateFileUtil.java DateUtil.java FileCopy.java ...