基于Spring4+Hibernate4的通用数据访问层（Dao层）设计与实现！

于 2017-08-15 16:41:08 发布
阅读量984 收藏
点赞数
分类专栏： spring+springMVC+hibernate 文章标签： spring+springMVC+hib
通过泛型依赖注入，可显著减少代码量并提高复用性。采用BaseDao与BaseService简化了DAO层和服务层的实现，使得针对不同Model的操作更加统一且高效。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

基于泛型的依赖注入。当我们的项目中有很多的Model时，相应的Dao（DaoImpl),Service(ServiceImpl)也会增多。

而我们对这些Model的操作很多都是类似的，下面是我举出的一些（见名知意，其它自行脑补）：

1.save
2.saveAll
3.findById
4.update
5.saveOrUpdate
6.delete
7.deleteAll
8.deleteById
9.loadAll
10.load(int page,int rows)
11.getTotalCount
12.getScrollData(int firstResult, int maxResult)
13.getScrollData(int firstResult, int maxResult, LinkedHashMap orderby)
14.getScrollData(int firstResult, int maxResult, String where, Object[] params)
15.getScrollData(int firstResult, int maxResult, String where, Object[] params, LinkedHashMap orderby)

 

如果我们在每个Dao(DaoImpl),Service(ServiceImpl)中都定义这些方法，我们来算一下。假如有20个Model，那么：
20*15*（2+2）= 1200。纳里，这么一堆破东西就花了1200个方法！！！！（下次可以用这个凑代码量了。。。。）平均每个方法实现了20次，平均每个方法复制了不下40次。还要保证不出任何错误，这个还真是个苦力活。下面是我们更先进的方法。【注：次方法必须将spring更新到4，Spring3还不支持泛型注入！】

我们在Dao(DaoImpl),Service(ServiceImpl)中定义BaseDao(BaseDaoImpl),BaseService(BaseServiceImpl),然后由于ORM使用的是hibernate，我们在操作一个实体的时候其实只需要知道两个属性{Model.id.class（主键类型），Model.class（实体类类型）}，好吧其实都是Class类型，还是可序列化的。这样我们的BaseDao在实现的时候不需要关注具体是哪个实体类，根据Model.id.class和Model.class即可获取操作的一切【那CURD操作来说】。然后每个具体的Dao继承BaseDao,就可以拥有BaseDao中定义的十多个方法（不需重复复制代码），还可以根据业务需求扩展具体Dao中的方法，做到了很大程度的解耦（基础操作和特殊操作的解耦）。然后具体的DaoImpl首先继承自BaseDaoImpl（这样那十多个基础方法的实现就又可以省去了）再实现自己Dao的特殊业务逻辑方法。解耦很到位！【当然既然是基于泛型的那么别传错了Model类！！！】，Service（ServiceImpl）层也是一样的！！！

下面是包的结构：

com.xy.model
{Car,Driver,Passenger}
com.xy.dao
{BaseDao,CarDao,DriverDao,PassengerDao}
com.xy.dao.impl
{BaseDaoImpl,CarDaoImpl,DriverDaoImpl,PassengerDaoImpl}
com.xy.service
{BaseService,CarService,DriverService,PassengerService}
com.xy.service.impl
{BaseServiceImpl,CarServiceImpl,DriverServiceImpl,PassengerServiceImpl}



下面是配置文件信息：【本来觉得这个不是重点，没有必要填上来的，不过还是贴了】
##web.xml

[html] view plain copy
  1. <span><listener>  
  2.     <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>  
  3. </listener>  
  4. <listener>  
  5.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  6. </listener>  
  7. <context-param>  
  8.     <param-name>contextConfigLocation</param-name>  
  9.     <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>  
  10. </context-param>  
  11. <listener>  
  12.     <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
  13. </listener>  
  14. <filter>  
  15.     <filter-name>openSessionInViewFilter</filter-name>  
  16.     <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>  
  17.     <init-param>  
  18.         <param-name>singleSession</param-name>  
  19.         <param-value>true</param-value>  
  20.     </init-param>  
  21. </filter>  
  22. <filter-mapping>  
  23.     <filter-name>openSessionInViewFilter</filter-name>  
  24.     <url-pattern>*.action</url-pattern>  
  25. </filter-mapping></span>  


##Spring.xml

[html] view plain copy
  1. <span><?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. xmlns:context="http://www.springframework.org/schema/context"  
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7. http://www.springframework.org/schema/context  
  8. http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  9. ">  
  10.   
  11.     <!-- 引入属性文件,config.properties位于src/main/resources目录下 -->  
  12.     <context:property-placeholder location="classpath:config.properties" />  
  13.   
  14.     <!-- 自动扫描dao和service包(自动注入) -->  
  15.     <context:component-scan base-package="com.xy.dao.**,com.xy.service.**" />  
  16.   
  17. </beans></span>  



