Spring结合hibernate配置文件_this.getsession().createcriteria(entityclass);-CSDN博客

本文链接：https://blog.csdn.net/w4bobo/article/details/7962452

本实例数据库是MySQL:

1.为了方便维护与管理，建立一个数据库配置文件dbconfig.properties,文件内容如下：

dataBaseType = MySQL

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
hibernate.dialect=org.hibernate.dialect.MySQLDialect

jdbc.initialPoolSize=10
#Output SQL statements to console,true:yes ,false:no
hibernate.show_sql=true
#Inquires the cache true:yes ,false:no
hibernate.cache.use_query_cache=true
hibernate.substitutions=true 1, false 0, yes 'Y', no 'N'
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

2. spring配置数据库文件applicationContext-db.xml

<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  <bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
      <property name="locations">
         <list>
          <value>classpath:dbconfig.properties</value>
         </list>
      </property>
   </bean>
    <!-- 数据库连接池配置，本例以用c3p0方式配置 -->
    <bean id="sysDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
      <!-- 数据库驱动 -->
      <property name="driverClass"><value>${jdbc.driverClassName}</value></property>
      <!-- 数据库连接地址 -->
      <property name="jdbcUrl"><value>${jdbc.url}</value></property>
       <!-- 用户名 -->
      <property name="user"><value>${jdbc.username}</value></property>
      <!-- 用户密码 -->
      <property name="password"><value>${jdbc.password}</value></property>
      <!-- 初始化连接池大小 -->
      <property name="initialPoolSize"><value>${jdbc.initialPoolSize}</value></property>
    </bean>
   
 <!-- JDBC start 无事务-->
 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="sysDataSource" />
 </bean>
 <!-- JDBc end -->
 
    <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  
  <property name="dataSource">
   <ref bean="sysDataSource" />
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">${hibernate.dialect}</prop>
    <prop key="hibernate.show_sql">${hibernate.show_sql}</prop> 
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                <prop key="hibernate.jdbc.batch_size">30</prop>
   </props>
   
  </property>
  <!-- hibernate配置文件（xml类型） -->
  <property name="mappingResources">
   <list>
       <value>/****.xml</value>  
     </list>
  </property> 
  <!-- hibernate配置文件（annotation类型） -->
  <property name="annotatedClasses">
   <list>
        <value>com.**.pojo.*Model</value>
   </list>
  </property>
  
</bean>
  <!-- jdbc操作数据库模板 -->
 <bean id="CDBManager"  class="com.***.CDBManager">
</bean>
</beans>

3. spring事物管理配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
   <!-- 事务管理器，将委托给HibernateTransactionManager进行管理//-->
   <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>
 
 <!-- 事务处理的AOP配置 所有服务层bean声明都要继承此bean//-->
 <bean id="TransactionProxyTemplate" abstract="true"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager" ref="transactionManager" />
  <property name="transactionAttributes">
   <props>
       <!-- 为了保证服务层统一的事务处理。服务层接口，类的方法必须以下面的方法为开口  -->
       <!--spring 捕获到RuntimeException和其他一些异常时才会回滚，不是所有异常都会回滚，-Exception 设置 为任何异常都回滚     -->
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
    <prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>
    <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
    <prop key="delete*">PROPAGATION_REQUIRED,-Exception </prop>
    <prop key="execute*">PROPAGATION_REQUIRED,-Exception</prop>
   </props>
  </property>
 </bean>
    <!-- 提供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法 -->
 <bean id="springApplicationContextUtil"  class="**.util.SpringApplicationContextUtil"></bean>
</beans>

4. jdbc数据连接类CDBManager.java

import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * <p>Title:简单的数据连接类</p>
 */
public class CDBManager implements ApplicationContextAware {
 
 private static ApplicationContext applicationContext;

 /**
  * 获取数据源
  * @return
  */
 public static DataSource getDataSource() {
  DataSource dataSource = (DataSource) applicationContext.getBean("sysDataSource");
  return dataSource;
 }

 /**
  * 获取连接
  * @return
  */
 public static Connection getConn() {
  DataSource ds = null;
  Connection con = null;
  try {
   ds = getDataSource();
   con = ds.getConnection();
  } catch (SQLException e) {
   e.printStackTrace();
  }
  return con;
 }

