程序博客网 > 理财分红天天系统源码

仅一行代码完成各种数据库操作，基于spring的HibernateTemplate

来源：互联网 发布：理财分红天天系统源码 编辑：程序博客网 时间：2024/06/01 07:46

转自：http://www.oschina.net/code/snippet_561293_10813

在用到时，只需要继承自BaseHibernate，可以实现所有接口对于数据库的操作，增、删、改、查、分页、统计等。


[1].[代码] [Java]代码 跳至 [1] [2] [3]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
importjava.sql.SQLException;
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.List;
importjava.util.Map;
 
importorg.hibernate.Criteria;
importorg.hibernate.HibernateException;
importorg.hibernate.Query;
importorg.hibernate.Session;
importorg.hibernate.criterion.MatchMode;
importorg.hibernate.criterion.Projections;
importorg.hibernate.criterion.Property;
importorg.springframework.orm.hibernate3.HibernateCallback;
importorg.springframework.orm.hibernate3.HibernateTemplate;
 
publicclass BaseHibernate {
    privatestatic HibernateTemplate hibernateTemplate;
 
    @SuppressWarnings("static-access")
    publicvoid setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
 
    /**
     * 插入对象
     *
     * @param entity
     * @return
     */
    publicint save(Object entity) {
        return(Integer) hibernateTemplate.save(entity);
    }
 
    /**
     * 删除对象
     *
     * @param entity
     */
    publicvoid delete(Object entity) {
        hibernateTemplate.delete(entity);
    }
 
    /**
     * 修改对象
     *
     * @param entity
     */
    publicvoid update(Object entity) {
        hibernateTemplate.update(entity);
    }
 
    /**
     * 根据ID查询对象
     *
     * @param entityClass
     *            类名,如:String.class
     * @param id
     *            ID值
     */
    public<T> T query(Class<T> entityClass, intid) {
        returnhibernateTemplate.get(entityClass, id);
    }
 
    /**
     * 查询全部
     *
     * @param className
     *            类名
     * @return
     */
    @SuppressWarnings("unchecked")
    public<T> List<T> queryAll(Class<?> className) {
        returnhibernateTemplate.find("from " + className.getName());
    }
 
    /**
     * 分页
     *
     * @param entityClass
     *            类名
     * @param index
     *            当前页数
     * @param size
     *            每页显示的大小
     * @param order
     *            排序类型
     * @param propertyName
     *            要排序的属性名
     * @return
     */
    @SuppressWarnings("unchecked")
    public<T> List<T> paging(finalClass<?> entityClass, finalint index,
            finalint size, finalOrder order, finalString... propertyName) {
        List<T> list = hibernateTemplate.executeFind(newHibernateCallback() {
            publicObject doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                if(propertyName != null&& propertyName.length > 0) {
                    switch(order) {
                    caseASC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .asc(propertyName[0]));
                        break;
                    caseDESC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .desc(propertyName[0]));
                        break;
                    }
                }
                criteria.setFirstResult((index - 1) * size);
                criteria.setMaxResults(size);
                returncriteria.list();
            }
        });
        returnlist;
    }
 
    @SuppressWarnings("unchecked")
    publiclong getSumRecord(finalClass<?> className) {
        List<Long> count = newArrayList<Long>();
        count = hibernateTemplate.find("select COUNT(*) from "
                + className.getName());
        returncount.size() > 0? (count.get(0)) : 0L;
    }
 
    /**
     * 获取总页数
     *
     * @param className
     *            类名
     * @param size
     *            每页显示的大小
     * @return
     */
    @SuppressWarnings("unchecked")
    publiclong sumPage(finalClass<?> className, intsize) {
        List<Long> count = newArrayList<Long>();
        count = hibernateTemplate.find("select COUNT(*) from "
                + className.getName());
        returncount.size() > 0? (count.get(0) - 1+ size) / size : 0L;
    }
 
    /**
     * 根据字段查询
     *
     * @param params
     *            字段列表
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public<T> List<T> queryByProperty(finalClass<?> className,
            finalMap<String, Object> params) {
        returnhibernateTemplate.executeFind(newHibernateCallback() {
            publicList<?> doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                for(String field : params.keySet())
                    criteria.add(Property.forName(field).eq(params.get(field)));
                returncriteria.list();
            }
        });
    }
 
    /**
     * 根据字段查询可以分的页数
     *
     * @param className
     *            要查询的实体类
     * @param params
     *            属性列表
     * @param size
     *            每页显示的大小
     * @return
     */
    @SuppressWarnings("unchecked")
    publiclong queryByPropertyGetSumPage(finalClass<?> className,
            finalMap<String, Object> params, finalint size) {
        List<Integer> object = hibernateTemplate
                .executeFind(newHibernateCallback() {
                    publicObject doInHibernate(Session session)
                            throwsHibernateException, SQLException {
                        Criteria criteria = session.createCriteria(className);
                        for(String field : params.keySet())
                            criteria.add(Property.forName(field).eq(
                                    params.get(field)));
                        criteria.setProjection(Projections.rowCount());
                        returncriteria.list();
                    }
                });
        intcount = object == null? 0: object.get(0);
        returncount > 0? (count + size - 1) / size : 0L;
    }
 
    /**
     * 获取总记录数根据属性
     *
     * @param className
     * @param params
     * @param size
     * @return
     */
    @SuppressWarnings("unchecked")
    publiclong queryByPropertyGetSumRecord(finalClass<?> className,
            finalMap<String, Object> params) {
        List<Integer> object = hibernateTemplate
                .executeFind(newHibernateCallback() {
                    publicObject doInHibernate(Session session)
                            throwsHibernateException, SQLException {
                        Criteria criteria = session.createCriteria(className);
                        for(String field : params.keySet())
                            criteria.add(Property.forName(field).eq(
                                    params.get(field)));
                        criteria.setProjection(Projections.rowCount());
                        returncriteria.list();
                    }
                });
        returnobject == null? 0: object.get(0);
    }
 
    /**
     * 根据字段查询并分页显示
     *
     * @param className
     *            要分页的实体类
     * @param params
     *            字段列表
     * @param index
     *            当前页
     * @param size
     *            每页显示的大小
     * @param order
     *            排序
     * @return
     */
    @SuppressWarnings("unchecked")
    public<T> List<T> queryByPropertyPaging(finalClass<?> className,
            finalMap<String, Object> params, finalint index, finalint size,
            finalOrder order, finalString... field) {
        returnhibernateTemplate.executeFind(newHibernateCallback() {
            publicList<?> doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                for(String f : params.keySet())
                    criteria.add(Property.forName(f).eq(params.get(f)));
                if(field != null&& field.length != 0) {
                    switch(order) {
                    caseASC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .asc(field[0]));
                        break;
                    caseDESC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .desc(field[0]));
                        break;
                    }
                }
                criteria.setFirstResult((index - 1) * size);
                criteria.setMaxResults(size);
                returncriteria.list();
            }
        });
    }
 
    /**
     * 保存或更新对象
     *
     * @param entity
     *            对象
     */
    publicvoid saveOrUpdate(Object entity) {
        hibernateTemplate.saveOrUpdate(entity);
    }
 
    /**
     * 批量修改
     *
     * @param queryString
     *            HQL语句
     * @return 受影响行数
     */
    publicint bulkUpdate(String queryString) {
        returnhibernateTemplate.bulkUpdate(queryString);
    }
 
    /**
     * 批量修改
     *
     * @param queryString
     *            HQL语句
     * @param values
     *            参数的值
     * @return 受影响行数
     */
    publicint bulkUpdate(String queryString, Object... values) {
        returnhibernateTemplate.bulkUpdate(queryString, values);
    }
 
    /**
     * 批量删除
     *
     * @param collection
     *            要删除的集合
     */
    publicvoid deleteAll(Collection<?> collection) {
        hibernateTemplate.deleteAll(collection);
    }
 
    /**
     * 模糊查询
     *
     * @param className
     *            类名
     * @param field
     *            字段名
     * @param value
     *            值
     * @param matchMode
     *            匹配模式:ANYWHERE->任意位置、END->结束、START->开始、EXACT->精确匹配
     */
    @SuppressWarnings("unchecked")
    public<T> List<T> Querylike(finalClass<?> className, finalString field,
            finalString value, finalMatchMode matchMode) {
        List objects = newArrayList<Object>();
        objects = hibernateTemplate.executeFind(newHibernateCallback() {
            publicObject doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                criteria.add(Property.forName(field).like(value, matchMode));
                returncriteria.list();
            }
        });
        returnobjects;
    }
 
    /**
     * 执行hql查询语句
     *
     * @param hql
     *            hql语句
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public<T> Object executeQuery(finalString hql, finalObject... values) {
        returnhibernateTemplate.execute(newHibernateCallback() {
 
            publicObject doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                returnquery.list();
            }
        });
    }
 
    /**
     * 查询单个值
     *
     * @param hql
     *            hql语句
     * @param values
     *            参数列表
     * @return 返回单个值
     */
    @SuppressWarnings("unchecked")
    public<T> Object executeSacale(finalString hql, finalObject... values) {
        returnhibernateTemplate.execute(newHibernateCallback() {
            publicObject doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                query.setMaxResults(1);
                returnquery.uniqueResult();
            }
        });
    }
 
    /**
     * 执行hql删除、修改语句
     *
     * @param hql
     *            hql语句
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    publicint executNonQuery(finalString hql, finalObject... values) {
        returnhibernateTemplate.execute(newHibernateCallback() {
            publicInteger doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                returnquery.executeUpdate();
            }
        });
    }
 
    /**
     * 删除表数据
     * @param tableName 表名
     */
     
    @SuppressWarnings("unchecked")
    publicvoid truncate(finalString tableName) {
        hibernateTemplate.execute(newHibernateCallback() {
            publicObject doInHibernate(Session session)
                    throwsHibernateException, SQLException {
                session.createSQLQuery("truncate table " + tableName).executeUpdate();
                returnnew ArrayList();
            }
        });
 
    }
 
    privatevoid setParams(Query query, Object... values) {
        if(!isEmptyOrNull(values)) {
            for(inti = 0; i < values.length; i++) {
                query.setParameter(i, values[i]);
            }
 
        }
    }
 
    /**
     * 判断值是否为空或
     *
     * @param values
     * @return
     */
    privateboolean isEmptyOrNull(Object... values) {
        if(values == null|| values.length == 0)
            returntrue;
        returnfalse;
    }
 
}