##Spring-hibernate.xml

[html] view plain copy
  1. <span><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="  
  3. http://www.springframework.org/schema/beans  
  4. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  5. http://www.springframework.org/schema/tx  
  6. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
  7. http://www.springframework.org/schema/aop  
  8. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  9. ">  
  10.   
  11.     <!-- 配置数据源 -->  
  12.     <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
  13.         <property name="url" value="${jdbc_url}" />  
  14.         <property name="username" value="${jdbc_username}" />  
  15.         <property name="password" value="${jdbc_password}" />  
  16.   
  17.         <!-- 初始化连接大小 -->  
  18.         <property name="initialSize" value="0" />  
  19.         <!-- 连接池最大使用连接数量 -->  
  20.         <property name="maxActive" value="20" />  
  21.         <!-- 连接池最小空闲 -->  
  22.         <property name="minIdle" value="0" />  
  23.         <!-- 获取连接最大等待时间 -->  
  24.         <property name="maxWait" value="60000" />  
  25.   
  26.         <property name="validationQuery" value="${validationQuery}" />  
  27.         <property name="testOnBorrow" value="false" />  
  28.         <property name="testOnReturn" value="false" />  
  29.         <property name="testWhileIdle" value="true" />  
  30.   
  31.         <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->  
  32.         <property name="timeBetweenEvictionRunsMillis" value="60000" />  
  33.         <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->  
  34.         <property name="minEvictableIdleTimeMillis" value="25200000" />  
  35.   
  36.         <!-- 打开removeAbandoned功能 -->  
  37.         <property name="removeAbandoned" value="true" />  
  38.         <!-- 1800秒，也就是30分钟 -->  
  39.         <property name="removeAbandonedTimeout" value="1800" />  
  40.         <!-- 关闭abanded连接时输出错误日志 -->  
  41.         <property name="logAbandoned" value="true" />  
  42.   
  43.         <!-- 监控数据库 -->  
  44.         <!-- <property name="filters" value="stat" /> -->  
  45.         <property name="filters" value="mergeStat" />  
  46.     </bean>  
  47.   
  48.     <!-- 配置hibernate session工厂 -->  
  49.     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
  50.         <property name="dataSource" ref="dataSource" />  
  51.         <property name="hibernateProperties">  
  52.             <props>  
  53.                 <!-- web项目启动时是否更新表结构 -->  
  54.                 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>  
  55.                 <!-- 系统使用的数据库方言，也就是使用的数据库类型 -->  
  56.                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
  57.                 <!-- 是否打印Hibernate生成的SQL到控制台 -->  
  58.                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
  59.                 <!-- 是否格式化打印出来的SQL -->  
  60.                 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>  
  61.             </props>  
  62.         </property>  
  63.         <!-- 自动扫描注解方式配置的hibernate类文件 -->  
  64.         <property name="packagesToScan">  
  65.             <list>  
  66.                 <value>com.xy.model</value>  
  67.             </list>  
  68.         </property>  
  69.   
  70.         <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->  
  71.         <!--  
  72.         <property name="mappingDirectoryLocations">  
  73.             <list>  
  74.                 <value>classpath:me/gacl/model/hbm</value>  
  75.             </list>  
  76.         </property>  
  77.          -->  
  78.     </bean>  
  79.   
  80.     <!-- 配置事务管理器 -->  
  81.     <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  82.         <property name="sessionFactory" ref="sessionFactory"></property>  
  83.     </bean>  
  84.   
  85.     <!-- 注解方式配置事物 -->  
  86.     <tx:annotation-driven transaction-manager="transactionManager" />  
  87. </beans></span>  


后面到了重点了！！！

#BaseDao.Java

