qq1988627
- 浏览: 105995 次
- 性别:
- 来自: 深圳
-
最新评论
-
qq1988627：
gaolegao2008 写道说的是个啥。有冲突怎么办呢。也不 ...
xfire与spring组合创建webservice -
gaolegao2008：
说的是个啥。有冲突怎么办呢。也不说个解决的办法。唉
xfire与spring组合创建webservice -
xiaoliefengfeng：
加油，为码农争光啊
我要的其实并不多 你为什么拒绝我 -
qq1988627：
huchaoqqqq 写道用的ext几版本做的呢，有没有相关资 ...
第一次使用Ext写系统 -
huchaoqqqq：
用的ext几版本做的呢，有没有相关资料，我也想最近弄下ext ...
第一次使用Ext写系统
1. package ao.base.hibernate;
2.
3. import java.io.Serializable;
4. import java.util.Collection;
5. import java.util.List;
6.
7. import dao.obj.AbstractHandleObj;
8.
9. import org.hibernate.type.Type;
10.
11. /**
12. * 基础Dao接口,定义通用的操作
13. *
14. * @version v1.1 2009/07/17
15. *
16. */
17. public interface IBaseDao {
18.
19. /**
20. * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
21. * 设置返回记录数，若 top为0不设置
22. */
23. public void setMaxResults(int top);
24.
25. /**
26. * 保存 AbstractHandleObj实体
27. * @param hobj 继承AbstractHandleObj抽象类的实体
28. * @return Serializable 主键
29. */
30. public Serializable save(AbstractHandleObj hobj);
31.
32. /**
33. * 更新 AbstractHandleObj实体
34. * @param hobj 继承AbstractHandleObj抽象类的实体
35. */
36. public void update(AbstractHandleObj hobj);
37.
38. /**
39. * 保存或更新 AbstractHandleObj实体
40. * @param hobj 继承AbstractHandleObj抽象类的实体
41. */
42. public void saveOrUpdate(AbstractHandleObj hobj);
43.
44. /**
45. * 保存或跟新实体集合 Collection<AbstractHandleObj>
46. * 若实体已经存（根据主键判断）在则更新实体，则保存实体
47. * @param hobjList 继承AbstractHandleObj抽象类的实体集合
48. */
49. public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);
50.
51. /**
52. * 删除 AbstractHandleObj实体
53. * @param hobj 继承AbstractHandleObj抽象类的实体
54. */
55. public void delete(AbstractHandleObj hobj);
56.
57. /**
58. * 删除 Collection<AbstractHandleObj>集合实体
59. * @param hobjList 继承AbstractHandleObj抽象类的实体集合
60. */
61. public void deleteAll(Collection<AbstractHandleObj> hobjList);
62.
63. /**
64. * 根据主键值获得继承 AbstractHandleObj的实体
65. * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)
66. * @param id 实体主键
67. * @return AbstractHandleObj
68. */
69. public AbstractHandleObj findByID(String entityName, String id);
70.
71. /**
72. * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型
73. * @param hql HQL 查询语句
74. * @return List<AbstractHandleObj>
75. */
76. public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);
77.
78. /**
79. * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型
80. * @param hql HQL 查询语句
81. * @param obj 查询参数，匹配站位符?
82. * @return List<AbstractHandleObj>
83. */
84. public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);
85.
86. /**
87. * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型
88. * @param hql HQL 查询语句
89. * @param objs 查询参数数组，按顺序匹配站位符?
90. * @return List<AbstractHandleObj>
91. */
92. public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);
93.
94. /**
95. * 根据hql语句查找某些列，返回List<Object[]>类型
96. * @param hql HQL 查询语句
97. * @return List<Object[]>
98. */
99. public List<Object[]> findColsByHqlQuery(String hql);
100.
101. /**
102. * 根据hql语句查找某些列，返回List<Object[]>类型
103. * @param hql HQL 查询语句
104. * @param obj 查询参数，匹配站位符?
105. * @return List<Object[]>
106. */
107. public List<Object[]> findColsByHqlQuery(String hql, Object obj);
108.
109. /**
110. * 根据hql语句查找某些列，返回List<Object[]>类型
111. * @param hql HQL 查询语句
112. * @param objs 查询参数数组，按顺序匹配站位符?
113. * @return List<Object[]>
114. */
115. public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;
116.
117. /**
118. * 根据hql语句查找某些列，返回List<Object>类型
119. * @param hql HQL 查询语句
120. * @return List<Object>
121. */
122. public List<Object> findColByHqlQuery(String hql) ;
123.
124. /**
125. * 根据hql语句查找某些列，返回List<Object>类型
126. * @param hql HQL 查询语句
127. * @param obj 查询参数，匹配站位符?
128. * @return List<Object>
129. */
130. public List<Object> findColByHqlQuery(String hql, Object obj);
131.
132. /**
133. * 根据hql语句查找某些列，返回List<Object>类型
134. * @param hql HQL 查询语句
135. * @param objs 查询参数数组，按顺序匹配站位符?
136. * @return List<Object>
137. */
138. public List<Object> findColByHqlQuery(String hql, Object[] objs);
139.
140. /**
141. * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
142. * @param hql HQL 查询语句
143. * @param start 查找记录数其实位置（从0开始）
144. * @param reCount 要返回的记录数（页显示记录数）
145. * @return List<Object[]>
146. */
147. public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);
148.
149. /**
150. * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
151. * @param hql HQL 查询语句
152. * @param objs 查询参数数组，按顺序匹配站位符?
153. * @param types 查询参数类型数组，按顺序对应objs中的参数类型
154. * 注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
155. * @param start 查找记录数其实位置（从0开始）
156. * @param reCount 要返回的记录数（页显示记录数）
157. * @return List<Object[]>
158. */
159. public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,
160. Type[] types, int start, int reCount);
161.
162. /**
163. * 根据hql语句查找，获得记录数
164. * 例如：select count(*) from T
165. * @param hql HQL 查询语句
166. * @return long
167. */
168. public long getRecordCountByHqlQuery(String hql) ;
169.
170. /**
171. * 根据hql语句查找，获得记录数
172. * 例如：select count(*) from T where ...
173. * @param hql HQL 查询语句
174. * @param obj 查询参数，匹配站位符?
175. * @return long
176. */
177. public long getRecordCountByHqlQuery(String hql, Object obj) ;
178.
179. /**
180. * 根据hql语句查找，获得记录数
181. * 例如：select count(*) from T where ...
182. * @param hql
183. * @param objs 查询参数数组，按顺序匹配站位符?
184. * @return long
185. */
186. public long getRecordCountByHqlQuery(String hql, Object[] objs) ;
187.
188. /**
189. * 执行更新update/ 删除delete操作
190. * @param hql
191. * @return int 更新数量/删除数量
192. */
193. public int executeHqlQuery(String hql) ;
194.
195. /**
196. * 执行更新update/ 删除delete操作
197. * @param hql
198. * @param obj 查询参数，匹配站位符?
199. * @return int 更新数量/删除数量
200. */
201. public int executeHqlQuery(String hql, Object obj);
202.
203. /**
204. * 执行更新update/ 删除delete操作
205. * @param hql
206. * @param objs 查询参数数组，按顺序匹配站位符?
207. * @return int 更新数量/删除数量
208. */
209. public int executeHqlQuery(String hql, Object[] objs) ;
210.
211. /**
212. * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
213. * @param hql HQL 查询语句
214. * @param start 查找记录数其实位置（从0开始）
215. * @param reCount 要返回的记录数（页显示记录数）
216. * @return List<AbstractHandleObj>
217. */
218. public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql,
219. int start, int reCount);
220.
221. /**
222. * 根据hql语句查找 AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
223. * @param hql HQL 查询语句
224. * @param objs 查询参数数组，按顺序匹配站位符?
225. * @param types 查询参数类型数组，按顺序对应objs中的参数类型
226. * 注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
227. * @param start 查找记录数其实位置（从0开始）
228. * @param reCount 要返回的记录数（页显示记录数）
229. * @return List<AbstractHandleObj>
230. */
231. public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,
232. Type[] types, int start, int reCount) ;
233.
234. /**
235. * 支持SQL查询，根据 sql语句查找某些列，返回List<String[]>类型
236. * @param sql SQL 查询语句
237. * @return List<Object[]>
238. */
239. public List<Object[]> findColsBySqlQuery(String sql) ;
240.
241. /**
242. * 支持SQL查询，根据 sql语句查找某列，返回List<Object>类型
243. * @param sql SQL 查询语句
244. * @return List<Object>
245. */
246. public List<Object> findColBySqlQuery(String sql) ;
247.
# package dao.base.hibernate;
#
# import java.io.Serializable;
# import java.sql.SQLException;
# import java.util.ArrayList;
# import java.util.Collection;
# import java.util.List;
#
# import dao.obj.AbstractHandleObj;
#
# import org.hibernate.HibernateException;
# import org.hibernate.Query;
# import org.hibernate.Session;
# import org.hibernate.type.Type;
# import org.springframework.orm.hibernate3.HibernateCallback;
# import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
#
#
#
# /**
# * 基础Dao接口,实现通用操作
# * @version v1.1 2009/07/17
# *
# */
# public class BaseDaoImpl extends HibernateDaoSupport implements IBaseDao {
#
#
# /**
# * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
# * 设置返回记录数，若 top为0不设置
# */
# public void setMaxResults(int top){
# if(top > 0){
# getHibernateTemplate().setMaxResults(top);
# }
# }
#
# public Serializable save(AbstractHandleObj hobj){
# return getHibernateTemplate().save(hobj);
# }
#
# public void update(AbstractHandleObj hobj) {
# getHibernateTemplate().update(hobj);
#
# }
#
# public void saveOrUpdate(AbstractHandleObj hobj) {
# getHibernateTemplate().saveOrUpdate(hobj);
#
# }
#
# public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList) {
# getHibernateTemplate().saveOrUpdateAll(hobjList);
# }
#
# public void delete(AbstractHandleObj hobj) {
# getHibernateTemplate().delete(hobj);
# }
#
# public void deleteAll(Collection<AbstractHandleObj> hobjList) {
# getHibernateTemplate().deleteAll(hobjList);
# }
#
# public AbstractHandleObj findByID(String entityName, String id)
# {
# return (AbstractHandleObj) getHibernateTemplate().get(entityName, id);
# }
#
# @SuppressWarnings("unchecked")
# public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql)
# {
# List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
# resultList = getHibernateTemplate().find(hql);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj)
# {
# List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
# resultList = getHibernateTemplate().find(hql, obj);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs)
# {
# List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
# resultList = getHibernateTemplate().find(hql, objs);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsByHqlQuery(String hql)
# {
# List<Object[]> resultList = getHibernateTemplate().find(hql);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsByHqlQuery(String hql, Object obj)
# {
# List<Object[]> resultList = getHibernateTemplate().find(hql, obj);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsByHqlQuery(String hql, Object[] objs)
# {
# List<Object[]> resultList = getHibernateTemplate().find(hql, objs);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object> findColByHqlQuery(String hql)
# {
# List<Object> resultList = getHibernateTemplate().find(hql);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object> findColByHqlQuery(String hql, Object obj)
# {
# List<Object> resultList = getHibernateTemplate().find(hql, obj);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object> findColByHqlQuery(String hql, Object[] objs)
# {
# List<Object> resultList = getHibernateTemplate().find(hql, objs);
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,final int start,
# final int reCount) {
# List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
# public Object doInHibernate(Session session)
# throws HibernateException, SQLException {
# Query query = session.createQuery(hql);
# query.setFirstResult(start);
# query.setMaxResults(reCount);
#
# return query.list();
# }
# });
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,
# final Object[] objs, final Type[] types, final int start, final int reCount)
# {
# List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
# public Object doInHibernate(Session session)
# throws HibernateException, SQLException {
# Query query = session.createQuery(hql);
# /*设置参数*/
# query.setParameters(objs, types);
# query.setFirstResult(start);
# query.setMaxResults(reCount);
#
# return query.list();
# }
# });
# return resultList;
# }
#
# public long getRecordCountByHqlQuery(String hql) {
# long recordCount = (Long) getHibernateTemplate().find(hql).get(0);
# return recordCount;
# }
#
# public long getRecordCountByHqlQuery(String hql, Object obj) {
# long recordCount = (Long) getHibernateTemplate().find(hql, obj).get(0);
# return recordCount;
# }
#
# public long getRecordCountByHqlQuery(String hql, Object[] objs) {
# long recordCount = (Long) getHibernateTemplate().find(hql, objs).get(0);
# return recordCount;
# }
#
# public int executeHqlQuery(String hql) {
# return getHibernateTemplate().bulkUpdate(hql);
# }
#
# public int executeHqlQuery(String hql, Object obj) {
# return getHibernateTemplate().bulkUpdate(hql, obj);
# }
#
# public int executeHqlQuery(String hql, Object[] objs) {
# return getHibernateTemplate().bulkUpdate(hql, objs);
# }
#
# @SuppressWarnings("unchecked")
# public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql,
# final int start, final int reCount) {
# List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
# public Object doInHibernate(Session session)
# throws HibernateException, SQLException {
# Query query = session.createQuery(hql);
# query.setFirstResult(start);
# query.setMaxResults(reCount);
#
# return query.list();
# }
# });
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql, final Object[] objs,
# final Type[] types, final int start, final int reCount) {
# List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
# public Object doInHibernate(Session session)
# throws HibernateException, SQLException {
# Query query = session.createQuery(hql);
# /*设置参数*/
# query.setParameters(objs, types);
# query.setFirstResult(start);
# query.setMaxResults(reCount);
#
# return query.list();
# }
# });
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object[]> findColsBySqlQuery(final String sql) {
# List<Object[]> resultList = new ArrayList<Object[]>();
# Session session = getHibernateTemplate().getSessionFactory().openSession();
# resultList = session.createSQLQuery(sql).list();
# session.close();
# return resultList;
# }
#
# @SuppressWarnings("unchecked")
# public List<Object> findColBySqlQuery(String sql) {
# List<Object> resultList = new ArrayList<Object>();
# Session session = getHibernateTemplate().getSessionFactory().openSession();
# resultList = session.createSQLQuery(sql).list();
# session.close();
# return resultList;
# }
#
# public int executeSqlQuery(final String sql) {
# int result = 0;
# Session session = getHibernateTemplate().getSessionFactory().openSession();
# result = session.createSQLQuery(sql).executeUpdate();
# session.close();
# return result;
# }
} 248. /**
249. * 支持SQL操作，执行 sql语句update/delete/存储过程
250. * @param sql SQL 语句
251. * @return int
252. */
253. public int executeSqlQuery(String sql) ;
254.
255. }
分享到：
发表评论
-
进制转换
2014-08-29 18:55 959package com.byd.core; imp ... -
Java发送Email
2011-11-07 13:57 1030package byd.core; import java. ... -
天干地支算法
2011-10-10 11:44 1155/** * <url>http://en.w ... -
MD5
2011-09-27 09:34 738public class Encryptor { ... -
java运行可以执行文件
2011-08-15 10:44 757# package com.yymt.pf.rpc.loadb ... -
随记生成验证码
2011-08-06 09:28 980package com.hrm.houfei.utils; ... -
TLD生成
2011-08-06 09:16 1014package j2ee.util; import ja ... -
页面解析
2011-08-06 09:13 860package com.atom.util; impor ... -
StringUtils 工具类
2011-08-06 09:11 1081package com.atom.util; impor ... -
重构HashTable
2011-08-06 09:03 903package com.atom.util; impor ... -
文件解析
2011-08-06 08:52 553package com.byd.portal.pagedesi ... -
工作流（workflow）
2011-08-06 08:39 1215package com.byd.mes.plugins.wor ... -
缓存处理工具类
2011-08-06 08:20 1package com.byd.mes.util.cache; ... -
缓存处理工具类
2011-08-06 08:20 1188package com.byd.mes.util.cache; ... -
Java执行javascript
2011-08-06 08:17 922package com.byd.mes.util.script ... -
文件处理工具类
2011-08-05 17:12 886/* * MyUtils.java * * */ ... -
Struts2文件上传下载
2011-08-05 16:42 1182package com.byd.action; impo ... -
对于不同数据库分页分查询析
2011-08-05 16:32 1056package zxc.utils; /** * 这 ... -
类转换
2011-08-05 16:30 829package zxc.utils; import ja ... -
数字转中文
2011-08-05 16:28 823package zxc.utils; import ja ...
相关推荐
**Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式，它模仿了Spring框架中的`HibernateTemplate`类，旨在提供一个简单易用的DAO（Data Access Object）层，方便开发人员进行数据库操作...
本资源“Hibernate_通用DAO模式”提供了一种适用于不同类型表单的DAO实现，基于SSH（Struts2、Spring、Hibernate）框架，特别强调简洁、易懂和高可移植性。 首先，SSH框架是Java Web开发中的经典组合，Struts2负责...
Java源代码 一个简单的通用DAO实现 （基于hibernate）面向应用层按POJO类缓存hibernate的session对象.使用举例： DAO dao = DAOFactory.getDAO(POJO.class);//获得一个全局类单例的DAO实例 dao.save(pojo); 你也可以...
基于泛型的通用Dao接口和Hibernate的实现 基于泛型的通用Dao接口是指使用泛型来实现数据访问对象（DAO）的接口，主要是在使用 Hibernate 或 JPA 时使用。泛型可以使得DAO接口更灵活、更通用。 泛型Dao接口的优点：...
HibernateDao 是一种基于 Hibernate ORM（对象关系映射）框架的通用数据访问对象，它简化了对数据库的操作，提供了更高级别的抽象，使开发者能够更加专注于业务逻辑而不是底层的数据操作。在Java开发中，Hibernate...
标题中的“基于Hibernate的泛型Dao框架”是指在Java开发中使用Hibernate ORM工具，并结合泛型设计模式构建的数据库访问对象（DAO）框架。这样的框架旨在提高代码复用性，减少重复工作，使得数据访问层的实现更加简洁...
【描述】"基于hibernate5 泛型Dao实例，下载后改一下数据库配置直接可以用"，意味着这个压缩包文件提供了一个已经实现好的Hibernate5版本的泛型Dao示例项目。用户只需要根据自己的数据库环境修改相应的配置信息，就...
标题中的“vc生成hibernate的dao类”指的是在Visual C++（vc6.0）环境下，利用特定工具或插件来自动化生成基于Hibernate框架的Data Access Object（DAO）类。DAO模式是软件设计中常用的一种模式，它将业务逻辑与数据...
- **作用**：表明本文档或代码主要关注的是基于Hibernate实现的DAO模式。 #### 四、部分内容分析 根据提供的部分代码内容，我们可以对其中的关键知识点进行详细解析： 1. **包声明与导入语句** - `package ...
而HibernateDAO则是基于Hibernate进行数据访问的对象，是业务逻辑层和持久层之间的桥梁。本文将详细探讨HibernateDAO的实现方式以及常见设计模式，旨在帮助开发者更好地理解和运用这一技术。 1. HibernateDAO的基本...
总结来说，"SSH中通用DAO类"是基于SSH框架设计的可复用数据访问组件，它利用Spring的DAO支持和Hibernate的ORM能力，提供了一套标准的数据库操作接口和实现，以满足多种业务需求。在实际开发中，这样的DAO设计有助于...
标题“ssh通用基于泛型的dao”指的是使用SSH（Spring、Struts2、Hibernate）框架开发的一个通用的、基于泛型的DAO实现，它旨在提高开发效率，减少重复工作。 SSH框架是Java企业级应用开发的常用组合，Spring提供了...
总的来说，"SSHWithAnnotationDemo"项目展示了如何利用现代Java技术栈的高级特性，包括Struts2、Spring3和Hibernate的注解功能，DAO层的泛型设计以及通用的分页实现，来构建一个高效、可维护的Web应用。这样的实践...
下面我们将深入探讨基于注解的SSH实现通用DAO的CRUD（创建、读取、更新、删除）操作。 首先，让我们从Spring开始。在Spring 4中，注解的使用已经非常广泛，例如`@Autowired`用于自动装配bean，`@Service`、`@...
而泛型DAO（Data Access Object）则是基于Hibernate进一步抽象出来的一个设计模式，用于提供更通用的数据操作方法。本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先，我们来看一下泛型DAO...
现在无论做什么应用，基本上都会有涉及对象... 其实，利用Java面向对象的基本特性及JDK5新引入的泛型语法，我们可以创建通用的DAO对象的CRUD方法，同时又可保证类型的安全性。下面DAO的实现以Hibernate为基础加以演示。
**基于Hibernate的BaseDAO** 在Java企业级开发中，数据访问层（DAO，Data Access Object）是连接业务逻辑层和数据库的重要桥梁。BaseDAO是一种通用的设计模式，它封装了Hibernate框架的基本操作，使得业务逻辑层...
通用道在 JPA/HIbernate/Spring 环境中使用泛型提供 DAO API，因此它可以与此类架构中的任何 Hibernate POJO 一起使用，而无需为每个域类创建专用的数据访问接口。 Maven 依赖项： <dependency> <groupId>org....
现在无论做什么应用，基本上都会有涉及对象... 其实，利用Java面向对象的基本特性及JDK5新引入的泛型语法，我们可以创建通用的DAO对象的CRUD方法，同时又可保证类型的安全性。下面DAO的实现以Hibernate为基础加以演示。
而DAO层通过泛型接口和实现类，实现了对所有实体类的通用操作，例如： ```java public interface GenericDao<T> { void save(T entity); T findById(Class<T> clazz, Serializable id); List<T> findAll(Class...