From 9211f4d7fe979c8a6eedca69349b9a4e1e03aba3 Mon Sep 17 00:00:00 2001 From: wxm <115806199+youfanx@users.noreply.github.com> Date: Wed, 21 Feb 2024 17:39:08 +0800 Subject: [PATCH] up rxlib-x --- agent/pom.xml | 2 +- pom.xml | 34 +- rxlib-x/pom.xml | 51 + .../java/org/rx/jdbc/ConnectionPoolKind.java | 13 + .../org/rx/jdbc/ConnectionPoolMXBean.java | 25 + .../java/org/rx/jdbc/DataSourceConfig.java | 16 + .../java/org/rx/jdbc/DriverClassFlag.java | 45 + .../src/main/java/org/rx/jdbc/JdbcConfig.java | 69 ++ .../main/java/org/rx/jdbc/JdbcExecutable.java | 50 + .../main/java/org/rx/jdbc/JdbcExecutor.java | 589 ++++++++++ .../src/main/java/org/rx/jdbc/JdbcUtil.java | 198 ++++ .../org/rx/jdbc/ResultSetProxyObject.java | 1006 +++++++++++++++++ .../java/org/rx/jdbc/SqlStatementType.java | 11 + .../java/org/rx/jdbc/SuperDataSource.java | 32 + .../src/main/java/org/rx/jdbc/SuperJdbc.java | 33 + .../java/org/rx/jdbc/TimeoutEventArgs.java | 13 + .../src/test/java/org/rx/jdbc/TestJdbc.java | 13 + rxlib/pom.xml | 48 +- rxlib/src/test/java/org/rx/bean/TestBean.java | 2 + rxlib/src/test/java/org/rx/core/TestCore.java | 2 +- rxlib/src/test/java/org/rx/io/TestIO.java | 3 + rxlib/src/test/java/org/rx/net/TestSocks.java | 1 + .../java/org/rx/{bean => test}/ErrorBean.java | 2 +- .../java/org/rx/{bean => test}/GirlBean.java | 3 +- .../rx/{bean => test}/HttpUserManager.java | 2 +- .../java/org/rx/{bean => test}/IPerson.java | 2 +- .../org/rx/{bean => test}/PersonBean.java | 5 +- .../org/rx/{bean => test}/PersonGender.java | 3 +- .../org/rx/{bean => test}/UserEventArgs.java | 2 +- .../org/rx/{bean => test}/UserManager.java | 2 +- .../rx/{bean => test}/UserManagerImpl.java | 2 +- rxlib/src/test/java/org/rx/util/TestUtil.java | 3 + 32 files changed, 2247 insertions(+), 35 deletions(-) create mode 100644 rxlib-x/pom.xml create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolKind.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolMXBean.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/DataSourceConfig.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/DriverClassFlag.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/JdbcConfig.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutable.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutor.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/JdbcUtil.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/ResultSetProxyObject.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/SqlStatementType.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/SuperDataSource.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/SuperJdbc.java create mode 100644 rxlib-x/src/main/java/org/rx/jdbc/TimeoutEventArgs.java create mode 100644 rxlib-x/src/test/java/org/rx/jdbc/TestJdbc.java rename rxlib/src/test/java/org/rx/{bean => test}/ErrorBean.java (98%) rename rxlib/src/test/java/org/rx/{bean => test}/GirlBean.java (95%) rename rxlib/src/test/java/org/rx/{bean => test}/HttpUserManager.java (96%) rename rxlib/src/test/java/org/rx/{bean => test}/IPerson.java (79%) rename rxlib/src/test/java/org/rx/{bean => test}/PersonBean.java (93%) rename rxlib/src/test/java/org/rx/{bean => test}/PersonGender.java (86%) rename rxlib/src/test/java/org/rx/{bean => test}/UserEventArgs.java (94%) rename rxlib/src/test/java/org/rx/{bean => test}/UserManager.java (95%) rename rxlib/src/test/java/org/rx/{bean => test}/UserManagerImpl.java (97%) diff --git a/agent/pom.xml b/agent/pom.xml index d503fe0f..2b3ef6a9 100644 --- a/agent/pom.xml +++ b/agent/pom.xml @@ -4,7 +4,7 @@ com.github.rockylomo rx - 2.19.10 + 2.19.12 agent diff --git a/pom.xml b/pom.xml index d46beb1c..d86cf161 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,6 @@ - + 4.0.0 com.github.rockylomo rx @@ -12,9 +13,10 @@ 9 - rxlib - agent daemon + agent + rxlib + rxlib-x rx @@ -54,8 +56,34 @@ 1.8 true false + + 1.18.30 + 5.9.1 + 1.36 + + + org.projectlombok + lombok + ${lombok.version} + provided + + + + org.junit.jupiter + junit-jupiter + ${junit.version} + test + + + org.openjdk.jmh + jmh-generator-annprocess + ${jmh.version} + test + + + diff --git a/rxlib-x/pom.xml b/rxlib-x/pom.xml new file mode 100644 index 00000000..b73520d3 --- /dev/null +++ b/rxlib-x/pom.xml @@ -0,0 +1,51 @@ + + + 4.0.0 + + com.github.rockylomo + rx + 2.19.13-SNAPSHOT + + rxlib-x + jar + rxlib-x + A set of utilities for Java + + + 8 + 8 + UTF-8 + 1.18.30 + + + + + com.github.rockylomo + rxlib + ${parent.version} + + + mysql + mysql-connector-java + 5.1.49 + + + com.zaxxer + HikariCP + 4.0.3 + + + slf4j-api + org.slf4j + + + + + com.alibaba + druid + 1.2.21 + + + diff --git a/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolKind.java b/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolKind.java new file mode 100644 index 00000000..35c795fc --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolKind.java @@ -0,0 +1,13 @@ +package org.rx.jdbc; + +/** + * Created by IntelliJ IDEA. + * + * @author wangxiaoming + * Date: 2019/12/10 + */ +public enum ConnectionPoolKind { + NONE, + HikariCP, + Druid +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolMXBean.java b/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolMXBean.java new file mode 100644 index 00000000..ca1fcb9d --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/ConnectionPoolMXBean.java @@ -0,0 +1,25 @@ +package org.rx.jdbc; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +/** + * Created by IntelliJ IDEA. + * + * @author wangxiaoming + * Date: 2019/12/10 + */ +@NoArgsConstructor +@AllArgsConstructor +@Data +public class ConnectionPoolMXBean implements Serializable { + private static final long serialVersionUID = -8774671998907063174L; + private String name; + private int idleConnections; + private int activeConnections; + private int totalConnections; + private int threadsAwaitingConnection; +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/DataSourceConfig.java b/rxlib-x/src/main/java/org/rx/jdbc/DataSourceConfig.java new file mode 100644 index 00000000..e84e11b8 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/DataSourceConfig.java @@ -0,0 +1,16 @@ +package org.rx.jdbc; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +@NoArgsConstructor +@AllArgsConstructor +@Data +public class DataSourceConfig implements Serializable { + private static final long serialVersionUID = 8722778295417630020L; + String jdbcUrl; + String username, password; +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/DriverClassFlag.java b/rxlib-x/src/main/java/org/rx/jdbc/DriverClassFlag.java new file mode 100644 index 00000000..667d2add --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/DriverClassFlag.java @@ -0,0 +1,45 @@ +package org.rx.jdbc; + +import lombok.Getter; +import org.rx.bean.NEnum; +import org.rx.core.Arrays; +import org.rx.core.Linq; +import org.rx.core.Strings; +import org.rx.exception.InvalidException; + +import java.util.Collections; +import java.util.List; + +/** + * Created by IntelliJ IDEA. + * + * @author wangxiaoming + * Date: 2019/9/2 + */ +@Getter +public enum DriverClassFlag implements NEnum { + MySQL(1, "com.mysql.jdbc.Driver", "jdbc:mysql:"), + PostgreSQL(2, "org.postgresql.Driver", "jdbc:postgresql:"), + Oracle(3, "oracle.jdbc.driver.OracleDriver", "jdbc:oracle:"), + SQLServer(4, "com.microsoft.sqlserver.jdbc.SQLServerDriver", "jdbc:sqlserver:", "jdbc:microsoft:sqlserver:"), + H2(5, "org.h2.Driver", "jdbc:h2:"), + MongoDB(6, "com.xdbc.jdbc.mongodb.MongoDriver", "jdbc:mongodb:"); + + private final int value; + private final String driverClassName; + private final List urlPrefixes; + + DriverClassFlag(int value, String driverClassName, String... urlPrefixes) { + this.value = value; + this.driverClassName = driverClassName; + this.urlPrefixes = Collections.unmodifiableList(Arrays.toList(urlPrefixes)); + } + + public static DriverClassFlag recognize(String jdbcUrl) { + DriverClassFlag flag = Linq.from(DriverClassFlag.values()).firstOrDefault(p -> Linq.from(p.urlPrefixes).any(x -> Strings.startsWithIgnoreCase(jdbcUrl, x))); + if (flag == null) { + throw new InvalidException("Recognize url {} fail", jdbcUrl); + } + return flag; + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/JdbcConfig.java b/rxlib-x/src/main/java/org/rx/jdbc/JdbcConfig.java new file mode 100644 index 00000000..7c47e368 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/JdbcConfig.java @@ -0,0 +1,69 @@ +package org.rx.jdbc; + +import lombok.*; +import org.rx.net.Sockets; + +import java.net.InetSocketAddress; + +@Data +@EqualsAndHashCode(callSuper = true) +public class JdbcConfig extends DataSourceConfig { + private static final long serialVersionUID = 2890340670027176789L; + + private long connectionTimeoutMillis = 30000; + private long idleTimeoutMillis = 60000; + private long maxLifetimeMillis = 1800000; + private int minPoolSize = 10; + private int maxPoolSize = 10; + private ConnectionPoolKind poolKind = ConnectionPoolKind.HikariCP; + + private String poolName; + private boolean enableStreamingResults; + private long executeTimeoutMillis = 30000; + private boolean interruptTimeoutExecution = false; + + @Getter(AccessLevel.PRIVATE) + @Setter(AccessLevel.PRIVATE) + private InetSocketAddress endpoint; + @Getter(AccessLevel.PRIVATE) + @Setter(AccessLevel.PRIVATE) + private String databaseName; + + public void setUrl(String url) { + jdbcUrl = url; + endpoint = null; + databaseName = null; + } + + public InetSocketAddress getEndpointFromUrl() { + if (endpoint == null) { + endpoint = getEndpointFromUrl(jdbcUrl); + } + return endpoint; + } + + public String getDatabaseNameFromUrl() { + if (databaseName == null) { + databaseName = getDatabaseNameFromUrl(jdbcUrl); + } + return databaseName; + } + + public static InetSocketAddress getEndpointFromUrl(String url) { + return Sockets.parseEndpoint(findChars(url, "://", "/", 0)); + } + + public static String getDatabaseNameFromUrl(String url) { + return findChars(url, "/", "?", url.indexOf("://") + 3); + } + + private static String findChars(String url, String begin, String end, int startIndex) { + int s = url.indexOf(begin, startIndex); + if (s == -1) { +// throw new InvalidOperationException("begin flag not found"); + return null; + } + int offset = s + begin.length(), e = url.indexOf(end, offset); + return e == -1 ? url.substring(offset) : url.substring(offset, e); + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutable.java b/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutable.java new file mode 100644 index 00000000..8f080420 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutable.java @@ -0,0 +1,50 @@ +package org.rx.jdbc; + +import lombok.NonNull; +import org.rx.bean.$; +import org.rx.util.function.BiFunc; + +import java.sql.ResultSet; +import java.util.List; + +public interface JdbcExecutable { + ResultSet executeQuery(String sql, Object[] params); + + ResultSet executeQuery(String sql, Object[] params, long executeTimeoutMillis); + + T executeQuery(String sql, Object[] params, BiFunc func); + + T executeQuery(String sql, Object[] params, BiFunc func, long executeTimeoutMillis); + + int execute(String sql, Object[] params); + + int execute(String sql, Object[] params, long executeTimeoutMillis); + + int execute(String sql, Object[] params, int generatedKeys, $ lastInsertId); + + int execute(String sql, Object[] params, long executeTimeoutMillis, int generatedKeys, $ lastInsertId); + + int[] executeBatch(String sql, List batchParams); + + int[] executeBatch(String sql, @NonNull List batchParams, long executeTimeoutMillis); + + ResultSet executeQuery(String sql); + + ResultSet executeQuery(String sql, long executeTimeoutMillis); + + T executeQuery(String sql, BiFunc func); + + T executeQuery(String sql, BiFunc func, long executeTimeoutMillis); + + int execute(String sql); + + int execute(String sql, long executeTimeoutMillis); + + int execute(String sql, int generatedKeys, $ lastInsertId); + + int execute(String sql, long executeTimeoutMillis, int generatedKeys, $ lastInsertId); + + int[] executeBatch(List batchSql); + + int[] executeBatch(@NonNull List batchSql, long executeTimeoutMillis); +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutor.java b/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutor.java new file mode 100644 index 00000000..ae7bdf69 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/JdbcExecutor.java @@ -0,0 +1,589 @@ +package org.rx.jdbc; + +import com.alibaba.druid.pool.DruidDataSource; +import com.mysql.jdbc.MySQLConnection; +import com.mysql.jdbc.StatementImpl; +import com.mysql.jdbc.exceptions.jdbc4.MySQLQueryInterruptedException; +import com.zaxxer.hikari.HikariConfig; +import com.zaxxer.hikari.HikariDataSource; +import com.zaxxer.hikari.HikariPoolMXBean; +import com.zaxxer.hikari.pool.ProxyStatement; +import lombok.*; +import lombok.extern.slf4j.Slf4j; +import org.rx.bean.$; +import org.rx.bean.Tuple; +import org.rx.core.Delegate; +import org.rx.core.StringBuilder; +import org.rx.core.*; +import org.rx.exception.InvalidException; +import org.rx.io.MemoryStream; +import org.rx.util.function.BiFunc; + +import javax.sql.DataSource; +import java.net.InetSocketAddress; +import java.sql.*; +import java.util.List; + +import static org.rx.core.Extends.*; +import static org.rx.core.Sys.*; + +@Slf4j +public class JdbcExecutor extends Disposable implements EventPublisher, JdbcExecutable { + @RequiredArgsConstructor + static class DefaultDataSource extends SuperDataSource { + final DataSourceConfig config; + + @Override + public Connection getConnection() throws SQLException { + return getConnection(config.username, config.password); + } + + @Override + public Connection getConnection(String username, String password) throws SQLException { + return DriverManager.getConnection(config.jdbcUrl, username, password); + } + } + + static final String SPLIT_SYMBOL = ";"; + public static final String STRING_SYMBOL = "`"; + + public static String buildMysqlConnectionString(String host, int port, String database, long connectTimeout, long readWriteTimeout) { + StringBuilder connStr = new StringBuilder("jdbc:mysql://" + host + ":" + port); + if (!Strings.isEmpty(database)) { + connStr.append("/").append(database); + } + connStr.append("?useUnicode=true&characterEncoding=utf-8"); + if (connectTimeout > 0) { + connStr.append("&connectTimeout=").append(String.valueOf(connectTimeout)); + } + if (readWriteTimeout > 0) { + connStr.append("&socketTimeout=").append(String.valueOf(readWriteTimeout)); + } + return connStr.toString(); + } + + public static String buildMysqlConnectionString(InetSocketAddress endpoint, String database, long connectTimeout, long readWriteTimeout) { + return buildMysqlConnectionString(endpoint.getHostString(), endpoint.getPort(), database, connectTimeout, readWriteTimeout); + } + + public static void fillParams(PreparedStatement cmd, String rawSql, Object[] params) throws SQLException { + if (Arrays.isEmpty(params)) { + return; + } + + for (int i = 0; i < params.length; i++) { + int pi = i + 1; + if (!tryAs(params[i], MemoryStream.class, p -> { + p.setPosition(0); + cmd.setBinaryStream(pi, p.getReader()); + })) { + cmd.setObject(pi, params[i]); + } + } + } + + @SneakyThrows + public static long getLastInsertId(Statement statement) { + try (ResultSet resultSet = statement.getGeneratedKeys()) { + if (!resultSet.next()) { +// throw new InvalidOperationException("Generate keys fail"); + return -1; + } + return resultSet.getLong(1); + } + } + + //HikariDataSource Enhancer Connection 冲突 + public static T behaviorClose(T cmd) { + Class type = cmd instanceof PreparedStatement ? PreparedStatement.class : Statement.class; + return (T) proxy(type, (m, p) -> { + if (Reflects.isCloseMethod(m)) { + tryClose(cmd); + tryClose(cmd.getConnection()); + return null; + } + return p.fastInvoke(cmd); + }, true); + } + + @SneakyThrows + public static ResultSet behaviorClose(ResultSet resultSet, Connection conn) { +// resultSet.getStatement().closeOnCompletion(); //无效 + return new ResultSetProxyObject(resultSet, () -> tryClose(conn)); //cmd.getConnection() 是真实连接，需要关闭代理连接 + } + + public final Delegate onExecuteTimeout = Delegate.create(); + @Getter + final DataSourceConfig config; + final DataSource dataSource; + protected boolean closeDataSource; + @Setter + private boolean enableStreamingResults; + @Setter + private long executeTimeoutMillis; + private boolean interruptTimeoutExecution; + + public JdbcExecutor(@NonNull String jdbcUrl, String username, String password) { + this(new DataSourceConfig(jdbcUrl, username, password)); + } + + public JdbcExecutor(@NonNull DataSourceConfig config) { + this.dataSource = createDataSource(this.config = config); + } + + public JdbcExecutor(@NonNull DataSource dataSource) { + this.config = JdbcUtil.getDataSourceConfig(dataSource); + this.dataSource = dataSource; + } + + @SneakyThrows + @Override + protected void freeObjects() { + if (closeDataSource) { + tryClose(dataSource); + } + } + + private DataSource createDataSource(DataSourceConfig config) { + DriverClassFlag driverClassFlag = recognizeUrl(config.getJdbcUrl()); + JdbcConfig jdbcConfig = as(config, JdbcConfig.class); + if (jdbcConfig == null) { + return new DefaultDataSource(config); + } + + try { + closeDataSource = true; + enableStreamingResults = jdbcConfig.isEnableStreamingResults(); + executeTimeoutMillis = jdbcConfig.getExecuteTimeoutMillis(); + interruptTimeoutExecution = jdbcConfig.isInterruptTimeoutExecution(); + ConnectionPoolKind poolKind = jdbcConfig.getPoolKind(); + if (poolKind == null) { + poolKind = ConnectionPoolKind.HikariCP; + } + switch (poolKind) { + case HikariCP: + HikariConfig conf = new HikariConfig(); + conf.setDriverClassName(driverClassFlag.getDriverClassName()); + conf.setJdbcUrl(jdbcConfig.getJdbcUrl()); + conf.setUsername(jdbcConfig.getUsername()); + conf.setPassword(jdbcConfig.getPassword()); + conf.setMinimumIdle(jdbcConfig.getMinPoolSize()); + conf.setMaximumPoolSize(jdbcConfig.getMaxPoolSize()); + conf.setConnectionTimeout(jdbcConfig.getConnectionTimeoutMillis()); + conf.setIdleTimeout(jdbcConfig.getIdleTimeoutMillis()); + conf.setMaxLifetime(jdbcConfig.getMaxLifetimeMillis()); + conf.setLeakDetectionThreshold(60000); +// conf.setScheduledExecutor(); + switch (driverClassFlag) { + case MySQL: + //https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-configuration-properties.html + conf.addDataSourceProperty("useSSL", Boolean.FALSE); + conf.addDataSourceProperty("useCompression", Boolean.FALSE); + conf.addDataSourceProperty("useUnicode", Boolean.TRUE); + conf.addDataSourceProperty("characterEncoding", "utf-8"); + int multiple = 10; + conf.addDataSourceProperty("cachePrepStmts", Boolean.TRUE); + conf.addDataSourceProperty("prepStmtCacheSize", 25 * multiple); + conf.addDataSourceProperty("prepStmtCacheSqlLimit", 256 * multiple); + conf.addDataSourceProperty("cacheResultSetMetadata", Boolean.TRUE); + conf.addDataSourceProperty("metadataCacheSize", 50 * multiple); + conf.addDataSourceProperty("useServerPrepStmts", Boolean.TRUE); + conf.addDataSourceProperty("useLocalSessionState", Boolean.TRUE); + conf.addDataSourceProperty("rewriteBatchedStatements", Boolean.TRUE); + conf.addDataSourceProperty("cacheServerConfiguration", Boolean.TRUE); + conf.addDataSourceProperty("elideSetAutoCommits", Boolean.TRUE); + conf.addDataSourceProperty("maintainTimeStats", Boolean.FALSE); + + conf.addDataSourceProperty("generateSimpleParameterMetadata", Boolean.TRUE); + conf.addDataSourceProperty("netTimeoutForStreamingResults", 0); + //connectionAttributes + break; + } + if (jdbcConfig.getPoolName() != null) { + conf.setPoolName(jdbcConfig.getPoolName()); + } + return new HikariDataSource(conf); + case Druid: + DruidDataSource dataSource = new DruidDataSource(); + dataSource.setDriverClassName(driverClassFlag.getDriverClassName()); + dataSource.setUrl(jdbcConfig.getJdbcUrl()); + dataSource.setUsername(jdbcConfig.getUsername()); + dataSource.setPassword(jdbcConfig.getPassword()); + dataSource.setMinIdle(jdbcConfig.getMinPoolSize()); + dataSource.setInitialSize(dataSource.getMinIdle()); + dataSource.setAsyncInit(true); + dataSource.setMaxActive(jdbcConfig.getMaxPoolSize()); + dataSource.setMaxWait(jdbcConfig.getConnectionTimeoutMillis()); + dataSource.setMinEvictableIdleTimeMillis(jdbcConfig.getIdleTimeoutMillis()); + dataSource.setMaxEvictableIdleTimeMillis(jdbcConfig.getMaxLifetimeMillis()); + if (jdbcConfig.getPoolName() != null) { + dataSource.setName(jdbcConfig.getPoolName()); + } + return dataSource; + default: + return new DefaultDataSource(config); + } + } catch (Exception e) { + throw new InvalidException(config.toString(), e); + } + } + + @SneakyThrows + private DriverClassFlag recognizeUrl(String jdbcUrl) { + DriverClassFlag driverClassFlag = DriverClassFlag.recognize(jdbcUrl); + Class.forName(driverClassFlag.getDriverClassName()); + return driverClassFlag; + } + + public ConnectionPoolMXBean getPoolMXBean() { + ConnectionPoolMXBean poolBean = new ConnectionPoolMXBean(); + if (tryAs(dataSource, HikariDataSource.class, p -> { + poolBean.setName(p.getPoolName()); + HikariPoolMXBean mxBean = p.getHikariPoolMXBean(); + poolBean.setIdleConnections(mxBean.getIdleConnections()); + poolBean.setActiveConnections(mxBean.getActiveConnections()); + poolBean.setTotalConnections(mxBean.getTotalConnections()); + poolBean.setThreadsAwaitingConnection(mxBean.getThreadsAwaitingConnection()); + }) || tryAs(dataSource, DruidDataSource.class, p -> { + poolBean.setName(p.getName()); + poolBean.setActiveConnections(p.getActiveCount()); + poolBean.setTotalConnections(p.getPoolingCount()); + poolBean.setIdleConnections(poolBean.getTotalConnections() - poolBean.getActiveConnections()); + poolBean.setThreadsAwaitingConnection(p.getWaitThreadCount()); + })) ; + return poolBean; + } + + @SneakyThrows + protected Connection createConnection() { + return dataSource.getConnection(); + } + +// @SneakyThrows +// public PreparedStatement prepareStatement(String sql, int generatedKeys) { +// Connection conn = createConnection(); +// return conn.prepareStatement(sql, generatedKeys); +//// return behaviorClose(conn.prepareStatement(sql, generatedKeys)); +// } + + @SneakyThrows + public Tuple getMetaData(String sql) { + try (Connection conn = createConnection(); + PreparedStatement cmd = conn.prepareStatement(sql)) { + return Tuple.of(cmd.getParameterMetaData(), cmd.getMetaData()); + } + } + + public boolean testConnect() { + return ifNull(quietly(() -> { + try (Connection conn = createConnection()) { + return conn.isValid(5); + } + }), false); + } + + @Override + public ResultSet executeQuery(String sql, Object[] params) { + return executeQuery(sql, params, executeTimeoutMillis); + } + + @Override + public ResultSet executeQuery(String sql, Object[] params, long executeTimeoutMillis) { + return executeQuery(sql, params, 0, executeTimeoutMillis); + } + + public ResultSet executeQuery(String sql, Object[] params, int cursorType) { + return executeQuery(sql, params, cursorType, executeTimeoutMillis); + } + + @SneakyThrows + public ResultSet executeQuery(String sql, Object[] params, int cursorType, long executeTimeoutMillis) { + int rsType = ResultSet.TYPE_FORWARD_ONLY; + int rsConcur = ResultSet.CONCUR_READ_ONLY; + int fetchSize = 0; + switch (cursorType) { + //mysql默认 + case ResultSet.TYPE_FORWARD_ONLY: + case ResultSet.CONCUR_READ_ONLY: + if (enableStreamingResults) { + fetchSize = Integer.MIN_VALUE; + } + break; + case ResultSet.TYPE_SCROLL_INSENSITIVE: + rsType = ResultSet.TYPE_SCROLL_INSENSITIVE; + break; + case ResultSet.CONCUR_UPDATABLE: + rsConcur = ResultSet.CONCUR_UPDATABLE; + break; + } + + Connection conn = createConnection(); + PreparedStatement cmd = conn.prepareStatement(sql, rsType, rsConcur); + if (fetchSize != 0) { + cmd.setFetchSize(fetchSize); + } +// log.info("ResultSetType {} + {} + {}", cmd.getResultSetType(), cmd.getResultSetConcurrency(), cmd.getFetchSize()); + TimeoutFuture f = null; + try { + fillParams(cmd, sql, params); +// log.info("sql {} [timeout={}]", cmd.toString(), executeTimeoutMillis); + f = queryTimeout(cmd, executeTimeoutMillis, sql, params); + return behaviorClose(cmd.executeQuery(), conn); + } catch (Throwable e) { + tryClose(conn); + throw handleError(e, sql, params); + } finally { + if (f != null) { + f.cancel(); + } + } + } + + @Override + public T executeQuery(String sql, Object[] params, BiFunc func) { + return executeQuery(sql, params, func, executeTimeoutMillis); + } + + @Override + @SneakyThrows + public T executeQuery(String sql, Object[] params, BiFunc func, long executeTimeoutMillis) { + try (Connection conn = createConnection(); PreparedStatement cmd = conn.prepareStatement(sql)) { + fillParams(cmd, sql, params); + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, params); + try { + return func.invoke(cmd.executeQuery()); + } catch (Throwable e) { + throw handleError(e, sql, params); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } + + @Override + public int execute(String sql, Object[] params) { + return execute(sql, params, executeTimeoutMillis); + } + + @Override + public int execute(String sql, Object[] params, long executeTimeoutMillis) { + return execute(sql, params, executeTimeoutMillis, Statement.NO_GENERATED_KEYS, null); + } + + @Override + public int execute(String sql, Object[] params, int generatedKeys, $ lastInsertId) { + return execute(sql, params, executeTimeoutMillis, generatedKeys, lastInsertId); + } + + @Override + @SneakyThrows + public int execute(String sql, Object[] params, long executeTimeoutMillis, int generatedKeys, $ lastInsertId) { + try (Connection conn = createConnection(); PreparedStatement cmd = conn.prepareStatement(sql, generatedKeys)) { + fillParams(cmd, sql, params); + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, params); + try { + int rowsAffected = cmd.executeUpdate(); + if (generatedKeys == Statement.RETURN_GENERATED_KEYS && lastInsertId != null) { + lastInsertId.v = getLastInsertId(cmd); + } + return rowsAffected; + } catch (Throwable e) { + throw handleError(e, sql, params); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } + + @Override + public int[] executeBatch(String sql, List batchParams) { + return executeBatch(sql, batchParams, executeTimeoutMillis); + } + + @Override + @SneakyThrows + public int[] executeBatch(String sql, @NonNull List batchParams, long executeTimeoutMillis) { + try (Connection conn = createConnection(); PreparedStatement cmd = conn.prepareStatement(sql)) { + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, batchParams.toArray()); + try { + conn.setAutoCommit(false); + for (Object[] params : batchParams) { + fillParams(cmd, sql, params); + cmd.addBatch(); + } + int[] rowsAffected = cmd.executeBatch(); + conn.commit(); + return rowsAffected; + } catch (Throwable e) { + throw handleError(e, sql, Linq.from(batchParams).firstOrDefault()); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } + + TimeoutFuture queryTimeout(Statement cmd, long executeTimeoutMillis, String sql, Object[] params) { + if (executeTimeoutMillis <= 0) { + return null; + } + + //cmd.isClosed() 有锁不能用, mysql cancel 不灵, mysqlStmt.getConnection() 有锁 + return Tasks.timer().setTimeout(() -> { + if (interruptTimeoutExecution) { + Statement realStmt = cmd; + ProxyStatement as = as(realStmt, ProxyStatement.class); + if (as != null) { + realStmt = Reflects.readField(realStmt, "delegate"); + } + if (!tryAs(realStmt, StatementImpl.class, mysqlStmt -> { + MySQLConnection mysqlConn = Reflects.readField(mysqlStmt, "connection"); + String killCmd = JdbcUtil.killCommand(mysqlConn); + log.info("[ExecCancel] {} -> {}", killCmd, sql); + try (Connection conn = createConnection(); Statement stmt = conn.createStatement()) { + stmt.executeUpdate(killCmd); + } catch (MySQLQueryInterruptedException e) { + //ignore + log.info("KILL QUERY FAIL: {}", e.getMessage()); + } + })) { + log.info("[ExecCancel] {}", sql); + cmd.cancel(); + } + } else { + log.info("[ExecTimeout] {}", sql); + } + raiseEvent(onExecuteTimeout, new TimeoutEventArgs(executeTimeoutMillis, sql, params)); + return false; + }, executeTimeoutMillis); + } + + Throwable handleError(Throwable e, String sql, Object[] params) { + tryAs(e, SQLSyntaxErrorException.class, p -> { + String pJson = Strings.EMPTY; + if (!Arrays.isEmpty(params)) { + pJson = toJsonString(params); + } + log.error("SQLSyntax {}\t{}", sql, pJson); + }); + return e; + } + + @Override + public ResultSet executeQuery(String sql) { + return executeQuery(sql, executeTimeoutMillis); + } + + @Override + @SneakyThrows + public ResultSet executeQuery(String sql, long executeTimeoutMillis) { + Connection conn = createConnection(); + Statement cmd = conn.createStatement(); + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, Arrays.EMPTY_OBJECT_ARRAY); + try { + return behaviorClose(conn.createStatement().executeQuery(sql), conn); + } catch (Throwable e) { + tryClose(conn); + throw handleError(e, sql, null); + } finally { + if (f != null) { + f.cancel(); + } + } + } + + @Override + public T executeQuery(String sql, BiFunc func) { + return executeQuery(sql, func, executeTimeoutMillis); + } + + @Override + @SneakyThrows + public T executeQuery(String sql, BiFunc func, long executeTimeoutMillis) { + try (Connection conn = createConnection(); Statement cmd = conn.createStatement()) { + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, Arrays.EMPTY_OBJECT_ARRAY); + try { + return func.invoke(cmd.executeQuery(sql)); + } catch (Throwable e) { + throw handleError(e, sql, null); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } + + @Override + public int execute(String sql) { + return execute(sql, executeTimeoutMillis); + } + + @Override + public int execute(String sql, long executeTimeoutMillis) { + return execute(sql, executeTimeoutMillis, Statement.NO_GENERATED_KEYS, null); + } + + @Override + public int execute(String sql, int generatedKeys, $ lastInsertId) { + return execute(sql, executeTimeoutMillis, generatedKeys, lastInsertId); + } + + @Override + @SneakyThrows + public int execute(String sql, long executeTimeoutMillis, int generatedKeys, $ lastInsertId) { + try (Connection conn = createConnection(); Statement cmd = conn.createStatement()) { + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, sql, null); + try { + int rowsAffected = cmd.executeUpdate(sql, generatedKeys); + if (generatedKeys == Statement.RETURN_GENERATED_KEYS && lastInsertId != null) { + lastInsertId.v = getLastInsertId(cmd); + } + return rowsAffected; + } catch (Throwable e) { + throw handleError(e, sql, null); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } + + @Override + public int[] executeBatch(List batchSql) { + return executeBatch(batchSql, executeTimeoutMillis); + } + + @Override + @SneakyThrows + public int[] executeBatch(@NonNull List batchSql, long executeTimeoutMillis) { + if (batchSql.isEmpty()) { + return Arrays.EMPTY_INT_ARRAY; + } + + try (Connection conn = createConnection(); Statement cmd = conn.createStatement()) { + TimeoutFuture f = queryTimeout(cmd, executeTimeoutMillis, String.join(SPLIT_SYMBOL, batchSql), null); + try { + conn.setAutoCommit(false); + for (String sql : batchSql) { + cmd.addBatch(sql); + } + int[] rowsAffected = cmd.executeBatch(); + conn.commit(); + return rowsAffected; + } catch (Throwable e) { + throw handleError(e, batchSql.get(0), null); + } finally { + if (f != null) { + f.cancel(); + } + } + } + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/JdbcUtil.java b/rxlib-x/src/main/java/org/rx/jdbc/JdbcUtil.java new file mode 100644 index 00000000..eb585950 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/JdbcUtil.java @@ -0,0 +1,198 @@ +package org.rx.jdbc; + +import com.alibaba.druid.pool.DruidDataSource; +import com.mysql.jdbc.MySQLConnection; +import com.mysql.jdbc.StringUtils; +import com.zaxxer.hikari.HikariDataSource; +import com.zaxxer.hikari.pool.ProxyConnection; +import lombok.SneakyThrows; +import org.rx.core.Linq; +import org.rx.core.Reflects; +import org.rx.core.StringBuilder; +import org.rx.core.Strings; +import org.rx.exception.InvalidException; + +import javax.sql.DataSource; +import java.io.InputStream; +import java.io.Reader; +import java.lang.reflect.Field; +import java.math.BigDecimal; +import java.sql.*; +import java.util.Collections; +import java.util.Map; + +import static org.rx.core.Extends.as; + +public class JdbcUtil { + static final String HINT_PREFIX = "/*", HINT_SUFFIX = "*/"; + static final int HINT_PREFIX_AND_SUFFIX_LEN = HINT_PREFIX.length() + HINT_SUFFIX.length(); + static final String HINT_MAP_PAIR = ":", HINT_MAP_DELIMITER = ","; + static final Linq TRANS_KEYWORDS = Linq.from("COMMIT", "ROLLBACK", "SAVEPOINT", "RELEASE"); + + public static String appendHeadHint(String sql, Map headHints) { + return appendHeadHint(sql, Linq.from(headHints.entrySet()).where(p -> p.getValue() != null).toJoinString(HINT_MAP_DELIMITER, p -> { + String val = p.getValue().toString(); + if (Strings.containsAny(val, HINT_MAP_DELIMITER, HINT_MAP_PAIR)) { + throw new InvalidException("Value can not contains ',' & ':'"); + } + return p.getKey() + HINT_MAP_PAIR + val; + })); + } + + public static String appendHeadHint(String sql, String headHint) { + return new StringBuilder(sql.length() + headHint.length() + HINT_PREFIX_AND_SUFFIX_LEN) + .append(HINT_PREFIX).append(headHint).append(HINT_SUFFIX) + .append(sql).toString(); + } + + public static Map getHeadHintAsMap(String sql) { + String hint = getHeadHint(sql); + if (Strings.isEmpty(hint)) { + return Collections.emptyMap(); + } + return Linq.from(Strings.split(hint, HINT_MAP_DELIMITER)).select(p -> { + String[] pair = new String[2]; + int i = p.indexOf(HINT_MAP_PAIR); + if (i == -1) { + pair[0] = p; + return pair; + } + pair[0] = p.substring(0, i); + pair[1] = p.substring(i + 1); + return pair; + }).toMap(p -> p[0], p -> p[1]); + } + + public static String getHeadHint(String sql) { + sql = Strings.stripStart(sql, null); + if (!Strings.startsWith(sql, HINT_PREFIX)) { + return Strings.EMPTY; + } + int e = sql.indexOf(HINT_SUFFIX); + if (e == -1) { + return Strings.EMPTY; + } + return sql.substring(HINT_PREFIX.length(), e); + } + + public static SqlStatementType getStatementType(String query) { + String stripComments = StringUtils.stripComments(query, "'\"", "'\"", true, false, true, true); + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "SELECT")) { + return SqlStatementType.SELECT; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "UPDATE")) { + return SqlStatementType.UPDATE; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "INSERT")) { + return SqlStatementType.INSERT; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "DELETE")) { + return SqlStatementType.DELETE; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "SET") + || TRANS_KEYWORDS.any(p -> StringUtils.startsWithIgnoreCaseAndWs(stripComments, p))) { + return SqlStatementType.SET; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "USE")) { + return SqlStatementType.USE; + } + if (StringUtils.startsWithIgnoreCaseAndWs(stripComments, "SHOW")) { + return SqlStatementType.SHOW; + } + throw new InvalidException("Unknown statement type, {}", query); +// return SqlStatementType.UPDATE; + } + + public static String killCommand(Connection conn) { + ProxyConnection as = as(conn, ProxyConnection.class); + if (as != null) { + conn = Reflects.readField(conn, "delegate"); + } + return killCommand((MySQLConnection) conn); + } + + @SneakyThrows + public static String killCommand(MySQLConnection mysqlConn) { + Long threadId = Reflects.readField(mysqlConn.getIO(), "threadId"); + return "KILL QUERY " + threadId; + } + + public static DataSourceConfig getDataSourceConfig(DataSource ds) { + if (ds instanceof HikariDataSource) { + HikariDataSource hds = (HikariDataSource) ds; + return new DataSourceConfig(hds.getJdbcUrl(), hds.getUsername(), hds.getPassword()); + } + if (ds instanceof DruidDataSource) { + DruidDataSource dhs = ((DruidDataSource) ds); + return new DataSourceConfig(dhs.getUrl(), dhs.getUsername(), dhs.getPassword()); + } + if (ds instanceof JdbcExecutor.DefaultDataSource) { + return ((JdbcExecutor.DefaultDataSource) ds).config; + } + throw new UnsupportedOperationException(String.format("DataSource %s not support", ds.getClass())); + } + + @SneakyThrows + public static String getSqlTypeName(int sqlType) { + for (Field field : Types.class.getFields()) { + if (field.getInt(null) == sqlType) { + return field.getName(); + } + } + return "VARCHAR"; + } + + public static int getSqlType(Object val) { + if (val == null) { + return Types.NULL; + } + + if (val instanceof Boolean) { + return Types.BOOLEAN; + } else if (val instanceof Byte) { + return Types.TINYINT; + } else if (val instanceof Short) { + return Types.SMALLINT; + } else if (val instanceof Integer) { + return Types.INTEGER; + } else if (val instanceof Long) { + return Types.BIGINT; + } else if (val instanceof Float) { + return Types.FLOAT; + } else if (val instanceof Double) { + return Types.DOUBLE; + } else if (val instanceof Time) { + return Types.TIME; + } else if (val instanceof Timestamp) { + return Types.TIMESTAMP; + } else if (val instanceof BigDecimal) { + return Types.DECIMAL; + } else if ( +// val instanceof Date || + val instanceof java.util.Date) { + return Types.DATE; + } else if (val instanceof InputStream) { + return Types.LONGVARBINARY; + } else if (val instanceof Reader) { + return Types.LONGVARCHAR; + } + return Types.VARCHAR; + } + + @SneakyThrows + public static void print(ResultSet resultSet) { + try (ResultSet x = resultSet) { + ResultSetMetaData metaData = x.getMetaData(); + for (int i = 1; i <= metaData.getColumnCount(); i++) { + System.out.print(metaData.getColumnLabel(i) + "\t"); + } + System.out.println(); + while (x.next()) { + for (int i = 1; i <= metaData.getColumnCount(); i++) { + System.out.print(x.getObject(i) + "\t"); + } + System.out.println(); + } + } + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/ResultSetProxyObject.java b/rxlib-x/src/main/java/org/rx/jdbc/ResultSetProxyObject.java new file mode 100644 index 00000000..39dc15f0 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/ResultSetProxyObject.java @@ -0,0 +1,1006 @@ +package org.rx.jdbc; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.SneakyThrows; +import org.rx.exception.TraceHandler; +import org.rx.util.function.Action; +import org.rx.util.function.Func; + +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; +import java.net.URL; +import java.sql.*; +import java.util.Calendar; +import java.util.Map; + +import static org.rx.core.Extends.tryClose; + +@RequiredArgsConstructor +public class ResultSetProxyObject implements ResultSet { + @Getter + final ResultSet raw; + final Action onClose; + ResultSetMetaData rawMetaData; + @Setter + Func metaDataInterceptor; +// @Getter +// @Setter +// Object state; + + @SneakyThrows + public ResultSetMetaData getRawMetaData() { + if (rawMetaData == null) { + rawMetaData = raw.getMetaData(); + } + return rawMetaData; + } + + @Override + public boolean next() throws SQLException { + return raw.next(); + } + + @Override + public void close() throws SQLException { + tryClose(raw); + if (onClose != null) { + try { + onClose.invoke(); + } catch (Throwable e) { + TraceHandler.INSTANCE.log("onClose", e); + } + } + } + + @Override + public boolean wasNull() throws SQLException { + return raw.wasNull(); + } + + @Override + public String getString(int columnIndex) throws SQLException { + return raw.getString(columnIndex); + } + + @Override + public boolean getBoolean(int columnIndex) throws SQLException { + return raw.getBoolean(columnIndex); + } + + @Override + public byte getByte(int columnIndex) throws SQLException { + return raw.getByte(columnIndex); + } + + @Override + public short getShort(int columnIndex) throws SQLException { + return raw.getShort(columnIndex); + } + + @Override + public int getInt(int columnIndex) throws SQLException { + return raw.getInt(columnIndex); + } + + @Override + public long getLong(int columnIndex) throws SQLException { + return raw.getLong(columnIndex); + } + + @Override + public float getFloat(int columnIndex) throws SQLException { + return raw.getFloat(columnIndex); + } + + @Override + public double getDouble(int columnIndex) throws SQLException { + return raw.getDouble(columnIndex); + } + + @Override + public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { + return raw.getBigDecimal(columnIndex, scale); + } + + @Override + public byte[] getBytes(int columnIndex) throws SQLException { + return raw.getBytes(columnIndex); + } + + @Override + public Date getDate(int columnIndex) throws SQLException { + return raw.getDate(columnIndex); + } + + @Override + public Time getTime(int columnIndex) throws SQLException { + return raw.getTime(columnIndex); + } + + @Override + public Timestamp getTimestamp(int columnIndex) throws SQLException { + return raw.getTimestamp(columnIndex); + } + + @Override + public InputStream getAsciiStream(int columnIndex) throws SQLException { + return raw.getAsciiStream(columnIndex); + } + + @Override + public InputStream getUnicodeStream(int columnIndex) throws SQLException { + return raw.getUnicodeStream(columnIndex); + } + + @Override + public InputStream getBinaryStream(int columnIndex) throws SQLException { + return raw.getBinaryStream(columnIndex); + } + + @Override + public String getString(String columnLabel) throws SQLException { + return raw.getString(columnLabel); + } + + @Override + public boolean getBoolean(String columnLabel) throws SQLException { + return raw.getBoolean(columnLabel); + } + + @Override + public byte getByte(String columnLabel) throws SQLException { + return raw.getByte(columnLabel); + } + + @Override + public short getShort(String columnLabel) throws SQLException { + return raw.getShort(columnLabel); + } + + @Override + public int getInt(String columnLabel) throws SQLException { + return raw.getInt(columnLabel); + } + + @Override + public long getLong(String columnLabel) throws SQLException { + return raw.getLong(columnLabel); + } + + @Override + public float getFloat(String columnLabel) throws SQLException { + return raw.getFloat(columnLabel); + } + + @Override + public double getDouble(String columnLabel) throws SQLException { + return raw.getDouble(columnLabel); + } + + @Override + public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException { + return raw.getBigDecimal(columnLabel, scale); + } + + @Override + public byte[] getBytes(String columnLabel) throws SQLException { + return raw.getBytes(columnLabel); + } + + @Override + public Date getDate(String columnLabel) throws SQLException { + return raw.getDate(columnLabel); + } + + @Override + public Time getTime(String columnLabel) throws SQLException { + return raw.getTime(columnLabel); + } + + @Override + public Timestamp getTimestamp(String columnLabel) throws SQLException { + return raw.getTimestamp(columnLabel); + } + + @Override + public InputStream getAsciiStream(String columnLabel) throws SQLException { + return raw.getAsciiStream(columnLabel); + } + + @Override + public InputStream getUnicodeStream(String columnLabel) throws SQLException { + return raw.getUnicodeStream(columnLabel); + } + + @Override + public InputStream getBinaryStream(String columnLabel) throws SQLException { + return raw.getBinaryStream(columnLabel); + } + + @Override + public SQLWarning getWarnings() throws SQLException { + return raw.getWarnings(); + } + + @Override + public void clearWarnings() throws SQLException { + raw.clearWarnings(); + } + + @Override + public String getCursorName() throws SQLException { + return raw.getCursorName(); + } + + @SneakyThrows + @Override + public ResultSetMetaData getMetaData() throws SQLException { + if (metaDataInterceptor == null) { + return raw.getMetaData(); + } + return metaDataInterceptor.invoke(); + } + + @Override + public Object getObject(int columnIndex) throws SQLException { + return raw.getObject(columnIndex); + } + + @Override + public Object getObject(String columnLabel) throws SQLException { + return raw.getObject(columnLabel); + } + + @Override + public int findColumn(String columnLabel) throws SQLException { + return raw.findColumn(columnLabel); + } + + @Override + public Reader getCharacterStream(int columnIndex) throws SQLException { + return raw.getCharacterStream(columnIndex); + } + + @Override + public Reader getCharacterStream(String columnLabel) throws SQLException { + return raw.getCharacterStream(columnLabel); + } + + @Override + public BigDecimal getBigDecimal(int columnIndex) throws SQLException { + return raw.getBigDecimal(columnIndex); + } + + @Override + public BigDecimal getBigDecimal(String columnLabel) throws SQLException { + return raw.getBigDecimal(columnLabel); + } + + @Override + public boolean isBeforeFirst() throws SQLException { + return raw.isBeforeFirst(); + } + + @Override + public boolean isAfterLast() throws SQLException { + return raw.isAfterLast(); + } + + @Override + public boolean isFirst() throws SQLException { + return raw.isFirst(); + } + + @Override + public boolean isLast() throws SQLException { + return raw.isLast(); + } + + @Override + public void beforeFirst() throws SQLException { + raw.beforeFirst(); + } + + @Override + public void afterLast() throws SQLException { + raw.afterLast(); + } + + @Override + public boolean first() throws SQLException { + return raw.first(); + } + + @Override + public boolean last() throws SQLException { + return raw.last(); + } + + @Override + public int getRow() throws SQLException { + return raw.getRow(); + } + + @Override + public boolean absolute(int row) throws SQLException { + return raw.absolute(row); + } + + @Override + public boolean relative(int rows) throws SQLException { + return raw.relative(rows); + } + + @Override + public boolean previous() throws SQLException { + return raw.previous(); + } + + @Override + public void setFetchDirection(int direction) throws SQLException { + raw.setFetchDirection(direction); + } + + @Override + public int getFetchDirection() throws SQLException { + return raw.getFetchDirection(); + } + + @Override + public void setFetchSize(int rows) throws SQLException { + raw.setFetchSize(rows); + } + + @Override + public int getFetchSize() throws SQLException { + return raw.getFetchSize(); + } + + @Override + public int getType() throws SQLException { + return raw.getType(); + } + + @Override + public int getConcurrency() throws SQLException { + return raw.getConcurrency(); + } + + @Override + public boolean rowUpdated() throws SQLException { + return raw.rowUpdated(); + } + + @Override + public boolean rowInserted() throws SQLException { + return raw.rowInserted(); + } + + @Override + public boolean rowDeleted() throws SQLException { + return raw.rowDeleted(); + } + + @Override + public void updateNull(int columnIndex) throws SQLException { + raw.updateNull(columnIndex); + } + + @Override + public void updateBoolean(int columnIndex, boolean x) throws SQLException { + raw.updateBoolean(columnIndex, x); + } + + @Override + public void updateByte(int columnIndex, byte x) throws SQLException { + raw.updateByte(columnIndex, x); + } + + @Override + public void updateShort(int columnIndex, short x) throws SQLException { + raw.updateShort(columnIndex, x); + } + + @Override + public void updateInt(int columnIndex, int x) throws SQLException { + raw.updateInt(columnIndex, x); + } + + @Override + public void updateLong(int columnIndex, long x) throws SQLException { + raw.updateLong(columnIndex, x); + } + + @Override + public void updateFloat(int columnIndex, float x) throws SQLException { + raw.updateFloat(columnIndex, x); + } + + @Override + public void updateDouble(int columnIndex, double x) throws SQLException { + raw.updateDouble(columnIndex, x); + } + + @Override + public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { + raw.updateBigDecimal(columnIndex, x); + } + + @Override + public void updateString(int columnIndex, String x) throws SQLException { + raw.updateString(columnIndex, x); + } + + @Override + public void updateBytes(int columnIndex, byte[] x) throws SQLException { + raw.updateBytes(columnIndex, x); + } + + @Override + public void updateDate(int columnIndex, Date x) throws SQLException { + raw.updateDate(columnIndex, x); + } + + @Override + public void updateTime(int columnIndex, Time x) throws SQLException { + raw.updateTime(columnIndex, x); + } + + @Override + public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException { + raw.updateTimestamp(columnIndex, x); + } + + @Override + public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException { + raw.updateAsciiStream(columnIndex, x, length); + } + + @Override + public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException { + raw.updateBinaryStream(columnIndex, x, length); + } + + @Override + public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException { + raw.updateCharacterStream(columnIndex, x, length); + } + + @Override + public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException { + raw.updateObject(columnIndex, x, scaleOrLength); + } + + @Override + public void updateObject(int columnIndex, Object x) throws SQLException { + raw.updateObject(columnIndex, x); + } + + @Override + public void updateNull(String columnLabel) throws SQLException { + raw.updateNull(columnLabel); + } + + @Override + public void updateBoolean(String columnLabel, boolean x) throws SQLException { + raw.updateBoolean(columnLabel, x); + } + + @Override + public void updateByte(String columnLabel, byte x) throws SQLException { + raw.updateByte(columnLabel, x); + } + + @Override + public void updateShort(String columnLabel, short x) throws SQLException { + raw.updateShort(columnLabel, x); + } + + @Override + public void updateInt(String columnLabel, int x) throws SQLException { + raw.updateInt(columnLabel, x); + } + + @Override + public void updateLong(String columnLabel, long x) throws SQLException { + raw.updateLong(columnLabel, x); + } + + @Override + public void updateFloat(String columnLabel, float x) throws SQLException { + raw.updateFloat(columnLabel, x); + } + + @Override + public void updateDouble(String columnLabel, double x) throws SQLException { + raw.updateDouble(columnLabel, x); + } + + @Override + public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException { + raw.updateBigDecimal(columnLabel, x); + } + + @Override + public void updateString(String columnLabel, String x) throws SQLException { + raw.updateString(columnLabel, x); + } + + @Override + public void updateBytes(String columnLabel, byte[] x) throws SQLException { + raw.updateBytes(columnLabel, x); + } + + @Override + public void updateDate(String columnLabel, Date x) throws SQLException { + raw.updateDate(columnLabel, x); + } + + @Override + public void updateTime(String columnLabel, Time x) throws SQLException { + raw.updateTime(columnLabel, x); + } + + @Override + public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException { + raw.updateTimestamp(columnLabel, x); + } + + @Override + public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException { + raw.updateAsciiStream(columnLabel, x, length); + } + + @Override + public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException { + raw.updateBinaryStream(columnLabel, x, length); + } + + @Override + public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException { + raw.updateCharacterStream(columnLabel, reader, length); + } + + @Override + public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException { + raw.updateObject(columnLabel, x, scaleOrLength); + } + + @Override + public void updateObject(String columnLabel, Object x) throws SQLException { + raw.updateObject(columnLabel, x); + } + + @Override + public void insertRow() throws SQLException { + raw.insertRow(); + } + + @Override + public void updateRow() throws SQLException { + raw.updateRow(); + } + + @Override + public void deleteRow() throws SQLException { + raw.deleteRow(); + } + + @Override + public void refreshRow() throws SQLException { + raw.refreshRow(); + } + + @Override + public void cancelRowUpdates() throws SQLException { + raw.cancelRowUpdates(); + } + + @Override + public void moveToInsertRow() throws SQLException { + raw.moveToInsertRow(); + } + + @Override + public void moveToCurrentRow() throws SQLException { + raw.moveToCurrentRow(); + } + + @Override + public Statement getStatement() throws SQLException { + return raw.getStatement(); + } + + @Override + public Object getObject(int columnIndex, Map> map) throws SQLException { + return raw.getObject(columnIndex, map); + } + + @Override + public Ref getRef(int columnIndex) throws SQLException { + return raw.getRef(columnIndex); + } + + @Override + public Blob getBlob(int columnIndex) throws SQLException { + return raw.getBlob(columnIndex); + } + + @Override + public Clob getClob(int columnIndex) throws SQLException { + return raw.getClob(columnIndex); + } + + @Override + public Array getArray(int columnIndex) throws SQLException { + return raw.getArray(columnIndex); + } + + @Override + public Object getObject(String columnLabel, Map> map) throws SQLException { + return raw.getObject(columnLabel, map); + } + + @Override + public Ref getRef(String columnLabel) throws SQLException { + return raw.getRef(columnLabel); + } + + @Override + public Blob getBlob(String columnLabel) throws SQLException { + return raw.getBlob(columnLabel); + } + + @Override + public Clob getClob(String columnLabel) throws SQLException { + return raw.getClob(columnLabel); + } + + @Override + public Array getArray(String columnLabel) throws SQLException { + return raw.getArray(columnLabel); + } + + @Override + public Date getDate(int columnIndex, Calendar cal) throws SQLException { + return raw.getDate(columnIndex, cal); + } + + @Override + public Date getDate(String columnLabel, Calendar cal) throws SQLException { + return raw.getDate(columnLabel, cal); + } + + @Override + public Time getTime(int columnIndex, Calendar cal) throws SQLException { + return raw.getTime(columnIndex, cal); + } + + @Override + public Time getTime(String columnLabel, Calendar cal) throws SQLException { + return raw.getTime(columnLabel, cal); + } + + @Override + public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException { + return raw.getTimestamp(columnIndex, cal); + } + + @Override + public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException { + return raw.getTimestamp(columnLabel, cal); + } + + @Override + public URL getURL(int columnIndex) throws SQLException { + return raw.getURL(columnIndex); + } + + @Override + public URL getURL(String columnLabel) throws SQLException { + return raw.getURL(columnLabel); + } + + @Override + public void updateRef(int columnIndex, Ref x) throws SQLException { + raw.updateRef(columnIndex, x); + } + + @Override + public void updateRef(String columnLabel, Ref x) throws SQLException { + raw.updateRef(columnLabel, x); + } + + @Override + public void updateBlob(int columnIndex, Blob x) throws SQLException { + raw.updateBlob(columnIndex, x); + } + + @Override + public void updateBlob(String columnLabel, Blob x) throws SQLException { + raw.updateBlob(columnLabel, x); + } + + @Override + public void updateClob(int columnIndex, Clob x) throws SQLException { + raw.updateClob(columnIndex, x); + } + + @Override + public void updateClob(String columnLabel, Clob x) throws SQLException { + raw.updateClob(columnLabel, x); + } + + @Override + public void updateArray(int columnIndex, Array x) throws SQLException { + raw.updateArray(columnIndex, x); + } + + @Override + public void updateArray(String columnLabel, Array x) throws SQLException { + raw.updateArray(columnLabel, x); + } + + @Override + public RowId getRowId(int columnIndex) throws SQLException { + return raw.getRowId(columnIndex); + } + + @Override + public RowId getRowId(String columnLabel) throws SQLException { + return raw.getRowId(columnLabel); + } + + @Override + public void updateRowId(int columnIndex, RowId x) throws SQLException { + raw.updateRowId(columnIndex, x); + } + + @Override + public void updateRowId(String columnLabel, RowId x) throws SQLException { + raw.updateRowId(columnLabel, x); + } + + @Override + public int getHoldability() throws SQLException { + return raw.getHoldability(); + } + + @Override + public boolean isClosed() throws SQLException { + return raw.isClosed(); + } + + @Override + public void updateNString(int columnIndex, String nString) throws SQLException { + raw.updateNString(columnIndex, nString); + } + + @Override + public void updateNString(String columnLabel, String nString) throws SQLException { + raw.updateNString(columnLabel, nString); + } + + @Override + public void updateNClob(int columnIndex, NClob nClob) throws SQLException { + raw.updateNClob(columnIndex, nClob); + } + + @Override + public void updateNClob(String columnLabel, NClob nClob) throws SQLException { + raw.updateNClob(columnLabel, nClob); + } + + @Override + public NClob getNClob(int columnIndex) throws SQLException { + return raw.getNClob(columnIndex); + } + + @Override + public NClob getNClob(String columnLabel) throws SQLException { + return raw.getNClob(columnLabel); + } + + @Override + public SQLXML getSQLXML(int columnIndex) throws SQLException { + return raw.getSQLXML(columnIndex); + } + + @Override + public SQLXML getSQLXML(String columnLabel) throws SQLException { + return raw.getSQLXML(columnLabel); + } + + @Override + public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { + raw.updateSQLXML(columnIndex, xmlObject); + } + + @Override + public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException { + raw.updateSQLXML(columnLabel, xmlObject); + } + + @Override + public String getNString(int columnIndex) throws SQLException { + return raw.getNString(columnIndex); + } + + @Override + public String getNString(String columnLabel) throws SQLException { + return raw.getNString(columnLabel); + } + + @Override + public Reader getNCharacterStream(int columnIndex) throws SQLException { + return raw.getNCharacterStream(columnIndex); + } + + @Override + public Reader getNCharacterStream(String columnLabel) throws SQLException { + return raw.getNCharacterStream(columnLabel); + } + + @Override + public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException { + raw.updateNCharacterStream(columnIndex, x, length); + } + + @Override + public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { + raw.updateNCharacterStream(columnLabel, reader, length); + } + + @Override + public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException { + raw.updateAsciiStream(columnIndex, x, length); + } + + @Override + public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException { + raw.updateBinaryStream(columnIndex, x, length); + } + + @Override + public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException { + raw.updateCharacterStream(columnIndex, x, length); + } + + @Override + public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException { + raw.updateAsciiStream(columnLabel, x, length); + } + + @Override + public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException { + raw.updateBinaryStream(columnLabel, x, length); + } + + @Override + public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { + raw.updateCharacterStream(columnLabel, reader, length); + } + + @Override + public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException { + raw.updateBlob(columnIndex, inputStream, length); + } + + @Override + public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { + raw.updateBlob(columnLabel, inputStream, length); + } + + @Override + public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { + raw.updateClob(columnIndex, reader, length); + } + + @Override + public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { + raw.updateClob(columnLabel, reader, length); + } + + @Override + public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { + raw.updateNClob(columnIndex, reader, length); + } + + @Override + public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { + raw.updateNClob(columnLabel, reader, length); + } + + @Override + public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException { + raw.updateNCharacterStream(columnIndex, x); + } + + @Override + public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException { + raw.updateNCharacterStream(columnLabel, reader); + } + + @Override + public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException { + raw.updateAsciiStream(columnIndex, x); + } + + @Override + public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException { + raw.updateBinaryStream(columnIndex, x); + } + + @Override + public void updateCharacterStream(int columnIndex, Reader x) throws SQLException { + raw.updateCharacterStream(columnIndex, x); + } + + @Override + public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException { + raw.updateAsciiStream(columnLabel, x); + } + + @Override + public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException { + raw.updateBinaryStream(columnLabel, x); + } + + @Override + public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException { + raw.updateCharacterStream(columnLabel, reader); + } + + @Override + public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { + raw.updateBlob(columnIndex, inputStream); + } + + @Override + public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { + raw.updateBlob(columnLabel, inputStream); + } + + @Override + public void updateClob(int columnIndex, Reader reader) throws SQLException { + raw.updateClob(columnIndex, reader); + } + + @Override + public void updateClob(String columnLabel, Reader reader) throws SQLException { + raw.updateClob(columnLabel, reader); + } + + @Override + public void updateNClob(int columnIndex, Reader reader) throws SQLException { + raw.updateNClob(columnIndex, reader); + } + + @Override + public void updateNClob(String columnLabel, Reader reader) throws SQLException { + raw.updateNClob(columnLabel, reader); + } + + @Override + public T getObject(int columnIndex, Class type) throws SQLException { + return raw.getObject(columnIndex, type); + } + + @Override + public T getObject(String columnLabel, Class type) throws SQLException { + return raw.getObject(columnLabel, type); + } + + @Override + public T unwrap(Class iface) throws SQLException { + return raw.unwrap(iface); + } + + @Override + public boolean isWrapperFor(Class iface) throws SQLException { + return raw.isWrapperFor(iface); + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/SqlStatementType.java b/rxlib-x/src/main/java/org/rx/jdbc/SqlStatementType.java new file mode 100644 index 00000000..b8d45d02 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/SqlStatementType.java @@ -0,0 +1,11 @@ +package org.rx.jdbc; + +public enum SqlStatementType { + SELECT, + INSERT, + UPDATE, + DELETE, + USE, + SET, + SHOW +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/SuperDataSource.java b/rxlib-x/src/main/java/org/rx/jdbc/SuperDataSource.java new file mode 100644 index 00000000..859d12bb --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/SuperDataSource.java @@ -0,0 +1,32 @@ +package org.rx.jdbc; + +import javax.sql.DataSource; +import java.io.PrintWriter; +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.util.logging.Logger; + +public abstract class SuperDataSource extends SuperJdbc implements DataSource { + @Override + public PrintWriter getLogWriter() throws SQLException { + return null; + } + + @Override + public void setLogWriter(PrintWriter out) throws SQLException { + } + + @Override + public void setLoginTimeout(int seconds) throws SQLException { + } + + @Override + public int getLoginTimeout() throws SQLException { + return 0; + } + + @Override + public Logger getParentLogger() throws SQLFeatureNotSupportedException { + return Logger.getGlobal(); + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/SuperJdbc.java b/rxlib-x/src/main/java/org/rx/jdbc/SuperJdbc.java new file mode 100644 index 00000000..5d2ea611 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/SuperJdbc.java @@ -0,0 +1,33 @@ +package org.rx.jdbc; + +import org.rx.core.Disposable; + +import java.sql.SQLException; +import java.sql.Wrapper; + +/** + * Created by IntelliJ IDEA. + * User: wangxiaoming + * Date: 2019/8/26 + */ +public abstract class SuperJdbc extends Disposable implements Wrapper { + public static final String CATALOG = "def"; + + @Override + protected void freeObjects() { + } + + @Override + public T unwrap(Class iface) throws SQLException { + try { + return iface.cast(this); + } catch (ClassCastException e) { + throw new SQLException("Unable to unwrap to " + iface); + } + } + + @Override + public boolean isWrapperFor(Class iface) { + return iface.isInstance(this); + } +} diff --git a/rxlib-x/src/main/java/org/rx/jdbc/TimeoutEventArgs.java b/rxlib-x/src/main/java/org/rx/jdbc/TimeoutEventArgs.java new file mode 100644 index 00000000..14677427 --- /dev/null +++ b/rxlib-x/src/main/java/org/rx/jdbc/TimeoutEventArgs.java @@ -0,0 +1,13 @@ +package org.rx.jdbc; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.rx.core.EventArgs; + +@Data +@EqualsAndHashCode(callSuper = true) +public class TimeoutEventArgs extends EventArgs { + final long executeTimeoutMillis; + final String sql; + final Object[] parameters; +} diff --git a/rxlib-x/src/test/java/org/rx/jdbc/TestJdbc.java b/rxlib-x/src/test/java/org/rx/jdbc/TestJdbc.java new file mode 100644 index 00000000..70216328 --- /dev/null +++ b/rxlib-x/src/test/java/org/rx/jdbc/TestJdbc.java @@ -0,0 +1,13 @@ +package org.rx.jdbc; + +import org.junit.jupiter.api.Test; + +public class TestJdbc { + @Test + public void jdbcExec() { + JdbcExecutor d = new JdbcExecutor("jdbc:mysql://", "", "bG1hbG1#"); + JdbcUtil.print(d.executeQuery("select * from emr.t_third_api_record\n" + + "# where third_order_id = 'A01202402201715030375693'\n" + + "order by updated_time desc")); + } +} diff --git a/rxlib/pom.xml b/rxlib/pom.xml index ef96fdc0..3a391975 100644 --- a/rxlib/pom.xml +++ b/rxlib/pom.xml @@ -6,14 +6,13 @@ rx 2.19.13-SNAPSHOT + rxlib jar - rxlib A set of utilities for Java - 1.18.30 2.0.4 1.3.12 2.0.46 @@ -33,7 +32,6 @@ 2.5.14 5.3.20 1.9.7 - 1.36 @@ -59,12 +57,6 @@ ${aspectj.version} - - org.projectlombok - lombok - ${lombok.version} - provided - net.bytebuddy byte-buddy @@ -144,16 +136,42 @@ org.apache.sshd sshd-netty ${sshd.version} + + + netty-handler + io.netty + + + netty-transport + io.netty + + + slf4j-api + org.slf4j + + org.apache.sshd sshd-sftp ${sshd.version} + + + slf4j-api + org.slf4j + + org.apache.sshd sshd-scp ${sshd.version} + + + slf4j-api + org.slf4j + + @@ -186,18 +204,6 @@ javax.activation 1.2.0 - - org.junit.jupiter - junit-jupiter - 5.9.1 - test - - - org.openjdk.jmh - jmh-generator-annprocess - ${jmh.version} - test - org.apache.commons commons-pool2 diff --git a/rxlib/src/test/java/org/rx/bean/TestBean.java b/rxlib/src/test/java/org/rx/bean/TestBean.java index 224d99d8..a7f8abcd 100644 --- a/rxlib/src/test/java/org/rx/bean/TestBean.java +++ b/rxlib/src/test/java/org/rx/bean/TestBean.java @@ -8,6 +8,8 @@ import org.rx.core.StringBuilder; import org.rx.core.Tasks; import org.rx.io.Bytes; +import org.rx.test.PersonBean; +import org.rx.test.PersonGender; import java.util.HashSet; import java.util.Set; diff --git a/rxlib/src/test/java/org/rx/core/TestCore.java b/rxlib/src/test/java/org/rx/core/TestCore.java index aecc9bab..bab9272f 100644 --- a/rxlib/src/test/java/org/rx/core/TestCore.java +++ b/rxlib/src/test/java/org/rx/core/TestCore.java @@ -16,13 +16,13 @@ import org.rx.codec.RSAUtil; import org.rx.core.cache.DiskCache; import org.rx.exception.ApplicationException; -import org.rx.exception.ExceptionLevel; import org.rx.exception.InvalidException; import org.rx.exception.TraceHandler; import org.rx.io.EntityDatabase; import org.rx.io.EntityQueryLambda; import org.rx.io.MemoryStream; import org.rx.net.Sockets; +import org.rx.test.*; import org.rx.third.open.CrcModel; import org.rx.util.function.Func; import org.rx.util.function.TripleAction; diff --git a/rxlib/src/test/java/org/rx/io/TestIO.java b/rxlib/src/test/java/org/rx/io/TestIO.java index 492cc099..ade90b23 100644 --- a/rxlib/src/test/java/org/rx/io/TestIO.java +++ b/rxlib/src/test/java/org/rx/io/TestIO.java @@ -14,6 +14,9 @@ import org.rx.core.*; import org.rx.net.http.HttpClient; import org.rx.net.socks.SocksUser; +import org.rx.test.GirlBean; +import org.rx.test.PersonBean; +import org.rx.test.PersonGender; import java.io.File; import java.io.InputStream; diff --git a/rxlib/src/test/java/org/rx/net/TestSocks.java b/rxlib/src/test/java/org/rx/net/TestSocks.java index 1e18229f..094462a9 100644 --- a/rxlib/src/test/java/org/rx/net/TestSocks.java +++ b/rxlib/src/test/java/org/rx/net/TestSocks.java @@ -59,6 +59,7 @@ import org.rx.net.transport.TcpServer; import org.rx.net.transport.TcpServerConfig; import org.rx.net.transport.UdpClient; +import org.rx.test.*; import org.rx.third.apache.ntp.*; import org.rx.util.function.TripleAction; diff --git a/rxlib/src/test/java/org/rx/bean/ErrorBean.java b/rxlib/src/test/java/org/rx/test/ErrorBean.java similarity index 98% rename from rxlib/src/test/java/org/rx/bean/ErrorBean.java rename to rxlib/src/test/java/org/rx/test/ErrorBean.java index f69d113f..2f4eec1a 100644 --- a/rxlib/src/test/java/org/rx/bean/ErrorBean.java +++ b/rxlib/src/test/java/org/rx/test/ErrorBean.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import lombok.Getter; import lombok.NoArgsConstructor; diff --git a/rxlib/src/test/java/org/rx/bean/GirlBean.java b/rxlib/src/test/java/org/rx/test/GirlBean.java similarity index 95% rename from rxlib/src/test/java/org/rx/bean/GirlBean.java rename to rxlib/src/test/java/org/rx/test/GirlBean.java index 1888b0c8..1a32b98a 100644 --- a/rxlib/src/test/java/org/rx/bean/GirlBean.java +++ b/rxlib/src/test/java/org/rx/test/GirlBean.java @@ -1,8 +1,9 @@ -package org.rx.bean; +package org.rx.test; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import org.rx.bean.ULID; import javax.validation.Valid; import javax.validation.constraints.NotNull; diff --git a/rxlib/src/test/java/org/rx/bean/HttpUserManager.java b/rxlib/src/test/java/org/rx/test/HttpUserManager.java similarity index 96% rename from rxlib/src/test/java/org/rx/bean/HttpUserManager.java rename to rxlib/src/test/java/org/rx/test/HttpUserManager.java index 04bd3a0c..d8e71dc9 100644 --- a/rxlib/src/test/java/org/rx/bean/HttpUserManager.java +++ b/rxlib/src/test/java/org/rx/test/HttpUserManager.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; diff --git a/rxlib/src/test/java/org/rx/bean/IPerson.java b/rxlib/src/test/java/org/rx/test/IPerson.java similarity index 79% rename from rxlib/src/test/java/org/rx/bean/IPerson.java rename to rxlib/src/test/java/org/rx/test/IPerson.java index 3018c4d2..b0ccbd8b 100644 --- a/rxlib/src/test/java/org/rx/bean/IPerson.java +++ b/rxlib/src/test/java/org/rx/test/IPerson.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import org.rx.io.Compressible; diff --git a/rxlib/src/test/java/org/rx/bean/PersonBean.java b/rxlib/src/test/java/org/rx/test/PersonBean.java similarity index 93% rename from rxlib/src/test/java/org/rx/bean/PersonBean.java rename to rxlib/src/test/java/org/rx/test/PersonBean.java index 5ea78afc..ed72e281 100644 --- a/rxlib/src/test/java/org/rx/bean/PersonBean.java +++ b/rxlib/src/test/java/org/rx/test/PersonBean.java @@ -1,10 +1,13 @@ -package org.rx.bean; +package org.rx.test; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import org.rx.annotation.DbColumn; import org.rx.annotation.Metadata; +import org.rx.bean.DateTime; +import org.rx.bean.Decimal; +import org.rx.bean.ULID; import org.rx.core.Arrays; import org.rx.core.Extends; diff --git a/rxlib/src/test/java/org/rx/bean/PersonGender.java b/rxlib/src/test/java/org/rx/test/PersonGender.java similarity index 86% rename from rxlib/src/test/java/org/rx/bean/PersonGender.java rename to rxlib/src/test/java/org/rx/test/PersonGender.java index 72d86d1d..352223ec 100644 --- a/rxlib/src/test/java/org/rx/bean/PersonGender.java +++ b/rxlib/src/test/java/org/rx/test/PersonGender.java @@ -1,8 +1,9 @@ -package org.rx.bean; +package org.rx.test; import lombok.Getter; import lombok.RequiredArgsConstructor; import org.rx.annotation.Metadata; +import org.rx.bean.NEnum; @RequiredArgsConstructor public enum PersonGender implements NEnum { diff --git a/rxlib/src/test/java/org/rx/bean/UserEventArgs.java b/rxlib/src/test/java/org/rx/test/UserEventArgs.java similarity index 94% rename from rxlib/src/test/java/org/rx/bean/UserEventArgs.java rename to rxlib/src/test/java/org/rx/test/UserEventArgs.java index 8f4c92e3..8a99f144 100644 --- a/rxlib/src/test/java/org/rx/bean/UserEventArgs.java +++ b/rxlib/src/test/java/org/rx/test/UserEventArgs.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import lombok.Getter; import lombok.RequiredArgsConstructor; diff --git a/rxlib/src/test/java/org/rx/bean/UserManager.java b/rxlib/src/test/java/org/rx/test/UserManager.java similarity index 95% rename from rxlib/src/test/java/org/rx/bean/UserManager.java rename to rxlib/src/test/java/org/rx/test/UserManager.java index 5dc407d2..a11720ab 100644 --- a/rxlib/src/test/java/org/rx/bean/UserManager.java +++ b/rxlib/src/test/java/org/rx/test/UserManager.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import org.rx.annotation.ErrorCode; import org.rx.core.EventPublisher; diff --git a/rxlib/src/test/java/org/rx/bean/UserManagerImpl.java b/rxlib/src/test/java/org/rx/test/UserManagerImpl.java similarity index 97% rename from rxlib/src/test/java/org/rx/bean/UserManagerImpl.java rename to rxlib/src/test/java/org/rx/test/UserManagerImpl.java index 9b0d46c6..175396fe 100644 --- a/rxlib/src/test/java/org/rx/bean/UserManagerImpl.java +++ b/rxlib/src/test/java/org/rx/test/UserManagerImpl.java @@ -1,4 +1,4 @@ -package org.rx.bean; +package org.rx.test; import lombok.extern.slf4j.Slf4j; import org.rx.core.Delegate; diff --git a/rxlib/src/test/java/org/rx/util/TestUtil.java b/rxlib/src/test/java/org/rx/util/TestUtil.java index 1d28e0fc..ab8cedb6 100644 --- a/rxlib/src/test/java/org/rx/util/TestUtil.java +++ b/rxlib/src/test/java/org/rx/util/TestUtil.java @@ -16,6 +16,9 @@ import org.rx.bean.*; import org.rx.core.*; import org.rx.exception.InvalidException; +import org.rx.test.GirlBean; +import org.rx.test.PersonBean; +import org.rx.test.PersonGender; import org.rx.test.UserStruct; import org.rx.third.guava.CaseFormat;