[java] view plain copy
  1. public interface BaseDaoInter<K extends Serializable ,T extends Serializable> {  
  2.     /** 
  3.      * 由session工厂获取当前session对象 
  4.      * @return 
  5.      */  
  6.     public Session getSession();  
  7.     /** 
  8.      * 将实体对象保存到数据库中 
  9.      * @param t 待保存的实体对象 
  10.      * @return 实体对象的ID 
  11.      */  
  12.     public K save(T t);  
  13.     /** 
  14.      * 将实体对象【集合】保存到数据库中 
  15.      * @param ct 实体对象【集合】 
  16.      */  
  17.     public void saveAll(Collection<T> ct);  
  18.     /** 
  19.      * 根据Id查询实体对象 
  20.      * @param id 表记录中的对应的id字段 
  21.      * @return 对应的实体对象 
  22.      */  
  23.     public T findById(K id);  
  24.     /** 
  25.      * 更新一条记录 
  26.      * @param t 待更新记录对应的实体对象 
  27.      * @return 更新后的实体对象 
  28.      */  
  29.     public T update(T t);  
  30.     /** 
  31.      * 保存或更新一个实体对象到表记录中 
  32.      * @param t 待更新的实体对象 
  33.      * @return 更新后的实体对象 
  34.      */  
  35.     public T saveOrUpdate(T t);  
  36.     /** 
  37.      * 删除一个实体对象对应的表记录 
  38.      * @param t 待删除的实体对象 
  39.      */  
  40.     public void delete(T t);  
  41.     /** 
  42.      * 删除一组记录 
  43.      * @param ct 待删除记录集合 
  44.      */  
  45.     public void deleteAll(Collection<T> ct);  
  46.     /** 
  47.      * 根据id删除一条记录 
  48.      * @param id 待删除记录id 
  49.      * @return 是否删除成功（id是否有效） 
  50.      */  
  51.     public boolean deleteById(K id);  
  52.     /** 
  53.      * 加载所有记录集合 
  54.      * @return 所有记录集合 
  55.      */  
  56.     public QueryResult<T> loadAll();  
  57.     /** 
  58.      * 分页加载记录集合 
  59.      * @param page 当前第多少页 
  60.      * @param rows 每页最多多少行数据 
  61.      * @return 第page页的数据集合 
  62.      */  
  63.     public QueryResult<T> load(int page,int rows);  
  64.     /** 
  65.      * 获取总记录数 
  66.      * @return 总数 
  67.      */  
  68.     public long getTotalCount();  
  69.       
  70.     /******************************HQL******************************/  
  71.     /** 
  72.      * 分页获取所有记录 
  73.      * @return 
  74.      */  
  75.     public QueryResult<T> getScrollData();  
  76.     /** 
  77.      * 分页获取记录 
  78.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  79.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  80.      * @return 
  81.      */  
  82.     public QueryResult<T> getScrollData(int firstResult, int maxResult);  
  83.     /** 
  84.      * 分页获取记录 
  85.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  86.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  87.      * @param orderby 排序,Key为排序属性,Value为asc/desc,如: 
  88.      *  LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>(); 
  89.         orderby.put("email", "asc"); 
  90.         orderby.put("password", "desc"); 
  91.      * @return 
  92.      */  
  93.     public QueryResult<T> getScrollData(int firstResult, int maxResult, LinkedHashMap<String, String> orderby);  
  94.     /** 
  95.      * 分页获取记录 
  96.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  97.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  98.      * @param where 条件语句,不带where关键字,条件语句只能使用位置参数,位置参数的索引值以1开始,如:o.username=?1 and o.password=?2 
  99.      * @param params 条件语句出现的位置参数值 
  100.      * @return 
  101.      */  
  102.     public QueryResult<T> getScrollData(int firstResult, int maxResult, String where, Object[] params);  
  103.     /** 
  104.      * 分页获取记录 
  105.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  106.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  107.      * @param where 条件语句,不带where关键字,条件语句只能使用位置参数,位置参数的索引值以1开始,如:o.username=?1 and o.password=?2 
  108.      * @param params 条件语句出现的位置参数值 
  109.      * @param orderby 排序,Key为排序属性,Value为asc/desc,如: 
  110.      *  LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>(); 
  111.         orderby.put("email", "asc"); 
  112.         orderby.put("password", "desc"); 
  113.      * @return 
  114.      */  
  115.     public QueryResult<T> getScrollData(int firstResult, int maxResult, String where, Object[] params, LinkedHashMap<String, String> orderby);  
  116.   
  117. }  

#CarDao.java
[java] view plain copy
  1. public interface CarDaoInter extends BaseDaoInter<Integer,Car>{  
  2.       
  3. }  

#DriverDao.java 

<span class="pln">public interface DriverDaoInter extends BaseDaoInter</span><span class="tag"><Integer</span><span class="pln">,</span><span class="atn">Driver</span><span class="tag">></span><span class="pln">{

}</span>
#BaseDaoImpl.java

