Spring结合hibernate配置文件

最新推荐文章于 2024-04-17 04:21:28 发布
最新推荐文章于 2024-04-17 04:21:28 发布
阅读量698 收藏
点赞数

本实例数据库是MySQL:

 

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


[plain] view plain copy print ?
  1. dataBaseType = MySQL  
  2.   
  3. jdbc.driverClassName=com.mysql.jdbc.Driver  
  4. jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8  
  5. jdbc.username=root  
  6. jdbc.password=root  
  7. hibernate.dialect=org.hibernate.dialect.MySQLDialect  
  8.   
  9. jdbc.initialPoolSize=10  
  10. #Output SQL statements to console,true:yes ,false:no  
  11. hibernate.show_sql=true  
  12. #Inquires the cache true:yes ,false:no  
  13. hibernate.cache.use_query_cache=true  
  14. hibernate.substitutions=true 1, false 0, yes 'Y', no 'N'  
  15. hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider  
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

[html] view plain copy print ?
  1. <beans  
  2.  xmlns="http://www.springframework.org/schema/beans"  
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.   <bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  6.       <property name="locations">  
  7.          <list>  
  8.           <value>classpath:dbconfig.properties</value>  
  9.          </list>  
  10.       </property>  
  11.    </bean>  
  12.     <!-- 数据库连接池配置，本例以用c3p0方式配置 -->  
  13.     <bean id="sysDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
  14.       <!-- 数据库驱动 -->  
  15.       <property name="driverClass"><value>${jdbc.driverClassName}</value></property>  
  16.       <!-- 数据库连接地址 -->  
  17.       <property name="jdbcUrl"><value>${jdbc.url}</value></property>  
  18.        <!-- 用户名 -->  
  19.       <property name="user"><value>${jdbc.username}</value></property>  
  20.       <!-- 用户密码 -->  
  21.       <property name="password"><value>${jdbc.password}</value></property>  
  22.       <!-- 初始化连接池大小 -->  
  23.       <property name="initialPoolSize"><value>${jdbc.initialPoolSize}</value></property>  
  24.     </bean>  
  25.      
  26.  <!-- JDBC start 无事务-->  
  27.  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  28.         <property name="dataSource" ref="sysDataSource" />  
  29.  </bean>  
  30.  <!-- JDBc end -->  
  31.    
  32.     <bean id="sessionFactory"  
  33.   class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  34.     
  35.   <property name="dataSource">  
  36.    <ref bean="sysDataSource" />  
  37.   </property>  
  38.   <property name="hibernateProperties">  
  39.    <props>  
  40.     <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
  41.     <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>   
  42.                 <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>  
  43.                 <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>  
  44.                 <prop key="hibernate.jdbc.batch_size">30</prop>  
  45.    </props>  
  46.      
  47.   </property>  
  48.   <!-- hibernate配置文件（xml类型） -->  
  49.   <property name="mappingResources">  
  50.    <list>  
  51.        <value>/****.xml</value>    
  52.      </list>  
  53.   </property>   
  54.   <!-- hibernate配置文件（annotation类型） -->  
  55.   <property name="annotatedClasses">  
  56.    <list>  
  57.         <value>com.**.pojo.*Model</value>  
  58.    </list>  
  59.   </property>  
  60.     
  61. </bean>  
  62.   <!-- jdbc操作数据库模板 -->  
  63.  <bean id="CDBManager"  class="com.***.CDBManager">  
  64. </bean>  
  65. </beans>  
<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事物管理配置文件

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.  xmlns="http://www.springframework.org/schema/beans"  
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  6.    
  7.    <!-- 事务管理器，将委托给HibernateTransactionManager进行管理//-->  
  8.    <bean id="transactionManager"  
  9.   class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  10.   <property name="sessionFactory" ref="sessionFactory" />  
  11.  </bean>  
  12.    
  13.  <!-- 事务处理的AOP配置 所有服务层bean声明都要继承此bean//-->  
  14.  <bean id="TransactionProxyTemplate" abstract="true"  
  15.   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  16.   <property name="transactionManager" ref="transactionManager" />  
  17.   <property name="transactionAttributes">  
  18.    <props>  
  19.        <!-- 为了保证服务层统一的事务处理。服务层接口，类的方法必须以下面的方法为开口  -->  
  20.        <!--spring 捕获到RuntimeException和其他一些异常时才会回滚，不是所有异常都会回滚，-Exception 设置 为任何异常都回滚     -->  
  21.     <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  22.     <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>  
  23.     <prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>  
  24.     <prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>  
  25.     <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>  
  26.     <prop key="delete*">PROPAGATION_REQUIRED,-Exception </prop>  
  27.     <prop key="execute*">PROPAGATION_REQUIRED,-Exception</prop>  
  28.    </props>  
  29.   </property>  
  30.  </bean>  
  31.     <!-- 提供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法 -->  
  32.  <bean id="springApplicationContextUtil"  class="**.util.SpringApplicationContextUtil"></bean>  
  33. </beans>  
<?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

[java] view plain copy print ?
  1. import java.sql.Connection;  
  2. import java.sql.SQLException;  
  3. import javax.sql.DataSource;  
  4.   
  5. import org.springframework.beans.BeansException;  
  6. import org.springframework.context.ApplicationContext;  
  7. import org.springframework.context.ApplicationContextAware;  
  8.   
  9. /** 
  10.  * <p>Title:简单的数据连接类</p> 
  11.  */  
  12. public class CDBManager implements ApplicationContextAware {  
  13.    
  14.  private static ApplicationContext applicationContext;  
  15.   
  16.  /** 
  17.   * 获取数据源 
  18.   * @return 
  19.   */  
  20.  public static DataSource getDataSource() {  
  21.   DataSource dataSource = (DataSource) applicationContext.getBean("sysDataSource");  
  22.   return dataSource;  
  23.  }  
  24.   
  25.  /** 
  26.   * 获取连接 
  27.   * @return 
  28.   */  
  29.  public static Connection getConn() {  
  30.   DataSource ds = null;  
  31.   Connection con = null;  
  32.   try {  
  33.    ds = getDataSource();  
  34.    con = ds.getConnection();  
  35.   } catch (SQLException e) {  
  36.    e.printStackTrace();  
  37.   }  
  38.   return con;  
  39.  }  
  40.   
  41.  /** 
  42.   * 获取数据源上下文 
  43.   */  
  44.  public void setApplicationContext(ApplicationContext context) throws BeansException {  
  45.   applicationContext = context;  
  46.  }  
  47. }  
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

