From ef32ca8ced9c90e172fec9c876b0f122c47f222f Mon Sep 17 00:00:00 2001
From: yn147 <2270338776@qq.com>
Date: 星期四, 01 六月 2023 16:18:03 +0800
Subject: [PATCH] 问卷管理的多个查询
---
src/main/java/com/qxueyou/scc/base/dao/BaseDAO.java | 796 ++++++++++++++++++++++++++++----------------------------
1 files changed, 400 insertions(+), 396 deletions(-)
diff --git a/src/main/java/com/qxueyou/scc/base/dao/BaseDAO.java b/src/main/java/com/qxueyou/scc/base/dao/BaseDAO.java
index 5335a03..843a3db 100644
--- a/src/main/java/com/qxueyou/scc/base/dao/BaseDAO.java
+++ b/src/main/java/com/qxueyou/scc/base/dao/BaseDAO.java
@@ -1,12 +1,13 @@
/******************************************************************************
* Copyright (C) 2015 Shenzhen Penguin Network Technology Co., Ltd
* All Rights Reserved.
- * 本软件为深圳企鹅网络科技有限公司开发研制。未经本公司正式书面同意，其他任何个人、团体
- * 不得使用、复制、修改或发布本软件.
+ * 鏈蒋浠朵负娣卞湷浼侀箙缃戠粶绉戞妧鏈夐檺鍏徃寮�鍙戠爺鍒躲�傛湭缁忔湰鍏徃姝ｅ紡涔﹂潰鍚屾剰锛屽叾浠栦换浣曚釜浜恒�佸洟浣�
+ * 涓嶅緱浣跨敤銆佸鍒躲�佷慨鏀规垨鍙戝竷鏈蒋浠�.
*****************************************************************************/
package com.qxueyou.scc.base.dao;
+import java.beans.Transient;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.ArrayList;
@@ -29,21 +30,23 @@
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
+import org.springframework.transaction.annotation.Transactional;
/**
- * 基础DAO类,自动注入sessionFactory
+ * 鍩虹DAO绫�,鑷姩娉ㄥ叆sessionFactory
*
- * @author 夏德虎
+ * @author 澶忓痉铏�
* @since JDK1.6
- * @history 2010-07-28 夏德虎 新建
+ * @history 2010-07-28 澶忓痉铏� 鏂板缓
*/
+@Transactional(readOnly=false)
public class BaseDAO extends HibernateDaoSupport {
-
- /** 注释 rawtypes */
- private static final String RAW_TYPES = "rawtypes";
-
+
+ /** 娉ㄩ噴 rawtypes */
+ private static final String RAW_TYPES = "rawtypes";
+
/**
- * 注入sessionFactory
+ * 娉ㄥ叆sessionFactory
*
* @param sessionFactory
*/
@@ -53,82 +56,83 @@
}
/**
- * 读取对象
+ * 璇诲彇瀵硅薄
*
- * @param <T> 泛型类型
- * @param clz VO CLASS类型
- * @param key VO 主键
- * @return 查找到的结果,如果没找到,返回null
+ * @param <T> 娉涘瀷绫诲瀷
+ * @param clz VO CLASS绫诲瀷
+ * @param key VO 涓婚敭
+ * @return 鏌ユ壘鍒扮殑缁撴灉,濡傛灉娌℃壘鍒�,杩斿洖null
*/
public <T> T read(Class<T> clz, Serializable key) {
- if(key==null){
- return null;
- }
+ if(key==null){
+ return null;
+ }
return clz.cast(this.getHibernateTemplate().get(clz, key));
}
/**
- * 保存对象
+ * 淇濆瓨瀵硅薄
*/
public void update(Object obj) {
this.getHibernateTemplate().update(obj);
}
-
+
/**
- * 保存对象
+ * 淇濆瓨瀵硅薄
*/
public void save(Object obj) {
this.getHibernateTemplate().save(obj);
}
/**
- * 保存或更新对象
+ * 淇濆瓨鎴栨洿鏂板璞�
*/
+ @Transactional(readOnly = false)
public void saveOrUpdate(Object obj) {
this.getHibernateTemplate().saveOrUpdate(obj);
}
/**
- * 保存或更新集合对象
+ * 淇濆瓨鎴栨洿鏂伴泦鍚堝璞�
*/
public void saveOrUpdateAll(@SuppressWarnings(RAW_TYPES) Collection collection) {
for(Object obj:collection){
- this.getHibernateTemplate().saveOrUpdate(obj);
+ this.getHibernateTemplate().saveOrUpdate(obj);
}
}
/**
- * 保存或更新对象
+ * 淇濆瓨鎴栨洿鏂板璞�
*/
public void deleteAll(@SuppressWarnings(RAW_TYPES) Collection col) {
this.getHibernateTemplate().deleteAll(col);
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings("unchecked")
- public <T> List<T> find(String hql, Class<T> cls) {
+ public <T> List<T> find(String hql, Class<T> cls) {
return find(hql,Collections.EMPTY_LIST,cls);
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- public <T> List<T> find(final String hql,final List<Object> args,final Class<T> cls) {
- return this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
+ public <T> List<T> find(final String hql,final List<Object> args,final Class<T> cls) {
+ return this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
@SuppressWarnings("unchecked")
- public List<T> doInHibernate(Session session) {
+ public List<T> doInHibernate(Session session) {
Query query = session.createQuery(hql);
int i = 0;
for (Object arg : args) {
@@ -140,88 +144,88 @@
}
});
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- @SuppressWarnings("unchecked")
- public List<Object[]> findwithRawResult(String hql, List<Object> args) {
+ @SuppressWarnings("unchecked")
+ public List<Object[]> findwithRawResult(String hql, List<Object> args) {
return (List<Object[]>) this.getHibernateTemplate().find(hql, args.toArray());
}
-
+
/**
- * 根据hql查询,返回列表数据总数
+ * 鏍规嵁hql鏌ヨ,杩斿洖鍒楄〃鏁版嵁鎬绘暟
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- public int findCount(final String hql, final List<Object> args) {
- return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
-
+ public int findCount(final String hql, final List<Object> args) {
+ return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
+
@Override
public Integer doInHibernate(Session session){
-
- Query query = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
- int i = 0;
- for (Object arg : args) {
+
+ Query query = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
+ int i = 0;
+ for (Object arg : args) {
query.setParameter(i++, arg);
}
-
- if(null != query.uniqueResult()){
- return ((Long)query.uniqueResult()).intValue();
- }else{
- return 0 ;
- }
+
+ if(null != query.uniqueResult()){
+ return ((Long)query.uniqueResult()).intValue();
+ }else{
+ return 0 ;
+ }
}
});
}
-
- /**
- * 根据hql查询,返回列表数据总数
+
+ /**
+ * 鏍规嵁hql鏌ヨ,杩斿洖鍒楄〃鏁版嵁鎬绘暟
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- public int findCountBySql(final String sql, final List<Object> args) {
- return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
-
+ public int findCountBySql(final String sql, final List<Object> args) {
+ return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
+
@Override
public Integer doInHibernate(Session session){
-
- Query query = session.createSQLQuery(sql.trim().startsWith("from")?"select count(1) ".concat(sql):sql);
- int i = 0;
- for (Object arg : args) {
+
+ Query query = session.createSQLQuery(sql.trim().startsWith("from")?"select count(1) ".concat(sql):sql);
+ int i = 0;
+ for (Object arg : args) {
query.setParameter(i++, arg);
}
-
- if(null != query.uniqueResult()){
- return ((BigInteger)query.uniqueResult()).intValue();
- }else{
- return 0 ;
- }
+
+ if(null != query.uniqueResult()){
+ return ((BigInteger)query.uniqueResult()).intValue();
+ }else{
+ return 0 ;
+ }
}
});
}
-
+
/**
- * 根据hql查询,返回列表分页数据
+ * 鏍规嵁hql鏌ヨ,杩斿洖鍒楄〃鍒嗛〉鏁版嵁
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({ "unchecked" })
- public <T> List<T> findList(final String hql, final Pager page, final List<Object> args,Class<T> cls) {
+ public <T> List<T> findList(final String hql, final Pager page, final List<Object> args,Class<T> cls) {
return this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
public List<T> doInHibernate(Session session) {
@@ -236,17 +240,17 @@
}
});
}
-
+
/**
- * 根据hql查询,返回唯一的数据
+ * 鏍规嵁hql鏌ヨ,杩斿洖鍞竴鐨勬暟鎹�
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({ RAW_TYPES, "unchecked" })
- public <T> T findUnique(final String hql, final List<Object> args,Class<T> cls) {
+ public <T> T findUnique(final String hql, final List<Object> args,Class<T> cls) {
return (T)this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
@@ -265,11 +269,11 @@
}
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({ RAW_TYPES})
@@ -287,13 +291,13 @@
});
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({ RAW_TYPES})
@@ -307,504 +311,504 @@
query.setParameter(i++, arg);
}
query.setFirstResult(pager.getPageSize()*(pager.getPageNum()-1));
- query.setMaxResults(pager.getPageSize());
+ query.setMaxResults(pager.getPageSize());
return query.list();
}
});
}
-
-
+
+
/**
- * hql只含单一参数
+ * hql鍙惈鍗曚竴鍙傛暟
*
- * @param hql 查询语句
- * @param args 参数数组
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟鏁扮粍
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
public Result bulkUpdateInLoop(String hql, Object args[]) {
- int iCount = 0;
+ int iCount = 0;
for(Object arg:args){
- iCount += getHibernateTemplate().bulkUpdate(hql, arg);
+ iCount += getHibernateTemplate().bulkUpdate(hql, arg);
}
Map<String,Object> attrs = new HashMap<String,Object>(1);
attrs.put("doCount", iCount);
Result result = new Result(true);
result.setData(attrs);
- return result;
+ return result;
}
-
+
/**
- * hql只含单一参数
+ * hql鍙惈鍗曚竴鍙傛暟
*
- * @param hql 查询语句
- * @param args 参数数组
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟鏁扮粍
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
public Result bulkUpdate(String hql, Object args[]) {
- int count = getHibernateTemplate().bulkUpdate(hql, args);
+ int count = getHibernateTemplate().bulkUpdate(hql, args);
Map<String,Object> attrs = new HashMap<String,Object>(1);
attrs.put("doCount", count);
Result result = new Result(true);
result.setData(attrs);
- return result;
+ return result;
}
-
+
/**
- * 存储过程语句
+ * 瀛樺偍杩囩▼璇彞
*
- * @param hql call 存储语句 sql语句
- * @param args 参数数组
+ * @param hql call 瀛樺偍璇彞 sql璇彞
+ * @param args 鍙傛暟鏁扮粍
* @return
*/
- public Result executeProduce(final String sql, final Object args[]) {
-
- Integer result = getHibernateTemplate().execute(new HibernateCallback<Integer>(){
+ public Result executeProduce(final String sql, final Object args[]) {
- @Override
- public Integer doInHibernate(Session session)
- throws HibernateException {
-
- Query query = session.createSQLQuery("{ "+sql+" }");
- for(int i=0;i<args.length;i++){
- query.setParameter(i, args[i]);
- }
+ Integer result = getHibernateTemplate().execute(new HibernateCallback<Integer>(){
+
+ @Override
+ public Integer doInHibernate(Session session)
+ throws HibernateException {
+
+ Query query = session.createSQLQuery("{ "+sql+" }");
+ for(int i=0;i<args.length;i++){
+ query.setParameter(i, args[i]);
+ }
return query.executeUpdate();
- }
-
+ }
+
});
return new Result(true,String.valueOf(result));
}
-
+
/**
- * 执行sql删除
+ * 鎵цsql鍒犻櫎
*
- * @param hql 查询语句
- * @param args 参数数组
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟鏁扮粍
* @return
*/
- public int executeSqlDelete(final String sql, final Object args[]) {
-
- return getHibernateTemplate().execute(new HibernateCallback<Integer>(){
+ public int executeSqlDelete(final String sql, final Object args[]) {
- @Override
- public Integer doInHibernate(Session session)
- throws HibernateException {
-
- Query query = session.createSQLQuery(sql);
- for(int i=0;i<args.length;i++){
- query.setParameter(i, args[i]);
- }
+ return getHibernateTemplate().execute(new HibernateCallback<Integer>(){
+
+ @Override
+ public Integer doInHibernate(Session session)
+ throws HibernateException {
+
+ Query query = session.createSQLQuery(sql);
+ for(int i=0;i<args.length;i++){
+ query.setParameter(i, args[i]);
+ }
return query.executeUpdate();
- }
-
+ }
+
});
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({RAW_TYPES, "unchecked" })
public List<Object[]> findRawByComplexHql(final String hql, final Map<String, Object> map) {
- // 查询结果
+ // 鏌ヨ缁撴灉
return (List<Object[]>)this.getHibernateTemplate().execute(new HibernateCallback<List>() {
public List doInHibernate(Session session) {
Query query = session.createQuery(hql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- query.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- query.setParameterList(string, (Object[])obj);
- }else{
- query.setParameter(string, obj);
- }
- }
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ query.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ query.setParameterList(string, (Object[])obj);
+ }else{
+ query.setParameter(string, obj);
+ }
+ }
+ }
return query.list();
}
});
- }
-
+ }
+
/**
- * 根据hql查询,返回列表数据总数
+ * 鏍规嵁hql鏌ヨ,杩斿洖鍒楄〃鏁版嵁鎬绘暟
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- public int findCountByComplexHql(final String hql, final Map<String, Object> map) {
- return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
-
+ public int findCountByComplexHql(final String hql, final Map<String, Object> map) {
+ return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
+
@Override
public Integer doInHibernate(Session session){
-
- Query queryHql = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
-
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- queryHql.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- queryHql.setParameterList(string, (Object[])obj);
- }else{
- queryHql.setParameter(string, obj);
- }
- }
- }
-
- if(null != queryHql.uniqueResult()){
- return ((Long)queryHql.uniqueResult()).intValue();
- }else{
- return 0 ;
- }
+
+ Query queryHql = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
+
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ queryHql.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ queryHql.setParameterList(string, (Object[])obj);
+ }else{
+ queryHql.setParameter(string, obj);
+ }
+ }
+ }
+
+ if(null != queryHql.uniqueResult()){
+ return ((Long)queryHql.uniqueResult()).intValue();
+ }else{
+ return 0 ;
+ }
}
});
}
-
- /**
- * 根据sql查询,返回列表数据总数
+
+ /**
+ * 鏍规嵁sql鏌ヨ,杩斿洖鍒楄〃鏁版嵁鎬绘暟
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
- public int findCountByComplexSql(final String hql, final Map<String, Object> map) {
- return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
-
+ public int findCountByComplexSql(final String hql, final Map<String, Object> map) {
+ return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
+
@Override
public Integer doInHibernate(Session session){
-
- Query querySql = session.createSQLQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
-
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- querySql.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- querySql.setParameterList(string, (Object[])obj);
- }else{
- querySql.setParameter(string, obj);
- }
- }
- }
-
- if(null != querySql.uniqueResult()){
- return ((BigInteger)querySql.uniqueResult()).intValue();
- }else{
- return 0 ;
- }
+
+ Query querySql = session.createSQLQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
+
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ querySql.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ querySql.setParameterList(string, (Object[])obj);
+ }else{
+ querySql.setParameter(string, obj);
+ }
+ }
+ }
+
+ if(null != querySql.uniqueResult()){
+ return ((BigInteger)querySql.uniqueResult()).intValue();
+ }else{
+ return 0 ;
+ }
}
});
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
public <T> List<T> findByComplexHql(final String hql, final Map<String, Object> map, Class<T> cls) {
- Pager page = new Pager();
- page.setPageSize(Integer.MAX_VALUE);
- page.setPageNum(1);
+ Pager page = new Pager();
+ page.setPageSize(Integer.MAX_VALUE);
+ page.setPageNum(1);
return findByComplexHql(hql, page, map, cls);
}
-
+
/**
- * 复杂hql
+ * 澶嶆潅hql
* @param sql
* @param map
* @param cls
* @return
*/
public <T> T findUniqueByHql(final String hql, final Map<String, Object> map){
- // 查询结果
+ // 鏌ヨ缁撴灉
List<T> lst = this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
-
+
@SuppressWarnings("unchecked")
- public List<T> doInHibernate(Session session) {
+ public List<T> doInHibernate(Session session) {
Query queryHql = session.createQuery(hql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- queryHql.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- queryHql.setParameterList(string, (Object[])obj);
- }else{
- queryHql.setParameter(string, obj);
- }
- }
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ queryHql.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ queryHql.setParameterList(string, (Object[])obj);
+ }else{
+ queryHql.setParameter(string, obj);
+ }
+ }
+ }
queryHql.setFirstResult(0);
queryHql.setMaxResults(1);
-
+
List<?> r = queryHql.list();
-
+
List<T> lst = new ArrayList<T>(r.size());
for(Object o:r) {
- lst.add((T)o);
+ lst.add((T)o);
}
return lst;
}
});
-
+
return lst.isEmpty()?null:lst.get(0);
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果，列表数据为Map
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉锛屽垪琛ㄦ暟鎹负Map
*
- * @param hql 查询语句
- * @param args 参数
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
* @return
*/
public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> map) {
- Pager page = new Pager();
- page.setPageNum(1);
- page.setPageSize(Integer.MAX_VALUE);
-
+ Pager page = new Pager();
+ page.setPageNum(1);
+ page.setPageSize(Integer.MAX_VALUE);
+
return findListWithMapByHql(hql,map,page);
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果，列表数据为Map
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉锛屽垪琛ㄦ暟鎹负Map
*
- * @param hql 查询语句
- * @param args 参数
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
* @return
*/
@SuppressWarnings("unchecked")
public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> map,final Pager page) {
- // 查询结果
+ // 鏌ヨ缁撴灉
List<Map<String,Object>> lst = getHibernateTemplate().execute(new HibernateCallback<List<Map<String,Object>>>() {
- public List<Map<String,Object>> doInHibernate(Session session) {
+ public List<Map<String,Object>> doInHibernate(Session session) {
Query query = session.createQuery(hql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- query.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- query.setParameterList(string, (Object[])obj);
- }else{
- query.setParameter(string, obj);
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ query.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ query.setParameterList(string, (Object[])obj);
+ }else{
+ query.setParameter(string, obj);
+ }
}
- }
+ }
query.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
query.setMaxResults(page.getPageSize());
return query.list();
}
});
-
+
return lst;
}
-
+
/**
- * 根据hql查询,并返回唯一一条结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炲敮涓�涓�鏉＄粨鏋�
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({RAW_TYPES })
public <T> T findUniqueByComplexHql(final String hql, final Map<String, Object> map, Class<T> cls) {
- // 查询结果
+ // 鏌ヨ缁撴灉
List<T> lst = this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
public List doInHibernate(Session session) {
Query query = session.createQuery(hql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- query.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- query.setParameterList(string, (Object[])obj);
- }else{
- query.setParameter(string, obj);
- }
- }
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ query.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ query.setParameterList(string, (Object[])obj);
+ }else{
+ query.setParameter(string, obj);
+ }
+ }
+ }
query.setFirstResult(0);
query.setMaxResults(1);
return query.list();
}
});
-
+
return lst.isEmpty()?null:cls.cast(lst.get(0));
}
-
+
/**
- * 根据Sql查询,并返回执行类型的列表结果
+ * 鏍规嵁Sql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
public <T> List<T> findByComplexSql(final String sql, final Map<String, Object> map, Class<T> cls) {
- Pager page = new Pager();
- page.setPageSize(Integer.MAX_VALUE);
- page.setPageNum(1);
+ Pager page = new Pager();
+ page.setPageSize(Integer.MAX_VALUE);
+ page.setPageNum(1);
return findByComplexSql(sql, page, map, cls);
}
-
-
+
+
/**
- * 根据Sql查询,并返回执行类型的列表结果
+ * 鏍规嵁Sql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({RAW_TYPES, "unchecked" })
public List<Object[]> findRawByComplexSql(final String sql, final Map<String, Object> map) {
- // 查询结果
+ // 鏌ヨ缁撴灉
return (List<Object[]>)this.getHibernateTemplate().execute(new HibernateCallback<List>() {
public List doInHibernate(Session session) {
SQLQuery query = session.createSQLQuery(sql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- query.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- query.setParameterList(string, (Object[])obj);
- }else{
- query.setParameter(string, obj);
- }
- }
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ query.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ query.setParameterList(string, (Object[])obj);
+ }else{
+ query.setParameter(string, obj);
+ }
+ }
+ }
return query.list();
}
});
-
-
+
+
}
-
+
/**
- * 根据hql查询,并返回执行类型的列表结果
+ * 鏍规嵁hql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({RAW_TYPES })
public <T> List<T> findByComplexHql(final String hql,final Pager page, final Map<String, Object> map, Class<T> cls) {
- // 查询结果
+ // 鏌ヨ缁撴灉
List lst = this.getHibernateTemplate().execute(new HibernateCallback<List>() {
public List doInHibernate(Session session) {
Query queryHql = session.createQuery(hql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- queryHql.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- queryHql.setParameterList(string, (Object[])obj);
- }else{
- queryHql.setParameter(string, obj);
- }
- }
- }
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ queryHql.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ queryHql.setParameterList(string, (Object[])obj);
+ }else{
+ queryHql.setParameter(string, obj);
+ }
+ }
+ }
queryHql.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
queryHql.setMaxResults(page.getPageSize());
return queryHql.list();
}
});
-
- // 组装结果
+
+ // 缁勮缁撴灉
List<T> result = new ArrayList<T>();
for (Object obj : lst) {
result.add(cls.cast(obj));
}
return result;
}
-
+
/**
- * 根据Sql查询,并返回执行类型的列表结果
+ * 鏍规嵁Sql鏌ヨ,骞惰繑鍥炴墽琛岀被鍨嬬殑鍒楄〃缁撴灉
*
- * @param hql 查询语句
- * @param args 参数
- * @param cls 返回类型
+ * @param hql 鏌ヨ璇彞
+ * @param args 鍙傛暟
+ * @param cls 杩斿洖绫诲瀷
* @return
*/
@SuppressWarnings({RAW_TYPES })
public <T> List<T> findByComplexSql(final String sql,final Pager page, final Map<String, Object> map, Class<T> cls) {
- // 查询结果
+ // 鏌ヨ缁撴灉
List lst = this.getHibernateTemplate().execute(new HibernateCallback<List>() {
public List doInHibernate(Session session) {
- SQLQuery querySql = session.createSQLQuery(sql);
- if (map != null) {
- Set<String> keySet = map.keySet();
- for (String string : keySet) {
- Object obj = map.get(string);
- //这里考虑传入的参数是什么类型，不同类型使用的方法不同
- if(obj instanceof Collection<?>){
- querySql.setParameterList(string, (Collection<?>)obj);
- }else if(obj instanceof Object[]){
- querySql.setParameterList(string, (Object[])obj);
- }else{
- querySql.setParameter(string, obj);
- }
- }
- }
+ SQLQuery querySql = session.createSQLQuery(sql);
+ if (map != null) {
+ Set<String> keySet = map.keySet();
+ for (String string : keySet) {
+ Object obj = map.get(string);
+ //杩欓噷鑰冭檻浼犲叆鐨勫弬鏁版槸浠�涔堢被鍨嬶紝涓嶅悓绫诲瀷浣跨敤鐨勬柟娉曚笉鍚�
+ if(obj instanceof Collection<?>){
+ querySql.setParameterList(string, (Collection<?>)obj);
+ }else if(obj instanceof Object[]){
+ querySql.setParameterList(string, (Object[])obj);
+ }else{
+ querySql.setParameter(string, obj);
+ }
+ }
+ }
querySql.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
querySql.setMaxResults(page.getPageSize());
return querySql.list();
}
});
-
- // 组装结果
+
+ // 缁勮缁撴灉
List<T> result = new ArrayList<T>();
for (Object obj : lst) {
result.add(cls.cast(obj));
}
return result;
}
-
-
+
+
}
--
Gitblit v1.8.0