[java] view plain copy
  1. /** 
  2.  * 不一定必须是abstract类型的， 请不要对BaseDaoImpl使用@Repository注解，因为无法直接指定clatt属性值 
  3.  * class值由继承类来指定 
  4.  *  
  5.  * @author BearSmall 
  6.  * 
  7.  * @param <T> 
  8.  */  
  9. public abstract class BaseDaoImpl<K extends Serializable, T extends Serializable>  
  10.         implements BaseDaoInter<K, T> {  
  11.     @Autowired  
  12.     private SessionFactory sessionFactory; // 从容器中注入session工厂【无需get,set方法】  
  13.   
  14.     private Class<T> clatt; // 【实体类对应的Class对象】  
  15.   
  16.     /** 
  17.      * //向子类暴露的接口获用来获取sessionFactory 
  18.      *  
  19.      * @return sessionFactory 
  20.      */  
  21.     public SessionFactory getSessionFactory() {  
  22.         return sessionFactory;  
  23.     }  
  24.   
  25.     /** 
  26.      * 保留指定clatt值的接口【通过子类显示调用父类的构造函数来指定】 
  27.      *  
  28.      * @param clatt 
  29.      */  
  30.     public BaseDaoImpl(Class<T> clatt) {  
  31.         this.clatt = clatt;  
  32.     }  
  33.   
  34.     // @SuppressWarnings("unchecked")  
  35.     // public BaseDaoImpl() {//另外一种方式指定clatt值，要求类必须是abstract类型  
  36.     // ParameterizedType parameterizedType =  
  37.     // (ParameterizedType)this.getClass().getGenericSuperclass();  
  38.     // clatt= (Class<T>)(parameterizedType.getActualTypeArguments()[0]);  
  39.     // }  
  40.   
  41.     @Override  
  42.     public Session getSession() {  
  43.         return getSessionFactory().getCurrentSession();  
  44.     }  
  45.   
  46.     @SuppressWarnings("unchecked")  
  47.     @Override  
  48.     public K save(T t) {  
  49.         Session session = getSession();  
  50.         return (K) session.save(t);  
  51.     }  
  52.   
  53.     @Override  
  54.     public T findById(K id) {  
  55.         Session session = getSession();  
  56.         @SuppressWarnings("unchecked")  
  57.         T t = (T) session.get(clatt, id);  
  58.         return t;  
  59.     }  
  60.   
  61.     @Override  
  62.     public void saveAll(Collection<T> ct) {  
  63.         Session session = getSession();  
  64.         for (T t : ct) {  
  65.             session.save(t);  
  66.         }  
  67.     }  
  68.   
  69.     @Override  
  70.     public T update(T t) {  
  71.         Session session = getSession();  
  72.         session.update(t);  
  73.         return t;  
  74.     }  
  75.   
  76.     @Override  
  77.     public void deleteAll(Collection<T> ct) {  
  78.         Session session = getSession();  
  79.         for (T t : ct) {  
  80.             session.delete(t);  
  81.         }  
  82.     }  
  83.   
  84.     @Override  
  85.     public T saveOrUpdate(T t) {  
  86.         Session session = getSession();  
  87.         session.saveOrUpdate(t);  
  88.         return t;  
  89.     }  
  90.   
  91.     @Override  
  92.     public void delete(T t) {  
  93.         Session session = getSession();  
  94.         session.delete(t);  
  95.     }  
  96.   
  97.     @Override  
  98.     public boolean deleteById(K id) {  
  99.         Session session = getSession();  
  100.         @SuppressWarnings("unchecked")  
  101.         T t = (T) session.get(clatt, id);  
  102.         if (t == null)  
  103.             return false;  
  104.         session.delete(t);  
  105.         return true;  
  106.     }  
  107.   
  108.     @SuppressWarnings("unchecked")  
  109.     @Override  
  110.     public QueryResult<T> loadAll() {  
  111.         Session session = getSession();  
  112.         Criteria criteria = session.createCriteria(clatt);  
  113.         QueryResult<T> result = new QueryResult<>();  
  114.         result.setDatas(criteria.list());  
  115.         result.setTotalCount(Long.parseLong(criteria  
  116.                 .setProjection(Projections.rowCount()).uniqueResult()  
  117.                 .toString()));  
  118.         return result;  
  119.     }  
  120.   
  121.     @SuppressWarnings("unchecked")  
  122.     @Override  
  123.     public QueryResult<T> load(int page, int rows) {  
  124.         Session session = getSession();  
  125.         Criteria criteria = session.createCriteria(clatt);  
  126.         criteria.setFirstResult((page - 1) * rows);  
  127.         criteria.setMaxResults(rows);  
  128.         QueryResult<T> result = new QueryResult<>();  
  129.         result.setDatas(criteria.list());  
  130.         result.setTotalCount(Long.parseLong(criteria  
  131.                 .setProjection(Projections.rowCount()).uniqueResult()  
  132.                 .toString()));  
  133.         return result;  
  134.     }  
  135.   
  136.     @Override  
  137.     public long getTotalCount() {  
  138.         Session session = getSession();  
  139.         Criteria criteria = session.createCriteria(clatt);  
  140.         Object object = criteria.setProjection(Projections.rowCount())  
  141.                 .uniqueResult();  
  142.         long totalCount = 0;  
  143.         if (object != null) {  
  144.             totalCount = Long.parseLong(object.toString());  
  145.         }  
  146.         return totalCount;  
  147.     }  
  148.   
  149.     /****************************** HQL ******************************/  
  150.     @Override  
  151.     public QueryResult<T> getScrollData() {  
  152.         return getScrollData(-1, -1, null, null, null);  
  153.     }  
  154.   
  155.     @Override  
  156.     public QueryResult<T> getScrollData(int firstResult, int maxResult) {  
  157.         return getScrollData(firstResult, maxResult, null, null, null);  
  158.     }  
  159.   
  160.     @Override  
  161.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  162.             LinkedHashMap<String, String> orderby) {  
  163.         return getScrollData(firstResult, maxResult, null, null, orderby);  
  164.     }  
  165.   
  166.     @Override  
  167.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  168.             String where, Object[] params) {  
  169.         return getScrollData(firstResult, maxResult, where, params, null);  
  170.     }  
  171.   
  172.     @Override  
  173.     @SuppressWarnings("unchecked")  
  174.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  175.             String where, Object[] params, LinkedHashMap<String, String> orderby) {  
  176.         String entityName = clatt.getSimpleName();  
  177.         String whereql = where != null && !"".equals(where.trim()) ? " where "  
  178.                 + where : "";  
  179.         Session session = getSession();  
  180.         Query query = session.createQuery("select o from " + entityName + " o"  
  181.                 + whereql + buildOrderby(orderby));  
  182.         if (firstResult != -1 && maxResult != -1)  
  183.             query.setFirstResult(firstResult).setMaxResults(maxResult);  
  184.         setQueryParameter(query, params);  
  185.   
  186.         QueryResult<T> qr = new QueryResult<T>();  
  187.         // qr.setResultlist(query.getResultList());  
  188.         Query queryCount = session.createQuery("select count(o) from "  
  189.                 + entityName + " o" + whereql);  
  190.         setQueryParameter(queryCount, params);  
  191.         long count = (Long) queryCount.uniqueResult();  
  192.         qr.setTotalCount(count);  
  193.         qr.setDatas(query.list());  
  194.         return qr;  
  195.     }  
  196.   
  197.     /** 
  198.      * 设置查询参数 
  199.      *  
  200.      * @param query 
  201.      *            查询对象 
  202.      * @param params 
  203.      *            参数值 
  204.      */  
  205.     public static void setQueryParameter(Query query, Object[] params) {  
  206.         if (params != null) {  
  207.             for (int i = 0; i < params.length; i++) {  
  208.                 query.setParameter(i, params[i]);  
  209.             }  
  210.         }  
  211.     }  
  212.   
  213.     /** 
  214.      * 构建排序语句 
  215.      *  
  216.      * @param orderby 
  217.      *            排序属性与asc/desc, Key为属性,Value为asc/desc 
  218.      * @return 
  219.      */  
  220.     public static String buildOrderby(LinkedHashMap<String, String> orderby) {  
  221.         StringBuilder sb = new StringBuilder();  
  222.         if (orderby != null && !orderby.isEmpty()) {  
  223.             sb.append(" order by ");  
  224.             for (Map.Entry<String, String> entry : orderby.entrySet()) {  
  225.                 sb.append("o.").append(entry.getKey()).append(" ")  
  226.                         .append(entry.getValue()).append(',');  
  227.             }  
  228.             sb.deleteCharAt(sb.length() - 1);  
  229.         }  
  230.         return sb.toString();  
  231.     }  
  232.   
  233. }  

