4 | * 通过调用PageFactory的方法获取封装好的翻页对象，用于在前台展示。 5 | */ 6 | package com.opensource.dbhelp.page; -------------------------------------------------------------------------------- /DbHelper/src/main/java/com/opensource/dbhelp/page/PageShow.java: -------------------------------------------------------------------------------- 1 | package com.opensource.dbhelp.page; 2 | 3 | /** 4 | * 定义根据封装的分页对象获取页面展示分页导航html的接口。 5 | *
6 | * Copyright: Copyright (c) Feb 6, 2009 3:39:21 PM 7 | *
8 | * Company: GNU General Public License 9 | *
10 | * Author: GNU General Public License 11 | *
12 | * Version: 1.0 13 | *
14 | */ 15 | public interface PageShow { 16 | 17 | /** 18 | * 获得分页导航HTML 19 | * 20 | * @param page 21 | * 分页对象 22 | * @return HTML字符，用于在前台展示分页导航 23 | */ 24 | public String getPageIndex(ListPage page); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /DbHelper/src/main/java/com/opensource/dbhelp/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 提供数据访问的封装。 3 | *
4 | * 5 | *
6 | *
7 | * // 获取默认helper实例
8 | * DbHelper oracleDbHelper = DbHelperManager.getHelper();
9 | *
10 | * // oracle 数据库
11 | * DbHelper oracleDbHelper = DbHelperManager.getInstance().getHelper("oracle", "oracle");
12 | *
13 | * // mysql 数据库
14 | * DbHelper mySqlDbHelper = DbHelperManager.getInstance().getHelper("mysql", "mysql");
15 | *
16 | * // 事务对象
17 | * DbTransaction transaction = mySqlDbHelper.getDbTransaction();
18 | *
19 | *
20 | */
21 | package com.opensource.dbhelp;
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dialect/PageSqlParserFactory.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp.dialect;
2 |
3 | import com.opensource.dbhelp.dialect.mysql.MySqlPageParser;
4 | import com.opensource.dbhelp.dialect.oracle.OraclePageSqlParser;
5 |
6 | /**
7 | * 获取翻页sql解析对象
8 | *
9 | * Copyright: Copyright (c) 13-1-15 上午9:27
10 | *
11 | * Company: GNU General Public License
12 | *
13 | * Author: GNU General Public License
14 | *
15 | * Version: 1.0
16 | *
17 | */
18 | public class PageSqlParserFactory {
19 |
20 | /**
21 | * 获取翻页解析对象
22 | *
23 | * @param dialect
24 | * 数据库类型
25 | * @return PageSqlParser
26 | */
27 | public static PageSqlParser getParser(String dialect) {
28 | if ("mysql".equals(dialect)) {
29 | return new MySqlPageParser();
30 | } else {
31 | return new OraclePageSqlParser();
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/wrappers/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 |
5 | /**
6 | * Wrappers that add functionality to java.sql classes.
7 | */
8 | package com.opensource.dbhelp.dbutils.wrappers;
9 |
10 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 |
5 | /**
6 | * Implementations of the com.opensource.dbhelp.dbutils.ResultSetHandler interface.
7 | */
8 | package com.opensource.dbhelp.dbutils.handlers;
9 |
10 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dialect/PageSqlParser.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp.dialect;
2 |
3 | /**
4 | * 翻页SQL接口
5 | *
6 | * Copyright: Copyright (c) 13-1-14 下午3:57
7 | *
8 | * Company: GNU General Public License
9 | *
10 | * Author: GNU General Public License
11 | *
12 | * Version: 1.0
13 | *
14 | */
15 | public interface PageSqlParser {
16 |
17 | /**
18 | * 生成查询一页数据的sql语句
19 | *
20 | * @param sql
21 | * 原查询语句
22 | * @param hasOffset
23 | * true 不是第一页 false 第一页
24 | * @return 查询当前页的SQL
25 | */
26 | public String getPageSql(String sql, boolean hasOffset);
27 |
28 | /**
29 | * 获取查询记录数的sql语句
30 | *
31 | * @param sql
32 | * 原查询语句
33 | * @return 查询记录数的SQL
34 | */
35 | public String getCountingSql(String sql);
36 |
37 | /**
38 | * 附加翻页参数
39 | *
40 | * @param params
41 | * 原有参数
42 | * @param hasOffset
43 | * true 不是第一页 false 第一页
44 | * @param startIndex
45 | * 开始索引
46 | * @param pageSize
47 | * 每页记录数
48 | * @return 附加翻页后的传入参数
49 | */
50 | public Object[] attachPageParam(Object[] params, boolean hasOffset, int startIndex, int pageSize);
51 | }
52 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dialect/mysql/MySqlPageParser.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp.dialect.mysql;
2 |
3 | import org.apache.commons.lang3.ArrayUtils;
4 |
5 | import com.opensource.dbhelp.dialect.PageSqlParser;
6 |
7 | /**
8 | * Mysql 翻页接口实现
9 | *
10 | * Copyright: Copyright (c) 13-1-14 下午4:01
11 | *
12 | * Company: GNU General Public License
13 | *
14 | * Author: GNU General Public License
15 | *
16 | * Version: 1.0
17 | *
18 | */
19 | public class MySqlPageParser implements PageSqlParser {
20 |
21 | @Override
22 | public String getPageSql(String sql, boolean hasOffset) {
23 | if (hasOffset) {
24 | return sql + " limit ?, ?";
25 | } else {
26 | return sql + " limit ?";
27 | }
28 | }
29 |
30 | @Override
31 | public String getCountingSql(String sql) {
32 | return "select count(1) from ( " + sql + ") as __tc";
33 | }
34 |
35 | @Override
36 | public Object[] attachPageParam(Object[] params, boolean hasOffset, int startIndex, int pageSize) {
37 | if (hasOffset) {
38 | params = ArrayUtils.add(params, startIndex - 1);
39 | params = ArrayUtils.add(params, pageSize);
40 | } else {
41 | params = ArrayUtils.add(params, pageSize);
42 | }
43 | return params;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 |
5 | /**
6 | * DbUtils is a small set of classes designed to make working with JDBC easier. JDBC resource cleanup code is mundane, error prone work so these classes abstract out all of the cleanup tasks from your code leaving you with what you really wanted to do with JDBC in the first place: query and update data. This package contains the core classes and interfaces - DbUtils, QueryRunner and the ResultSetHandler interface should be your first items of interest.
7 | */
8 | package com.opensource.dbhelp.dbutils;
9 |
10 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dialect/oracle/OraclePageSqlParser.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp.dialect.oracle;
2 |
3 | import org.apache.commons.lang3.ArrayUtils;
4 |
5 | import com.opensource.dbhelp.dialect.PageSqlParser;
6 |
7 | /**
8 | * Oracle 翻页接口实现
9 | *
10 | * Copyright: Copyright (c) 13-1-14 下午3:57
11 | *
12 | * Company: GNU General Public License
13 | *
14 | * Author: GNU General Public License
15 | *
16 | * Version: 1.0
17 | *
18 | */
19 | public class OraclePageSqlParser implements PageSqlParser {
20 |
21 | @Override
22 | public String getPageSql(String sql, boolean hasOffset) {
23 | StringBuilder ret = new StringBuilder(sql.length() + 100);
24 | if (hasOffset) {
25 | ret.append("select * from ( select row_.*, rownum rownum_ from ( ");
26 | } else {
27 | ret.append("select * from ( ");
28 | }
29 | ret.append(sql);
30 | if (hasOffset) {
31 | ret.append(" ) row_ where rownum < ?) where rownum_ >= ?");
32 | } else {
33 | ret.append(" ) where rownum < ?");
34 | }
35 | return ret.toString();
36 | }
37 |
38 | @Override
39 | public String getCountingSql(String sql) {
40 | return "select count(1) from ( " + sql + ")";
41 | }
42 |
43 | @Override
44 | public Object[] attachPageParam(Object[] params, boolean hasOffset, int startIndex, int pageSize) {
45 | if (hasOffset) {
46 | params = ArrayUtils.add(params, startIndex + pageSize);
47 | params = ArrayUtils.add(params, startIndex);
48 | } else {
49 | params = ArrayUtils.add(params, startIndex + pageSize);
50 | }
51 | return params;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/ResultSetHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 |
9 | /**
10 | * Implementations of this interface convert ResultSets into other objects.
11 | *
12 | * @param ResultSet into an Object.
19 | *
20 | * @param rs
21 | * The ResultSet to handle. It has not been touched before being passed to this method.
22 | * @return An Object initialized with ResultSet data. It is legal for implementations to return null if the ResultSet contained 0 rows.
23 | * @throws java.sql.SQLException
24 | * if a database access error occurs
25 | */
26 | T handle(ResultSet rs) throws SQLException;
27 |
28 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/page/ListPage.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp.page;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | /**
7 | * 使用List封装数据的分页对象。
8 | * 9 | *
10 | * Copyright: Copyright (c) Feb 6, 2009 3:39:21 PM 11 | *
12 | * Company: GNU General Public License 13 | *
14 | * Author: GNU General Public License 15 | *
16 | * Version: 1.0 17 | *
18 | */
19 | public class ListPage
11 | * 根据查询语句和页码查询出当页数据。
12 | *
13 | * Copyright: Copyright (c) Feb 6, 2009 3:39:21 PM
14 | *
15 | * Company: GNU General Public License
16 | *
17 | * Author: GNU General Public License
18 | *
19 | * Version: 1.0
20 | *
21 | */
22 | public abstract class AbstractPagedStatement
17 | * This class is thread-safe.
18 | *
158 | * The keys are stored as they are given [BUG #DBUTILS-34], so we maintain an internal mapping from lowercase keys to the real keys in order to achieve the case insensitive lookup.
159 | *
160 | * Note: This implementation does not allow null for key, whereas {@link java.util.HashMap} does, because of the code:
161 | *
162 | *
171 | * Any query operation using the key ({@link #get(Object)}, {@link #containsKey(Object)}) is done in three steps:
172 | * StringRowProcessor implementations convert ResultSet rows into various other objects. Implementations can extend BasicStringRowProcessor to protect themselves from changes to this interface.
12 | *
13 | * @see BasicStringRowProcessor
14 | */
15 | public interface StringRowProcessor {
16 |
17 | /**
18 | * Create an String[] from the column values in one ResultSet row. The ResultSet should be positioned on a valid row before passing it to this method. Implementations of this method must not alter the row position of the ResultSet.
19 | *
20 | * @param rs
21 | * ResultSet that supplies the array data
22 | * @throws java.sql.SQLException
23 | * if a database access error occurs
24 | * @return the newly created array
25 | */
26 | String[] toArray(ResultSet rs) throws SQLException;
27 |
28 | /**
29 | * Create a Map from the column values in one ResultSet row. The ResultSet should be positioned on a valid row before passing it to this method. Implementations of this method must not alter the row position of the ResultSet.
30 | *
31 | * @param rs
32 | * ResultSet that supplies the map data
33 | * @throws java.sql.SQLException
34 | * if a database access error occurs
35 | * @return the newly created Map
36 | */
37 | MapResultSetHandler classes that convert ResultSet into List.
15 | *
16 | * @param ResultSet handler. It produce List as result. To convert individual rows into Java objects it uses handleRow(ResultSet) method.
24 | *
25 | * @see #handleRow(java.sql.ResultSet)
26 | * @param rs
27 | * ResultSet to process.
28 | * @return a list of all rows in the result set
29 | * @throws java.sql.SQLException
30 | * error occurs
31 | */
32 | @Override
33 | public ListResultSet to process.
46 | * @return row processing result
47 | * @throws java.sql.SQLException
48 | * error occurs
49 | */
50 | protected abstract T handleRow(ResultSet rs) throws SQLException;
51 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/ArrayListHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.handlers;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 |
9 | import com.opensource.dbhelp.dbutils.RowProcessor;
10 |
11 | /**
12 | * ResultSetHandler implementation that converts the ResultSet into a List of Object[]s. This class is thread safe.
13 | *
14 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
15 | */
16 | public class ArrayListHandler extends AbstractListHandlerBasicRowProcessor for conversions.
25 | */
26 | public ArrayListHandler() {
27 | this(ArrayHandler.ROW_PROCESSOR);
28 | }
29 |
30 | /**
31 | * Creates a new instance of ArrayListHandler.
32 | *
33 | * @param convert
34 | * The RowProcessor implementation to use when converting rows into Object[]s.
35 | */
36 | public ArrayListHandler(RowProcessor convert) {
37 | super();
38 | this.convert = convert;
39 | }
40 |
41 | /**
42 | * Convert row's columns into an Object[].
43 | *
44 | * @param rs
45 | * ResultSet to process.
46 | * @return Object[], never null.
47 | * @throws java.sql.SQLException
48 | * if a database access error occurs
49 | * @see com.opensource.dbhelp.dbutils.handlers.AbstractListHandler#handle(java.sql.ResultSet)
50 | */
51 | @Override
52 | protected Object[] handleRow(ResultSet rs) throws SQLException {
53 | return this.convert.toArray(rs);
54 | }
55 |
56 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/StringArrayListHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.handlers;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 |
9 | import com.opensource.dbhelp.dbutils.StringRowProcessor;
10 |
11 | /**
12 | * ResultSetHandler implementation that converts the ResultSet into a List of String[]s. This class is thread safe.
13 | *
14 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
15 | */
16 | public class StringArrayListHandler extends AbstractListHandlerBasicStringRowProcessor for conversions.
25 | */
26 | public StringArrayListHandler() {
27 | this(StringArrayHandler.ROW_PROCESSOR);
28 | }
29 |
30 | /**
31 | * Creates a new instance of ArrayListHandler.
32 | *
33 | * @param convert
34 | * The StringRowProcessor implementation to use when converting rows into String[]s.
35 | */
36 | public StringArrayListHandler(StringRowProcessor convert) {
37 | super();
38 | this.convert = convert;
39 | }
40 |
41 | /**
42 | * Convert row's columns into an Object[].
43 | *
44 | * @return Object[], never null.
45 | * @throws java.sql.SQLException
46 | * if a database access error occurs
47 | * @see com.opensource.dbhelp.dbutils.handlers.AbstractListHandler#handle(java.sql.ResultSet)
48 | */
49 | @Override
50 | protected String[] handleRow(ResultSet rs) throws SQLException {
51 | return this.convert.toArray(rs);
52 | }
53 |
54 | }
55 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/MapListHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.handlers;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 | import java.util.Map;
9 |
10 | import com.opensource.dbhelp.dbutils.RowProcessor;
11 |
12 | /**
13 | * ResultSetHandler implementation that converts a ResultSet into a List of Maps. This class is thread safe.
14 | *
15 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
16 | */
17 | public class MapListHandler extends AbstractListHandlerBasicRowProcessor for conversion.
26 | */
27 | public MapListHandler() {
28 | this(ArrayHandler.ROW_PROCESSOR);
29 | }
30 |
31 | /**
32 | * Creates a new instance of MapListHandler.
33 | *
34 | * @param convert
35 | * The RowProcessor implementation to use when converting rows into Maps.
36 | */
37 | public MapListHandler(RowProcessor convert) {
38 | super();
39 | this.convert = convert;
40 | }
41 |
42 | /**
43 | * Converts the ResultSet row into a Map object.
44 | *
45 | * @param rs
46 | * ResultSet to process.
47 | * @return A Map, never null.
48 | * @throws java.sql.SQLException
49 | * if a database access error occurs
50 | * @see com.opensource.dbhelp.dbutils.handlers.AbstractListHandler#handle(java.sql.ResultSet)
51 | */
52 | @Override
53 | protected MapResultSetHandler implementation that converts a ResultSet into a List of Maps. This class is thread safe.
14 | *
15 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
16 | */
17 | public class StringMapListHandler extends AbstractListHandlerBasicStringRowProcessor for conversion.
26 | */
27 | public StringMapListHandler() {
28 | this(StringArrayHandler.ROW_PROCESSOR);
29 | }
30 |
31 | /**
32 | * Creates a new instance of MapListHandler.
33 | *
34 | * @param convert
35 | * The StringRowProcessor implementation to use when converting rows into Maps.
36 | */
37 | public StringMapListHandler(StringRowProcessor convert) {
38 | super();
39 | this.convert = convert;
40 | }
41 |
42 | /**
43 | * Converts the ResultSet row into a Map object.
44 | *
45 | * @return A Map, never null.
46 | * @throws java.sql.SQLException
47 | * if a database access error occurs
48 | * @see com.opensource.dbhelp.dbutils.handlers.AbstractListHandler#handle(java.sql.ResultSet)
49 | */
50 | @Override
51 | protected MapResultSetHandler implementation that converts the first ResultSet row into a Map. This class is thread safe.
15 | *
16 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
17 | */
18 | public class MapHandler implements ResultSetHandlerBasicRowProcessor for conversion.
27 | */
28 | public MapHandler() {
29 | this(ArrayHandler.ROW_PROCESSOR);
30 | }
31 |
32 | /**
33 | * Creates a new instance of MapHandler.
34 | *
35 | * @param convert
36 | * The RowProcessor implementation to use when converting rows into Maps.
37 | */
38 | public MapHandler(RowProcessor convert) {
39 | super();
40 | this.convert = convert;
41 | }
42 |
43 | /**
44 | * Converts the first row in the ResultSet into a Map.
45 | *
46 | * @param rs
47 | * ResultSet to process.
48 | * @return A Map with the values from the first row or null if there are no rows in the ResultSet.
49 | * @throws java.sql.SQLException
50 | * if a database access error occurs
51 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler#handle(java.sql.ResultSet)
52 | */
53 | @Override
54 | public MapResultSetHandler implementation that converts the first ResultSet row into a Map. This class is thread safe.
15 | *
16 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
17 | */
18 | public class StringMapHandler implements ResultSetHandlerBasicStringRowProcessor for conversion.
27 | */
28 | public StringMapHandler() {
29 | this(StringArrayHandler.ROW_PROCESSOR);
30 | }
31 |
32 | /**
33 | * Creates a new instance of MapHandler.
34 | *
35 | * @param convert
36 | * The StringRowProcessor implementation to use when converting rows into Maps.
37 | */
38 | public StringMapHandler(StringRowProcessor convert) {
39 | super();
40 | this.convert = convert;
41 | }
42 |
43 | /**
44 | * Converts the first row in the ResultSet into a Map.
45 | *
46 | * @return A Map with the values from the first row or null if there are no rows in the ResultSet.
47 | * @throws java.sql.SQLException
48 | * if a database access error occurs
49 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler#handle(java.sql.ResultSet)
50 | */
51 | @Override
52 | public MapResultSetHandler implementation that converts a ResultSet into an Object[]. This class is thread safe.
15 | *
16 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
17 | */
18 | public class ArrayHandler implements ResultSetHandlerBasicRowProcessor for conversion.
32 | */
33 | public ArrayHandler() {
34 | this(ROW_PROCESSOR);
35 | }
36 |
37 | /**
38 | * Creates a new instance of ArrayHandler.
39 | *
40 | * @param convert
41 | * The RowProcessor implementation to use when converting rows into arrays.
42 | */
43 | public ArrayHandler(RowProcessor convert) {
44 | super();
45 | this.convert = convert;
46 | }
47 |
48 | /**
49 | * Places the column values from the first row in an Object[].
50 | *
51 | * @param rs
52 | * ResultSet to process.
53 | * @return An Object[] or null if there are no rows in the ResultSet.
54 | * @throws java.sql.SQLException
55 | * if a database access error occurs
56 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler#handle(java.sql.ResultSet)
57 | */
58 | @Override
59 | public Object[] handle(ResultSet rs) throws SQLException {
60 | return rs.next() ? this.convert.toArray(rs) : null;
61 | }
62 |
63 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/StringArrayHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.handlers;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 |
9 | import com.opensource.dbhelp.dbutils.BasicStringRowProcessor;
10 | import com.opensource.dbhelp.dbutils.ResultSetHandler;
11 | import com.opensource.dbhelp.dbutils.StringRowProcessor;
12 |
13 | /**
14 | * ResultSetHandler implementation that converts a ResultSet into an String[]. This class is thread safe.
15 | *
16 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler
17 | */
18 | public class StringArrayHandler implements ResultSetHandlerBasicRowProcessor for conversion.
32 | */
33 | public StringArrayHandler() {
34 | this(ROW_PROCESSOR);
35 | }
36 |
37 | /**
38 | * Creates a new instance of ArrayHandler.
39 | *
40 | * @param convert
41 | * The StringRowProcessor implementation to use when converting rows into arrays.
42 | */
43 | public StringArrayHandler(StringRowProcessor convert) {
44 | super();
45 | this.convert = convert;
46 | }
47 |
48 | /**
49 | * Places the column values from the first row in an Object[].
50 | *
51 | * @return An Object[] or null if there are no rows in the ResultSet.
52 | * @throws java.sql.SQLException
53 | * if a database access error occurs
54 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler#handle(java.sql.ResultSet)
55 | */
56 | @Override
57 | public String[] handle(ResultSet rs) throws SQLException {
58 | return rs.next() ? this.convert.toArray(rs) : null;
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/handlers/BeanListHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.handlers;
5 |
6 | import java.sql.ResultSet;
7 | import java.sql.SQLException;
8 | import java.util.List;
9 |
10 | import com.opensource.dbhelp.dbutils.ResultSetHandler;
11 | import com.opensource.dbhelp.dbutils.RowProcessor;
12 |
13 | /**
14 | * ResultSetHandler implementation that converts a ResultSet into a List of beans. This class is thread safe.
15 | *
16 | * @param handle() are created from.
37 | */
38 | public BeanListHandler(Classhandle() are created from.
47 | * @param convert
48 | * The RowProcessor implementation to use when converting rows into beans.
49 | */
50 | public BeanListHandler(ClassResultSet into a List of beans with the Class given in the constructor.
57 | *
58 | * @param rs
59 | * The ResultSet to handle.
60 | * @return A List of beans, never null.
61 | * @throws java.sql.SQLException
62 | * if a database access error occurs
63 | * @see com.opensource.dbhelp.dbutils.RowProcessor#toBeanList(java.sql.ResultSet, Class)
64 | */
65 | @Override
66 | public ListResultSetHandler implementation that converts the first ResultSet row into a JavaBean. This class is thread safe.
14 | *
15 | * @param handle() are created from.
36 | */
37 | public BeanHandler(Classhandle() are created from.
46 | * @param convert
47 | * The RowProcessor implementation to use when converting rows into beans.
48 | */
49 | public BeanHandler(ClassResultSet into a bean with the Class given in the constructor.
56 | *
57 | * @param rs
58 | * ResultSet to process.
59 | * @return An initialized JavaBean or null if there were no rows in the ResultSet.
60 | * @throws java.sql.SQLException
61 | * if a database access error occurs
62 | * @see com.opensource.dbhelp.dbutils.ResultSetHandler#handle(java.sql.ResultSet)
63 | */
64 | @Override
65 | public T handle(ResultSet rs) throws SQLException {
66 | return rs.next() ? this.convert.toBean(rs, this.type) : null;
67 | }
68 |
69 | }
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # DbHelper
2 | DbHelper是支持定制化SQL、存储过程以及高级映射的高效性轻量级持久层框架，其主要就完成2件事情：封装JDBC操作；利用反射打通Java类与SQL语句之间的相互转换。DbHelper的主要设计目的是让我们对执行SQL语句时对输入输出的数据管理更加方便，高效快捷地写出SQL和方便地获取SQL的执行结果。经过长期的维护，目前DbHelper支持返回的数据类型基本囊括了各种项目所需，包括分页、POJO、Array、Map、List\RowProcessor interface.
16 | * ResultSet row into an Object[]. This implementation copies column values into the array in the same order they're returned from the ResultSet. Array elements will be set to null if the column was SQL NULL.
71 | *
72 | * @see com.cplatform.dbhelp.dbutils.RowProcessor#toArray(java.sql.ResultSet)
73 | * @param rs
74 | * ResultSet that supplies the array data
75 | * @throws java.sql.SQLException
76 | * if a database access error occurs
77 | * @return the newly created array
78 | */
79 | @Override
80 | public Object[] toArray(ResultSet rs) throws SQLException {
81 | ResultSetMetaData meta = rs.getMetaData();
82 | int cols = meta.getColumnCount();
83 | Object[] result = new Object[cols];
84 |
85 | for (int i = 0; i < cols; i++) {
86 | result[i] = rs.getObject(i + 1);
87 | }
88 |
89 | return result;
90 | }
91 |
92 | /**
93 | * Convert a ResultSet row into a JavaBean. This implementation delegates to a BeanProcessor instance.
94 | *
95 | * @see com.cplatform.dbhelp.dbutils.RowProcessor#toBean(java.sql.ResultSet, Class)
96 | * @see com.cplatform.dbhelp.dbutils.BeanProcessor#toBean(java.sql.ResultSet, Class)
97 | * @param ResultSet into a List of JavaBeans. This implementation delegates to a BeanProcessor instance.
114 | *
115 | * @see com.cplatform.dbhelp.dbutils.RowProcessor#toBeanList(java.sql.ResultSet, Class)
116 | * @see com.cplatform.dbhelp.dbutils.BeanProcessor#toBeanList(java.sql.ResultSet, Class)
117 | * @param List of beans with the given type in the order they were returned by the ResultSet.
126 | */
127 | @Override
128 | public ResultSet row into a Map. This implementation returns a Map with case insensitive column names as keys. Calls to map.get("COL") and map.get("col") return the same value.
134 | *
135 | * @see com.cplatform.dbhelp.dbutils.RowProcessor#toMap(java.sql.ResultSet)
136 | * @param rs
137 | * ResultSet that supplies the map data
138 | * @throws java.sql.SQLException
139 | * if a database access error occurs
140 | * @return the newly created Map
141 | */
142 | @Override
143 | public Map
163 | * key.toString().toLowerCase()
164 | *
165 | */
166 | private static class CaseInsensitiveHashMap extends HashMap
173 | *
177 | *
Connection, avoid closing if null.
28 | *
29 | * @param conn
30 | * Connection to close.
31 | * @throws java.sql.SQLException
32 | * if a database access error occurs
33 | */
34 | public static void close(Connection conn) throws SQLException {
35 | if (conn != null) {
36 | conn.close();
37 | }
38 | }
39 |
40 | /**
41 | * Close a ResultSet, avoid closing if null.
42 | *
43 | * @param rs
44 | * ResultSet to close.
45 | * @throws java.sql.SQLException
46 | * if a database access error occurs
47 | */
48 | public static void close(ResultSet rs) throws SQLException {
49 | if (rs != null) {
50 | rs.close();
51 | }
52 | }
53 |
54 | /**
55 | * Close a Statement, avoid closing if null.
56 | *
57 | * @param stmt
58 | * Statement to close.
59 | * @throws java.sql.SQLException
60 | * if a database access error occurs
61 | */
62 | public static void close(Statement stmt) throws SQLException {
63 | if (stmt != null) {
64 | stmt.close();
65 | }
66 | }
67 |
68 | /**
69 | * Close a Connection, avoid closing if null and hide any SQLExceptions that occur.
70 | *
71 | * @param conn
72 | * Connection to close.
73 | */
74 | public static void closeQuietly(Connection conn) {
75 | try {
76 | close(conn);
77 | }
78 | catch (SQLException e) { // NOPMD
79 | // quiet
80 | }
81 | }
82 |
83 | /**
84 | * Close a Connection, Statement and ResultSet. Avoid closing if null and hide any SQLExceptions that occur.
85 | *
86 | * @param conn
87 | * Connection to close.
88 | * @param stmt
89 | * Statement to close.
90 | * @param rs
91 | * ResultSet to close.
92 | */
93 | public static void closeQuietly(Connection conn, Statement stmt, ResultSet rs) {
94 |
95 | try {
96 | closeQuietly(rs);
97 | }
98 | finally {
99 | try {
100 | closeQuietly(stmt);
101 | }
102 | finally {
103 | closeQuietly(conn);
104 | }
105 | }
106 |
107 | }
108 |
109 | /**
110 | * Close a ResultSet, avoid closing if null and hide any SQLExceptions that occur.
111 | *
112 | * @param rs
113 | * ResultSet to close.
114 | */
115 | public static void closeQuietly(ResultSet rs) {
116 | try {
117 | close(rs);
118 | }
119 | catch (SQLException e) { // NOPMD
120 | // quiet
121 | }
122 | }
123 |
124 | /**
125 | * Close a Statement, avoid closing if null and hide any SQLExceptions that occur.
126 | *
127 | * @param stmt
128 | * Statement to close.
129 | */
130 | public static void closeQuietly(Statement stmt) {
131 | try {
132 | close(stmt);
133 | }
134 | catch (SQLException e) { // NOPMD
135 | // quiet
136 | }
137 | }
138 |
139 | /**
140 | * Commits a Connection then closes it, avoid closing if null.
141 | *
142 | * @param conn
143 | * Connection to close.
144 | * @throws java.sql.SQLException
145 | * if a database access error occurs
146 | */
147 | public static void commitAndClose(Connection conn) throws SQLException {
148 | if (conn != null) {
149 | try {
150 | conn.commit();
151 | }
152 | finally {
153 | conn.close();
154 | }
155 | }
156 | }
157 |
158 | /**
159 | * Commits a Connection then closes it, avoid closing if null and hide any SQLExceptions that occur.
160 | *
161 | * @param conn
162 | * Connection to close.
163 | */
164 | public static void commitAndCloseQuietly(Connection conn) {
165 | try {
166 | commitAndClose(conn);
167 | }
168 | catch (SQLException e) { // NOPMD
169 | // quiet
170 | }
171 | }
172 |
173 | /**
174 | * Loads and registers a database driver class. If this succeeds, it returns true, else it returns false.
175 | *
176 | * @param driverClassName
177 | * of driver to load
178 | * @return boolean true if the driver was found, otherwise false
179 | */
180 | public static boolean loadDriver(String driverClassName) {
181 | return loadDriver(DbUtils.class.getClassLoader(), driverClassName);
182 | }
183 |
184 | /**
185 | * Loads and registers a database driver class. If this succeeds, it returns true, else it returns false.
186 | *
187 | * @param classLoader
188 | * the class loader used to load the driver class
189 | * @param driverClassName
190 | * of driver to load
191 | * @return boolean true if the driver was found, otherwise false
192 | * @since 1.4
193 | */
194 | public static boolean loadDriver(ClassLoader classLoader, String driverClassName) {
195 | try {
196 | classLoader.loadClass(driverClassName).newInstance();
197 | return true;
198 |
199 | }
200 | catch (IllegalAccessException e) {
201 | // Constructor is private, OK for DriverManager contract
202 | return true;
203 |
204 | }
205 | catch (Exception e) {
206 | return false;
207 |
208 | }
209 | }
210 |
211 | /**
212 | * Print the stack trace for a SQLException to STDERR.
213 | *
214 | * @param e
215 | * SQLException to print stack trace of
216 | */
217 | public static void printStackTrace(SQLException e) {
218 | printStackTrace(e, new PrintWriter(System.err));
219 | }
220 |
221 | /**
222 | * Print the stack trace for a SQLException to a specified PrintWriter.
223 | *
224 | * @param e
225 | * SQLException to print stack trace of
226 | * @param pw
227 | * PrintWriter to print to
228 | */
229 | public static void printStackTrace(SQLException e, PrintWriter pw) {
230 |
231 | SQLException next = e;
232 | while (next != null) {
233 | next.printStackTrace(pw);
234 | next = next.getNextException();
235 | if (next != null) {
236 | pw.println("Next SQLException:");
237 | }
238 | }
239 | }
240 |
241 | /**
242 | * Print warnings on a Connection to STDERR.
243 | *
244 | * @param conn
245 | * Connection to print warnings from
246 | */
247 | public static void printWarnings(Connection conn) {
248 | printWarnings(conn, new PrintWriter(System.err));
249 | }
250 |
251 | /**
252 | * Print warnings on a Connection to a specified PrintWriter.
253 | *
254 | * @param conn
255 | * Connection to print warnings from
256 | * @param pw
257 | * PrintWriter to print to
258 | */
259 | public static void printWarnings(Connection conn, PrintWriter pw) {
260 | if (conn != null) {
261 | try {
262 | printStackTrace(conn.getWarnings(), pw);
263 | }
264 | catch (SQLException e) {
265 | printStackTrace(e, pw);
266 | }
267 | }
268 | }
269 |
270 | /**
271 | * Rollback any changes made on the given connection.
272 | *
273 | * @param conn
274 | * Connection to rollback. A null value is legal.
275 | * @throws java.sql.SQLException
276 | * if a database access error occurs
277 | */
278 | public static void rollback(Connection conn) throws SQLException {
279 | if (conn != null) {
280 | conn.rollback();
281 | }
282 | }
283 |
284 | /**
285 | * Performs a rollback on the Connection then closes it, avoid closing if null.
286 | *
287 | * @param conn
288 | * Connection to rollback. A null value is legal.
289 | * @throws java.sql.SQLException
290 | * if a database access error occurs
291 | * @since DbUtils 1.1
292 | */
293 | public static void rollbackAndClose(Connection conn) throws SQLException {
294 | if (conn != null) {
295 | try {
296 | conn.rollback();
297 | }
298 | finally {
299 | conn.close();
300 | }
301 | }
302 | }
303 |
304 | /**
305 | * Performs a rollback on the Connection then closes it, avoid closing if null and hide any SQLExceptions that occur.
306 | *
307 | * @param conn
308 | * Connection to rollback. A null value is legal.
309 | * @since DbUtils 1.1
310 | */
311 | public static void rollbackAndCloseQuietly(Connection conn) {
312 | try {
313 | rollbackAndClose(conn);
314 | }
315 | catch (SQLException e) { // NOPMD
316 | // quiet
317 | }
318 | }
319 |
320 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/DbTransaction.java:
--------------------------------------------------------------------------------
1 | package com.opensource.dbhelp;
2 |
3 | import java.sql.Connection;
4 | import java.sql.SQLException;
5 | import java.util.List;
6 |
7 | import javax.sql.DataSource;
8 |
9 | import org.apache.commons.logging.Log;
10 | import org.apache.commons.logging.LogFactory;
11 |
12 | import com.opensource.dbhelp.dbutils.DbUtils;
13 | import com.opensource.dbhelp.dbutils.QueryRunner;
14 | import com.opensource.dbhelp.dbutils.handlers.BeanHandler;
15 | import com.opensource.dbhelp.dbutils.handlers.BeanListHandler;
16 | import com.opensource.dbhelp.dbutils.handlers.StringArrayHandler;
17 | import com.opensource.dbhelp.dbutils.handlers.StringArrayListHandler;
18 |
19 | /**
20 | * 数据库事务处理帮助类。
21 | *
22 | * 典型的调用方法如下：
25 | * DbTransaction dbc = DbHelperManager.getHelper().getDbTransaction();
26 | * try {
27 | * dbc.connect();
28 | * dbc.begin();
29 | *
30 | * dbc.execute("select ...", new Object[]{...});
31 | * dbc.execute("insert into ...", ...);
32 | * dbc.execute("insert into ...");
33 | *
34 | * String[] tmp1 = dbc.find("select ...", new Object[]{...});
35 | * System.out.println( org.apache.commons.lang.builder.ToStringBuilder.reflectionToString(tmp1) );
36 | *
37 | * List params = new ArrayList();
38 | * params.add(new Object[]{3213, "20080920101111"});
39 | * params.add(new Object[]{3214, "20080920101111"});
40 | * params.add(new Object[]{3215, "20080920101111"});
41 | *
42 | * dbc.batch("insert into ... values (?, ?)", params);
43 | *
44 | * List tmp2 = dbc.query("select * from ...");
45 | * System.out.println( org.apache.commons.lang.builder.ToStringBuilder.reflectionToString(tmp2) );
46 | *
47 | * dbc.execute("delete from ...", new Object[]{...});
48 | *
49 | * dbc.commit();
50 | * } catch (Exception e) {
51 | * dbc.rollback();
52 | * throw e;
53 | * } finally {
54 | * dbc.close();
55 | * }
56 | *
57 | *
58 | * Copyright: Copyright (c) Feb 6, 2009 3:39:21 PM
59 | *
60 | * Company: GNU General Public License
61 | *
62 | * Author: GNU General Public License
63 | *
64 | * Version: 1.0
65 | *
66 | */
67 | public class DbTransaction {
68 |
69 | /**
70 | * logger
71 | */
72 | private static final Log logger = LogFactory.getLog(DbTransaction.class);
73 |
74 | /**
75 | * sql logger，用于把执行的SQL语句及参数进行单独记录
76 | */
77 | private static final Log sqllogger = LogFactory.getLog("com.opensource.SQL");
78 |
79 | /**
80 | * 数据库连接
81 | */
82 | private Connection conn = null;
83 |
84 | /**
85 | * 是否自动提交
86 | */
87 | private boolean isAutoCommit;
88 |
89 | /**
90 | * QueryRunner对象
91 | */
92 | private QueryRunner run = null;
93 |
94 | /**
95 | * 初始化时初始化QueryRunner对象
96 | *
97 | * @param dataSource
98 | * 使用的数据源
99 | */
100 | public DbTransaction(DataSource dataSource) {
101 | run = new QueryRunner(dataSource);
102 | }
103 |
104 | /**
105 | * 建立数据库连接
106 | *
107 | * @throws SQLException
108 | * - 如果不能建立连接
109 | */
110 | public void connect() throws SQLException {
111 | try {
112 | conn = run.getDataSource().getConnection();
113 | }
114 | catch (SQLException ex) {
115 | logger.error("get connection error!", ex);
116 | throw ex;
117 | }
118 | }
119 |
120 | /**
121 | * 事务生命周期开始
122 | *
123 | * @throws SQLException
124 | * SQL异常
125 | */
126 | public void begin() throws SQLException {
127 | try {
128 | isAutoCommit = conn.getAutoCommit();
129 | conn.setAutoCommit(false);
130 | }
131 | catch (SQLException ex) {
132 | logger.error("begin transaction error!", ex);
133 | throw ex;
134 | }
135 | }
136 |
137 | /**
138 | * 获取数据库连接
139 | *
140 | * @return 数据库连接对象
141 | */
142 | public Connection getConnection() {
143 | return conn;
144 | }
145 |
146 | /**
147 | * 结束事务生命周期，提交所有变更
148 | *
149 | * @throws SQLException
150 | * SQL异常
151 | */
152 | public void commit() throws SQLException {
153 | try {
154 | conn.commit();
155 | conn.setAutoCommit(isAutoCommit);
156 | }
157 | catch (SQLException ex) {
158 | logger.error("commit transaction error!", ex);
159 | throw ex;
160 | }
161 | }
162 |
163 | /**
164 | * 事务回滚
165 | */
166 | public void rollback() {
167 | try {
168 | conn.rollback();
169 | conn.setAutoCommit(isAutoCommit);
170 | }
171 | catch (SQLException ex) {
172 | logger.error("rollback transaction error!", ex);
173 | }
174 | }
175 |
176 | /**
177 | * 判断是否为自动加入数据模式
178 | *
179 | * @return 是否为自动提交
180 | * @throws SQLException
181 | * SQL异常
182 | */
183 | public boolean getAutoCommit() throws SQLException {
184 | boolean result;
185 | try {
186 | result = conn.getAutoCommit();
187 | }
188 | catch (SQLException ex) {
189 | logger.error("get auto commit status error!", ex);
190 | throw ex;
191 | }
192 | return result;
193 | }
194 |
195 | /**
196 | * sql执行操作，用于数据更新，主要是Update，Insert，delete
197 | *
198 | * @param sql
199 | * 要执行的sql语句
200 | * @return 影响的行数
201 | * @throws SQLException
202 | * 捕捉错误
203 | */
204 | public int execute(String sql) throws SQLException {
205 | return execute(sql, (Object[]) null);
206 | }
207 |
208 | /**
209 | * sql执行操作，用于数据更新，主要是Update，Insert，delete
210 | *
211 | * @param sql
212 | * 要执行的sql语句
213 | * @param param
214 | * 参数对象
215 | * @return 影响的行数
216 | * @throws SQLException
217 | * 捕捉错误
218 | */
219 | public int execute(String sql, Object param) throws SQLException {
220 | return execute(sql, new Object[] { param });
221 | }
222 |
223 | /**
224 | * sql执行操作，用于数据更新，主要是Update，Insert，delete
225 | *
226 | * @param sql
227 | * 要执行的sql语句
228 | * @param params
229 | * 参数数组对象
230 | * @return 影响的行数
231 | * @throws SQLException
232 | * 捕捉错误
233 | */
234 | public int execute(String sql, Object... params) throws SQLException {
235 | debug(sql, params);
236 | return run.update(conn, sql, params);
237 | }
238 |
239 | /**
240 | * 批处理执行sql
241 | *
242 | * @param sql
243 | * 要执行的SQL语句
244 | * @param params
245 | * 参数数组对象
246 | * @return The number of rows updated per statement.
247 | * @throws SQLException
248 | * SQL异常
249 | */
250 | public int[] batch(String sql, ListParameterMetaData.
51 | *
52 | * @param pmdKnownBroken
53 | * Some drivers don't support {@link java.sql.ParameterMetaData#getParameterType(int) }; if pmdKnownBroken is set to true, we won't even try it; if false, we'll try it, and if it breaks, we'll remember not to use it again.
54 | */
55 | public AbstractQueryRunner(boolean pmdKnownBroken) {
56 | this.pmdKnownBroken = pmdKnownBroken;
57 | ds = null;
58 | }
59 |
60 | /**
61 | * Constructor to provide a DataSource. Methods that do not take a Connection parameter will retrieve connections from this DataSource.
62 | *
63 | * @param ds
64 | * The DataSource to retrieve connections from.
65 | */
66 | public AbstractQueryRunner(DataSource ds) {
67 | this.ds = ds;
68 | }
69 |
70 | /**
71 | * Constructor to provide a DataSource and control the use of ParameterMetaData. Methods that do not take a Connection parameter will retrieve connections from this DataSource.
72 | *
73 | * @param ds
74 | * The DataSource to retrieve connections from.
75 | * @param pmdKnownBroken
76 | * Some drivers don't support {@link java.sql.ParameterMetaData#getParameterType(int) }; if pmdKnownBroken is set to true, we won't even try it; if false, we'll try it, and if it breaks, we'll remember not to use it again.
77 | */
78 | public AbstractQueryRunner(DataSource ds, boolean pmdKnownBroken) {
79 | this.pmdKnownBroken = pmdKnownBroken;
80 | this.ds = ds;
81 | }
82 |
83 | /**
84 | * Returns the DataSource this runner is using. QueryRunner methods always call this method to get the DataSource so subclasses can provide specialized behavior.
85 | *
86 | * @return DataSource the runner is using
87 | */
88 | public DataSource getDataSource() {
89 | return this.ds;
90 | }
91 |
92 | /**
93 | * Some drivers don't support {@link java.sql.ParameterMetaData#getParameterType(int) }; if pmdKnownBroken is set to true, we won't even try it; if false, we'll try it, and if it breaks, we'll remember not to use it again.
94 | *
95 | * @return the flag to skip (or not) {@link java.sql.ParameterMetaData#getParameterType(int) }
96 | * @since 1.4
97 | */
98 | public boolean isPmdKnownBroken() {
99 | return pmdKnownBroken;
100 | }
101 |
102 | /**
103 | * Factory method that creates and initializes a PreparedStatement object for the given SQL. QueryRunner methods always call this method to prepare statements for them. Subclasses can override this method to provide special PreparedStatement configuration if needed. This implementation simply calls conn.prepareStatement(sql).
104 | *
105 | * @param conn
106 | * The Connection used to create the PreparedStatement
107 | * @param sql
108 | * The SQL statement to prepare.
109 | * @return An initialized PreparedStatement.
110 | * @throws java.sql.SQLException
111 | * if a database access error occurs
112 | */
113 | protected PreparedStatement prepareStatement(Connection conn, String sql) throws SQLException {
114 |
115 | return conn.prepareStatement(sql);
116 | }
117 |
118 | /**
119 | * Factory method that creates and initializes a Connection object. QueryRunner methods always call this method to retrieve connections from its DataSource. Subclasses can override this method to provide special Connection configuration if needed. This implementation simply calls ds.getConnection().
120 | *
121 | * @return An initialized Connection.
122 | * @throws java.sql.SQLException
123 | * if a database access error occurs
124 | * @since DbUtils 1.1
125 | */
126 | protected Connection prepareConnection() throws SQLException {
127 | if (this.getDataSource() == null) {
128 | throw new SQLException("QueryRunner requires a DataSource to be " + "invoked in this way, or a Connection should be passed in");
129 | }
130 | return this.getDataSource().getConnection();
131 | }
132 |
133 | /**
134 | * Fill the PreparedStatement replacement parameters with the given objects.
135 | *
136 | * @param stmt
137 | * PreparedStatement to fill
138 | * @param params
139 | * Query replacement parameters; null is a valid value to pass in.
140 | * @throws java.sql.SQLException
141 | * if a database access error occurs
142 | */
143 | public void fillStatement(PreparedStatement stmt, Object... params) throws SQLException {
144 |
145 | // check the parameter count, if we can
146 | ParameterMetaData pmd = null;
147 | if (!pmdKnownBroken) {
148 | pmd = stmt.getParameterMetaData();
149 | int stmtCount = pmd.getParameterCount();
150 | int paramsCount = params == null ? 0 : params.length;
151 |
152 | if (stmtCount != paramsCount) {
153 | throw new SQLException("Wrong number of parameters: expected " + stmtCount + ", was given " + paramsCount);
154 | }
155 | }
156 |
157 | // nothing to do here
158 | if (params == null) {
159 | return;
160 | }
161 |
162 | for (int i = 0; i < params.length; i++) {
163 | if (params[i] != null) {
164 | stmt.setObject(i + 1, params[i]);
165 | } else {
166 | // VARCHAR works with many drivers regardless
167 | // of the actual column type. Oddly, NULL and
168 | // OTHER don't work with Oracle's drivers.
169 | int sqlType = Types.VARCHAR;
170 | if (!pmdKnownBroken) {
171 | try {
172 | /*
173 | * It's not possible for pmdKnownBroken to change from true to false, (once true, always true) so pmd cannot be null here.
174 | */
175 | sqlType = pmd.getParameterType(i + 1);
176 | }
177 | catch (SQLException e) {
178 | pmdKnownBroken = true;
179 | }
180 | }
181 | stmt.setNull(i + 1, sqlType);
182 | }
183 | }
184 | }
185 |
186 | /**
187 | * Fill the PreparedStatement replacement parameters with the given object's bean property values.
188 | *
189 | * @param stmt
190 | * PreparedStatement to fill
191 | * @param bean
192 | * a JavaBean object
193 | * @param properties
194 | * an ordered array of properties; this gives the order to insert values in the statement
195 | * @throws java.sql.SQLException
196 | * if a database access error occurs
197 | */
198 | public void fillStatementWithBean(PreparedStatement stmt, Object bean, PropertyDescriptor[] properties) throws SQLException {
199 | Object[] params = new Object[properties.length];
200 | for (int i = 0; i < properties.length; i++) {
201 | PropertyDescriptor property = properties[i];
202 | Object value = null;
203 | Method method = property.getReadMethod();
204 | if (method == null) {
205 | throw new RuntimeException("No read method for bean property " + bean.getClass() + " " + property.getName());
206 | }
207 | try {
208 | value = method.invoke(bean, new Object[0]);
209 | }
210 | catch (InvocationTargetException e) {
211 | throw new RuntimeException("Couldn't invoke method: " + method, e);
212 | }
213 | catch (IllegalArgumentException e) {
214 | throw new RuntimeException("Couldn't invoke method with 0 arguments: " + method, e);
215 | }
216 | catch (IllegalAccessException e) {
217 | throw new RuntimeException("Couldn't invoke method: " + method, e);
218 | }
219 | params[i] = value;
220 | }
221 | fillStatement(stmt, params);
222 | }
223 |
224 | /**
225 | * Fill the PreparedStatement replacement parameters with the given object's bean property values.
226 | *
227 | * @param stmt
228 | * PreparedStatement to fill
229 | * @param bean
230 | * A JavaBean object
231 | * @param propertyNames
232 | * An ordered array of property names (these should match the getters/setters); this gives the order to insert values in the statement
233 | * @throws java.sql.SQLException
234 | * If a database access error occurs
235 | */
236 | public void fillStatementWithBean(PreparedStatement stmt, Object bean, String... propertyNames) throws SQLException {
237 | PropertyDescriptor[] descriptors;
238 | try {
239 | descriptors = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
240 | }
241 | catch (IntrospectionException e) {
242 | throw new RuntimeException("Couldn't introspect bean " + bean.getClass().toString(), e);
243 | }
244 | PropertyDescriptor[] sorted = new PropertyDescriptor[propertyNames.length];
245 | for (int i = 0; i < propertyNames.length; i++) {
246 | String propertyName = propertyNames[i];
247 | if (propertyName == null) {
248 | throw new NullPointerException("propertyName can't be null: " + i);
249 | }
250 | boolean found = false;
251 | for (int j = 0; j < descriptors.length; j++) {
252 | PropertyDescriptor descriptor = descriptors[j];
253 | if (propertyName.equals(descriptor.getName())) {
254 | sorted[i] = descriptor;
255 | found = true;
256 | break;
257 | }
258 | }
259 | if (!found) {
260 | throw new RuntimeException("Couldn't find bean property: " + bean.getClass() + " " + propertyName);
261 | }
262 | }
263 | fillStatementWithBean(stmt, bean, sorted);
264 | }
265 |
266 | /**
267 | * Throws a new exception with a more informative error message.
268 | *
269 | * @param cause
270 | * The original exception that will be chained to the new exception when it's rethrown.
271 | * @param sql
272 | * The query that was executing when the exception happened.
273 | * @param params
274 | * The query replacement parameters; null is a valid value to pass in.
275 | * @throws java.sql.SQLException
276 | * if a database access error occurs
277 | */
278 | protected void rethrow(SQLException cause, String sql, Object... params) throws SQLException {
279 |
280 | String causeMessage = cause.getMessage();
281 | if (causeMessage == null) {
282 | causeMessage = "";
283 | }
284 | StringBuffer msg = new StringBuffer(causeMessage);
285 |
286 | msg.append(" Query: ");
287 | msg.append(sql);
288 | msg.append(" Parameters: ");
289 |
290 | if (params == null) {
291 | msg.append("[]");
292 | } else {
293 | msg.append(Arrays.deepToString(params));
294 | }
295 |
296 | SQLException e = new SQLException(msg.toString(), cause.getSQLState(), cause.getErrorCode());
297 | e.setNextException(cause);
298 |
299 | throw e;
300 | }
301 |
302 | /**
303 | * Wrap the ResultSet in a decorator before processing it. This implementation returns the ResultSet it is given without any decoration.
304 | * 305 | * Often, the implementation of this method can be done in an anonymous inner class like this: 306 | *
307 | * 308 | *
309 | *
310 | * QueryRunner run = new QueryRunner() {
311 | *
312 | * protected ResultSet wrap(ResultSet rs) {
313 | * return StringTrimmedResultSet.wrap(rs);
314 | * }
315 | * };
316 | *
317 | *
318 | * @param rs
319 | * The ResultSet to decorate; never null.
320 | * @return The ResultSet wrapped in some decorator.
321 | */
322 | protected ResultSet wrap(ResultSet rs) {
323 | return rs;
324 | }
325 |
326 | /**
327 | * Close a Connection. This implementation avoids closing if null and does not suppress any exceptions. Subclasses can override to provide special handling like logging.
328 | *
329 | * @param conn
330 | * Connection to close
331 | * @throws java.sql.SQLException
332 | * if a database access error occurs
333 | * @since DbUtils 1.1
334 | */
335 | protected void close(Connection conn) throws SQLException {
336 | DbUtils.close(conn);
337 | }
338 |
339 | /**
340 | * Close a Statement. This implementation avoids closing if null and does not suppress any exceptions. Subclasses can override to provide special handling like logging.
341 | *
342 | * @param stmt
343 | * Statement to close
344 | * @throws java.sql.SQLException
345 | * if a database access error occurs
346 | * @since DbUtils 1.1
347 | */
348 | protected void close(Statement stmt) throws SQLException {
349 | DbUtils.close(stmt);
350 | }
351 |
352 | /**
353 | * Close a ResultSet. This implementation avoids closing if null and does not suppress any exceptions. Subclasses can override to provide special handling like logging.
354 | *
355 | * @param rs
356 | * ResultSet to close
357 | * @throws java.sql.SQLException
358 | * if a database access error occurs
359 | * @since DbUtils 1.1
360 | */
361 | protected void close(ResultSet rs) throws SQLException {
362 | DbUtils.close(rs);
363 | }
364 |
365 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/BeanProcessor.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils;
5 |
6 | import java.beans.BeanInfo;
7 | import java.beans.IntrospectionException;
8 | import java.beans.Introspector;
9 | import java.beans.PropertyDescriptor;
10 | import java.lang.reflect.InvocationTargetException;
11 | import java.lang.reflect.Method;
12 | import java.sql.ResultSet;
13 | import java.sql.ResultSetMetaData;
14 | import java.sql.SQLException;
15 | import java.sql.SQLXML;
16 | import java.sql.Timestamp;
17 | import java.util.ArrayList;
18 | import java.util.Arrays;
19 | import java.util.HashMap;
20 | import java.util.List;
21 | import java.util.Map;
22 |
23 | /**
24 | *
25 | * BeanProcessor matches column names to bean property names and converts ResultSet columns into objects for those bean properties. Subclasses should override the methods in the processing chain to customize behavior.
26 | *
28 | * This class is thread-safe. 29 | *
30 | * 31 | * @see BasicRowProcessor 32 | * @since DbUtils 1.1 33 | */ 34 | public class BeanProcessor { 35 | 36 | /** 37 | * Special array value used bymapColumnsToProperties that indicates there is no bean property that matches a column from a ResultSet.
38 | */
39 | protected static final int PROPERTY_NOT_FOUND = -1;
40 |
41 | /**
42 | * Set a bean's primitive properties to these defaults when SQL NULL is returned. These are the same as the defaults that ResultSet get* methods return in the event of a NULL column.
43 | */
44 | private static final MapResultSet row into a JavaBean. This implementation uses reflection and BeanInfo classes to match column names to bean property names. Properties are matched to columns based on several factors:
91 | * Primitive bean properties are set to their defaults when SQL NULL is returned from the ResultSet. Numeric fields are set to 0 and booleans are set to false. Object bean properties are set to null when SQL NULL is returned. This is the same behavior as the ResultSet get* methods.
92 | *
ResultSet into a List of JavaBeans. This implementation uses reflection and BeanInfo classes to match column names to bean property names. Properties are matched to columns based on several factors:
121 | * Primitive bean properties are set to their defaults when SQL NULL is returned from the ResultSet. Numeric fields are set to 0 and booleans are set to false. Object bean properties are set to null when SQL NULL is returned. This is the same behavior as the ResultSet get* methods.
122 | *
PropertyDescriptor[] for the bean property that matches the column name. If no bean property was found for a column, the position is set to PROPERTY_NOT_FOUND.
344 | *
345 | * @param rsmd
346 | * The ResultSetMetaData containing column information.
347 | * @param props
348 | * The bean property descriptors.
349 | * @throws java.sql.SQLException
350 | * if a database access error occurs
351 | * @return An int[] with column index to property index mappings. The 0th element is meaningless because JDBC column indexing starts at 1.
352 | */
353 | protected int[] mapColumnsToProperties(ResultSetMetaData rsmd, PropertyDescriptor[] props) throws SQLException {
354 |
355 | int cols = rsmd.getColumnCount();
356 | int[] columnToProperty = new int[cols + 1];
357 | Arrays.fill(columnToProperty, PROPERTY_NOT_FOUND);
358 |
359 | for (int col = 1; col <= cols; col++) {
360 | String columnName = rsmd.getColumnLabel(col);
361 | if (null == columnName || 0 == columnName.length()) {
362 | columnName = rsmd.getColumnName(col);
363 | }
364 | String propertyName = columnToPropertyOverrides.get(columnName);
365 | if (propertyName == null) {
366 | propertyName = columnName;
367 | }
368 | for (int i = 0; i < props.length; i++) {
369 |
370 | if (propertyName.equalsIgnoreCase(props[i].getName())) {
371 | columnToProperty[col] = i;
372 | break;
373 | }
374 | }
375 | }
376 |
377 | return columnToProperty;
378 | }
379 |
380 | /**
381 | * Convert a ResultSet column into an object. Simple implementations could just call rs.getObject(index) while more complex implementations could perform type manipulation to match the column's type to the bean property type.
382 | *
383 | * This implementation calls the appropriate ResultSet getter method for the given property type to perform the type conversion. If the property type doesn't match one of the supported ResultSet types, getObject is called.
384 | *
ResultSet currently being processed. It is positioned on a valid row before being passed into this method.
388 | * @param index
389 | * The current column index being processed.
390 | * @param propType
391 | * The bean property type that this column needs to be converted into.
392 | * @throws java.sql.SQLException
393 | * if a database access error occurs
394 | * @return The object from the ResultSet at the given column index after optional type processing or null if the column value was SQL NULL.
395 | */
396 | protected Object processColumn(ResultSet rs, int index, Class propType) throws SQLException {
397 |
398 | if (!propType.isPrimitive() && rs.getObject(index) == null) {
399 | return null;
400 | }
401 |
402 | if (propType.equals(String.class)) {
403 | return rs.getString(index);
404 |
405 | } else if (propType.equals(Integer.TYPE) || propType.equals(Integer.class)) {
406 | return Integer.valueOf(rs.getInt(index));
407 |
408 | } else if (propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) {
409 | return Boolean.valueOf(rs.getBoolean(index));
410 |
411 | } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) {
412 | return Long.valueOf(rs.getLong(index));
413 |
414 | } else if (propType.equals(Double.TYPE) || propType.equals(Double.class)) {
415 | return Double.valueOf(rs.getDouble(index));
416 |
417 | } else if (propType.equals(Float.TYPE) || propType.equals(Float.class)) {
418 | return Float.valueOf(rs.getFloat(index));
419 |
420 | } else if (propType.equals(Short.TYPE) || propType.equals(Short.class)) {
421 | return Short.valueOf(rs.getShort(index));
422 |
423 | } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) {
424 | return Byte.valueOf(rs.getByte(index));
425 |
426 | } else if (propType.equals(Timestamp.class)) {
427 | return rs.getTimestamp(index);
428 |
429 | } else if (propType.equals(SQLXML.class)) {
430 | return rs.getSQLXML(index);
431 |
432 | } else {
433 | return rs.getObject(index);
434 | }
435 |
436 | }
437 |
438 | }
--------------------------------------------------------------------------------
/DbHelper/src/main/java/com/opensource/dbhelp/dbutils/wrappers/SqlNullCheckedResultSet.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
3 | */
4 | package com.opensource.dbhelp.dbutils.wrappers;
5 |
6 | import java.io.InputStream;
7 | import java.io.Reader;
8 | import java.lang.reflect.InvocationHandler;
9 | import java.lang.reflect.Method;
10 | import java.math.BigDecimal;
11 | import java.net.URL;
12 | import java.sql.Blob;
13 | import java.sql.Clob;
14 | import java.sql.Date;
15 | import java.sql.Ref;
16 | import java.sql.ResultSet;
17 | import java.sql.Time;
18 | import java.sql.Timestamp;
19 | import java.util.HashMap;
20 | import java.util.Map;
21 |
22 | import com.opensource.dbhelp.dbutils.ProxyFactory;
23 |
24 | /**
25 | * Decorates a ResultSet with checks for a SQL NULL value on each getXXX method. If a column value obtained by a getXXX method is not SQL NULL, the column value is returned. If the column value is SQL null, an alternate value is returned. The alternate value defaults to the Java null value, which can be overridden for instances of the class.
26 | * 27 | * Usage example:
28 | *
29 | *
30 | * Connection conn = // somehow get a connection
31 | * Statement stmt = conn.createStatement();
32 | * ResultSet rs = stmt.executeQuery("SELECT col1, col2 FROM table1");
33 | *
34 | * // Wrap the result set for SQL NULL checking
35 | * SqlNullCheckedResultSet wrapper = new SqlNullCheckedResultSet(rs);
36 | * wrapper.setNullString("---N/A---"); // Set null string
37 | * wrapper.setNullInt(-999); // Set null integer
38 | * rs = ProxyFactory.instance().createResultSet(wrapper);
39 | *
40 | * while (rs.next()) {
41 | * // If col1 is SQL NULL, value returned will be "---N/A---"
42 | * String col1 = rs.getString("col1");
43 | * // If col2 is SQL NULL, value returned will be -999
44 | * int col2 = rs.getInt("col2");
45 | * }
46 | * rs.close();
47 | *
48 | *
49 | *
50 | *
51 | * 52 | * Unlike some other classes in DbUtils, this class is NOT thread-safe. 53 | *
54 | */ 55 | public class SqlNullCheckedResultSet implements InvocationHandler { 56 | 57 | /** 58 | * Maps normal method names (ie. "getBigDecimal") to the corresponding null Method object (ie. getNullBigDecimal). 59 | */ 60 | private static final MapResultSet in an instance of this class. This is equivalent to:
88 | *
89 | * 90 | * ProxyFactory.instance().createResultSet(new SqlNullCheckedResultSet(rs)); 91 | *92 | * 93 | * @param rs 94 | * The
ResultSet to wrap.
95 | * @return wrapped ResultSet
96 | */
97 | public static ResultSet wrap(ResultSet rs) {
98 | return factory.createResultSet(new SqlNullCheckedResultSet(rs));
99 | }
100 |
101 | private InputStream nullAsciiStream = null;
102 |
103 | private BigDecimal nullBigDecimal = null;
104 |
105 | private InputStream nullBinaryStream = null;
106 |
107 | private Blob nullBlob = null;
108 |
109 | private boolean nullBoolean = false;
110 |
111 | private byte nullByte = 0;
112 |
113 | private byte[] nullBytes = null;
114 |
115 | private Reader nullCharacterStream = null;
116 |
117 | private Clob nullClob = null;
118 |
119 | private Date nullDate = null;
120 |
121 | private double nullDouble = 0.0;
122 |
123 | private float nullFloat = 0.0f;
124 |
125 | private int nullInt = 0;
126 |
127 | private long nullLong = 0;
128 |
129 | private Object nullObject = null;
130 |
131 | private Ref nullRef = null;
132 |
133 | private short nullShort = 0;
134 |
135 | private String nullString = null;
136 |
137 | private Time nullTime = null;
138 |
139 | private Timestamp nullTimestamp = null;
140 |
141 | private URL nullURL = null;
142 |
143 | /**
144 | * The wrapped result.
145 | */
146 | private final ResultSet rs;
147 |
148 | /**
149 | * Constructs a new instance of SqlNullCheckedResultSet to wrap the specified ResultSet.
150 | *
151 | * @param rs
152 | * ResultSet to wrap
153 | */
154 | public SqlNullCheckedResultSet(ResultSet rs) {
155 | super();
156 | this.rs = rs;
157 | }
158 |
159 | /**
160 | * Returns the value when a SQL null is encountered as the result of invoking a getAsciiStream method.
161 | *
162 | * @return the value
163 | */
164 | public InputStream getNullAsciiStream() {
165 | return this.nullAsciiStream;
166 | }
167 |
168 | /**
169 | * Returns the value when a SQL null is encountered as the result of invoking a getBigDecimal method.
170 | *
171 | * @return the value
172 | */
173 | public BigDecimal getNullBigDecimal() {
174 | return this.nullBigDecimal;
175 | }
176 |
177 | /**
178 | * Returns the value when a SQL null is encountered as the result of invoking a getBinaryStream method.
179 | *
180 | * @return the value
181 | */
182 | public InputStream getNullBinaryStream() {
183 | return this.nullBinaryStream;
184 | }
185 |
186 | /**
187 | * Returns the value when a SQL null is encountered as the result of invoking a getBlob method.
188 | *
189 | * @return the value
190 | */
191 | public Blob getNullBlob() {
192 | return this.nullBlob;
193 | }
194 |
195 | /**
196 | * Returns the value when a SQL null is encountered as the result of invoking a getBoolean method.
197 | *
198 | * @return the value
199 | */
200 | public boolean getNullBoolean() {
201 | return this.nullBoolean;
202 | }
203 |
204 | /**
205 | * Returns the value when a SQL null is encountered as the result of invoking a getByte method.
206 | *
207 | * @return the value
208 | */
209 | public byte getNullByte() {
210 | return this.nullByte;
211 | }
212 |
213 | /**
214 | * Returns the value when a SQL null is encountered as the result of invoking a getBytes method.
215 | *
216 | * @return the value
217 | */
218 | public byte[] getNullBytes() {
219 | if (this.nullBytes == null) {
220 | return null;
221 | }
222 | byte[] copy = new byte[this.nullBytes.length];
223 | System.arraycopy(this.nullBytes, 0, copy, 0, this.nullBytes.length);
224 | return copy;
225 | }
226 |
227 | /**
228 | * Returns the value when a SQL null is encountered as the result of invoking a getCharacterStream method.
229 | *
230 | * @return the value
231 | */
232 | public Reader getNullCharacterStream() {
233 | return this.nullCharacterStream;
234 | }
235 |
236 | /**
237 | * Returns the value when a SQL null is encountered as the result of invoking a getClob method.
238 | *
239 | * @return the value
240 | */
241 | public Clob getNullClob() {
242 | return this.nullClob;
243 | }
244 |
245 | /**
246 | * Returns the value when a SQL null is encountered as the result of invoking a getDate method.
247 | *
248 | * @return the value
249 | */
250 | public Date getNullDate() {
251 | return this.nullDate;
252 | }
253 |
254 | /**
255 | * Returns the value when a SQL null is encountered as the result of invoking a getDouble method.
256 | *
257 | * @return the value
258 | */
259 | public double getNullDouble() {
260 | return this.nullDouble;
261 | }
262 |
263 | /**
264 | * Returns the value when a SQL null is encountered as the result of invoking a getFloat method.
265 | *
266 | * @return the value
267 | */
268 | public float getNullFloat() {
269 | return this.nullFloat;
270 | }
271 |
272 | /**
273 | * Returns the value when a SQL null is encountered as the result of invoking a getInt method.
274 | *
275 | * @return the value
276 | */
277 | public int getNullInt() {
278 | return this.nullInt;
279 | }
280 |
281 | /**
282 | * Returns the value when a SQL null is encountered as the result of invoking a getLong method.
283 | *
284 | * @return the value
285 | */
286 | public long getNullLong() {
287 | return this.nullLong;
288 | }
289 |
290 | /**
291 | * Returns the value when a SQL null is encountered as the result of invoking a getObject method.
292 | *
293 | * @return the value
294 | */
295 | public Object getNullObject() {
296 | return this.nullObject;
297 | }
298 |
299 | /**
300 | * Returns the value when a SQL null is encountered as the result of invoking a getRef method.
301 | *
302 | * @return the value
303 | */
304 | public Ref getNullRef() {
305 | return this.nullRef;
306 | }
307 |
308 | /**
309 | * Returns the value when a SQL null is encountered as the result of invoking a getShort method.
310 | *
311 | * @return the value
312 | */
313 | public short getNullShort() {
314 | return this.nullShort;
315 | }
316 |
317 | /**
318 | * Returns the value when a SQL null is encountered as the result of invoking a getString method.
319 | *
320 | * @return the value
321 | */
322 | public String getNullString() {
323 | return this.nullString;
324 | }
325 |
326 | /**
327 | * Returns the value when a SQL null is encountered as the result of invoking a getTime method.
328 | *
329 | * @return the value
330 | */
331 | public Time getNullTime() {
332 | return this.nullTime;
333 | }
334 |
335 | /**
336 | * Returns the value when a SQL null is encountered as the result of invoking a getTimestamp method.
337 | *
338 | * @return the value
339 | */
340 | public Timestamp getNullTimestamp() {
341 | return this.nullTimestamp;
342 | }
343 |
344 | /**
345 | * Returns the value when a SQL null is encountered as the result of invoking a getURL method.
346 | *
347 | * @return the value
348 | */
349 | public URL getNullURL() {
350 | return this.nullURL;
351 | }
352 |
353 | /**
354 | * Intercepts calls to get* methods and calls the appropriate getNull* method if the ResultSet returned null.
355 | *
356 | * @see java.lang.reflect.InvocationHandler#invoke(Object, java.lang.reflect.Method, Object[])
357 | * @param proxy
358 | * Not used; all method calls go to the internal result set
359 | * @param method
360 | * The method to invoke on the result set
361 | * @param args
362 | * The arguments to pass to the result set
363 | * @return null checked result
364 | * @throws Throwable
365 | * error
366 | */
367 | @Override
368 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
369 |
370 | Object result = method.invoke(this.rs, args);
371 |
372 | Method nullMethod = nullMethods.get(method.getName());
373 |
374 | // Check nullMethod != null first so that we don't call wasNull()
375 | // before a true getter method was invoked on the ResultSet.
376 | return (nullMethod != null && this.rs.wasNull()) ? nullMethod.invoke(this, (Object[]) null) : result;
377 | }
378 |
379 | /**
380 | * Sets the value to return when a SQL null is encountered as the result of invoking a getAsciiStream method.
381 | *
382 | * @param nullAsciiStream
383 | * the value
384 | */
385 | public void setNullAsciiStream(InputStream nullAsciiStream) {
386 | this.nullAsciiStream = nullAsciiStream;
387 | }
388 |
389 | /**
390 | * Sets the value to return when a SQL null is encountered as the result of invoking a getBigDecimal method.
391 | *
392 | * @param nullBigDecimal
393 | * the value
394 | */
395 | public void setNullBigDecimal(BigDecimal nullBigDecimal) {
396 | this.nullBigDecimal = nullBigDecimal;
397 | }
398 |
399 | /**
400 | * Sets the value to return when a SQL null is encountered as the result of invoking a getBinaryStream method.
401 | *
402 | * @param nullBinaryStream
403 | * the value
404 | */
405 | public void setNullBinaryStream(InputStream nullBinaryStream) {
406 | this.nullBinaryStream = nullBinaryStream;
407 | }
408 |
409 | /**
410 | * Sets the value to return when a SQL null is encountered as the result of invoking a getBlob method.
411 | *
412 | * @param nullBlob
413 | * the value
414 | */
415 | public void setNullBlob(Blob nullBlob) {
416 | this.nullBlob = nullBlob;
417 | }
418 |
419 | /**
420 | * Sets the value to return when a SQL null is encountered as the result of invoking a getBoolean method.
421 | *
422 | * @param nullBoolean
423 | * the value
424 | */
425 | public void setNullBoolean(boolean nullBoolean) {
426 | this.nullBoolean = nullBoolean;
427 | }
428 |
429 | /**
430 | * Sets the value to return when a SQL null is encountered as the result of invoking a getByte method.
431 | *
432 | * @param nullByte
433 | * the value
434 | */
435 | public void setNullByte(byte nullByte) {
436 | this.nullByte = nullByte;
437 | }
438 |
439 | /**
440 | * Sets the value to return when a SQL null is encountered as the result of invoking a getBytes method.
441 | *
442 | * @param nullBytes
443 | * the value
444 | */
445 | public void setNullBytes(byte[] nullBytes) {
446 | byte[] copy = new byte[nullBytes.length];
447 | System.arraycopy(nullBytes, 0, copy, 0, nullBytes.length);
448 | this.nullBytes = copy;
449 | }
450 |
451 | /**
452 | * Sets the value to return when a SQL null is encountered as the result of invoking a getCharacterStream method.
453 | *
454 | * @param nullCharacterStream
455 | * the value
456 | */
457 | public void setNullCharacterStream(Reader nullCharacterStream) {
458 | this.nullCharacterStream = nullCharacterStream;
459 | }
460 |
461 | /**
462 | * Sets the value to return when a SQL null is encountered as the result of invoking a getClob method.
463 | *
464 | * @param nullClob
465 | * the value
466 | */
467 | public void setNullClob(Clob nullClob) {
468 | this.nullClob = nullClob;
469 | }
470 |
471 | /**
472 | * Sets the value to return when a SQL null is encountered as the result of invoking a getDate method.
473 | *
474 | * @param nullDate
475 | * the value
476 | */
477 | public void setNullDate(Date nullDate) {
478 | this.nullDate = nullDate;
479 | }
480 |
481 | /**
482 | * Sets the value to return when a SQL null is encountered as the result of invoking a getDouble method.
483 | *
484 | * @param nullDouble
485 | * the value
486 | */
487 | public void setNullDouble(double nullDouble) {
488 | this.nullDouble = nullDouble;
489 | }
490 |
491 | /**
492 | * Sets the value to return when a SQL null is encountered as the result of invoking a getFloat method.
493 | *
494 | * @param nullFloat
495 | * the value
496 | */
497 | public void setNullFloat(float nullFloat) {
498 | this.nullFloat = nullFloat;
499 | }
500 |
501 | /**
502 | * Sets the value to return when a SQL null is encountered as the result of invoking a getInt method.
503 | *
504 | * @param nullInt
505 | * the value
506 | */
507 | public void setNullInt(int nullInt) {
508 | this.nullInt = nullInt;
509 | }
510 |
511 | /**
512 | * Sets the value to return when a SQL null is encountered as the result of invoking a getLong method.
513 | *
514 | * @param nullLong
515 | * the value
516 | */
517 | public void setNullLong(long nullLong) {
518 | this.nullLong = nullLong;
519 | }
520 |
521 | /**
522 | * Sets the value to return when a SQL null is encountered as the result of invoking a getObject method.
523 | *
524 | * @param nullObject
525 | * the value
526 | */
527 | public void setNullObject(Object nullObject) {
528 | this.nullObject = nullObject;
529 | }
530 |
531 | /**
532 | * Sets the value to return when a SQL null is encountered as the result of invoking a getRef method.
533 | *
534 | * @param nullRef
535 | * the value
536 | */
537 | public void setNullRef(Ref nullRef) {
538 | this.nullRef = nullRef;
539 | }
540 |
541 | /**
542 | * Sets the value to return when a SQL null is encountered as the result of invoking a getShort method.
543 | *
544 | * @param nullShort
545 | * the value
546 | */
547 | public void setNullShort(short nullShort) {
548 | this.nullShort = nullShort;
549 | }
550 |
551 | /**
552 | * Sets the value to return when a SQL null is encountered as the result of invoking a getString method.
553 | *
554 | * @param nullString
555 | * the value
556 | */
557 | public void setNullString(String nullString) {
558 | this.nullString = nullString;
559 | }
560 |
561 | /**
562 | * Sets the value to return when a SQL null is encountered as the result of invoking a getTime method.
563 | *
564 | * @param nullTime
565 | * the value
566 | */
567 | public void setNullTime(Time nullTime) {
568 | this.nullTime = nullTime;
569 | }
570 |
571 | /**
572 | * Sets the value to return when a SQL null is encountered as the result of invoking a getTimestamp method.
573 | *
574 | * @param nullTimestamp
575 | * the value
576 | */
577 | public void setNullTimestamp(Timestamp nullTimestamp) {
578 | this.nullTimestamp = nullTimestamp;
579 | }
580 |
581 | /**
582 | * Sets the value to return when a SQL null is encountered as the result of invoking a getURL method.
583 | *
584 | * @param nullURL
585 | * the value
586 | */
587 | public void setNullURL(URL nullURL) {
588 | this.nullURL = nullURL;
589 | }
590 |
591 | }
--------------------------------------------------------------------------------