[java] view plain copy print ?
  1. import org.apache.commons.lang.StringUtils;  
  2. import org.springframework.beans.BeansException;  
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.ApplicationContextAware;  
  5. /** 
  6.  * <p>Title:springcontex类 </p> 
  7.  * <p>Description:提供供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法</p> 
  8.  */  
  9. public class SpringApplicationContextUtil implements ApplicationContextAware {  
  10.  //声明一个静态变量保存   
  11.  private static ApplicationContext context;  
  12.    
  13.  @SuppressWarnings("static-access")  
  14.  public void setApplicationContext(ApplicationContext context)  
  15.   throws BeansException {  
  16.   this.context = context;  
  17.  }  
  18.    
  19.     public static ApplicationContext getContext(){  
  20.   return context;  
  21.  }  
  22.     public static Object getBean(String beanName){  
  23.      if (StringUtils.isEmpty(beanName)) {  
  24.    return null;  
  25.   }  
  26.   return getContext().getBean(StringUtils.trim(beanName));  
  27.  }  
  28. }  
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）

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  5.  <!-- 测试Dao -->  
  6.  <bean id="testDao" class="com.**.HibernateEntityDao">  
  7.   <property name="sessionFactory" ref="sessionFactory"></property>  
  8.   <property name="entityClass" value="com.**.model.TestModel"></property>  
  9.  </bean>  
  10.    
  11.  <!-- 测试Service -->  
  12.  <bean id="testService" parent="TransactionProxyTemplate">  
  13.   <property name="target">  
  14.    <bean class="com.**.service.imp.testServiceImp">  
  15.     <property name="testDao" ref="testDao"></property>  
  16.    </bean>  
  17.   </property>  
  18.  </bean>  
  19.    
  20.  <!-- 测试Action -->  
  21.  <bean id="testAction" class="com.**.action.TestAction">  
  22.      <property name="testService" ref="testService"></property>  
  23.  </bean>  
  24.    
  25. </beans>  
<?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类

