文档章节

JDBC数据库通用DAO

J
 Java编程思想
发布于 2014/08/21 08:55
字数 1733
阅读 109
收藏 3

包括DAO、连接池、事务控制。 
连接池用的是 BoneCP。 
BoneCP运行时需要slf4jguava的支持。
当然也可以随意换成其他的连接池。
dao的vo是用结果转换器控制的,需要继承ResultConverter。
这招是和spring的jdbcTemplete学的
日志组件用的是slf4j,需要的可自行更换其他日志组件。
demo的在
 http://www.oschina.net/code/snippet_86510_4466
末尾有源码和试例包下载 


[1].[代码] 数据库连接池 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
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
packageorg.dave.common.database;
 
importjava.sql.Connection;
importjava.sql.SQLException;
importjava.util.ResourceBundle;
 
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
 
importcom.jolbox.bonecp.BoneCP;
importcom.jolbox.bonecp.BoneCPConfig;
 
/**
 * 数据库连接池
 * @author David Day
 */
publicfinalclassDatabaseConnectionPool {
 
    privatestaticfinalLogger LOG = LoggerFactory.getLogger(DatabaseConnectionPool.class);
    privatestaticfinalResourceBundle BUNDLE = ResourceBundle.getBundle("connection");
    privatestaticfinalString DRIVER ="driver";
    privatestaticfinalString URL ="url";
    privatestaticfinalString USERNAME ="username";
    privatestaticfinalString PASSWORD ="password";
    privatestaticfinalString MAX_CONNECTION ="max_connection";
    privatestaticBoneCP pool;
     
    /**
     * 开启连接池
     */
    publicstaticvoidstartup() {
        try{
            Class.forName(BUNDLE.getString(DRIVER));
            BoneCPConfig config =newBoneCPConfig();
            config.setJdbcUrl(BUNDLE.getString(URL));
            config.setUsername(BUNDLE.getString(USERNAME));
            config.setPassword(BUNDLE.getString(PASSWORD));
            config.setMaxConnectionsPerPartition(Integer.parseInt(BUNDLE.getString(MAX_CONNECTION)));
            pool =newBoneCP(config);
        }catch(Exception e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * 关闭连接池
     */
    publicstaticvoidshutdown() {
        pool.shutdown();
    }
     
    /**
     * @return 数据库连接
     */
    publicstaticConnection getConnection() {
        try{
            returnpool.getConnection();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
 
}

[2].[代码] 数据库异常 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
packageorg.dave.common.database;
 
/**
 * 数据库异常
 * @author David Day
 */
@SuppressWarnings("serial")
publicclassDatabaseExceptionextendsRuntimeException {
     
    publicDatabaseException(Throwable cause) {
        super(cause);
    }
 
}

[3].[代码] 事务控制 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
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
packageorg.dave.common.database;
 
importjava.sql.Connection;
importjava.sql.SQLException;
 
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
 
/**
 * 数据库事务
 * @author David Day
 */
publicclassDatabaseTransaction {
     
    /**
     * 日志工具
     */
    privatestaticfinalLogger LOG = LoggerFactory.getLogger(DatabaseTransaction.class);
     
    /**
     * 数据库连接
     */
    privateConnection conn;
 
    /**
     * 实例化一个默认连接的事务
     */
    publicDatabaseTransaction() {
        this(DatabaseConnectionPool.getConnection());
    }
 
    /**
     * 实例化一个默认连接的事务
     * @param isOpenTrans 是否打开事务
     */
    publicDatabaseTransaction(booleanisOpenTrans)throwsDatabaseException {
        this(DatabaseConnectionPool.getConnection(), isOpenTrans);
    }
 
    /**
     * 实例化一个默认连接的事务
     * @param conn 数据库连接
     */
    publicDatabaseTransaction(Connection conn) {
        this.conn = conn;
    }
 
    /**
     * 实例化一个默认连接的事务
     * @param conn 数据库连接
     * @param isOpenTrans 是否打开事务
     */
    publicDatabaseTransaction(Connection conn,booleanisOpenTrans)throwsDatabaseException {
        this.conn = conn;
        setAutoCommit(!isOpenTrans);
    }
 
    /**
     * @return 数据库连接
     */
    publicConnection getConnection() {
        returnconn;
    }
     
    /**
     * 设置是否自动提交
     * @param autoCommit 自动提交
     * @throws DatabaseException
     */
    privatevoidsetAutoCommit(booleanautoCommit)throwsDatabaseException {
        try{
            conn.setAutoCommit(autoCommit);
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * 开始事务
     * @throws DatabaseException
     */
    publicvoidbegin()throwsDatabaseException {
        setAutoCommit(false);
    }
     
    /**
     * @return 是否打开事务
     * @throws DatabaseException
     */
    publicbooleanisBegin()throwsDatabaseException {
        try{
            return!conn.getAutoCommit();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * 提交
     * @throws DatabaseException
     */
    publicvoidcommit()throwsDatabaseException {
        try{
            conn.commit();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * 回滚
     * @throws DatabaseException
     */
    publicvoidrollback()throwsDatabaseException {
        try{
            conn.rollback();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * 关闭连接
     * @throws DatabaseException
     */
    publicvoidclose()throwsDatabaseException {
        try{
            conn.close();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
     
    /**
     * @return 连接是否关闭
     * @throws DatabaseException
     */
    publicbooleanisClose()throwsDatabaseException {
        try{
            returnconn.isClosed();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDatabaseException(e);
        }
    }
 
}

[4].[代码] 通用数据模型 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
1
2
3
4
5
6
packageorg.dave.common.database;
 
importjava.io.Serializable;
 
@SuppressWarnings("serial")
publicabstractclassDataModelimplementsSerializable { }

[5].[代码] 结果转换器 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
packageorg.dave.common.database.convert;
 
importjava.sql.ResultSet;
importjava.sql.SQLException;
 
/**
 * 结果映射器
 * @author David Day
 */
publicinterfaceResultConverter<T> {
     
    /**
     * 映射
     * @param rs 结果集
     * @return 映射结果
     * @throws SQLException
     */
    publicT convert(ResultSet rs)throwsSQLException ;
 
}

[6].[代码] 通用dao 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
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
packageorg.dave.common.database.access;
 
importjava.sql.Connection;
importjava.sql.PreparedStatement;
importjava.sql.ResultSet;
importjava.sql.SQLException;
importjava.sql.Statement;
importjava.util.ArrayList;
importjava.util.List;
 
importorg.dave.common.database.convert.ResultConverter;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
 
/**
 * 数据存取类
 * @author David Day
 */
publicabstractclassDataAccess {
     
    /**
     * 日志工具
     */
    privatestaticfinalLogger LOG = LoggerFactory.getLogger(DataAccess.class);
    /**
     * 数据库连接
     */
    privateConnection conn;
 
    /**
     * @param conn 数据库连接
     */
    protectedDataAccess(Connection conn) {
        this.conn = conn;
    }
     
    /**
     * 插入数据
     * @param sql
     * @param generatedKeysConverter 主键映射
     * @param params
     * @return 主键
     * @throws DataAccessException
     */
    protected<T> T insert(String sql, ResultConverter<T> generatedKeysConverter, Object... params)throwsDataAccessException {
        try{
            PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            setParameters(pstmt, params);
            executeUpdate(pstmt);
            ResultSet rs = pstmt.getGeneratedKeys();
            nextResult(rs);
            returnconvertResult(rs, generatedKeysConverter);
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 更新数据
     * @param sql
     * @param params
     * @return 影响行数
     * @throws DataAccessException
     */
    protectedintupdate(String sql, Object... params)throwsDataAccessException {
        returnexecuteUpdate(getPreparedStatement(sql, params));
    }
     
    /**
     * 查询单个结果
     * @param <T>
     * @param sql
     * @param converter
     * @param params
     * @return
     */
    protected<T> T queryForObject(String sql, ResultConverter<T> converter, Object... params) {
        ResultSet rs = executeQuery(sql, params);
        if(nextResult(rs)) {
            returnconvertResult(rs, converter);
        }else{
            returnnull;
        }
    }
     
    /**
     * 查询结果列表
     * @param <T>
     * @param sql
     * @param converter
     * @param params
     * @return
     */
    protected<T> List<T> queryForList(String sql, ResultConverter<T> converter, Object... params) {
        ResultSet rs = executeQuery(sql, params);
        List<T> list =newArrayList<T>();
        while(nextResult(rs)) {
            list.add(convertResult(rs, converter));
        }
        returnlist;
    }
     
    /**
     * @param sql SQL语句
     * @return 预编译声明
     */
    privatePreparedStatement getPreparedStatement(String sql, Object... params)throwsDataAccessException {
        PreparedStatement pstmt = getPreparedStatement(sql);
        setParameters(pstmt, params);
        returnpstmt;
    }
     
    /**
     * @param sql SQL语句
     * @return 预编译声明
     */
    privatePreparedStatement getPreparedStatement(String sql)throwsDataAccessException {
        try{
            returnconn.prepareStatement(sql);
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 为预编译声明传入参数
     * @param pstmt 预编译声明
     * @param params 参数
     * @throws DataAccessException
     */
    privatevoidsetParameters(PreparedStatement pstmt, Object... params)throwsDataAccessException {
        try{
            for(inti =0; i < params.length; i++) {
                pstmt.setObject(i +1, params[i]);
            }
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 执行更新操作
     * @param pstmt
     * @return 影响行数
     * @throws DataAccessException
     */
    privateintexecuteUpdate(PreparedStatement pstmt)throwsDataAccessException {
        try{
            returnpstmt.executeUpdate();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 执行查询操作
     * @param pstmt 预编译声明
     * @return 结果集
     * @throws DataAccessException
     */
    privateResultSet executeQuery(PreparedStatement pstmt)throwsDataAccessException {
        try{
            returnpstmt.executeQuery();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 执行查询操作
     * @param sql SQL语句
     * @param params 参数
     * @return 结果集
     * @throws DataAccessException
     */
    privateResultSet executeQuery(String sql, Object... params)throwsDataAccessException {
        returnexecuteQuery(getPreparedStatement(sql, params));
    }
     
    /**
     * 移动到下一行记录
     * @param rs 结果集
     * @return 是否有下一行记录
     * @throws DataAccessException
     */
    privatebooleannextResult(ResultSet rs)throwsDataAccessException {
        try{
            returnrs.next();
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
     
    /**
     * 映射
     * @param rs 结果集
     * @return 映射结果
     * @throws DataAccessException
     */
    private<T> T convertResult(ResultSet rs, ResultConverter<T> converter)throwsDataAccessException {
        try{
            returnconverter.convert(rs);
        }catch(SQLException e) {
            e.printStackTrace();
            LOG.error(e.getMessage(), e);
            thrownewDataAccessException(e);
        }
    }
 
}

[7].[代码] 数据库存取异常 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
packageorg.dave.common.database.access;
 
/**
 * 数据库存取异常
 * @author David Day
 */
@SuppressWarnings("serial")
publicclassDataAccessExceptionextendsRuntimeException {
     
    publicDataAccessException(Throwable cause) {
        super(cause);
    }
 
}

[8].[文件] 源码和DEMO包 ~ 13KB    下载(1680) 跳至 [1] [2] [3] [4] [5] [6] [7] [8]

文件不存在或者代码语言不存在

本文转载自:http://www.oschina.net/code/snippet_86510_4404

J
粉丝 27
博文 166
码字总数 10234
作品 0
广州
程序员
私信 提问
我的JDBC通用DAO(解说)

前两篇的连接: 1,我的JDBC通用DAO 2,我的JDBC通用DAO(续) 为了方便大家阅读和调试,现在把demo发出来 先介绍一下新增的类 首先是主角登场,业务模型类 @Table(name="model")public class...

高得顺
2013/03/15
0
7
Hibernate反射DAO模式

在持久层框架中,如果我们要像简单的JDBC连接数据库那样写一个通用的Dao方法的话,那么把JDBC简单的业务逻辑搬到hibernate持久层框架中,当然是不可能的,这里主要的问题就在于hibernate持久...

zretc
2013/07/19
0
0
【广州】被客户叼晕了的【Java程序员】,来此【求职】哈~

先来些简历信息,让各位HR或主管经理过过目。。。 有木有单位愿意收留俺这枚应届生,屌丝程序猿。。。 专业能力:掌握Java语言编程,熟练JSP、Servlet、JDBC下开发; 熟悉Struts、Hibernate...

__啊
2014/07/23
2.7K
23
关于jndi和jdbc的一些问题

常见dao层链接数据库有 jdbc jndi hibernate mybatis 我理解的是 hibernate mybatis 都是对 jdbc的封装 那么jndi是对什么的封装 可以理解成jdbc和jndi是并列的关系吗? 也就是jndi也是一种连接...

伯函网络科技
2013/07/22
192
6
Spring框架笔记(二十四)——Spring中的JDBC的两种使用方式

为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架. 作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法...

HappyBKs
2015/08/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

好程序员分享placeholder属性详解

  好程序员分享placeholder属性详解,HTML5里新引入很多有趣的新特征;有些体现在HTML里,有些是JavaScript API,全部非常的有用。其中我最喜欢的一个特征就是文本框(INPUT)里的placehold...

好程序员IT
6分钟前
0
0
[学]ngin反向代理搭建与配置

Nginx安装地址:https://www.cnblogs.com/wyd168/p/6636529.html (linux) 必须安装的4个包: nginx-1.1.10.tar.gz openssl-1.0.1t.tar.gz pcre-8.39.tar.gz zlib-1.2.11.tar.gz 启动Nginx......

覃光林
9分钟前
0
0
互联网商城的上云改造之旅

在中国,经过十年的发展,云计算产业已走过概念普及的1.0时期,进入“上云”和落地的2. 0阶段,企业上云意识不断增强,越来越多的企业选择部署多云和混合IT。 如今,云计算生态一片繁荣,看似...

zhaowei121
11分钟前
0
0
fastJson 一些小例子

package com.*;import com.alibaba.fastjson.annotation.JSONField;public class VO { @JSONField(name="ID") private int id; public int getId() { ......

qimh
24分钟前
0
0
十年后,程序员的工资还能达到现在的水平吗?

一方面,程序员的门槛正在逐渐消失,因为计算机相关专业毕业生一年比一年多; IT 培训班出来的学生一年比一年多;网络上各种编程课程,也正在帮助无数人零基础转型软件开发…… 另一方面,程...

爱编程的浪子
32分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部