[2].[代码] 排序类型 跳至 [1] [2] [3]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 排序类型
 * @author cheng
 *
 */
publicenum Order {
    /**
     * 升序排列
     */
    ASC,
    /**
     * 降序排列
     */
    DESC;

[3].[代码] 实例应用 跳至 [1] [2] [3]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//UsersDao interface
publicinterface UsersDao{ 
         /**
     * 根据属性查询
     * @param attrName 属性名
     * @param attrValues 属性值
     * @return Users集合
     */
    publicList<Users> queryByProperty(Map<String, Object> propertys);
}
//UserDaoImpl
 
importjava.util.List;
importjava.util.Map;
 
importorg.ps.dao.UsersDao;
importorg.ps.entity.Users;
importorg.ps.util.BaseHibernate;
importorg.ps.util.Order;
 
publicclass UserDaoImpl extendsBaseHibernate implementsUsersDao {
 
publicList<Users> queryByProperty(Map<String, Object> propertys) {
        returnsuper.queryByProperty(Users.class, propertys);
    }
}
0 0
理财分红天天系统源码 理财分红天天系统源码
原创粉丝点击
热门IT博客
linux home代表什么linux home代表什么
男士休闲鞋淘宝男士休闲鞋淘宝
国产数控编程软件
超市语音播报软件
网络支付安全技术
邱少云 知乎
淘宝不能卖pos
mac未能自动存储文稿
融易汇软件使用说明
windows samba shared
java web书
淘宝如何投诉假货
unity3d 2d骨骼动画
微信兵工厂软件
魔方网表微信录数据
矩阵计算六讲 课后答案
软件iso9001认证要求
1314seo内链关键字
阿里云重装centos系统
mac os 制作u盘启动盘
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 京东30天保价细则 王天保下苏州1一42集从头唱 曲剧李天保吊孝全集 王天保下苏州1一42集8 天保得乐男贴 京东是7天保价还是30天 天保建设集团有限公司 南京天保驾校 南京考驾照多少钱 南京驾校 南京驾校价格 南京驾校排名 南京驾照 叶天楚信 逾期一天会不会上征信 天信 捷信逾期一天扣多少 网贷逾期一天会上征信么 链信任务有效期多少天 信用卡逾期3天会上征信吗 车贷逾期一天会上征信吗 信用卡逾期三天会上征信吗 天健集团 天健 天健医院 天健天骄 天健创新 中天健集团 天健论坛 天健网首页 天健会计师事务所 北京天健医院 000090天健集团 天健集团股吧 天健集团董事长 000090 天元集团 天元帝 天元零帝 天元 天元术

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里