#CarDaoImpl.java

[java] view plain copy
  1. @Repository("carDao")  
  2. public class CarDaoImpl extends BaseDaoImpl<Integer,Car> implements CarDaoInter{  
  3.     //通过调用父类的构造函数指定clazz值，即实体类的类类型  
  4.     public CarDaoImpl() {  
  5.         super(Car.class);  
  6.     }     
  7. }  

#DriverDaoImpl.java

[java] view plain copy
  1. @Repository(value="driverDao")  
  2. public class DriverDaoImpl extends BaseDaoImpl<Integer,Driver> implements DriverDaoInter{  
  3.     //通过调用父类的构造函数指定clazz值，即实体类的类类型  
  4.     public DriverDaoImpl() {  
  5.         super(Driver.class);  
  6.     }  
  7.       
  8. }  

#BaseService.java 

<span class="tag"></span><span class="pln"></span><span class="tag"></span>
#CarService.java
[java] view plain copy
  1. public interface CarServiceInter extends BaseServiceInter<Integer,Car>{  
  2.       
  3. }  

#DriverService.java
[java] view plain copy
  1. public interface DriverServiceInter extends BaseServiceInter<Integer,Driver>{  
  2.       
  3. }  

#BaseServiceImpl.java

[java] view plain copy
  1. @Transactional(propagation=Propagation.REQUIRED)  
  2. public abstract class BaseServiceImpl<K extends Serializable,T extends Serializable> implements BaseServiceInter<K,T> {  
  3.   
  4.     @Autowired  
  5.     private BaseDaoInter<K,T> baseDao;        //从容器中注入session工厂【无需get,set方法】  
  6.       
  7.     @Override  
  8.     public K save(T t) {  
  9.         return baseDao.save(t);  
  10.     }  
  11.   
  12.     @Override  
  13.     public void saveAll(Collection<T> ct) {  
  14.         baseDao.saveAll(ct);  
  15.     }  
  16.   
  17.     @Override  
  18.     public T findById(K id) {  
  19.         return baseDao.findById(id);  
  20.     }  
  21.   
  22.     @Override  
  23.     public T update(T t) {  
  24.         return baseDao.update(t);  
  25.     }  
  26.   
  27.     @Override  
  28.     public T saveOrUpdate(T t) {  
  29.         return baseDao.saveOrUpdate(t);  
  30.     }  
  31.   
  32.     @Override  
  33.     public void delete(T t) {  
  34.         baseDao.delete(t);  
  35.     }  
  36.   
  37.     @Override  
  38.     public void deleteAll(Collection<T> ct) {  
  39.         baseDao.deleteAll(ct);  
  40.     }  
  41.   
  42.     @Override  
  43.     public boolean deleteById(K id) {  
  44.         return baseDao.deleteById(id);  
  45.     }  
  46.   
  47.     @Override  
  48.     public QueryResult<T> loadAll() {  
  49.         return baseDao.loadAll();  
  50.     }  
  51.   
  52.     @Override  
  53.     public QueryResult<T> load(int page, int rows) {  
  54.         return baseDao.load(page, rows);  
  55.     }  
  56.   
  57.     @Override  
  58.     public long getTotalCount() {  
  59.         return baseDao.getTotalCount();  
  60.     }  
  61.     /******************************HQL******************************/  
  62.   
  63.     @Override  
  64.     public QueryResult<T> getScrollData() {  
  65.         return baseDao.getScrollData();  
  66.     }  
  67.   
  68.     @Override  
  69.     public QueryResult<T> getScrollData(int firstResult, int maxResult) {  
  70.         return baseDao.getScrollData(firstResult, maxResult);  
  71.     }  
  72.   
  73.     @Override  
  74.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  75.             LinkedHashMap<String, String> orderby) {  
  76.         return baseDao.getScrollData(firstResult, maxResult, orderby);  
  77.     }  
  78.   
  79.     @Override  
  80.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  81.             String where, Object[] params) {  
  82.         return baseDao.getScrollData(firstResult, maxResult, where, params);  
  83.     }  
  84.   
  85.     @Override  
  86.     public QueryResult<T> getScrollData(int firstResult, int maxResult,  
  87.             String where, Object[] params, LinkedHashMap<String, String> orderby) {  
  88.         return baseDao.getScrollData(firstResult, maxResult, where, params, orderby);  
  89.     }  
  90.       
  91. }  