[html] view plain copy print ?
  1. package com.bobo.base.db;  
  2.   
  3. import java.io.Serializable;  
  4. import java.lang.reflect.InvocationTargetException;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.regex.Matcher;  
  8. import java.util.regex.Pattern;  
  9.   
  10. import org.apache.commons.beanutils.PropertyUtils;  
  11. import org.hibernate.Criteria;  
  12. import org.hibernate.Query;  
  13. import org.hibernate.SQLQuery;  
  14. import org.hibernate.Session;  
  15. import org.hibernate.criterion.Criterion;  
  16. import org.hibernate.criterion.Order;  
  17. import org.hibernate.criterion.Projections;  
  18. import org.hibernate.criterion.Restrictions;  
  19. import org.hibernate.metadata.ClassMetadata;  
  20. import org.springframework.orm.hibernate3.HibernateCallback;  
  21. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  22.   
  23.   
  24.   
  25. /**  
  26.  * <p>Title:泛型DAO </p>  
  27.  * <p>Description:该类通过泛型定义了基于实体的基础DAO。该类继承HibernateDaoSupport，提供了常用的DAO方法。  
  28.  * @author    
  29.  * @version 1.0  2009-05-06  
  30.  */  
  31.   
  32. public class HibernateEntityDao<T>  extends HibernateDaoSupport {  
  33.   
  34.     private Class<T> entityClass;  
  35.   
  36.     public void setEntityClass(Class<T> entityClass) {  
  37.         this.entityClass = entityClass;  
  38.     }  
  39.     /** 是否起用查询缓存 TRUE是，FALSE不启用 */  
  40.     private static final boolean ISCACHE = true;  
  41.       
  42.     /**  
  43.      * 存取过程，删除基本信息  
  44.      * @param proce 调用存取过程 的字符串  
  45.      * @param param 参数  
  46.      */  
  47.     public void callProcedure(String proce,String param){  
  48.         Session session =this.getSession();     
  49.         SQLQuery query = session.createSQLQuery(proce);    
  50.         query.setString(0, param);  
  51.         query.executeUpdate();  
  52.     }  
  53.     /**  
  54.      * 根据指定的ID获取实体对象。  
  55.      *   
  56.      * @param id  
  57.      *            实体ID  
  58.      * @return 返回指定ID的实体对象，如果没有找到则返回null。  
  59.      */  
  60.     @SuppressWarnings("unchecked")  
  61.     public T get(Serializable id) {  
  62.         if (id == null) {  
  63.             return null;  
  64.         }  
  65.         return (T) getHibernateTemplate().get(entityClass, id);  
  66.     }  
  67.     /**  
  68.      * 根据指定的ID获取实体对象,支持延迟加载。  
  69.      *   
  70.      * @param id 实体ID  
  71.      * @return 返回指定ID的实体对象，如果没有找到则抛出异常。  
  72.      */  
  73.     @SuppressWarnings("unchecked")  
  74.     public T load(Serializable id) {  
  75.         if (id == null) {  
  76.             return null;  
  77.         }  
  78.         return (T) getHibernateTemplate().load(entityClass, id);  
  79.     }  
  80.   
  81.     /**  
  82.      * 保存实体对象。  
  83.      *   
  84.      * @param entity  
  85.      *            待保存实体对象  
  86.      */  
  87.     public void save(T entity) {  
  88.         getHibernateTemplate().save(entity);  
  89.     }  
  90.     /**  
  91.      * 保存或修改持久化对象  
  92.      *   
  93.      * @param object  
  94.      */  
  95.       
  96.     public void saveOrUpdate(Object object) {  
  97.         getHibernateTemplate().saveOrUpdate(object);  
  98.     }  
  99.     /**  
  100.      * 更新实体对象.  
  101.      *   
  102.      * @param entity  
  103.      * 待更新实体对象.  
  104.      */  
  105.     @SuppressWarnings({ "hiding", "unchecked" })  
  106.     public <T> T merge(T entity) {  
  107.         return (T)getHibernateTemplate().merge(entity);  
  108.     }  
  109.   
  110.     /**  
  111.      * 删除实体对象。  
  112.      *   
  113.      * @param entity  
  114.      *            待删除实体对象  
  115.      */  
  116.     public void remove(T entity) {  
  117.         getHibernateTemplate().delete(entity);  
  118.     }  
  119.   
  120.     /**  
  121.      * 根据ID删除实体对象。  
  122.      *   
  123.      * @param id  
  124.      *            待删除实体对象ID  
  125.      */  
  126.     public void remove(Serializable id) {  
  127.         getHibernateTemplate().delete(get(id));  
  128.     }  
  129.   
  130.     /**  
  131.      * 删除多个实体对象  
  132.      *   
  133.      * @param entitys  
  134.      *            待删除的实体对象集合  
  135.      */  
  136.     public void remove(List<T> entitys) {  
  137.         for (T entity : entitys) {  
  138.             getHibernateTemplate().delete(entity);  
  139.         }  
  140.     }  
  141.   
  142.     /**  
  143.      * 根据属性批量删除实体对象  
  144.      *   
  145.      * @param name  
  146.      *            属性名  
  147.      * @param value  
  148.      *            属性值  
  149.      */  
  150.     public void removeBy(String name, Object value) {  
  151.         Query query = createQuery("delete from " + entityClass.getName() + " where "  
  152.                 + name + "=?", value);  
  153.         query.executeUpdate();  
  154.     }  
  155.   
  156.     public int remove(String hsql, Object... values) {  
  157.         int result = 0;  
  158.         Query query = createQuery(hsql, values);  
  159.         result = query.executeUpdate();  
  160.         return result;  
  161.     }  
  162.       
  163.     public int removeByHql(String hsql) {  
  164.         int result = 0;  
  165.         Query query = createQuery(hsql);  
  166.         result = query.executeUpdate();  
  167.         return result;  
  168.     }  
  169.   
  170.   
  171.     /**  
  172.      * 清理当前Session。  
  173.      */  
  174.     public void clear() {  
  175.         getSession().clear();  
  176.     }  
  177.   
  178.     /**  
  179.      * 创建一个绑定实体类型的条件查询对象。  
  180.      *   
  181.      * @param criterions  
  182.      *            查询条件  
  183.      * @return 返回一个条件查询对象。  
  184.      */  
  185.     public Criteria createCriteria(Criterion... criterions) {  
  186.         Criteria criteria = getSession().createCriteria(entityClass);  
  187.         for (Criterion c : criterions) {  
  188.             criteria.add(c);  
  189.         }  
  190.         return criteria;  
  191.     }  
  192.   
  193.     /**  
  194.      * 创建一个查询对象。  
  195.      *   
  196.      * @param hql  
  197.      *            HQL语句  
  198.      * @param values  
  199.      *            参数值  
  200.      * @return 返回一个查询对象。  
  201.      */  
  202.     public Query createQuery(String hql, Object... values) {  
  203.         Query query = getSession().createQuery(hql);  
  204.         for (int i = 0; i < values.length; i++) {  
  205.             query.setParameter(i, values[i]);  
  206.         }  
  207.         return query;  
  208.     }  
  209.   
  210.     /**  
  211.      * 创建一个绑定实体并设定了排序的条件查询对象。  
  212.      *   
  213.      * @param orderBy  
  214.      *            排序属性  
  215.      * @param isAsc  
  216.      *            是否升序  
  217.      * @param criterions  
  218.      *            查询条件  
  219.      * @return 返回一个已设定排序的条件查询对象。  
  220.      */  
  221.     public Criteria createCriteria(String orderBy, Boolean isAsc,  
  222.             Criterion... criterions) {  
  223.         Criteria criteria = createCriteria(criterions);  
  224.         if (isAsc) {  
  225.             criteria.addOrder(Order.asc(orderBy));  
  226.         } else {  
  227.             criteria.addOrder(Order.desc(orderBy));  
  228.         }  
  229.         return criteria;  
  230.     }  
  231.   
  232.     /**  
  233.      * 获取指定类型的所有实体对象。  
  234.      *   
  235.      * @return 返回指定类型的所有实体对象。  
  236.      */  
  237.     @SuppressWarnings("unchecked")  
  238.     public List<T> getAll() {  
  239.         Criteria criteria = createCriteria();  
  240.         criteria.setCacheable(ISCACHE);  
  241.         return criteria.list();  
  242.     }  
  243.   
  244.     /**  
  245.      * 获取指定类型的所有实体对象并进行排序。  
  246.      *   
  247.      * @param orderBy  
  248.      *            排序的属性名  
  249.      * @param isAsc  
  250.      *            是否升序  
  251.      * @return 返回排序后的指定类型的所有实体对象。  
  252.      */  
  253.     @SuppressWarnings("unchecked")  
  254.     public List<T> getAll(String orderBy, Boolean isAsc) {  
  255.         Criteria criteria = createCriteria(orderBy, isAsc);  
  256.         criteria.setCacheable(ISCACHE);  
  257.         return criteria.list();  
  258.     }  
  259.   
  260.     /**  
  261.      * 根据属性的值查找实体对象。  
  262.      *   
  263.      * @param name  
  264.      *            属性名  
  265.      * @param value  
  266.      *            属性值  
  267.      * @return 返回属性值相符的实体对象集合，如果没有找到返回一个空的集合。  
  268.      */  
  269.     @SuppressWarnings("unchecked")  
  270.     public List<T> findBy(String name, Object value) {  
  271.         Criteria criteria = createCriteria();  
  272.         if (value == null) {  
  273.             criteria.add(Restrictions.isNull(name));  
  274.         } else {  
  275.             criteria.add(Restrictions.eq(name, value));  
  276.         }  
  277.         criteria.setCacheable(ISCACHE);  
  278.         return criteria.list();  
  279.     }  
  280.   
  281.     /**  
  282.      * 根据属性的值查找实体对象并进行排序。  
  283.      *   
  284.      * @param name  
  285.      *            属性名  
  286.      * @param value  
  287.      *            属性值  
  288.      * @param orderBy  
  289.      *            排序属性  
  290.      * @param isAsc  
  291.      *            是否升序  
  292.      * @return 返回排序后的属性值相符的实体对象集合，如果没有找到返回一个空的集合。  
  293.      */  
  294.     @SuppressWarnings("unchecked")  
  295.     public List<T> findBy(String name, Object value, String orderBy,  
  296.             boolean isAsc) {  
  297.         Criteria criteria = createCriteria(orderBy, isAsc);  
  298.         if (value == null) {  
  299.             criteria.add(Restrictions.isNull(name));  
  300.         } else {  
  301.             criteria.add(Restrictions.eq(name, value));  
  302.         }  
  303.         criteria.setCacheable(ISCACHE);  
  304.         return criteria.list();  
  305.     }  
  306.   
  307.     /**  
  308.      * 判断是否存在属性重复的实体对象。  
  309.      *   
  310.      * @param entity  
  311.      *            待判断的实体对象  
  312.      * @param propNames  
  313.      *            属性名，可以多个属性名用","分割  
  314.      * @return 如果存在重复的实体对象返回false，否则返回true。  
  315.      */  
  316.     public Boolean isUnique(T entity, String propNames) {  
  317.         Criteria criteria = createCriteria().setProjection(  
  318.                 Projections.rowCount());  
  319.         String[] nameList = propNames.split(",");  
  320.         try {  
  321.             for (String name : nameList) {  
  322.                 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(  
  323.                         entity, name)));  
  324.             }  
  325.             // 更新实体类时应该排除自身  
  326.             String idName = getIdName();  
  327.             Serializable id = getId(entity);  
  328.             if (id != null && !idName.equals(propNames)) {  
  329.                 criteria.add(Restrictions.not(Restrictions.eq(idName, id)));  
  330.             }  
  331.         } catch (Exception e) {  
  332.             throw new RuntimeException(e);  
  333.         }  
  334.         return Integer.parseInt(criteria.uniqueResult().toString()) == 0;  
  335.     }  
  336.   
  337.     /**  
  338.      * 根据属性的值查找唯一的实体对象。  
  339.      *   
  340.      * @param name  
  341.      *            属性名  
  342.      * @param value  
  343.      *            属性值  
  344.      * @return 返回指定唯一的实体对象，如果没有找到则返回null。  
  345.      */  
  346.     @SuppressWarnings("unchecked")  
  347.     public T findUnique(String name, Object value) {  
  348.         Criteria criteria = createCriteria(Restrictions.eq(name, value));  
  349.         criteria.setCacheable(ISCACHE);  
  350.         return (T) criteria.uniqueResult();  
  351.     }  
  352.   
  353.       
  354.     /**  
  355.      * 根据HQL查询语句进行查询。  
  356.      *   
  357.      * @param hql  
  358.      *            HQL查询语句  
  359.      * @param values  
  360.      *            参数值  
  361.      * @return 返回查询得到的分页对象。  
  362.      */  
  363.   
  364.     @SuppressWarnings("unchecked")  
  365.     public List findList(String hql, Object... values) {  
  366.         Query query =createQuery(hql, values);  
  367.         query.setCacheable(ISCACHE);  
  368.         return query.list();  
  369.     }  
  370.     /**  
  371.      * 根据HQL查询语句进行查询。  
  372.      * query.iterate 在启用缓存且查询数据量比较大时  
  373.      * 性能比 query.list()高  
  374.      * @param hql HQL查询语句  
  375.      * @param values 参数值  
  376.      * @return 返回查询得到Iterator 数据集 。  
  377.      */  
  378.     @SuppressWarnings("unchecked")  
  379.     public Iterator<T> findIterator(String hql, Object... values) {  
  380.         Query query =createQuery(hql, values);  
  381.         query.setCacheable(ISCACHE);  
  382.         return query.iterate();  
  383.     }  
  384.     /**  
  385.      * 根据HQL查询语句进行分页查询。  
  386.      *   
  387.      * @param hql  
  388.      *            HQL查询语句  
  389.      * @param pageNo  
  390.      *            待获取的页数  
  391.      * @param pageSize  
  392.      *            每页的记录数  
  393.      * @param values  
  394.      *            参数值  
  395.      * @return 返回查询得到的总数。  
  396.      */  
  397.     @SuppressWarnings("unchecked")  
  398.     public Integer getTotalCount(String hql,Object... values) {  
  399.         String countQueryString = " select count (*) "  
  400.                 + removeSelect(removeOrders(hql));  
  401.         List countlist = createQuery(countQueryString, values).setCacheable(  
  402.                 ISCACHE).list();  
  403.         int totalCount = Integer.parseInt(countlist.get(0).toString());  
  404.       
  405.         return totalCount;  
  406.     }  
  407.     /**  
  408.      * 根据HQL查询语句进行分页查询。  
  409.      *   
  410.      * @param hql  
  411.      *            HQL查询语句  
  412.      * @param pageNo  
  413.      *            待获取的页数  
  414.      * @param pageSize  
  415.      *            每页的记录数  
  416.      * @param values  
  417.      *            参数值  
  418.      * @return 返回查询得到的分页list对象。  
  419.      */  
  420.     @SuppressWarnings("unchecked")  
  421.     public List findPageList(String hql, Integer pageNo, Integer pageSize,  
  422.             Object... values) {  
  423.         String countQueryString = " select count (*) "  
  424.                 + removeSelect(removeOrders(hql));  
  425.         List countlist = createQuery(countQueryString, values).setCacheable(  
  426.                 ISCACHE).list();  
  427.         int totalCount = Integer.parseInt(countlist.get(0).toString());  
  428.   
  429.         Integer pageCount = 0;  
  430.         if (totalCount % pageSize > 0) {  
  431.             pageCount = totalCount / pageSize + 1;  
  432.         } else {  
  433.             pageCount = totalCount / pageSize;  
  434.         }  
  435.         if (pageNo > pageCount) {  
  436.             pageNo = pageCount;  
  437.         }  
  438.         if (pageNo < 1) {  
  439.             pageNo =1;  
  440.         }  
  441.         Query query = createQuery(hql, values);  
  442.         query.setCacheable(ISCACHE);  
  443.         List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();  
  444.         return list;  
  445.     }  
  446.   
  447.     /**  
  448.      * 获取实体类的主键值。  
  449.      */  
  450.     private Serializable getId(T entity) throws NoSuchMethodException,  
  451.             IllegalAccessException, InvocationTargetException {  
  452.         return (Serializable) PropertyUtils.getProperty(entity, getIdName());  
  453.     }  
  454.   
  455.     /**  
  456.      * 获取实体类的主键名。  
  457.      */  
  458.     private String getIdName() {  
  459.         ClassMetadata meta = getSession().getSessionFactory().getClassMetadata(  
  460.                 entityClass);  
  461.         return meta.getIdentifierPropertyName();  
  462.     }  
  463.   
  464.     /**  
  465.      * 去除HQL查询语句的select部分。  
  466.      *   
  467.      * @param hql  
  468.      *            HQL查询语句  
  469.      * @return 返回去除了select部分的语句。  
  470.      */  
  471.     private String removeSelect(String hql) {  
  472.         int beginPos = hql.toLowerCase().indexOf("from");  
  473.        return hql.substring(beginPos);  
  474.     }  
  475.   
  476.     /**  
  477.      * 去除HQL查询语句的order by部分。  
  478.      *   
  479.      * @param hql  
  480.      *            HQL查询语句  
  481.      * @return 返回去除了order by部分的语句。  
  482.      */  
  483.     private String removeOrders(String hql) {  
  484.         Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",  
  485.                 Pattern.CASE_INSENSITIVE);  
  486.         Matcher m = p.matcher(hql);  
  487.         StringBuffer sb = new StringBuffer();  
  488.         while (m.find()) {  
  489.             m.appendReplacement(sb, "");  
  490.         }  
  491.         m.appendTail(sb);  
  492.         return sb.toString();  
  493.     }  
  494.   
  495.       
  496.     /**  
  497.      * 支持sql查询  
  498.      * @param sql  
  499.      * @param values  
  500.      * @return  
  501.      */  
  502.     @SuppressWarnings("unchecked")  
  503.     public List executeSQL(final String sql,final Object... values) {  
  504.   
  505.         return (List)getHibernateTemplate().execute(new HibernateCallback() {  
  506.             public Object doInHibernate(Session session) {  
  507.                 Query query = session.createSQLQuery(sql);  
  508.                 for (int i = 0; i < values.length; i++) {  
  509.                     query.setParameter(i, values[i]);  
  510.                 }  
  511.                 return query.list();  
  512.             }  
  513.   
  514.         });  
  515.     }  
  516.       
  517.     /**  
  518.      * 支持sql查询  
  519.      * @param sql  
  520.      * @param values  
  521.      * @return  
  522.      */  
  523.     @SuppressWarnings("unchecked")  
  524.     public List executeSQL(final String sql,final List values) {  
  525.           
  526.         return (List)getHibernateTemplate().execute(new HibernateCallback() {  
  527.             public Object doInHibernate(Session session) {  
  528.                 Query query = session.createSQLQuery(sql);  
  529.                 for (int i = 0; i < values.size(); i++) {  
  530.                     query.setParameter(i, values.get(i));  
  531.                 }  
  532.                 return query.list();  
  533.             }  
  534.               
  535.         });  
  536.     }  
  537.     /**  
  538.      * 支持sql 新增 和修改  
  539.      * @param sql  
  540.      * @param values  
  541.      * @return  
  542.      */  
  543.     @SuppressWarnings("unchecked")  
  544.     public Object executeSQLInsertOrUpdate(final String sql,final Object... values) {  
  545.         return (Object)getHibernateTemplate().execute(new HibernateCallback() {  
  546.             public Object doInHibernate(Session session) {  
  547.                 Query query = session.createSQLQuery(sql);  
  548.                 for (int i = 0; i < values.length; i++) {  
  549.                     query.setParameter(i, values[i]);  
  550.                 }  
  551.                 return  query.executeUpdate();  
  552.                   
  553.             }  
  554.   
  555.         });  
  556.     }  
  557.     /**  
  558.      * 支持sql 新增 和修改  
  559.      * @param sql  
  560.      * @param values  
  561.      * @return  
  562.      */  
  563.     @SuppressWarnings("unchecked")  
  564.     public Object executeSQLInsertOrUpdate(final String sql,final List values) {  
  565.         return (Object)getHibernateTemplate().execute(new HibernateCallback() {  
  566.             public Object doInHibernate(Session session) {  
  567.                 Query query = session.createSQLQuery(sql);  
  568.                 for (int i = 0; i < values.size(); i++) {  
  569.                     query.setParameter(i, values.get(i));  
  570.                 }  
  571.                 return  query.executeUpdate();  
  572.                   
  573.             }  
  574.   
  575.         });  
  576.     }  
  577.       
  578.     /**  
  579.      * 支持 HQL方式 更新数据  
  580.      * @param hql  
  581.      * @param values  
  582.      * @return  
  583.      */  
  584.     @SuppressWarnings("unchecked")  
  585.     public Object update(final String hql,final Object... values) {  
  586.   
  587.         return (Object)getHibernateTemplate().execute(new HibernateCallback() {  
  588.             public Object doInHibernate(Session session) {  
  589.                 Query query = session.createQuery(hql);  
  590.                 for (int i = 0; i < values.length; i++) {  
  591.                     query.setParameter(i, values[i]);  
  592.                 }  
  593.                 return query.executeUpdate();  
  594.             }  
  595.   
  596.         });  
  597.     }  
  598.     /***  
  599.      * HQL查询结果集 根据结果集 返回结果集记录总数  
  600.      * @param countQueryString    
  601.      * @param values  
  602.      * @return  
  603.      */  
  604.     @SuppressWarnings("unchecked")  
  605.     public Integer  getQueryPageListCount(String hql,Object...values){  
  606.         int totalCount =0;  
  607.         List countlist = createQuery(hql, values).setCacheable(ISCACHE).list();  
  608.         if (countlist !=null) {  
  609.             totalCount = countlist.size();  
  610.         }  
  611.         return totalCount;  
  612.     }  
  613.     /****  
  614.      * 分页查询查询记录 同   
  615.      * getQueryPageListCount(String hql,Object...values)  
  616.      * 一起使用 达到分页查询  
  617.      * @param hql  
  618.      * @param pageNo 当前页   
  619.      * @param pageSize 每页大小  
  620.      * @param values  
  621.      * @return  
  622.      */  
  623.     @SuppressWarnings("unchecked")  
  624.     public List<T> findQueryPageList(String hql, Integer pageNo, Integer pageSize, Object... values) {  
  625.         Query query = createQuery(hql, values);  
  626.         query.setCacheable(ISCACHE);  
  627.         List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();  
  628.         return list;  
  629.     }  
  630.       
  631.       
  632.     /**  
  633.      * 执行返回MAP对象的 返回的对象属性全部为大写字母  
  634.      * <FIRSTNAME,"JISEN"><LASTNAME,"STANSEN">  
  635.      * @param sql  
  636.      * @return  
  637.      */  
  638.     @SuppressWarnings("unchecked")  
  639.     public List executeSql(String sql){  
  640.         return this.getSession().createSQLQuery(sql).setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP).list();  
  641.     }  
  642. }  
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();
	}
}