 /**
  * 获取数据源上下文
  */
 public void setApplicationContext(ApplicationContext context) throws BeansException {
  applicationContext = context;
 }
}

5.普通java类获取spring上下文类 SpringApplicationContextUtil.java

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
 * <p>Title:springcontex类 </p>
 * <p>Description:提供供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法</p>
 */
public class SpringApplicationContextUtil implements ApplicationContextAware {
 //声明一个静态变量保存
 private static ApplicationContext context;
 
 @SuppressWarnings("static-access")
 public void setApplicationContext(ApplicationContext context)
  throws BeansException {
  this.context = context;
 }
 
    public static ApplicationContext getContext(){
  return context;
 }
    public static Object getBean(String beanName){
     if (StringUtils.isEmpty(beanName)) {
   return null;
  }
  return getContext().getBean(StringUtils.trim(beanName));
 }
}

6.普通spring配置文件（applicationContext-test.xml）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <!-- 测试Dao -->
 <bean id="testDao" class="com.**.HibernateEntityDao">
  <property name="sessionFactory" ref="sessionFactory"></property>
  <property name="entityClass" value="com.**.model.TestModel"></property>
 </bean>
 
 <!-- 测试Service -->
 <bean id="testService" parent="TransactionProxyTemplate">
  <property name="target">
   <bean class="com.**.service.imp.testServiceImp">
    <property name="testDao" ref="testDao"></property>
   </bean>
  </property>
 </bean>
 
 <!-- 测试Action -->
 <bean id="testAction" class="com.**.action.TestAction">
     <property name="testService" ref="testService"></property>
 </bean>
 
</beans>

7.HIbernateEntityDao.java类

package com.bobo.base.db;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;



/**
 * <p>Title:泛型DAO </p>
 * <p>Description:该类通过泛型定义了基于实体的基础DAO。该类继承HibernateDaoSupport，提供了常用的DAO方法。
 * @author  
 * @version 1.0  2009-05-06
 */

public class HibernateEntityDao<T>  extends HibernateDaoSupport {

	private Class<T> entityClass;

	public void setEntityClass(Class<T> entityClass) {
		this.entityClass = entityClass;
	}
	/** 是否起用查询缓存 TRUE是，FALSE不启用 */
	private static final boolean ISCACHE = true;
	
	/**
	 * 存取过程，删除基本信息
	 * @param proce 调用存取过程 的字符串
	 * @param param 参数
	 */
	public void callProcedure(String proce,String param){
		Session session =this.getSession();   
		SQLQuery query = session.createSQLQuery(proce);  
		query.setString(0, param);
		query.executeUpdate();
	}
	/**
	 * 根据指定的ID获取实体对象。
	 * 
	 * @param id
	 *            实体ID
	 * @return 返回指定ID的实体对象，如果没有找到则返回null。
	 */
	@SuppressWarnings("unchecked")
	public T get(Serializable id) {
		if (id == null) {
			return null;
		}
		return (T) getHibernateTemplate().get(entityClass, id);
	}
	/**
	 * 根据指定的ID获取实体对象,支持延迟加载。
	 * 
	 * @param id 实体ID
	 * @return 返回指定ID的实体对象，如果没有找到则抛出异常。
	 */
	@SuppressWarnings("unchecked")
	public T load(Serializable id) {
		if (id == null) {
			return null;
		}
		return (T) getHibernateTemplate().load(entityClass, id);
	}

	/**
	 * 保存实体对象。
	 * 
	 * @param entity
	 *            待保存实体对象
	 */
	public void save(T entity) {
		getHibernateTemplate().save(entity);
	}
	/**
	 * 保存或修改持久化对象
	 * 
	 * @param object
	 */
	
	public void saveOrUpdate(Object object) {
		getHibernateTemplate().saveOrUpdate(object);
	}
	/**
	 * 更新实体对象.
	 * 
	 * @param entity
	 * 待更新实体对象.
	 */
	@SuppressWarnings({ "hiding", "unchecked" })
	public <T> T merge(T entity) {
		return (T)getHibernateTemplate().merge(entity);
	}

	/**
	 * 删除实体对象。
	 * 
	 * @param entity
	 *            待删除实体对象
	 */
	public void remove(T entity) {
		getHibernateTemplate().delete(entity);
	}