#BaseService

[java] view plain copy
  1. public interface BaseServiceInter<K extends Serializable,T extends Serializable>  {  
  2.     /** 
  3.      * 将实体对象保存到数据库中 
  4.      * @param t 待保存的实体对象 
  5.      * @return 实体对象的ID 
  6.      */  
  7.     public K save(T t);  
  8.     /** 
  9.      * 将实体对象【集合】保存到数据库中 
  10.      * @param ct 实体对象【集合】 
  11.      */  
  12.     public void saveAll(Collection<T> ct);  
  13.     /** 
  14.      * 根据Id查询实体对象 
  15.      * @param id 表记录中的对应的id字段 
  16.      * @return 对应的实体对象 
  17.      */  
  18.     public T findById(K id);  
  19.     /** 
  20.      * 更新一条记录 
  21.      * @param t 待更新记录对应的实体对象 
  22.      * @return 更新后的实体对象 
  23.      */  
  24.     public T update(T t);  
  25.     /** 
  26.      * 保存或更新一个实体对象到表记录中 
  27.      * @param t 待更新的实体对象 
  28.      * @return 更新后的实体对象 
  29.      */  
  30.     public T saveOrUpdate(T t);  
  31.     /** 
  32.      * 删除一个实体对象对应的表记录 
  33.      * @param t 待删除的实体对象 
  34.      */  
  35.     public void delete(T t);  
  36.     /** 
  37.      * 删除一组记录 
  38.      * @param ct 待删除记录集合 
  39.      */  
  40.     public void deleteAll(Collection<T> ct);  
  41.     /** 
  42.      * 根据id删除一条记录 
  43.      * @param id 待删除记录id 
  44.      * @return 是否删除成功（id是否有效） 
  45.      */  
  46.     public boolean deleteById(K id);  
  47.     /** 
  48.      * 加载所有记录集合 
  49.      * @return 所有记录集合 
  50.      */  
  51.     public QueryResult<T> loadAll();  
  52.     /** 
  53.      * 分页加载记录集合 
  54.      * @param page 当前第多少页 
  55.      * @param rows 每页最多多少行数据 
  56.      * @return 第page页的数据集合 
  57.      */  
  58.     public QueryResult<T> load(int page,int rows);  
  59.     /** 
  60.      * 获取总记录数 
  61.      * @return 总数 
  62.      */  
  63.     public long getTotalCount();  
  64.     /******************************HQL******************************/  
  65.     /** 
  66.      * 分页获取所有记录 
  67.      * @return 
  68.      */  
  69.     public QueryResult<T> getScrollData();  
  70.     /** 
  71.      * 分页获取记录 
  72.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  73.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  74.      * @return 
  75.      */  
  76.     public QueryResult<T> getScrollData(int firstResult, int maxResult);  
  77.     /** 
  78.      * 分页获取记录 
  79.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  80.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  81.      * @param orderby 排序,Key为排序属性,Value为asc/desc,如: 
  82.      *  LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>(); 
  83.         orderby.put("email", "asc"); 
  84.         orderby.put("password", "desc"); 
  85.      * @return 
  86.      */  
  87.     public QueryResult<T> getScrollData(int firstResult, int maxResult, LinkedHashMap<String, String> orderby);  
  88.     /** 
  89.      * 分页获取记录 
  90.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  91.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  92.      * @param where 条件语句,不带where关键字,条件语句只能使用位置参数,位置参数的索引值以1开始,如:o.username=?1 and o.password=?2 
  93.      * @param params 条件语句出现的位置参数值 
  94.      * @return 
  95.      */  
  96.     public QueryResult<T> getScrollData(int firstResult, int maxResult, String where, Object[] params);  
  97.     /** 
  98.      * 分页获取记录 
  99.      * @param firstResult 开始索引,如果输入值为-1,即获取全部数据 
  100.      * @param maxResult 每页获取的记录数,如果输入值为-1,即获取全部数据 
  101.      * @param where 条件语句,不带where关键字,条件语句只能使用位置参数,位置参数的索引值以1开始,如:o.username=?1 and o.password=?2 
  102.      * @param params 条件语句出现的位置参数值 
  103.      * @param orderby 排序,Key为排序属性,Value为asc/desc,如: 
  104.      *  LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>(); 
  105.         orderby.put("email", "asc"); 
  106.         orderby.put("password", "desc"); 
  107.      * @return 
  108.      */  
  109.     public QueryResult<T> getScrollData(int firstResult, int maxResult, String where, Object[] params, LinkedHashMap<String, String> orderby);  
  110.   
  111. }  