笨沙发
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
现有Mysql数据库，写Spring + Hibernate的配置文件
03-06
博文链接：https://sydxide2006.iteye.com/blog/127824
Spring对hibernate配置文件hibernate.cfg.xml的集成，来取代hibernate.cfg.xml的配置
hua00shao的专栏
04-22 702
spring对hibernate配置文件hibernate.cfg.xml的集成相当好，可以在Spring中配置Hibernate的SessionFactory从而取代Hibernate.cfg.xml和HibernateSessionFactory.java Spring在集成Hibernate时又分为两种形式：（集成后就不需要Hibernate.cfg.xml了） 1、继续使用Hibe
spring hibernate 配置文件
iteye_9815的博客
11-01 86
classpath:jdbc.properties ...
Spring hibernate 配置文件
weixin_33725239的博客
07-27 84
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://ww...
Spring+hibernate 配置文件
Ryosuke32Jump的博客
08-03 285
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www
spring_hibernate.xml配置文件
lss0555的博客
07-25 480
&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt; &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
Spring+hibernate配置文件
05-29 939
本实例数据库是MySQL:   1.为了方便维护与管理，建立一个数据库配置文件dbconfig.properties,文件内容如下： dataBaseType = MySQL jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=tr
SpringHibernate整合-配置文件
03-27 387
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www
spring中加入hibernate配置文件
anwenzhao0749的博客
09-28 219
<?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.spri...
spring和hibernate配置文件整合
路在脚下
06-25 600
为了操作方便，我们经常在spring整合hibernate的WEB项目中省去了用hibernate.cfg.xml的麻烦，将hibernate的信息直接配置在  Spring配置文件中  下面的都是针对Spring整合Hibernate（注解方式的hibernate）来说的  hibernate.cfg.xml和applicationContext.xml原始配置组合方式： 
SpringMVC+Hibernate框架搭建和配置
口袋里的小龙的专栏
03-28 1298
SpringMVC+Hibernate框架搭建和配置
【Java】spring+springmvc+hibernate最完整整合配置教程
最新发布
只恨天高的博客
04-17 578
【Java】spring+springmvc+hibernate最完整整合配置教程。SpringMVC只扫描Controller和ControllerAdvice。Spring排除扫描Controller和ControllerAdvice。
idea搭建Spring+SpringMVC+Hibernate框架环境
weixin_43094361的博客
04-04 2914
一、准备工作 安装并配置Java运行环境 Oracle数据库的安装与配置 安装并配置Tomcat 配置Maven环境 创建Maven web-app项目 二、项目结构 三、导包 因为使用Maven管理项目，所以jar无需手动导入包，只需在pom.xml中配置即可。 pom.xml配置文件如下 <?xml version="1.0" encoding="UTF-8"?...
Spring集成Hibernate
天之道居同文。
03-10 823
HibernateDaoSupport 包含HibernateTemplate 模板类，spring 对Hibernate再一次的封装， 使得代码可以更加简洁。声明式事务： 即在配置文件里，配置哪些方法是需要事务的。这些方法的事务的启动和提交，都交给 Spring 来处理。如果只是读取数据但不修改数据，可以设置read-only为true，对hibernate 可以有更好的优化。注意，dao的配置的parent 属性要设置成baseDao。业务操作可能是包含不同的dao的几个操作的。
spring+hibernate 两种整合方式配置文件
热门推荐
bit-cafe
07-05 1万+
之前的文章都是讲解springmvc+spring+mybatis 的整合，而很少有springmvc+spring+hibernate 因为工作的需要，最近在使用hibernate 所以下面我们来看看 spring整合hibernate的配置文件，这里只说spring+hibernate 的配置文件而不说springmvc 因为这些是不用变的。 spring整合hibernate 有两种方式
Spring + Hibernate 使用注解方式和配置文件方式映射实体类时spring_hibernate.xml 配置
阿飞
12-05 2345
Spring + Hibernate 使用注解方式和配置文件方式映射实体类时spring_hibernate.xml 配置
spring与hibernate集成--关于配置文件的最优化使用
行云流水
04-26 7162
spring对hibernate整合的相当完美，并且spring对hibernate配置文件hibernate.cfg.xml也做了整合，在spring中利用LocalSessionFactoryBean就可以把hibernate.cfg.xml文件的内容整合到spring的配置文件中，这确实相当好，减少了配置文件。其实，LocalSessionFactoryBean最吸引我的原因是mappi
搭建基于注解方式的SSH项目框架
爱清清的专栏
07-08 5176
搭建基于注解方式的SSH项目框架 1. 项目目录以及数据表结构 2. 准备jar包 下面是我开发项目准备的jar包，可能有一些是项目依赖的，例如其中的druid-1.0.13.jar、ftplet-api-1.0.6.jar ftpserver-core-1.0.6.jar、junit-4.1.1.jar、slf4j-api-1.7.12这几个包就是根据需要添加的，分别是阿里巴巴
spring整合hibernate中的配置文件hibernate.cfg.xml的详解总结
w635191928的博客
04-07 4189
applicationContext.xml配置文件 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:
SSH整合实战指南：Struts、Spring、Hibernate结合解析
- 配置SessionFactory：定义SessionFactory Bean，指定Hibernate配置文件，创建会话工厂。 - 配置事务：通过Spring的PlatformTransactionManager，实现事务的声明式管理。 教程的每个部分都包含了具体的配置代码和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值