与hibernate的Critical类似，是一种通用的Dao层简单化查询通用方法，是我在13年刚接触hibernate的，因为当时的业务性质，需要频繁的简单查询，但我还不知Critical，所以编写了这么一套通用查询方法，思想应该与Critical是一致的
首先是service层，这个通用的service使得可以直接从action层传递参数，查询出相应的对象或集合
package com.donglusoft.select.service;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.donglusoft.select.DAO.SelectAllObjectDAO;
@Service("selectAllObjectService")
public class SelectAllObjectService {
@Resource
private SelectAllObjectDAO selectAllObjectDAO;
/**
* 通用查询方法一：《相等》《相似》《单，双时间段》条件查询通用方法，返回符合条件的List
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap 例如new一个equalStringMap; equalStringMap.put("name", "张三"); —— 精确查询姓名叫张三的人
* @param closeStringMap 例如new一个closeStringMap; closeStringMap.put("name", "张"); —— 模糊查询姓张的人
* @param timeOne 例如 String[] timeOne = {"time","2013-08-12","2013-11-11"};
* @param timeTwo
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public List selectListByE_C_T(Map<String , String> equalStringMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo, Object ob){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
return selectAllObjectDAO.selectListByE_C_T(equalStringMap,closeStringMap,timeOne,timeTwo,className);
}
/**
* 通用查询方法二：《相等》《相似》《单，双时间段》条件查询通用方法，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap 例如Map<String, String> equalStringMap = new HashMap<String, String>(); equalStringMap.put("name", "张三"); —— 精确查询姓名叫张三的人
* @param closeStringMap 例如Map<String, String> closeStringMap = new HashMap<String, String>(); closeStringMap.put("name", "张"); —— 模糊查询姓张的人
* @param timeOne 例如 String[] timeOne = {"time","2013-08-12","2013-11-11"};
* @param timeTwo
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> selectMapByE_C_T(Map<String , String> equalStringMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo, Object ob){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
List list = selectAllObjectDAO.selectListByE_C_T(equalStringMap,closeStringMap,timeOne,timeTwo,className);
long count = Long.valueOf(list.size());
Map<String , Object> map = new HashMap<String, Object>();
map.put("objectList", list);
map.put("count", count);
return map;
}
/**
* 通用查询方法三：《相等》《相似》《单，双时间段》条件《分页》查询通用方法，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap 例如Map<String, String> equalStringMap = new HashMap<String, String>(); equalStringMap.put("name", "张三"); —— 精确查询姓名叫张三的人
* @param closeStringMap 例如Map<String, String> closeStringMap = new HashMap<String, String>(); closeStringMap.put("name", "张"); —— 模糊查询姓张的人
* @param timeOne 例如 String[] timeOne = {"time","2013-08-12","2013-11-11"};
* @param timeTwo
* @param start 分页起始页码
* @param limit 分页每组显示数量
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> selectPagingMapByE_C_T(Map<String , String> equalStringMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo, Object ob, int start,int limit){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
Map<String , Object> map = selectAllObjectDAO.selectPagingMapByE_C_T(equalStringMap,closeStringMap,timeOne,timeTwo,className,start,limit);
return map;
}
/**
* 通用查询方法四：遍历可用的表记录，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* @author liuyuqin
* @since 2013年11月29日14:49:29
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> queryObjectMap(Object ob){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
List list = selectAllObjectDAO.queryObjectMap(className);
long count = Long.valueOf(list.size());
Map<String , Object> map = new HashMap<String, Object>();
map.put("objectList", list);
map.put("count", count);
return map;
}
/**
* 通用查询方法五：《分页》遍历可用的表记录，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* @author liuyuqin
* @since 2013年11月29日14:49:29
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> queryPagingObjectMap(Object ob,int start,int limit){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
Map<String , Object> map = selectAllObjectDAO.queryPagingObjectMap(className,start,limit);
return map;
}
/**
* 通用查询方法六：根据特定对象Id找到相应对象,此方法适用于不需要持久态的对象，如果需要持久化对象，请用相关DAO层中的findById方法
* @author liuyuqin
* @since 2013年3月14日12:45:12
* @param ob 查询条件的JavaBean对象
* @return
*/
public Object findById(Object ob) throws Exception{
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
Class b = ob.getClass();
Method rAge = b.getMethod("getId");
String dictionaryObjectId = (String) rAge.invoke(ob);
return selectAllObjectDAO.findById(dictionaryObjectId,className);
}
/**
* 通用查询方法七：根据特定对象name找到相应对象
* @author liuyuqin
* @since 2013年11月26日15:04:22
* @param ob 查询条件的JavaBean对象
* @return
*/
public Object findByName(Object ob) throws Exception{
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
Class b = ob.getClass();
Method rAge = b.getMethod("getName");
String dictionaryObjectName = (String) rAge.invoke(ob);
return selectAllObjectDAO.findByName(dictionaryObjectName,className);
}
/**
* 通用查询方法八：《相等（字符串比较）》《相等（数字比较）》《相似》《单，双时间段》条件《分页》查询通用方法，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap 例如Map<String, String> equalStringMap = new HashMap<String, String>(); equalStringMap.put("name", "张三"); —— 精确查询姓名叫张三的人
* @param equalIntMap 例如Map<String, Integer> equalIntMap = new HashMap<String, Integer>(); equalIntMap.put("flag", 10); —— 精确flag等于10的记录
* @param closeStringMap 例如Map<String, String> closeStringMap = new HashMap<String, String>(); closeStringMap.put("name", "张"); —— 模糊查询姓张的人
* @param timeOne 例如 String[] timeOne = {"time","2013-08-12","2013-11-11"};
* @param timeTwo
* @param start 分页起始页码
* @param limit 分页每组显示数量
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> selectPagingMapByE_E_C_T(Map<String , String> equalStringMap ,
Map<String , Integer> equalIntMap ,Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo, Object ob, int start,int limit){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
Map<String , Object> map = selectAllObjectDAO.selectPagingMapByE_E_C_T(equalStringMap,equalIntMap,closeStringMap,timeOne,timeTwo,className,start,limit);
return map;
}
/**
* 通用查询方法九：《相等（字符串比较）》《相等（数字比较）》《相似》《单，双时间段》条件查询通用方法，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap 例如Map<String, String> equalStringMap = new HashMap<String, String>(); equalStringMap.put("name", "张三"); —— 精确查询姓名叫张三的人
* @param equalIntMap 例如Map<String, Integer> equalIntMap = new HashMap<String, Integer>(); equalIntMap.put("flag", 10); —— 精确flag等于10的记录
* @param closeStringMap 例如Map<String, String> closeStringMap = new HashMap<String, String>(); closeStringMap.put("name", "张"); —— 模糊查询姓张的人
* @param timeOne 例如 String[] timeOne = {"time","2013-08-12","2013-11-11"};
* @param timeTwo
* @param start 分页起始页码
* @param limit 分页每组显示数量
* @param ob 查询条件的JavaBean对象
* @return
* Map 中的List 的关键字为 objectList 取值为： map.get("objectList");
* Map 中的count 的关键字为 count 取值为 map.get("count");
*/
public Map<String , Object> selectMapByE_E_C_T(Map<String , String> equalStringMap ,
Map<String , Integer> equalIntMap ,Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo, Object ob, int start,int limit){
String className = ob.getClass().getName().substring(ob.getClass().getName().lastIndexOf(".")+1);
List list = selectAllObjectDAO.selectMapByE_E_C_T(equalStringMap,equalIntMap,closeStringMap,timeOne,timeTwo,className,start,limit);
long count = Long.valueOf(list.size());
Map<String , Object> map = new HashMap<String, Object>();
map.put("objectList", list);
map.put("count", count);
return map;
}
}然后是核心的dao层
package com.donglusoft.select.DAO;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.springframework.stereotype.Repository;
import com.donglusoft.zzz.util.BaseHibernateDAO;
import com.donglusoft.zzz.util.SystemState;
/**
* A data access object (DAO) providing persistence and search support for Role
* entities. Transaction control of the save(), update() and delete() operations
* can directly support Spring container-managed transactions or they can be
* augmented to handle user-managed Spring transactions. Each of these methods
* provides additional information for how to configure it for the desired type
* of transaction control.
*
* @see com.donglusoft.rightmanagerment.domain.Role
* @author MyEclipse Persistence Tools
*/
@Repository("selectAllObjectDAO")
public class SelectAllObjectDAO extends BaseHibernateDAO {
/**********************自定义方法（↓）****************************/
/**
* 通过Id查找特定的对象
* @author liuyuqin
* @since 2013年3月9日10:59:10
*/
public Object findById(String dictionaryObjectId,String className){
try{
String queryString = "from " + className + " as t where t.delstate="+SystemState.USE+" and " +
"t.id=:dictionaryObjectId";
Query query = getSession().createQuery(queryString);
query.setString("dictionaryObjectId", dictionaryObjectId);
return query.uniqueResult();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}
/**
* 通过name查找特定的对象
* @author liuyuqin
* @since 2013年3月10日12:52:55
*/
public List<Object> findByName(String dictionaryObjectName,String className){
try{
String queryString = "from "+className +" as t where t.name =:name and t.delstate ="+SystemState.USE;
Query query = getSession().createQuery(queryString);
query.setString("name", dictionaryObjectName);
return query.list();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}
/**
* 《相等》《相似》《双时间段》条件查询通用方法，返回符合条件的List
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月26日16:48:16
* @param equalStringMap
* @param closeStringMap
* @param timeOne
* @param timeTwo
* @param className
* @return
*/
public List selectListByE_C_T(Map<String , String> equalStringMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo,String className){
String[] values = new String[8];
String[] keys = new String[8];
//创建数组插入标志位置
int valueNumber = 0;
int keyNumber = 0;
StringBuffer hQLString = new StringBuffer();
hQLString.append("from "+className+" as t where t.delstate = "+SystemState.USE);
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalStringMap装载等于值
if(equalStringMap!=null){
Iterator equalIt = equalStringMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIt.hasNext()){
String perKey = (String)equalIt.next();
if(equalStringMap.get(perKey) != null && !(equalStringMap.get(perKey).equals(""))){
String perValue = (String)equalStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey+" =:"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = perValue;
keys[keyNumber] = simple;
valueNumber++;
keyNumber++;
}//结束于equalIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该closeStringMap装载相似值的map
if(closeStringMap!=null){
Iterator closeIt = closeStringMap.keySet().iterator();
//遍历每一个 相似条件 键值对
while(closeIt.hasNext()){
String perKey = (String)closeIt.next();
if(closeStringMap.get(perKey) != null && !(closeStringMap.get(perKey).equals(""))){
String perValue = (String)closeStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey +" like :"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = "%"+perValue+"%";
valueNumber++;
keys[keyNumber] = simple;
keyNumber++;
}//结束于closeIt的if
}
}
//时间段查询条件1
if( timeOne !=null && timeOne[0] != null){
hQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
}
//时间段查询条件2
if(timeTwo !=null &&timeTwo[0] != null){
hQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
}
String hql = hQLString.toString();
Query query = getSession().createQuery(hql);
//遍历数组赋值给变量
for (int i = 0; i < values.length; i++) {
if(values[i]!=null){
query.setParameter(keys[i],values[i]);
}
}
return query.list();
}
/**
* 《相等》《相似》《双时间段》条件《分页》查询通用方法，返回符合条件的Map
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月29日11:26:11
* @param equalStringMap
* @param closeStringMap
* @param timeOne
* @param timeTwo
* @param className
* @param start
* @param limit
* @return
*/
public Map<String , Object> selectPagingMapByE_C_T(Map<String, String> equalStringMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo,String className,int start,int limit){
String[] values = new String[8];
String[] keys = new String[8];
//创建数组插入标志位置
int valueNumber = 0;
int keyNumber = 0;
StringBuffer hQLString = new StringBuffer();
StringBuffer countHQLString = new StringBuffer();
hQLString.append("from "+className+" as t where t.delstate = "+SystemState.USE);
countHQLString.append("select count(*) from "+className+" as t where t.delstate = "+SystemState.USE);
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalStringMap装载等于值
if(equalStringMap!=null){
Iterator equalIt = equalStringMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIt.hasNext()){
String perKey = (String)equalIt.next();
if(equalStringMap.get(perKey) != null && !(equalStringMap.get(perKey).equals(""))){
String perValue = (String)equalStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey+" =:"+simple);
countHQLString.append(" and t."+perKey+" =:"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = perValue;
keys[keyNumber] = simple;
valueNumber++;
keyNumber++;
}//结束于equalIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该closeStringMap装载相似值的map
if(closeStringMap!=null){
Iterator closeIt = closeStringMap.keySet().iterator();
//遍历每一个 相似条件 键值对
while(closeIt.hasNext()){
String perKey = (String)closeIt.next();
if(closeStringMap.get(perKey) != null && !(closeStringMap.get(perKey).equals(""))){
String perValue = (String)closeStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接HQL语句来增加查询条件
hQLString.append(" and t."+perKey +" like :"+simple);
countHQLString.append(" and t."+perKey +" like :"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = "%"+perValue+"%";
valueNumber++;
keys[keyNumber] = simple;
keyNumber++;
}//结束于closeIt的if
}
}
//时间段查询条件1
if( timeOne !=null && timeOne[0] != null){
hQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
countHQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
}
//时间段查询条件2
if(timeTwo !=null &&timeTwo[0] != null){
hQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
countHQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
}
String hql = hQLString.toString();
String countHQL = countHQLString.toString();
Query query = getSession().createQuery(hql);
Query queryCount = getSession().createQuery(countHQL);
//遍历数组赋值给变量
for (int i = 0; i < values.length; i++) {
if(values[i]!=null){
query.setParameter(keys[i],values[i]);
queryCount.setParameter(keys[i],values[i]);
}
}
query.setFirstResult(start);
query.setMaxResults(limit);
List objectList = query.list();
Long count = (Long) queryCount.uniqueResult();
Map<String , Object> map = new HashMap<String, Object>();
map.put("objectList", objectList);
map.put("count", count);
return map;
}
/**
* 《相等（字符串比较）》《相等（数字比较）》《相似》《双时间段》条件《分页》查询通用方法，返回符合条件的Map
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月29日11:26:11
* @param equalStringMap
* @param closeStringMap
* @param timeOne
* @param timeTwo
* @param className
* @param start
* @param limit
* @return
*/
public Map<String , Object> selectPagingMapByE_E_C_T(Map<String, String> equalStringMap ,
Map<String , Integer> equalIntMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo,String className,int start,int limit){
String[] values = new String[8];
String[] keys = new String[8];
//创建数组插入标志位置
int valueNumber = 0;
int keyNumber = 0;
StringBuffer hQLString = new StringBuffer();
StringBuffer countHQLString = new StringBuffer();
hQLString.append("from "+className+" as t where t.delstate = "+SystemState.USE);
countHQLString.append("select count(*) from "+className+" as t where t.delstate = "+SystemState.USE);
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalStringMap装载等于值
if(equalStringMap!=null){
Iterator equalIt = equalStringMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIt.hasNext()){
String perKey = (String)equalIt.next();
if(equalStringMap.get(perKey) != null && !(equalStringMap.get(perKey).equals(""))){
String perValue = (String)equalStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey+" =:"+simple);
countHQLString.append(" and t."+perKey+" =:"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = perValue;
keys[keyNumber] = simple;
valueNumber++;
keyNumber++;
}//结束于equalIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalIntMap装载等于值
if(equalIntMap!=null){
Iterator equalIntIt = equalIntMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIntIt.hasNext()){
String perKey = (String)equalIntIt.next();
if(equalIntMap.get(perKey) != null && !(equalIntMap.get(perKey).equals(""))){
Integer perValue = equalIntMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey +" = "+simple);
countHQLString.append(" and t."+perKey +" = "+simple);
}//结束于equalIntIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该closeStringMap装载相似值的map
if(closeStringMap!=null){
Iterator closeIt = closeStringMap.keySet().iterator();
//遍历每一个 相似条件 键值对
while(closeIt.hasNext()){
String perKey = (String)closeIt.next();
if(closeStringMap.get(perKey) != null && !(closeStringMap.get(perKey).equals(""))){
String perValue = (String)closeStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接HQL语句来增加查询条件
hQLString.append(" and t."+perKey +" like :"+simple);
countHQLString.append(" and t."+perKey +" like :"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = "%"+perValue+"%";
valueNumber++;
keys[keyNumber] = simple;
keyNumber++;
}//结束于closeIt的if
}
}
//时间段查询条件1
if( timeOne !=null && timeOne[0] != null){
hQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
countHQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
}
//时间段查询条件2
if(timeTwo !=null &&timeTwo[0] != null){
hQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
countHQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
}
String hql = hQLString.toString();
String countHQL = countHQLString.toString();
Query query = getSession().createQuery(hql);
Query queryCount = getSession().createQuery(countHQL);
//遍历数组赋值给变量
for (int i = 0; i < values.length; i++) {
if(values[i]!=null){
query.setParameter(keys[i],values[i]);
queryCount.setParameter(keys[i],values[i]);
}
}
query.setFirstResult(start);
query.setMaxResults(limit);
List objectList = query.list();
Long count = (Long) queryCount.uniqueResult();
Map<String , Object> map = new HashMap<String, Object>();
map.put("objectList", objectList);
map.put("count", count);
return map;
}
/**
* 《相等（字符串比较）》《相等（数字比较）》《相似》《双时间段》条件查询通用方法，返回符合条件的List
* E表示equal相等，C表示close相似，T表示two双时间段
* @author liuyuqin
* @since 2013年11月29日11:26:11
* @param equalStringMap
* @param closeStringMap
* @param timeOne
* @param timeTwo
* @param className
* @param start
* @param limit
* @return
*/
public List selectMapByE_E_C_T(Map<String, String> equalStringMap ,
Map<String , Integer> equalIntMap , Map<String , String> closeStringMap
,String[] timeOne ,String[] timeTwo,String className,int start,int limit){
String[] values = new String[8];
String[] keys = new String[8];
//创建数组插入标志位置
int valueNumber = 0;
int keyNumber = 0;
StringBuffer hQLString = new StringBuffer();
hQLString.append("from "+className+" as t where t.delstate = "+SystemState.USE);
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalStringMap装载等于值
if(equalStringMap!=null){
Iterator equalIt = equalStringMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIt.hasNext()){
String perKey = (String)equalIt.next();
if(equalStringMap.get(perKey) != null && !(equalStringMap.get(perKey).equals(""))){
String perValue = (String)equalStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey+" =:"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = perValue;
keys[keyNumber] = simple;
valueNumber++;
keyNumber++;
}//结束于equalIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该equalIntMap装载等于值
if(equalIntMap!=null){
Iterator equalIntIt = equalIntMap.keySet().iterator();
//遍历每一个 相等条件 键值对
while(equalIntIt.hasNext()){
String perKey = (String)equalIntIt.next();
if(equalIntMap.get(perKey) != null && !(equalIntMap.get(perKey).equals(""))){
Integer perValue = equalIntMap.get(perKey);
//拼接SQL语句来增加查询条件
hQLString.append(" and t."+perKey +" = "+perValue);
}//结束于equalIntIt的if
}
}
//遍历查询条件及查询输入值的映射Map；特规定关键字为对象属性，值为对象属性输入值
//该closeStringMap装载相似值的map
if(closeStringMap!=null){
Iterator closeIt = closeStringMap.keySet().iterator();
//遍历每一个 相似条件 键值对
while(closeIt.hasNext()){
String perKey = (String)closeIt.next();
if(closeStringMap.get(perKey) != null && !(closeStringMap.get(perKey).equals(""))){
String perValue = (String)closeStringMap.get(perKey);
StringBuffer temp = new StringBuffer();
String[] args;
String simple;
if(perKey.contains(".")){
args = perKey.split("\\.");
for (int i = 0; i < args.length; i++) {
temp.append(args[i]);
}
simple = temp.toString();
}
else simple = perKey;
//拼接HQL语句来增加查询条件
hQLString.append(" and t."+perKey +" like :"+simple);
//将遍历出的每一个值添加到数组中
values[valueNumber] = "%"+perValue+"%";
valueNumber++;
keys[keyNumber] = simple;
keyNumber++;
}//结束于closeIt的if
}
}
//时间段查询条件1
if( timeOne !=null && timeOne[0] != null){
hQLString.append(" and t."+timeOne[0] +" between '"+timeOne[1]+"' and '"+timeOne[2]+"'");
}
//时间段查询条件2
if(timeTwo !=null &&timeTwo[0] != null){
hQLString.append(" and t."+timeTwo[0] +" between '"+timeTwo[1]+"' and '"+timeTwo[2]+"'");
}
String hql = hQLString.toString();
Query query = getSession().createQuery(hql);
//遍历数组赋值给变量
for (int i = 0; i < values.length; i++) {
if(values[i]!=null){
query.setParameter(keys[i],values[i]);
}
}
return query.list();
}
/**
*遍历可用的表记录，返回符合条件的List
* @author liuyuqin
* @since 2013年11月29日14:49:29
* @param className
* @return
*/
public List queryObjectMap(String className){
try{
String queryString = "from "+className +" as t where t.delstate ="+SystemState.USE;
Query query = getSession().createQuery(queryString);
return query.list();
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}
/**
* 分页遍历可用的表记录，返回符合条件的Map,Map有对象集合和对象集合长度<"objectList","count">;
* @author liuyuqin
* @since 2013年11月29日14:49:29
* @param className
* @param start
* @param limit
* @return
*/
public Map<String , Object> queryPagingObjectMap(String className,int start,int limit){
Map<String , Object> map = new HashMap<String, Object>();
try{
String queryString = "from "+className +" as t where t.delstate ="+SystemState.USE;
String countString = "select count(*) from "+className +" as t where t.delstate ="+SystemState.USE;
Query query = getSession().createQuery(queryString);
Query countQuery = getSession().createQuery(countString);
query.setFirstResult(start);
query.setMaxResults(limit);
List list = query.list();
long count = (Long) countQuery.uniqueResult();
map.put("objectList", list);
map.put("count", count);
return map;
} catch (HibernateException e) {
// TODO Auto-generated catch block
throw e;
}
}
}
备注：start，limit为分页属性，如果有成熟的分页对象，可以稍微修改
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