#CarServiceImpl.java

[java] view plain copy
  1. @Service("carProxy")  
  2. public class CarServiceImpl extends BaseServiceImpl<Integer,Car> implements CarServiceInter {  
  3.     @Autowired  
  4.     private CarDaoInter carDao;        //从容器中注入session工厂【无需get,set方法】  
  5. }  

#DriverServiceImpl.java

[java] view plain copy
  1. @Service("driverProxy")  
  2. public class DriverServiceImpl extends BaseServiceImpl<Integer,Driver> implements DriverServiceInter {  
  3.     @Autowired  
  4.     private DriverDaoInter driverDao;       //从容器中注入session工厂【无需get,set方法】  
  5. } 
基于Spring+Struts+Hibernate实现的健康管理平台
mengyu965的博客
04-22 1707
源码及资料： http://www.byamd.xyz/sss.html 摘要 随着网络技术的不断发展，网站的开发与运用变得更加广泛。这次采用java语言SSH框架(Spring，Struts，Hibernate)设计并实现了面向特定群体的健康管理平台。该网站主要有教师饮食管理、教师健康日志、教师体检管理、疾病预测评估等功能模块。通过该网站，教师可以更好的关注自己的体检状况以及最近的身体状况，根据自身情况调整饮食，睡眠等生活习惯，并且可以及时预测高血压以及糖尿病的患病可能性大小，以便采取有效地预防措.
Hibernate封装dao层
08-31
Hibernate封装dao层
spring,springMVC,Hibernate全注解案例加dao的封装
03-11
spring,springMVC,Hibernate全注解案例加dao的封装,基于MyEclise
hibernate的dao层通用设计
小哥的博客
07-26 2800
hibernate的dao层通用设计，hibernate作为一款优秀的数据库持久化框架，在现实的运用中是非常广泛的。它的出现让不熟悉sql语法的程序员能开发数据库连接层成为一种可能，但是理想与现实永远是有差距的。开发过程中如果只使用hql进行操作，并且表之间的关联配置很复杂的话，这将成为一种噩梦。还好我们伟大的hibernate支持原生的sql操作，这也大大的增加了hibernate的灵活性。下面我们探讨一下hibernate的dao
泛型DAO设计
03-12 5109
         泛型是JDK1.5的一个新的特性，使用泛型机制编写的程序代码要比那些杂乱的使用Object变量，然后再进行强制类型转换的代码具有更好的安全性和可读性。如果你的系统运行在JDK1.5以上的版本上，建议多使用泛型来代替无休止的对象转换。         在软件设计中我们开始对系统进行三层甚至是多层架构了，目的是职责更加的明确，功能更加的分离。而常常使用的三层架构就是将表现层、业务