	/**
	 * 根据ID删除实体对象。
	 * 
	 * @param id
	 *            待删除实体对象ID
	 */
	public void remove(Serializable id) {
		getHibernateTemplate().delete(get(id));
	}

	/**
	 * 删除多个实体对象
	 * 
	 * @param entitys
	 *            待删除的实体对象集合
	 */
	public void remove(List<T> entitys) {
		for (T entity : entitys) {
			getHibernateTemplate().delete(entity);
		}
	}

	/**
	 * 根据属性批量删除实体对象
	 * 
	 * @param name
	 *            属性名
	 * @param value
	 *            属性值
	 */
	public void removeBy(String name, Object value) {
		Query query = createQuery("delete from " + entityClass.getName() + " where "
				+ name + "=?", value);
		query.executeUpdate();
	}

	public int remove(String hsql, Object... values) {
		int result = 0;
		Query query = createQuery(hsql, values);
		result = query.executeUpdate();
		return result;
	}
	
	public int removeByHql(String hsql) {
		int result = 0;
		Query query = createQuery(hsql);
		result = query.executeUpdate();
		return result;
	}


	/**
	 * 清理当前Session。
	 */
	public void clear() {
		getSession().clear();
	}

	/**
	 * 创建一个绑定实体类型的条件查询对象。
	 * 
	 * @param criterions
	 *            查询条件
	 * @return 返回一个条件查询对象。
	 */
	public Criteria createCriteria(Criterion... criterions) {
		Criteria criteria = getSession().createCriteria(entityClass);
		for (Criterion c : criterions) {
			criteria.add(c);
		}
		return criteria;
	}

