diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..c1e2c64
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
diff --git a/pom.xml b/pom.xml
index e132180..b89cd4f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
xyz.zhouxy.jdbc
simple-jdbc
- 1.0.0-SNAPSHOT
+ 1.0.0-alpha
8
@@ -18,7 +18,7 @@
xyz.zhouxy.plusone
plusone-commons
- 1.0.0-SNAPSHOT
+ 1.0.0-alpha
@@ -35,28 +35,11 @@
test
+
- com.zaxxer
- HikariCP
- 4.0.3
-
-
- org.slf4j
- slf4j-api
-
-
- test
-
-
- org.postgresql
- postgresql
- 42.3.8
-
-
- org.checkerframework
- checker-qual
-
-
+ com.h2database
+ h2
+ 2.2.224
test
diff --git a/src/main/java/xyz/zhouxy/jdbc/DbRecord.java b/src/main/java/xyz/zhouxy/jdbc/DbRecord.java
index 33af73c..16edef9 100644
--- a/src/main/java/xyz/zhouxy/jdbc/DbRecord.java
+++ b/src/main/java/xyz/zhouxy/jdbc/DbRecord.java
@@ -16,49 +16,78 @@
package xyz.zhouxy.jdbc;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import javax.annotation.Nonnull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
+
import xyz.zhouxy.plusone.commons.collection.AbstractMapWrapper;
+import xyz.zhouxy.plusone.commons.util.AssertTools;
import xyz.zhouxy.plusone.commons.util.OptionalTools;
import xyz.zhouxy.plusone.commons.util.StringTools;
-import java.util.*;
-
+/**
+ * DbRecord
+ *
+ *
+ * 封装 Map，表示一条 DB 记录
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
@Beta
public class DbRecord extends AbstractMapWrapper {
public DbRecord() {
- super(new HashMap<>(), k -> Preconditions.checkArgument(StringTools.isNotBlank(k), "Key must has text."), null);
+ super(new HashMap<>(),
+ k -> AssertTools.checkArgument(StringTools.isNotBlank(k), "Key must has text."),
+ null);
}
public DbRecord(Map map) {
- super(map, k -> Preconditions.checkArgument(StringTools.isNotBlank(k), "Key must has text."), null);
+ super(map,
+ k -> AssertTools.checkArgument(StringTools.isNotBlank(k), "Key must has text."),
+ null);
}
+ /**
+ * 将值强转为 {@link String}，并放在 {@link Optional} 中。
+ * 如果 {@code key} 存在，而值不存在，则返回 {@link Optional#empty()}。
+ */
public Optional getValueAsString(String key) {
return this.getAndConvert(key);
}
- public List getValueAsList(String key) {
- return this.>getAndConvert(key)
- .map(l -> (l instanceof List) ? (List) l : new ArrayList<>(l))
- .orElse(Collections.emptyList());
- }
-
- public Set getValueAsSet(String key) {
- return this.>getAndConvert(key)
- .map(l -> (l instanceof Set) ? (Set) l : new HashSet<>(l))
- .orElse(Collections.emptySet());
- }
-
+ /**
+ * 将值强转为 {@code int}，并放在 {@link OptionalInt} 中。
+ * 如果 {@code key} 存在，而值不存在，则返回 {@link OptionalInt#empty()}。
+ */
+ @Nonnull
public OptionalInt getValueAsInt(String key) {
return OptionalTools.toOptionalInt(this.getAndConvert(key));
}
+ /**
+ * 将值强转为 {@code long}，并放在 {@link OptionalLong} 中。
+ * 如果 {@code key} 存在，而值不存在，则返回 {@link OptionalLong#empty()}。
+ */
+ @Nonnull
public OptionalLong getValueAsLong(String key) {
return OptionalTools.toOptionalLong(this.getAndConvert(key));
}
+ /**
+ * 将值强转为 {@code double}，并放在 {@link OptionalDouble} 中。
+ * 如果 {@code key} 存在，而值不存在，则返回 {@link OptionalDouble#empty()}。
+ */
+ @Nonnull
public OptionalDouble getValueAsDouble(String key) {
return OptionalTools.toOptionalDouble(this.getAndConvert(key));
}
diff --git a/src/main/java/xyz/zhouxy/jdbc/DefaultBeanRowMapper.java b/src/main/java/xyz/zhouxy/jdbc/DefaultBeanRowMapper.java
index f0dcd6b..901ba84 100644
--- a/src/main/java/xyz/zhouxy/jdbc/DefaultBeanRowMapper.java
+++ b/src/main/java/xyz/zhouxy/jdbc/DefaultBeanRowMapper.java
@@ -35,9 +35,28 @@ import javax.annotation.Nullable;
import com.google.common.base.CaseFormat;
+import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
+
+/**
+ * DefaultBeanRowMapper
+ *
+ *
+ * 默认实现的将 {@link ResultSet} 转换为 Java Bean 的 {@link RowMapper}。
+ *
+ *
+ *
+ * NOTE: 使用反射获取类型信息，也是使用反射调用无参构造器和 {@code setter} 方法。
+ * 实际使用中还是建议针对目标类型自定义 {@link RowMapper}。
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
public class DefaultBeanRowMapper implements RowMapper {
+ /** Bean 的无参构造器 */
private final Constructor constructor;
+
+ /** 列名到属性的映射 */
private final Map colPropertyMap;
private DefaultBeanRowMapper(Constructor constructor, Map colPropertyMap) {
@@ -45,10 +64,29 @@ public class DefaultBeanRowMapper implements RowMapper {
this.colPropertyMap = colPropertyMap;
}
+ /**
+ * 创建一个 DefaultBeanRowMapper
+ *
+ * @param Bean 类型
+ * @param beanType Bean 类型
+ * @return DefaultBeanRowMapper 对象
+ * @throws SQLException 创建 DefaultBeanRowMapper 出现错误的异常时抛出
+ */
+ @StaticFactoryMethod(DefaultBeanRowMapper.class)
public static DefaultBeanRowMapper of(Class beanType) throws SQLException {
return of(beanType, null);
}
+ /**
+ * 创建一个 DefaultBeanRowMapper
+ *
+ * @param Bean 类型
+ * @param beanType Bean 类型
+ * @param propertyColMap Bean 字段与列名的映射关系。key 是字段，value 是列名。
+ * @return DefaultBeanRowMapper 对象
+ * @throws SQLException 创建 DefaultBeanRowMapper 出现错误的异常时抛出
+ */
+ @StaticFactoryMethod(DefaultBeanRowMapper.class)
public static DefaultBeanRowMapper of(Class beanType, @Nullable Map propertyColMap)
throws SQLException {
try {
@@ -60,6 +98,7 @@ public class DefaultBeanRowMapper implements RowMapper {
BeanInfo beanInfo = Introspector.getBeanInfo(beanType);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
+ // Bean 的属性名为小驼峰，对应的列名为下划线
Function keyMapper;
if (propertyColMap == null || propertyColMap.isEmpty()) {
keyMapper = p -> CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, p.getName());
@@ -84,13 +123,17 @@ public class DefaultBeanRowMapper implements RowMapper {
}
}
+ /** {@inheritDoc} */
@Override
public T mapRow(ResultSet rs, int rowNumber) throws SQLException {
try {
+ // 调用无参构造器创建实例
T newInstance = this.constructor.newInstance();
ResultSetMetaData metaData = rs.getMetaData();
+ // 遍历结果的每一列
for (int i = 1; i <= metaData.getColumnCount(); i++) {
String colName = metaData.getColumnName(i);
+ // 获取查询结果列名对应的属性，调用 setter
PropertyDescriptor propertyDescriptor = this.colPropertyMap.get(colName);
if (propertyDescriptor != null) {
Method setter = propertyDescriptor.getWriteMethod();
diff --git a/src/main/java/xyz/zhouxy/jdbc/JdbcOperationSupport.java b/src/main/java/xyz/zhouxy/jdbc/JdbcOperationSupport.java
new file mode 100644
index 0000000..b1ae1bd
--- /dev/null
+++ b/src/main/java/xyz/zhouxy/jdbc/JdbcOperationSupport.java
@@ -0,0 +1,471 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed 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
+ *
+ * https://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.
+ */
+
+package xyz.zhouxy.jdbc;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import com.google.common.collect.Lists;
+
+import xyz.zhouxy.plusone.commons.collection.CollectionTools;
+import xyz.zhouxy.plusone.commons.util.AssertTools;
+import xyz.zhouxy.plusone.commons.util.OptionalTools;
+
+/**
+ * JdbcOperationSupport
+ *
+ *
+ * 提供静态方法，封装 JDBC 基础操作
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
+class JdbcOperationSupport {
+
+ // #region - query
+
+ /**
+ * 执行查询，并按照自定义处理逻辑对结果进行处理，将结果转换为指定类型并返回
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param resultHandler 结果处理器，用于处理 {@link ResultSet}
+ */
+ static T query(Connection conn, String sql, Object[] params, ResultHandler resultHandler)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertResultHandlerNotNull(resultHandler);
+ return queryInternal(conn, sql, params, resultHandler);
+ }
+
+ // #endregion
+
+ // #region - queryList
+
+ /**
+ * 执行查询，将查询结果的每一行数据按照指定逻辑进行处理，返回结果列表
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ static List queryList(Connection conn, String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertRowMapperNotNull(rowMapper);
+ return queryListInternal(conn, sql, params, rowMapper);
+ }
+
+ /**
+ * 执行查询，返回结果映射为指定的类型。当结果为单列时使用
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param clazz 将结果映射为指定的类型
+ */
+ static List queryList(Connection conn, String sql, Object[] params, Class clazz)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertClazzNotNull(clazz);
+ return queryListInternal(conn, sql, params, (rs, rowNumber) -> rs.getObject(1, clazz));
+ }
+
+ // #endregion
+
+ // #region - queryFirst
+
+ /**
+ * 执行查询，将查询结果的第一行数据按照指定逻辑进行处理，返回 {@link Optional}
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ static Optional queryFirst(Connection conn, String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertRowMapperNotNull(rowMapper);
+ return queryFirstInternal(conn, sql, params, rowMapper);
+ }
+
+ /**
+ * 查询第一行第一列，并转换为指定类型
+ *
+ * @param 目标类型
+ * @param sql SQL
+ * @param params 参数
+ * @param clazz 目标类型
+ */
+ static Optional queryFirst(Connection conn, String sql, Object[] params, Class clazz)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertClazzNotNull(clazz);
+ return queryFirstInternal(conn, sql, params, (rs, rowNumber) -> rs.getObject(1, clazz));
+ }
+
+ /**
+ * 查询第一行第一列，并转换为字符串
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ */
+ static Optional queryFirstString(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ return queryFirst(conn, sql, params, (rs, rowNumber) -> rs.getString(1));
+ }
+
+ /**
+ * 查询第一行第一列，并转换为整数值
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ */
+ static OptionalInt queryFirstInt(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ Optional result = queryFirst(conn, sql, params, (rs, rowNumber) -> rs.getInt(1));
+ return OptionalTools.toOptionalInt(result);
+ }
+
+ /**
+ * 查询第一行第一列，并转换为长整型
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ */
+ static OptionalLong queryFirstLong(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ Optional result = queryFirst(conn, sql, params, (rs, rowNumber) -> rs.getLong(1));
+ return OptionalTools.toOptionalLong(result);
+ }
+
+ /**
+ * 查询第一行第一列，并转换为双精度浮点型
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ */
+ static OptionalDouble queryFirstDouble(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ Optional result = queryFirst(conn, sql, params, (rs, rowNumber) -> rs.getDouble(1));
+ return OptionalTools.toOptionalDouble(result);
+ }
+
+ /**
+ * 查询第一行第一列，并转换为 {@link BigDecimal}
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ */
+ static Optional queryFirstBigDecimal(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ return queryFirst(conn, sql, params, (rs, rowNumber) -> rs.getBigDecimal(1));
+ }
+
+ // #endregion
+
+ // #region - update & batchUpdate
+
+ /**
+ * 执行更新操作
+ *
+ * @param conn 数据库连接
+ * @param sql 要执行的 SQL
+ * @param params 参数
+ * @return 更新记录数
+ */
+ static int update(Connection conn, String sql, Object[] params)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ fillStatement(stmt, params);
+ return stmt.executeUpdate();
+ }
+ }
+
+ /**
+ * 执行 SQL 并返回生成的 keys
+ *
+ * @param conn 数据库连接
+ * @param sql 要执行的 SQL
+ * @param params 参数
+ * @param rowMapper 行数据映射逻辑
+ *
+ * @return generated keys
+ * @throws SQLException 执行 SQL 遇到异常情况将抛出
+ */
+ static List update(Connection conn, String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ assertRowMapperNotNull(rowMapper);
+ final List result = new ArrayList<>();
+ try (PreparedStatement stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
+ fillStatement(stmt, params);
+ stmt.executeUpdate();
+ try (ResultSet generatedKeys = stmt.getGeneratedKeys();) {
+ int rowNumber = 0;
+ while (generatedKeys.next()) {
+ T e = rowMapper.mapRow(generatedKeys, rowNumber++);
+ result.add(e);
+ }
+ }
+ return result;
+ }
+ }
+
+ /**
+ * 执行批量更新，批量更新数据，返回每条记录更新的行数
+ *
+ * @param conn 数据库连接
+ * @param sql SQL 语句
+ * @param params 参数列表
+ * @param batchSize 每次批量更新的数据量
+ */
+ static List batchUpdate(Connection conn, String sql, Collection params, int batchSize)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+
+ if (params == null || params.isEmpty()) {
+ return Collections.emptyList();
+ }
+ int executeCount = params.size() / batchSize;
+ executeCount = (params.size() % batchSize == 0) ? executeCount : (executeCount + 1);
+ List result = Lists.newArrayListWithCapacity(executeCount);
+
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ int i = 0;
+ for (Object[] ps : params) {
+ i++;
+ fillStatement(stmt, ps);
+ stmt.addBatch();
+ if (i % batchSize == 0 || i >= params.size()) {
+ int[] n = stmt.executeBatch();
+ result.add(n);
+ stmt.clearBatch();
+ }
+ }
+ return result;
+ }
+ }
+
+ /**
+ * 批量更新，返回更新成功的记录行数。发生异常时不中断操作，将异常存入 {@code exceptions} 中
+ *
+ * @param conn 数据库连接
+ * @param sql sql语句
+ * @param params 参数列表
+ * @param batchSize 每次批量更新的数据量
+ * @param exceptions 异常列表，用于记录异常信息
+ */
+ static List batchUpdateAndIgnoreException(Connection conn,
+ String sql, @Nullable Collection params, int batchSize,
+ List exceptions)
+ throws SQLException {
+ assertConnectionNotNull(conn);
+ assertSqlNotNull(sql);
+ AssertTools.checkArgument(CollectionTools.isNotEmpty(exceptions),
+ "The list used to store exceptions should be non-null and empty.");
+ if (params == null || params.isEmpty()) {
+ return Collections.emptyList();
+ }
+ int executeCount = params.size() / batchSize;
+ executeCount = (params.size() % batchSize == 0) ? executeCount : (executeCount + 1);
+ List result = Lists.newArrayListWithCapacity(executeCount);
+
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ int i = 0;
+ for (Object[] ps : params) {
+ i++;
+ fillStatement(stmt, ps);
+ stmt.addBatch();
+ final int batchIndex = i % batchSize;
+ if (batchIndex == 0 || i >= params.size()) {
+ try {
+ int[] n = stmt.executeBatch();
+ result.add(n);
+ stmt.clearBatch();
+ }
+ catch (Exception e) {
+ int n = (i >= params.size() && batchIndex != 0) ? batchIndex : batchSize;
+ result.add(new int[n]);
+ stmt.clearBatch();
+ // 收集异常信息
+ exceptions.add(e);
+ }
+ }
+ }
+ return result;
+ }
+ }
+
+ // #endregion
+
+ // #region - internal
+
+ /**
+ * 执行查询，将查询结果按照指定逻辑进行处理并返回
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param resultHandler 结果处理器，用于处理 {@link ResultSet}
+ */
+ private static T queryInternal(@Nonnull Connection conn,
+ @Nonnull String sql,
+ @Nullable Object[] params,
+ @Nonnull ResultHandler resultHandler)
+ throws SQLException {
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ fillStatement(stmt, params);
+ try (ResultSet rs = stmt.executeQuery()) {
+ return resultHandler.handle(rs);
+ }
+ }
+ }
+
+ /**
+ * 执行查询，将查询结果的每一行数据按照指定逻辑进行处理，返回结果列表
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ private static List queryListInternal(@Nonnull Connection conn,
+ @Nonnull String sql,
+ @Nullable Object[] params,
+ @Nonnull RowMapper rowMapper)
+ throws SQLException {
+ return queryInternal(conn, sql, params, rs -> {
+ List result = new ArrayList<>();
+ int rowNumber = 0;
+ while (rs.next()) {
+ T e = rowMapper.mapRow(rs, rowNumber++);
+ result.add(e);
+ }
+ return result;
+ });
+ }
+
+ /**
+ * 执行查询，将查询结果的第一行数据按照指定逻辑进行处理，返回 {@link Optional}
+ *
+ * @param conn 数据库连接
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper 行数据映射逻辑
+ */
+ private static Optional queryFirstInternal(@Nonnull Connection conn,
+ @Nonnull String sql,
+ @Nullable Object[] params,
+ @Nonnull RowMapper rowMapper)
+ throws SQLException {
+ return queryInternal(conn, sql, params, rs -> {
+ if (rs.next()) {
+ return Optional.ofNullable(rowMapper.mapRow(rs, 0));
+ }
+ return Optional.empty();
+ });
+ }
+
+ // #endregion
+
+ /**
+ * 填充参数
+ */
+ private static void fillStatement(@Nonnull PreparedStatement stmt, @Nullable Object[] params)
+ throws SQLException {
+ if (params != null && params.length > 0) {
+ Object param;
+ for (int i = 0; i < params.length; i++) {
+ param = params[i];
+ if (param instanceof java.sql.Date) {
+ stmt.setDate(i + 1, (java.sql.Date) param);
+ }
+ else if (param instanceof java.sql.Time) {
+ stmt.setTime(i + 1, (java.sql.Time) param);
+ }
+ else if (param instanceof java.sql.Timestamp) {
+ stmt.setTimestamp(i + 1, (java.sql.Timestamp) param);
+ }
+ else {
+ stmt.setObject(i + 1, param);
+ }
+ }
+ }
+ }
+
+ // #region - 参数校验
+
+ private static void assertConnectionNotNull(Connection conn) {
+ AssertTools.checkArgumentNotNull(conn, "The argument \"conn\" could not be null.");
+ }
+
+ private static void assertSqlNotNull(String sql) {
+ AssertTools.checkArgumentNotNull(sql, "The argument \"sql\" could not be null.");
+ }
+
+ private static void assertRowMapperNotNull(RowMapper rowMapper) {
+ AssertTools.checkArgumentNotNull(rowMapper, "The argument \"rowMapper\" could not be null.");
+ }
+
+ private static void assertResultHandlerNotNull(ResultHandler resultHandler) {
+ AssertTools.checkArgumentNotNull(resultHandler, "The argument \"resultHandler\" could not be null.");
+ }
+
+ private static void assertClazzNotNull(Class clazz) {
+ AssertTools.checkArgumentNotNull(clazz, "The argument \"clazz\" could not be null.");
+ }
+
+ // #endregion
+
+ private JdbcOperationSupport() {
+ throw new IllegalStateException("Utility class");
+ }
+}
diff --git a/src/main/java/xyz/zhouxy/jdbc/JdbcOperations.java b/src/main/java/xyz/zhouxy/jdbc/JdbcOperations.java
new file mode 100644
index 0000000..2cfcd97
--- /dev/null
+++ b/src/main/java/xyz/zhouxy/jdbc/JdbcOperations.java
@@ -0,0 +1,359 @@
+package xyz.zhouxy.jdbc;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import javax.annotation.Nullable;
+
+/**
+ * JdbcOperations
+ *
+ *
+ * 定义 JdbcTemplate 的 API
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
+interface JdbcOperations {
+
+ // #region - query
+
+ /**
+ * 执行查询，并按照自定义处理逻辑对结果进行处理，将结果转换为指定类型并返回
+ *
+ * @param sql SQL
+ * @param params 参数
+ * @param resultHandler 结果处理器，用于处理 {@link ResultSet}
+ */
+ T query(String sql, Object[] params, ResultHandler resultHandler)
+ throws SQLException;
+
+ /**
+ * 执行查询，并按照自定义处理逻辑对结果进行处理，将结果转换为指定类型并返回
+ *
+ * @param sql SQL
+ * @param resultHandler 结果处理器，用于处理 {@link ResultSet}
+ */
+ T query(String sql, ResultHandler resultHandler)
+ throws SQLException;
+
+ // #endregion
+
+ // #region - queryList
+
+ /**
+ * 执行查询，将查询结果的每一行数据按照指定逻辑进行处理，返回结果列表
+ *
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ List queryList(String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 执行查询，返回结果映射为指定的类型。当结果为单列时使用
+ *
+ * @param sql SQL
+ * @param params 参数
+ * @param clazz 将结果映射为指定的类型
+ */
+ List queryList(String sql, Object[] params, Class clazz)
+ throws SQLException;
+
+ /**
+ * 执行查询，每一行数据映射为 {@code Map}，返回结果列表
+ *
+ * @param sql SQL
+ * @param params 参数列表
+ */
+ List> queryList(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 执行查询，每一行数据映射为 {@link DbRecord}，返回结果列表
+ *
+ * @param sql SQL
+ * @param params 参数列表
+ */
+ List queryRecordList(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 执行查询，将查询结果的每一行数据按照指定逻辑进行处理，返回结果列表
+ *
+ * @param sql SQL
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ List queryList(String sql, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 执行查询，返回结果映射为指定的类型。当结果为单列时使用
+ *
+ * @param sql SQL
+ * @param clazz 将结果映射为指定的类型
+ */
+ List queryList(String sql, Class clazz)
+ throws SQLException;
+
+ /**
+ * 执行查询，每一行数据映射为 {@code Map}，返回结果列表
+ *
+ * @param sql SQL
+ */
+ List> queryList(String sql)
+ throws SQLException;
+
+ /**
+ * 执行查询，每一行数据映射为 {@link DbRecord}，返回结果列表
+ *
+ * @param sql SQL
+ */
+ List queryRecordList(String sql)
+ throws SQLException;
+
+ // #endregion
+
+ // #region - queryFirst
+
+ /**
+ * 执行查询，将查询结果的第一行数据按照指定逻辑进行处理，返回 {@link Optional}
+ *
+ * @param sql SQL
+ * @param params 参数
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ Optional queryFirst(String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为指定类型
+ *
+ * @param 目标类型
+ * @param sql SQL
+ * @param params 参数
+ * @param clazz 目标类型
+ */
+ Optional queryFirst(String sql, Object[] params, Class clazz)
+ throws SQLException;
+
+ /**
+ * 执行查询，将第一行数据转为 Map
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ Optional> queryFirst(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 执行查询，将第一行数据转为 DbRecord
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ Optional queryFirstRecord(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为字符串
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ Optional queryFirstString(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为整数值
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ OptionalInt queryFirstInt(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为长整型
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ OptionalLong queryFirstLong(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为双精度浮点型
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ OptionalDouble queryFirstDouble(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为 {@link BigDecimal}
+ *
+ * @param sql SQL
+ * @param params 参数
+ */
+ Optional queryFirstBigDecimal(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 执行查询，将查询结果的第一行数据按照指定逻辑进行处理，返回 {@link Optional}
+ *
+ * @param sql SQL
+ * @param rowMapper {@link ResultSet} 中每一行的数据的处理逻辑
+ */
+ Optional queryFirst(String sql, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为指定类型
+ *
+ * @param 目标类型
+ * @param sql SQL
+ * @param clazz 目标类型
+ */
+ Optional queryFirst(String sql, Class clazz)
+ throws SQLException;
+
+ /**
+ * 执行查询，将第一行数据转为 Map
+ *
+ * @param sql SQL
+ */
+ Optional> queryFirst(String sql)
+ throws SQLException;
+
+ /**
+ * 执行查询，将第一行数据转为 DbRecord
+ *
+ * @param sql SQL
+ */
+ Optional queryFirstRecord(String sql)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为字符串
+ *
+ * @param sql SQL
+ */
+ Optional queryFirstString(String sql)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为整数值
+ *
+ * @param sql SQL
+ */
+ OptionalInt queryFirstInt(String sql)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为长整型
+ *
+ * @param sql SQL
+ */
+ OptionalLong queryFirstLong(String sql)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为双精度浮点型
+ *
+ * @param sql SQL
+ */
+ OptionalDouble queryFirstDouble(String sql)
+ throws SQLException;
+
+ /**
+ * 查询第一行第一列，并转换为 {@link BigDecimal}
+ *
+ * @param sql SQL
+ */
+ Optional queryFirstBigDecimal(String sql)
+ throws SQLException;
+
+ // #endregion
+
+ // #region - update & batchUpdate
+
+ /**
+ * 执行更新操作
+ *
+ * @param sql 要执行的 SQL
+ * @param params 参数
+ * @return 更新记录数
+ */
+ int update(String sql, Object[] params)
+ throws SQLException;
+
+ /**
+ * 执行更新操作
+ *
+ * @param sql 要执行的 SQL
+ * @return 更新记录数
+ */
+ int update(String sql)
+ throws SQLException;
+
+ /**
+ * 执行 SQL 并返回生成的 keys
+ *
+ * @param sql 要执行的 SQL
+ * @param params 参数
+ * @param rowMapper 行数据映射逻辑
+ *
+ * @return generated keys
+ * @throws SQLException 执行 SQL 遇到异常情况将抛出
+ */
+ List update(String sql, Object[] params, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 执行 SQL 并返回生成的 keys
+ *
+ * @param sql 要执行的 SQL
+ * @param rowMapper 行数据映射逻辑
+ *
+ * @return generated keys
+ * @throws SQLException 执行 SQL 遇到异常情况将抛出
+ */
+ List update(String sql, RowMapper rowMapper)
+ throws SQLException;
+
+ /**
+ * 执行批量更新，批量更新数据，返回每条记录更新的行数
+ *
+ * @param sql SQL 语句
+ * @param params 参数列表
+ * @param batchSize 每次批量更新的数据量
+ */
+ List batchUpdate(String sql, @Nullable Collection params, int batchSize)
+ throws SQLException;
+
+ /**
+ * 批量更新，返回更新成功的记录行数。发生异常时不中断操作，将异常存入 {@code exceptions} 中
+ *
+ * @param sql sql语句
+ * @param params 参数列表
+ * @param batchSize 每次批量更新的数据量
+ * @param exceptions 异常列表，用于记录异常信息
+ */
+ List batchUpdateAndIgnoreException(String sql, @Nullable Collection params,
+ int batchSize, List exceptions)
+ throws SQLException;
+
+ // #endregion
+}
diff --git a/src/main/java/xyz/zhouxy/jdbc/ParamBuilder.java b/src/main/java/xyz/zhouxy/jdbc/ParamBuilder.java
index 3dccdce..5bf9af0 100644
--- a/src/main/java/xyz/zhouxy/jdbc/ParamBuilder.java
+++ b/src/main/java/xyz/zhouxy/jdbc/ParamBuilder.java
@@ -27,12 +27,21 @@ import java.util.OptionalLong;
import java.util.function.Function;
import java.util.stream.Collectors;
-import com.google.common.base.Preconditions;
-
import xyz.zhouxy.plusone.commons.collection.CollectionTools;
import xyz.zhouxy.plusone.commons.util.ArrayTools;
+import xyz.zhouxy.plusone.commons.util.AssertTools;
import xyz.zhouxy.plusone.commons.util.OptionalTools;
+/**
+ * ParamBuilder
+ *
+ *
+ * JDBC 参数构造器，将数据转换为 {@code Object[]} 类型，以传给 {@link PreparedStatement}
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
public class ParamBuilder {
public static final Object[] EMPTY_OBJECT_ARRAY = {};
@@ -60,8 +69,8 @@ public class ParamBuilder {
}
public static List buildBatchParams(final Collection c, final Function func) {
- Preconditions.checkNotNull(c, "The collection can not be null.");
- Preconditions.checkNotNull(func, "The func can not be null.");
+ AssertTools.checkNotNull(c, "The collection can not be null.");
+ AssertTools.checkNotNull(func, "The func can not be null.");
if (CollectionTools.isEmpty(c)) {
return Collections.emptyList();
}
diff --git a/src/main/java/xyz/zhouxy/jdbc/ResultHandler.java b/src/main/java/xyz/zhouxy/jdbc/ResultHandler.java
index b15019e..ff64392 100644
--- a/src/main/java/xyz/zhouxy/jdbc/ResultHandler.java
+++ b/src/main/java/xyz/zhouxy/jdbc/ResultHandler.java
@@ -19,7 +19,21 @@ package xyz.zhouxy.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
+/**
+ * ResultHandler
+ *
+ *
+ * 处理 {@link ResultSet}
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
@FunctionalInterface
public interface ResultHandler {
+
+ /**
+ * 将 {@link ResultSet} 转换为指定类型的对象
+ */
T handle(ResultSet resultSet) throws SQLException;
}
diff --git a/src/main/java/xyz/zhouxy/jdbc/RowMapper.java b/src/main/java/xyz/zhouxy/jdbc/RowMapper.java
index 404013f..e7b6b33 100644
--- a/src/main/java/xyz/zhouxy/jdbc/RowMapper.java
+++ b/src/main/java/xyz/zhouxy/jdbc/RowMapper.java
@@ -22,10 +22,21 @@ import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
+/**
+ * RowMapper
+ *
+ *
+ * {@link ResultSet} 中每一行数据的处理逻辑。
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
@FunctionalInterface
public interface RowMapper {
T mapRow(ResultSet rs, int rowNumber) throws SQLException;
+ /** 每一行数据转换为 {@link HashMap} */
public static final RowMapper> HASH_MAP_MAPPER = (rs, rowNumber) -> {
Map result = new HashMap<>();
ResultSetMetaData metaData = rs.getMetaData();
@@ -37,13 +48,16 @@ public interface RowMapper {
return result;
};
+ /** 每一行数据转换为 {@link DbRecord} */
public static final RowMapper RECORD_MAPPER =
(rs, rowNumber) -> new DbRecord(HASH_MAP_MAPPER.mapRow(rs, rowNumber));
+ /** 默认实现的将 {@link ResultSet} 转换为 Java Bean 的 {@link RowMapper}。 */
public static RowMapper beanRowMapper(Class beanType) throws SQLException {
return DefaultBeanRowMapper.of(beanType);
}
+ /** 默认实现的将 {@link ResultSet} 转换为 Java Bean 的 {@link RowMapper}。 */
public static RowMapper beanRowMapper(Class beanType, Map propertyColMap)
throws SQLException {
return DefaultBeanRowMapper.of(beanType, propertyColMap);
diff --git a/src/main/java/xyz/zhouxy/jdbc/SimpleJdbcTemplate.java b/src/main/java/xyz/zhouxy/jdbc/SimpleJdbcTemplate.java
index fc44d6c..b8a647b 100644
--- a/src/main/java/xyz/zhouxy/jdbc/SimpleJdbcTemplate.java
+++ b/src/main/java/xyz/zhouxy/jdbc/SimpleJdbcTemplate.java
@@ -18,13 +18,8 @@ package xyz.zhouxy.jdbc;
import java.math.BigDecimal;
import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -36,13 +31,21 @@ import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.sql.DataSource;
-import com.google.common.collect.Lists;
-
-import xyz.zhouxy.plusone.commons.collection.CollectionTools;
+import xyz.zhouxy.plusone.commons.function.ThrowingConsumer;
+import xyz.zhouxy.plusone.commons.function.ThrowingPredicate;
import xyz.zhouxy.plusone.commons.util.AssertTools;
-import xyz.zhouxy.plusone.commons.util.OptionalTools;
-public class SimpleJdbcTemplate {
+/**
+ * SimpleJdbcTemplate
+ *
+ *
+ * 对 JDBC 的简单封装，方便数据库操作，支持事务，支持批量操作，支持自定义结果集映射
+ *
+ *
+ * @author ZhouXY
+ * @since 1.0.0
+ */
+public class SimpleJdbcTemplate implements JdbcOperations {
@Nonnull
private final DataSource dataSource;
@@ -54,17 +57,21 @@ public class SimpleJdbcTemplate {
// #region - query
+ /** {@inheritDoc} */
+ @Override
public T query(String sql, Object[] params, ResultHandler resultHandler)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.query(conn, sql, params, resultHandler);
+ return JdbcOperationSupport.query(conn, sql, params, resultHandler);
}
}
+ /** {@inheritDoc} */
+ @Override
public T query(String sql, ResultHandler resultHandler)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.query(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, resultHandler);
+ return JdbcOperationSupport.query(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, resultHandler);
}
}
@@ -72,59 +79,75 @@ public class SimpleJdbcTemplate {
// #region - queryList
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Object[] params, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, params, rowMapper);
+ return JdbcOperationSupport.queryList(conn, sql, params, rowMapper);
}
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Object[] params, Class clazz)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, params, clazz);
+ return JdbcOperationSupport.queryList(conn, sql, params, clazz);
}
}
+ /** {@inheritDoc} */
+ @Override
public List> queryList(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, params, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryList(conn, sql, params, RowMapper.HASH_MAP_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public List queryRecordList(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, params, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryList(conn, sql, params, RowMapper.RECORD_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
+ return JdbcOperationSupport.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
}
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Class clazz)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
+ return JdbcOperationSupport.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
}
}
+ /** {@inheritDoc} */
+ @Override
public List> queryList(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public List queryRecordList(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryList(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
}
}
@@ -132,129 +155,165 @@ public class SimpleJdbcTemplate {
// #region - queryFirst
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Object[] params, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, params, rowMapper);
+ return JdbcOperationSupport.queryFirst(conn, sql, params, rowMapper);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Object[] params, Class clazz)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, params, clazz);
+ return JdbcOperationSupport.queryFirst(conn, sql, params, clazz);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional> queryFirst(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, params, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryFirst(conn, sql, params, RowMapper.HASH_MAP_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstRecord(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, params, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryFirst(conn, sql, params, RowMapper.RECORD_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstString(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstString(conn, sql, params);
+ return JdbcOperationSupport.queryFirstString(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalInt queryFirstInt(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstInt(conn, sql, params);
+ return JdbcOperationSupport.queryFirstInt(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalLong queryFirstLong(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstLong(conn, sql, params);
+ return JdbcOperationSupport.queryFirstLong(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalDouble queryFirstDouble(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstDouble(conn, sql, params);
+ return JdbcOperationSupport.queryFirstDouble(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstBigDecimal(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstBigDecimal(conn, sql, params);
+ return JdbcOperationSupport.queryFirstBigDecimal(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
+ return JdbcOperationSupport.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Class clazz)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
+ return JdbcOperationSupport.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional> queryFirst(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstRecord(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryFirst(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstString(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstString(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.queryFirstString(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalInt queryFirstInt(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstInt(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.queryFirstInt(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalLong queryFirstLong(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstLong(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.queryFirstLong(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
+ /** {@inheritDoc} */
+ @Override
public OptionalDouble queryFirstDouble(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstDouble(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.queryFirstDouble(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstBigDecimal(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.queryFirstBigDecimal(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.queryFirstBigDecimal(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
@@ -262,66 +321,58 @@ public class SimpleJdbcTemplate {
// #region - update & batchUpdate
+ /** {@inheritDoc} */
+ @Override
public int update(String sql, Object[] params)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.update(conn, sql, params);
+ return JdbcOperationSupport.update(conn, sql, params);
}
}
+ /** {@inheritDoc} */
+ @Override
public int update(String sql)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.update(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
+ return JdbcOperationSupport.update(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY);
}
}
- /**
- * 执行 SQL 并更新后的数据
- *
- * @param sql 要执行的 SQL 语句
- * @param params 参数
- * @param rowMapper 结果映射规则
- *
- * @return 更新的数据
- * @throws SQLException 执行 SQL 遇到异常情况将抛出
- */
+ /** {@inheritDoc} */
+ @Override
public List update(String sql, Object[] params, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.update(conn, sql, params, rowMapper);
+ return JdbcOperationSupport.update(conn, sql, params, rowMapper);
}
}
- /**
- * 执行 SQL 并更新后的数据
- *
- * @param sql 要执行的 SQL 语句
- * @param params 参数
- * @param rowMapper 结果映射规则
- *
- * @return 更新的数据
- * @throws SQLException 执行 SQL 遇到异常情况将抛出
- */
+ /** {@inheritDoc} */
+ @Override
public List update(String sql, RowMapper rowMapper)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.update(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
+ return JdbcOperationSupport.update(conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
}
}
+ /** {@inheritDoc} */
+ @Override
public List batchUpdate(String sql, @Nullable Collection params, int batchSize)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.batchUpdate(conn, sql, params, batchSize);
+ return JdbcOperationSupport.batchUpdate(conn, sql, params, batchSize);
}
}
+ /** {@inheritDoc} */
+ @Override
public List batchUpdateAndIgnoreException(String sql, @Nullable Collection params,
int batchSize, List exceptions)
throws SQLException {
try (Connection conn = this.dataSource.getConnection()) {
- return JdbcExecutor.batchUpdateAndIgnoreException(conn, sql, params, batchSize, exceptions);
+ return JdbcOperationSupport.batchUpdateAndIgnoreException(conn, sql, params, batchSize, exceptions);
}
}
@@ -329,14 +380,26 @@ public class SimpleJdbcTemplate {
// #region - transaction
- public void executeTransaction(@Nonnull final DbOperations operations)
+ /**
+ * 执行事务。如果未发生异常，则提交事务；当有异常发生时，回滚事务
+ *
+ *
+ * operations 中使用 JdbcExecutor 实参进行 JDBC 操作，这些操作在一个连接中
+ *
+ *
+ * @param 异常类型
+ * @param operations 事务操作
+ * @throws SQLException SQL 异常
+ * @throws E 事务中的异常
+ */
+ public void executeTransaction(@Nonnull final ThrowingConsumer operations)
throws SQLException, E {
AssertTools.checkNotNull(operations, "Operations can not be null.");
try (Connection conn = this.dataSource.getConnection()) {
final boolean autoCommit = conn.getAutoCommit();
try {
conn.setAutoCommit(false);
- operations.execute(new JdbcExecutor(conn));
+ operations.accept(new JdbcExecutor(conn));
conn.commit();
}
catch (Exception e) {
@@ -349,7 +412,17 @@ public class SimpleJdbcTemplate {
}
}
- public void commitIfTrue(@Nonnull final PredicateWithThrowable operations)
+ /**
+ * 执行事务。
+ * 如果 {@code operations} 返回 {@code true}，则提交事务；
+ * 如果抛出异常，或返回 {@code false}，则回滚事务
+ *
+ * @param 事务中的异常
+ * @param operations 事务操作
+ * @throws SQLException 数据库异常
+ * @throws E 事务中的异常类型
+ */
+ public void commitIfTrue(@Nonnull final ThrowingPredicate operations)
throws SQLException, E {
AssertTools.checkNotNull(operations, "Operations can not be null.");
try (Connection conn = this.dataSource.getConnection()) {
@@ -373,19 +446,9 @@ public class SimpleJdbcTemplate {
}
}
- @FunctionalInterface
- public interface DbOperations {
- void execute(JdbcExecutor jdbcExecutor) throws E;
- }
-
- @FunctionalInterface
- public interface PredicateWithThrowable {
- boolean test(JdbcExecutor jdbcExecutor) throws E;
- }
-
// #endregion
- public static final class JdbcExecutor {
+ public static final class JdbcExecutor implements JdbcOperations {
private final Connection conn;
@@ -395,492 +458,259 @@ public class SimpleJdbcTemplate {
// #region - query
- public T query(String sql, Object[] params, ResultHandler resulthHandler)
+ /** {@inheritDoc} */
+ @Override
+ public T query(String sql, Object[] params, ResultHandler resultHandler)
throws SQLException {
- return JdbcExecutor.query(this.conn, sql, params, resulthHandler);
+ return JdbcOperationSupport.query(this.conn, sql, params, resultHandler);
}
- public T query(String sql, ResultHandler resulthHandler)
+ /** {@inheritDoc} */
+ @Override
+ public T query(String sql, ResultHandler resultHandler)
throws SQLException {
- return JdbcExecutor.query(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, resulthHandler);
+ return JdbcOperationSupport.query(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, resultHandler);
}
// #endregion
// #region - queryList
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Object[] params, RowMapper rowMapper)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, params, rowMapper);
+ return JdbcOperationSupport.queryList(this.conn, sql, params, rowMapper);
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Object[] params, Class clazz)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, params, clazz);
+ return JdbcOperationSupport.queryList(this.conn, sql, params, clazz);
}
+ /** {@inheritDoc} */
+ @Override
public List> queryList(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, params, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryList(this.conn, sql, params, RowMapper.HASH_MAP_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public List queryRecordList(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, params, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryList(this.conn, sql, params, RowMapper.RECORD_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, RowMapper rowMapper)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
+ return JdbcOperationSupport.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
}
+ /** {@inheritDoc} */
+ @Override
public List queryList(String sql, Class clazz)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
+ return JdbcOperationSupport.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
}
+ /** {@inheritDoc} */
+ @Override
public List> queryList(String sql)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public List queryRecordList(String sql)
throws SQLException {
- return JdbcExecutor.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryList(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
}
// #endregion
// #region - queryFirst
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Object[] params, RowMapper rowMapper)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, params, rowMapper);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, params, rowMapper);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Object[] params, Class clazz)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, params, clazz);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, params, clazz);
}
+ /** {@inheritDoc} */
+ @Override
public Optional> queryFirst(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, params, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, params, RowMapper.HASH_MAP_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstRecord(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, params, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, params, RowMapper.RECORD_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstString(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirstString(this.conn, sql, params);
+ return JdbcOperationSupport.queryFirstString(this.conn, sql, params);
}
+ /** {@inheritDoc} */
+ @Override
public OptionalInt queryFirstInt(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirstInt(this.conn, sql, params);
+ return JdbcOperationSupport.queryFirstInt(this.conn, sql, params);
}
+ /** {@inheritDoc} */
+ @Override
public OptionalLong queryFirstLong(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirstLong(this.conn, sql, params);
+ return JdbcOperationSupport.queryFirstLong(this.conn, sql, params);
}
+ /** {@inheritDoc} */
+ @Override
public OptionalDouble queryFirstDouble(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirstDouble(this.conn, sql, params);
+ return JdbcOperationSupport.queryFirstDouble(this.conn, sql, params);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstBigDecimal(String sql, Object[] params)
throws SQLException {
- return JdbcExecutor.queryFirstBigDecimal(this.conn, sql, params);
+ return JdbcOperationSupport.queryFirstBigDecimal(this.conn, sql, params);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, RowMapper rowMapper)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, rowMapper);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirst(String sql, Class clazz)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, clazz);
}
+ /** {@inheritDoc} */
+ @Override
public Optional> queryFirst(String sql)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.HASH_MAP_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public Optional queryFirstRecord(String sql)
throws SQLException {
- return JdbcExecutor.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
+ return JdbcOperationSupport.queryFirst(this.conn, sql, ParamBuilder.EMPTY_OBJECT_ARRAY, RowMapper.RECORD_MAPPER);
}
+ /** {@inheritDoc} */
+ @Override
public Optional