spring+hibernate中用好DAO模版设置
jackyrongvip的专栏
01-06 871
  在spring+hibernate中，由于基于hibernatedaosupport的dao组件必须获得sessionfactory的引用，因此可以让所有的DAO组件继承一个DAO模版，在其中防止其公用的部分，比如如下设置是很好的实践       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
基于Spring、Hibernate的通用DAO层与Service层的实现
做一个幸福的人
02-12 6197
因为DAO层基本的就是CRUD操作，变化不是很大，要是有变化的那就是查询。而确实没有必要为每一个实体写一个完整的DAO，但是没有还不行，那就“抽取”出来吧。而Service依赖与DAO层，有时就是简单调用一下，也确实没有必要每个都写。总之，不爱写多个，那就写一个通用的，而其他的继承或实现这个通用的可以了。 还是用代码说话吧。 Java代码   package org.
Spring+Hibernate整合下的通用DAO层设计与应用
Spring 框架主要负责业务层和表现层的管理，而 Hibernate 则是对象关系映射(ORM)工具，负责数据访问层的操作。将 Spring 和 Hibernate 结合起来，可以实现业务逻辑与数据访问的解耦，提高应用开发的效率和质量。 ...
AnyFoDao：Spring+Hibernate集成下的通用DAO层实现
在实际的项目开发中，为了简化开发流程，提高开发效率，开发者们通常会基于一些通用框架，如Spring和Hibernate，来实现一个通用的DAO层类，这便是AnyFoDao类的设计初衷。 ### 1. Spring和Hibernate整合简介 Spring...
(源码)基于Spring MVC + Spring + Hibernate的SSH平台.zip
最新发布
08-17
1. 数据访问层（DAO） 提供通用的数据访问对象（DAO）接口和实现类，支持CRUD操作和高级查询。 使用Hibernate作为ORM工具，简化数据库操作。 2. 业务逻辑层（Service） 通过Spring框架管理业务逻辑，实现业务...
Spring+Struts2+Hibernate4实现通用DAO CRUD操作
标题中提到的“基于注解ssh的通用dao的crud”和描述中的“spring4+struts2+hibernate4”指向了Java开发领域中一个常用的Web应用技术栈组合，通常称为SSH框架。SSH框架是由Spring Framework、Struts2和Hibernate三个...
Hibernate_通用DAO模式，一个写好的dao层
08-18
这个是不同类型的表单通用的dao模式，简洁明了，注释清楚，可移植性很强
重写Spring的HibernateDaoSupport 简化Dao层写法
03-28
NULL 博文链接：https://wxinpeng.iteye.com/blog/1162157
springboot2.0多数据源集成hibernate配置hibernateDaoSupport示例
04-12
springboot2.0多数据源集成hibernate配置hibernateDaoSupport， dao层继承hibernateDaoSupport， 不使用jpa方式。
SpringMVC+Hibernate4+MySQL实现数据库增加功能！
07-26
SpringMVC+Hibernate+MySQL实现简单数据库功能，关键是配置文件齐全，改下数据库配置即可用，绝对能跑通！适合初学者学习成长！
Hibernate DAO层 的BaseDao泛型写法
野狼e族 的博客
09-11 3773
package com.app.base; import java.lang.reflect.ParameterizedType; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import j
BBS项目笔记之一:Spring+Hibernate实现Dao层
thewebcode
12-19 167
之前的项目都比较小, 这个是s2sh做的 . Spring和Hibernate整合过好些次了 ,这次看别人写的还是收获挺多的 一:单分出applicationContext-dao.xml 和hibernate.cfg.xml spring的配置文件里单分出applicationContext-dao来 ,里边只配置和Dao有关的配置 web.xml里记得加个配置就行了 ...
HibernateDAO的写法
dapeng
12-06 326
关于spring 得到 dao层的写法，和spring 的ioc和 aop的写法，
dao 层封装(利用spring + hibernate)
csgvsjay1000的专栏
12-19 166
接口 baseDao   package com.dx.dao; import java.io.Serializable; import java.util.List; import org.hibernate.SQLQuery; public interface BaseDao { public void save(Object object); pu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值