	/**
	 * 创建一个查询对象。
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            参数值
	 * @return 返回一个查询对象。
	 */
	public Query createQuery(String hql, Object... values) {
		Query query = getSession().createQuery(hql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		return query;
	}

	/**
	 * 创建一个绑定实体并设定了排序的条件查询对象。
	 * 
	 * @param orderBy
	 *            排序属性
	 * @param isAsc
	 *            是否升序
	 * @param criterions
	 *            查询条件
	 * @return 返回一个已设定排序的条件查询对象。
	 */
	public Criteria createCriteria(String orderBy, Boolean isAsc,
			Criterion... criterions) {
		Criteria criteria = createCriteria(criterions);
		if (isAsc) {
			criteria.addOrder(Order.asc(orderBy));
		} else {
			criteria.addOrder(Order.desc(orderBy));
		}
		return criteria;
	}

	/**
	 * 获取指定类型的所有实体对象。
	 * 
	 * @return 返回指定类型的所有实体对象。
	 */
	@SuppressWarnings("unchecked")
	public List<T> getAll() {
		Criteria criteria = createCriteria();
		criteria.setCacheable(ISCACHE);
		return criteria.list();
	}

	/**
	 * 获取指定类型的所有实体对象并进行排序。
	 * 
	 * @param orderBy
	 *            排序的属性名
	 * @param isAsc
	 *            是否升序
	 * @return 返回排序后的指定类型的所有实体对象。
	 */
	@SuppressWarnings("unchecked")
	public List<T> getAll(String orderBy, Boolean isAsc) {
		Criteria criteria = createCriteria(orderBy, isAsc);
		criteria.setCacheable(ISCACHE);
		return criteria.list();
	}

	/**
	 * 根据属性的值查找实体对象。
	 * 
	 * @param name
	 *            属性名
	 * @param value
	 *            属性值
	 * @return 返回属性值相符的实体对象集合，如果没有找到返回一个空的集合。
	 */
	@SuppressWarnings("unchecked")
	public List<T> findBy(String name, Object value) {
		Criteria criteria = createCriteria();
		if (value == null) {
			criteria.add(Restrictions.isNull(name));
		} else {
			criteria.add(Restrictions.eq(name, value));
		}
		criteria.setCacheable(ISCACHE);
		return criteria.list();
	}

	/**
	 * 根据属性的值查找实体对象并进行排序。
	 * 
	 * @param name
	 *            属性名
	 * @param value
	 *            属性值
	 * @param orderBy
	 *            排序属性
	 * @param isAsc
	 *            是否升序
	 * @return 返回排序后的属性值相符的实体对象集合，如果没有找到返回一个空的集合。
	 */
	@SuppressWarnings("unchecked")
	public List<T> findBy(String name, Object value, String orderBy,
			boolean isAsc) {
		Criteria criteria = createCriteria(orderBy, isAsc);
		if (value == null) {
			criteria.add(Restrictions.isNull(name));
		} else {
			criteria.add(Restrictions.eq(name, value));
		}
		criteria.setCacheable(ISCACHE);
		return criteria.list();
	}

	/**
	 * 判断是否存在属性重复的实体对象。
	 * 
	 * @param entity
	 *            待判断的实体对象
	 * @param propNames
	 *            属性名，可以多个属性名用","分割
	 * @return 如果存在重复的实体对象返回false，否则返回true。
	 */
	public Boolean isUnique(T entity, String propNames) {
		Criteria criteria = createCriteria().setProjection(
				Projections.rowCount());
		String[] nameList = propNames.split(",");
		try {
			for (String name : nameList) {
				criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(
						entity, name)));
			}
			// 更新实体类时应该排除自身
			String idName = getIdName();
			Serializable id = getId(entity);
			if (id != null && !idName.equals(propNames)) {
				criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return Integer.parseInt(criteria.uniqueResult().toString()) == 0;
	}

	/**
	 * 根据属性的值查找唯一的实体对象。
	 * 
	 * @param name
	 *            属性名
	 * @param value
	 *            属性值
	 * @return 返回指定唯一的实体对象，如果没有找到则返回null。
	 */
	@SuppressWarnings("unchecked")
	public T findUnique(String name, Object value) {
		Criteria criteria = createCriteria(Restrictions.eq(name, value));
		criteria.setCacheable(ISCACHE);
		return (T) criteria.uniqueResult();
	}

	
	/**
	 * 根据HQL查询语句进行查询。
	 * 
	 * @param hql
	 *            HQL查询语句
	 * @param values
	 *            参数值
	 * @return 返回查询得到的分页对象。
	 */

	@SuppressWarnings("unchecked")
	public List findList(String hql, Object... values) {
		Query query =createQuery(hql, values);
		query.setCacheable(ISCACHE);
		return query.list();
	}
	/**
	 * 根据HQL查询语句进行查询。
	 * query.iterate 在启用缓存且查询数据量比较大时
	 * 性能比 query.list()高
	 * @param hql HQL查询语句
	 * @param values 参数值
	 * @return 返回查询得到Iterator 数据集 。
	 */
	@SuppressWarnings("unchecked")
	public Iterator<T> findIterator(String hql, Object... values) {
		Query query =createQuery(hql, values);
		query.setCacheable(ISCACHE);
		return query.iterate();
	}
	/**
	 * 根据HQL查询语句进行分页查询。
	 * 
	 * @param hql
	 *            HQL查询语句
	 * @param pageNo
	 *            待获取的页数
	 * @param pageSize
	 *            每页的记录数
	 * @param values
	 *            参数值
	 * @return 返回查询得到的总数。
	 */
	@SuppressWarnings("unchecked")
	public Integer getTotalCount(String hql,Object... values) {
		String countQueryString = " select count (*) "
				+ removeSelect(removeOrders(hql));
		List countlist = createQuery(countQueryString, values).setCacheable(
				ISCACHE).list();
		int totalCount = Integer.parseInt(countlist.get(0).toString());
	
		return totalCount;
	}
	/**
	 * 根据HQL查询语句进行分页查询。
	 * 
	 * @param hql
	 *            HQL查询语句
	 * @param pageNo
	 *            待获取的页数
	 * @param pageSize
	 *            每页的记录数
	 * @param values
	 *            参数值
	 * @return 返回查询得到的分页list对象。
	 */
	@SuppressWarnings("unchecked")
	public List findPageList(String hql, Integer pageNo, Integer pageSize,
			Object... values) {
		String countQueryString = " select count (*) "
				+ removeSelect(removeOrders(hql));
		List countlist = createQuery(countQueryString, values).setCacheable(
				ISCACHE).list();
		int totalCount = Integer.parseInt(countlist.get(0).toString());

		Integer pageCount = 0;
		if (totalCount % pageSize > 0) {
			pageCount = totalCount / pageSize + 1;
		} else {
			pageCount = totalCount / pageSize;
		}
		if (pageNo > pageCount) {
			pageNo = pageCount;
		}
		if (pageNo < 1) {
			pageNo =1;
		}
		Query query = createQuery(hql, values);
		query.setCacheable(ISCACHE);
		List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();
		return list;
	}

	/**
	 * 获取实体类的主键值。
	 */
	private Serializable getId(T entity) throws NoSuchMethodException,
			IllegalAccessException, InvocationTargetException {
		return (Serializable) PropertyUtils.getProperty(entity, getIdName());
	}

	/**
	 * 获取实体类的主键名。
	 */
	private String getIdName() {
		ClassMetadata meta = getSession().getSessionFactory().getClassMetadata(
				entityClass);
		return meta.getIdentifierPropertyName();
	}

	/**
	 * 去除HQL查询语句的select部分。
	 * 
	 * @param hql
	 *            HQL查询语句
	 * @return 返回去除了select部分的语句。
	 */
	private String removeSelect(String hql) {
		int beginPos = hql.toLowerCase().indexOf("from");
	   return hql.substring(beginPos);
	}

	/**
	 * 去除HQL查询语句的order by部分。
	 * 
	 * @param hql
	 *            HQL查询语句
	 * @return 返回去除了order by部分的语句。
	 */
	private String removeOrders(String hql) {
		Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",
				Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(hql);
		StringBuffer sb = new StringBuffer();
		while (m.find()) {
			m.appendReplacement(sb, "");
		}
		m.appendTail(sb);
		return sb.toString();
	}

	
	/**
	 * 支持sql查询
	 * @param sql
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List executeSQL(final String sql,final Object... values) {

		return (List)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createSQLQuery(sql);
				for (int i = 0; i < values.length; i++) {
					query.setParameter(i, values[i]);
				}
				return query.list();
			}

		});
	}
	
	/**
	 * 支持sql查询
	 * @param sql
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List executeSQL(final String sql,final List values) {
		
		return (List)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createSQLQuery(sql);
				for (int i = 0; i < values.size(); i++) {
					query.setParameter(i, values.get(i));
				}
				return query.list();
			}
			
		});
	}
	/**
	 * 支持sql 新增 和修改
	 * @param sql
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Object executeSQLInsertOrUpdate(final String sql,final Object... values) {
		return (Object)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createSQLQuery(sql);
				for (int i = 0; i < values.length; i++) {
					query.setParameter(i, values[i]);
				}
				return  query.executeUpdate();
				
			}

		});
	}
	/**
	 * 支持sql 新增 和修改
	 * @param sql
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Object executeSQLInsertOrUpdate(final String sql,final List values) {
		return (Object)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createSQLQuery(sql);
				for (int i = 0; i < values.size(); i++) {
					query.setParameter(i, values.get(i));
				}
				return  query.executeUpdate();
				
			}

		});
	}
	
	/**
	 * 支持 HQL方式 更新数据
	 * @param hql
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Object update(final String hql,final Object... values) {

		return (Object)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createQuery(hql);
				for (int i = 0; i < values.length; i++) {
					query.setParameter(i, values[i]);
				}
				return query.executeUpdate();
			}

		});
	}
	/***
	 * HQL查询结果集 根据结果集 返回结果集记录总数
	 * @param countQueryString  
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Integer  getQueryPageListCount(String hql,Object...values){
		int totalCount =0;
		List countlist = createQuery(hql, values).setCacheable(ISCACHE).list();
		if (countlist !=null) {
			totalCount = countlist.size();
		}
		return totalCount;
	}
	/****
	 * 分页查询查询记录 同 
	 * getQueryPageListCount(String hql,Object...values)
	 * 一起使用 达到分页查询
	 * @param hql
	 * @param pageNo 当前页 
	 * @param pageSize 每页大小
	 * @param values
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<T> findQueryPageList(String hql, Integer pageNo, Integer pageSize, Object... values) {
		Query query = createQuery(hql, values);
		query.setCacheable(ISCACHE);
		List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();
		return list;
	}
	
	
	/**
	 * 执行返回MAP对象的 返回的对象属性全部为大写字母
	 * <FIRSTNAME,"JISEN"><LASTNAME,"STANSEN">
	 * @param sql
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List executeSql(String sql){
		return this.getSession().createSQLQuery(sql).setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP).list();
	}
}