startTimeHolder = new AtomicReference<>();
212 |
213 | Flux queryExecutionFlux = Flux.empty()
214 | .ofType(Result.class)
215 | .doOnSubscribe(s -> {
216 |
217 | Instant startTime = this.clock.instant();
218 | startTimeHolder.set(startTime);
219 |
220 | String threadName = Thread.currentThread().getName();
221 | long threadId = Thread.currentThread().getId();
222 | executionInfo.setThreadName(threadName);
223 | executionInfo.setThreadId(threadId);
224 |
225 | executionInfo.setCurrentMappedResult(null);
226 |
227 | executionInfo.setProxyEventType(ProxyEventType.BEFORE_QUERY);
228 |
229 | listener.onQueryExecution(executionInfo);
230 | })
231 | .concatWith(flux)
232 | .doOnComplete(() -> {
233 | executionInfo.setSuccess(true);
234 | })
235 | .doOnError(throwable -> {
236 | executionInfo.setThrowable(throwable);
237 | executionInfo.setSuccess(false);
238 | })
239 | .doFinally(signalType -> {
240 |
241 | Instant startTime = startTimeHolder.get();
242 | Instant currentTime = this.clock.instant();
243 |
244 | Duration executionDuration = Duration.between(startTime, currentTime);
245 | executionInfo.setExecuteDuration(executionDuration);
246 |
247 | String threadName = Thread.currentThread().getName();
248 | long threadId = Thread.currentThread().getId();
249 | executionInfo.setThreadName(threadName);
250 | executionInfo.setThreadId(threadId);
251 |
252 | executionInfo.setCurrentMappedResult(null);
253 |
254 | executionInfo.setProxyEventType(ProxyEventType.AFTER_QUERY);
255 |
256 | listener.onQueryExecution(executionInfo);
257 | });
258 |
259 | ProxyFactory proxyFactory = this.proxyConfig.getProxyFactory();
260 |
261 | // return a publisher that returns proxy Result
262 | return Flux.from(queryExecutionFlux)
263 | .flatMap(queryResult -> Mono.just(proxyFactory.createResult(queryResult, executionInfo)));
264 |
265 | }
266 |
267 | public void setClock(Clock clock) {
268 | this.clock = clock;
269 | }
270 | }
271 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/JdkProxyFactory.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Connection;
5 | import io.r2dbc.spi.ConnectionFactory;
6 | import io.r2dbc.spi.Result;
7 | import io.r2dbc.spi.Statement;
8 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionHolder;
9 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
10 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
11 |
12 | import java.lang.reflect.InvocationHandler;
13 | import java.lang.reflect.Method;
14 | import java.lang.reflect.Proxy;
15 |
16 | /**
17 | * ProxyFactory using JDK dynamic proxy.
18 | *
19 | * @author Tadaya Tsuyukubo
20 | */
21 | public class JdkProxyFactory implements ProxyFactory {
22 |
23 | private ProxyConfig proxyConfig;
24 |
25 | @Override
26 | public void setProxyConfig(ProxyConfig proxyConfig) {
27 | this.proxyConfig = proxyConfig;
28 | }
29 |
30 | @Override
31 | public ConnectionFactory createConnectionFactory(ConnectionFactory connectionFactory) {
32 | return (ConnectionFactory) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
33 | new Class[]{ConnectionFactory.class, ProxyObject.class},
34 | new ConnectionFactoryInvocationHandler(connectionFactory, this.proxyConfig));
35 | }
36 |
37 | @Override
38 | public Connection createConnection(Connection connection, ConnectionInfo connectionInfo) {
39 | return (Connection) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
40 | new Class[]{Connection.class, ProxyObject.class, ConnectionHolder.class},
41 | new ConnectionInvocationHandler(connection, connectionInfo, this.proxyConfig));
42 | }
43 |
44 | @Override
45 | public Batch createBatch(Batch batch, ConnectionInfo connectionInfo) {
46 | return (Batch) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
47 | new Class[]{Batch.class, ProxyObject.class, ConnectionHolder.class},
48 | new BatchInvocationHandler(batch, connectionInfo, this.proxyConfig));
49 | }
50 |
51 | @Override
52 | public Statement createStatement(Statement statement, String query, ConnectionInfo connectionInfo) {
53 | return (Statement) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
54 | new Class[]{Statement.class, ProxyObject.class, ConnectionHolder.class},
55 | new StatementInvocationHandler(statement, query, connectionInfo, this.proxyConfig));
56 | }
57 |
58 | @Override
59 | public Result createResult(Result result, QueryExecutionInfo queryExecutionInfo) {
60 | return (Result) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
61 | new Class[]{Result.class, ProxyObject.class, ConnectionHolder.class},
62 | new ResultInvocationHandler(result, queryExecutionInfo, this.proxyConfig));
63 | }
64 |
65 | public static class ConnectionFactoryInvocationHandler implements InvocationHandler {
66 |
67 | private ReactiveConnectionFactoryCallback delegate;
68 |
69 | public ConnectionFactoryInvocationHandler(ConnectionFactory connectionFactory, ProxyConfig proxyConfig) {
70 | this.delegate = new ReactiveConnectionFactoryCallback(connectionFactory, proxyConfig);
71 | }
72 |
73 | @Override
74 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
75 | return delegate.invoke(proxy, method, args);
76 | }
77 | }
78 |
79 | public static class ConnectionInvocationHandler implements InvocationHandler {
80 |
81 | private ReactiveConnectionCallback delegate;
82 |
83 | public ConnectionInvocationHandler(Connection connection, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
84 | this.delegate = new ReactiveConnectionCallback(connection, connectionInfo, proxyConfig);
85 | }
86 |
87 | @Override
88 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
89 | return delegate.invoke(proxy, method, args);
90 | }
91 | }
92 |
93 | public static class BatchInvocationHandler implements InvocationHandler {
94 |
95 | private ReactiveBatchCallback delegate;
96 |
97 | public BatchInvocationHandler(Batch batch, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
98 | this.delegate = new ReactiveBatchCallback(batch, connectionInfo, proxyConfig);
99 | }
100 |
101 | @Override
102 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
103 | return delegate.invoke(proxy, method, args);
104 | }
105 | }
106 |
107 | public static class StatementInvocationHandler implements InvocationHandler {
108 |
109 | private ReactiveStatementCallback delegate;
110 |
111 | public StatementInvocationHandler(Statement statement, String query, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
112 | this.delegate = new ReactiveStatementCallback(statement, query, connectionInfo, proxyConfig);
113 | }
114 |
115 | @Override
116 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
117 | return delegate.invoke(proxy, method, args);
118 | }
119 | }
120 |
121 | public static class ResultInvocationHandler implements InvocationHandler {
122 |
123 | private ReactiveResultCallback delegate;
124 |
125 | public ResultInvocationHandler(Result result, QueryExecutionInfo queryExecutionInfo, ProxyConfig proxyConfig) {
126 | this.delegate = new ReactiveResultCallback(result, queryExecutionInfo, proxyConfig);
127 | }
128 |
129 | @Override
130 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
131 | return delegate.invoke(proxy, method, args);
132 | }
133 | }
134 |
135 | }
136 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ProxyConfig.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import net.ttddyy.dsproxy.r2dbc.core.CompositeProxyExecutionListener;
4 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionIdManager;
5 | import net.ttddyy.dsproxy.r2dbc.core.DefaultConnectionIdManager;
6 | import net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener;
7 |
8 | /**
9 | *
10 | * @author Tadaya Tsuyukubo
11 | */
12 | public class ProxyConfig {
13 |
14 | private CompositeProxyExecutionListener listeners = new CompositeProxyExecutionListener();
15 |
16 | private ConnectionIdManager connectionIdManager = new DefaultConnectionIdManager();
17 |
18 | private ProxyFactory proxyFactory = new JdkProxyFactory();
19 |
20 | {
21 | this.proxyFactory.setProxyConfig(this);
22 | }
23 |
24 | // public ProxyConfig(ProxyFactory proxyFactory) {
25 | // this.proxyFactory = proxyFactory;
26 | // }
27 |
28 | public ProxyFactory getProxyFactory() {
29 | return proxyFactory;
30 | }
31 |
32 | public void setProxyFactory(ProxyFactory proxyFactory) {
33 | this.proxyFactory = proxyFactory;
34 | this.proxyFactory.setProxyConfig(this);
35 | }
36 |
37 | public CompositeProxyExecutionListener getListeners() {
38 | return this.listeners;
39 | }
40 |
41 | public void addListener(ProxyExecutionListener listener) {
42 | this.listeners.add(listener);
43 | }
44 |
45 | public ConnectionIdManager getConnectionIdManager() {
46 | return connectionIdManager;
47 | }
48 |
49 | public void setConnectionIdManager(ConnectionIdManager connectionIdManager) {
50 | this.connectionIdManager = connectionIdManager;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ProxyFactory.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Connection;
5 | import io.r2dbc.spi.ConnectionFactory;
6 | import io.r2dbc.spi.Result;
7 | import io.r2dbc.spi.Statement;
8 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
9 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
10 |
11 | /**
12 | * @author Tadaya Tsuyukubo
13 | */
14 | public interface ProxyFactory {
15 |
16 | void setProxyConfig(ProxyConfig proxyConfig);
17 |
18 | ConnectionFactory createConnectionFactory(ConnectionFactory connectionFactory);
19 |
20 | Connection createConnection(Connection connection, ConnectionInfo connectionInfo);
21 |
22 | Batch createBatch(Batch batch, ConnectionInfo connectionInfo);
23 |
24 | Statement createStatement(Statement statement, String query, ConnectionInfo connectionInfo);
25 |
26 | Result createResult(Result result, QueryExecutionInfo executionInfo);
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ProxyObject.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import net.ttddyy.dsproxy.r2dbc.proxy.ProxyFactory;
4 | import net.ttddyy.dsproxy.r2dbc.proxy.ReactiveBatchCallback;
5 | import net.ttddyy.dsproxy.r2dbc.proxy.ReactiveConnectionCallback;
6 | import net.ttddyy.dsproxy.r2dbc.proxy.ReactiveConnectionFactoryCallback;
7 | import net.ttddyy.dsproxy.r2dbc.proxy.ReactiveStatementCallback;
8 |
9 | /**
10 | * Provide a method to unwrap the original object from proxy object.
11 | *
12 | * Proxy object created by {@link ProxyFactory} implements this interface.
13 | *
14 | * @author Tadaya Tsuyukubo
15 | * @see ProxyFactory
16 | * @see ReactiveConnectionFactoryCallback
17 | * @see ReactiveConnectionCallback
18 | * @see ReactiveBatchCallback
19 | * @see ReactiveStatementCallback
20 | */
21 | public interface ProxyObject {
22 |
23 | /**
24 | * Method to return the source object (ConnectionFactory, Connection, Batch, Statement).
25 | *
26 | * @return source object
27 | */
28 | Object getTarget();
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ProxyUtils.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Connection;
5 | import io.r2dbc.spi.Result;
6 | import io.r2dbc.spi.Statement;
7 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionHolder;
8 |
9 | /**
10 | * @author Tadaya Tsuyukubo
11 | */
12 | public class ProxyUtils {
13 |
14 | private ProxyUtils() {
15 | }
16 |
17 | public static Connection getOriginalConnection(Connection connection) {
18 | if (connection instanceof ProxyObject) {
19 | return (Connection) ((ProxyObject) connection).getTarget();
20 | }
21 | return connection;
22 | }
23 |
24 | public static Connection getOriginalConnection(Batch batch) {
25 | if (batch instanceof ConnectionHolder) {
26 | return ((ConnectionHolder) batch).getOriginalConnection();
27 | }
28 | return null;
29 | }
30 |
31 | public static Connection getOriginalConnection(Statement statement) {
32 | if (statement instanceof ConnectionHolder) {
33 | return ((ConnectionHolder) statement).getOriginalConnection();
34 | }
35 | return null;
36 | }
37 |
38 | public static Connection getOriginalConnection(Result result) {
39 | if (result instanceof ConnectionHolder) {
40 | return ((ConnectionHolder) result).getOriginalConnection();
41 | }
42 | return null;
43 | }
44 |
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ReactiveBatchCallback.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Result;
5 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
6 | import net.ttddyy.dsproxy.r2dbc.core.ExecutionType;
7 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
8 | import net.ttddyy.dsproxy.r2dbc.core.QueryInfo;
9 | import org.reactivestreams.Publisher;
10 |
11 | import java.lang.reflect.Method;
12 | import java.util.ArrayList;
13 | import java.util.List;
14 |
15 | import static java.util.stream.Collectors.toList;
16 |
17 | /**
18 | * Proxy callback for {@link Batch}.
19 | *
20 | * @author Tadaya Tsuyukubo
21 | */
22 | public class ReactiveBatchCallback extends CallbackSupport {
23 |
24 | private Batch batch;
25 |
26 | private ConnectionInfo connectionInfo;
27 | private List queries = new ArrayList<>();
28 |
29 | public ReactiveBatchCallback(Batch batch, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
30 | super(proxyConfig);
31 | this.batch = batch;
32 | this.connectionInfo = connectionInfo;
33 | }
34 |
35 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
36 |
37 | String methodName = method.getName();
38 |
39 | if ("getTarget".equals(methodName)) {
40 | return this.batch;
41 | } else if ("getOriginalConnection".equals(methodName)) {
42 | return this.connectionInfo.getOriginalConnection();
43 | }
44 |
45 | Object result = proceedExecution(method, this.batch, args, this.proxyConfig.getListeners(), this.connectionInfo, null, null);
46 |
47 | if ("add".equals(methodName)) {
48 | this.queries.add((String) args[0]);
49 | } else if ("execute".equals(methodName)) {
50 |
51 | List queryInfoList = this.queries.stream()
52 | .map(QueryInfo::new)
53 | .collect(toList());
54 |
55 | QueryExecutionInfo execInfo = new QueryExecutionInfo();
56 | execInfo.setType(ExecutionType.BATCH);
57 | execInfo.setQueries(queryInfoList);
58 | execInfo.setBatchSize(this.queries.size());
59 | execInfo.setMethod(method);
60 | execInfo.setMethodArgs(args);
61 | execInfo.setConnectionInfo(this.connectionInfo);
62 |
63 | // API defines "execute()" returns a publisher
64 | Publisher publisher = (Publisher) result;
65 |
66 | return interceptQueryExecution(publisher, execInfo);
67 | }
68 |
69 | return result;
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ReactiveConnectionCallback.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Connection;
5 | import io.r2dbc.spi.Statement;
6 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
7 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
8 |
9 | import java.lang.reflect.Method;
10 | import java.util.function.Consumer;
11 |
12 | /**
13 | * Proxy callback for {@link Connection}.
14 | *
15 | * @author Tadaya Tsuyukubo
16 | */
17 | public class ReactiveConnectionCallback extends CallbackSupport {
18 |
19 | private Connection connection;
20 | private ConnectionInfo connectionInfo;
21 |
22 | public ReactiveConnectionCallback(Connection connection, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
23 | super(proxyConfig);
24 | this.connection = connection;
25 | this.connectionInfo = connectionInfo;
26 | }
27 |
28 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
29 |
30 | String methodName = method.getName();
31 |
32 | if ("getTarget".equals(methodName)) {
33 | return this.connection;
34 | } else if ("getOriginalConnection".equals(methodName)) {
35 | return this.connection;
36 | }
37 |
38 | Consumer onComplete = null;
39 |
40 | // since these methods return Publisher pass the callback for doOnComplete().
41 | if ("beginTransaction".equals(methodName)) {
42 | onComplete = executionInfo -> {
43 | executionInfo.getConnectionInfo().incrementTransactionCount();
44 | };
45 | } else if ("commitTransaction".equals(methodName)) {
46 | onComplete = executionInfo -> {
47 | executionInfo.getConnectionInfo().incrementCommitCount();
48 | };
49 | } else if ("rollbackTransaction".equals(methodName)) {
50 | onComplete = executionInfo -> {
51 | executionInfo.getConnectionInfo().incrementRollbackCount();
52 | };
53 | } else if ("close".equals(methodName)) {
54 | onComplete = executionInfo -> {
55 | executionInfo.getConnectionInfo().setClosed(true);
56 | };
57 | }
58 | // TODO: createSavepoint, releaseSavepoint, rollbackTransactionToSavepoint
59 |
60 | Object result = proceedExecution(method, this.connection, args, this.proxyConfig.getListeners(), this.connectionInfo, null, onComplete);
61 |
62 | if ("createBatch".equals(methodName)) {
63 | return this.proxyConfig.getProxyFactory().createBatch((Batch) result, this.connectionInfo);
64 | } else if ("createStatement".equals(methodName)) {
65 | String query = (String) args[0];
66 | return this.proxyConfig.getProxyFactory().createStatement((Statement) result, query, this.connectionInfo);
67 | }
68 |
69 | return result;
70 | }
71 |
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ReactiveConnectionFactoryCallback.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Connection;
4 | import io.r2dbc.spi.ConnectionFactory;
5 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
6 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
7 |
8 | import java.lang.reflect.Method;
9 | import java.util.function.BiFunction;
10 |
11 | /**
12 | * Proxy callback for {@link ConnectionFactory}.
13 | *
14 | * @author Tadaya Tsuyukubo
15 | */
16 | public class ReactiveConnectionFactoryCallback extends CallbackSupport {
17 |
18 | private ConnectionFactory connectionFactory;
19 |
20 | public ReactiveConnectionFactoryCallback(ConnectionFactory connectionFactory, ProxyConfig proxyConfig) {
21 | super(proxyConfig);
22 | this.connectionFactory = connectionFactory;
23 | }
24 |
25 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
26 |
27 | String methodName = method.getName();
28 |
29 | if ("getTarget".equals(methodName)) {
30 | return this.connectionFactory;
31 | }
32 |
33 | BiFunction onMap = null;
34 | if ("create".equals(methodName)) {
35 |
36 | // callback for creating connection proxy
37 | onMap = (resultObj, executionInfo) -> {
38 | executionInfo.setResult(resultObj);
39 |
40 | Connection connection = (Connection) resultObj; // original connection
41 | String connectionId = this.proxyConfig.getConnectionIdManager().getId(connection);
42 |
43 | ConnectionInfo connectionInfo = new ConnectionInfo();
44 | connectionInfo.setConnectionId(connectionId);
45 | connectionInfo.setClosed(false);
46 | connectionInfo.setOriginalConnection(connection);
47 |
48 | executionInfo.setConnectionInfo(connectionInfo);
49 |
50 | Connection proxyConnection = proxyConfig.getProxyFactory().createConnection(connection, connectionInfo);
51 |
52 | return proxyConnection;
53 | };
54 |
55 | }
56 |
57 | Object result = proceedExecution(method, this.connectionFactory, args, this.proxyConfig.getListeners(), null, onMap, null);
58 | return result;
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ReactiveResultCallback.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Result;
4 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
5 | import net.ttddyy.dsproxy.r2dbc.core.ProxyEventType;
6 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
7 | import org.reactivestreams.Publisher;
8 | import reactor.core.publisher.Flux;
9 |
10 | import java.lang.reflect.Method;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 |
13 | /**
14 | * Proxy callback for {@link Result}.
15 | *
16 | * @author Tadaya Tsuyukubo
17 | */
18 | public class ReactiveResultCallback extends CallbackSupport {
19 |
20 | private Result result;
21 | private QueryExecutionInfo queryExecutionInfo;
22 |
23 | public ReactiveResultCallback(Result result, QueryExecutionInfo queryExecutionInfo, ProxyConfig proxyConfig) {
24 | super(proxyConfig);
25 | this.result = result;
26 | this.queryExecutionInfo = queryExecutionInfo;
27 | }
28 |
29 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
30 |
31 | String methodName = method.getName();
32 | ConnectionInfo connectionInfo = this.queryExecutionInfo.getConnectionInfo();
33 |
34 | if ("getTarget".equals(methodName)) { // for ProxyObject
35 | return this.result;
36 | } else if ("getOriginalConnection".equals(methodName)) { // for ConnectionHolder
37 | return connectionInfo.getOriginalConnection();
38 | }
39 |
40 |
41 | Object invocationResult = proceedExecution(method, this.result, args, this.proxyConfig.getListeners(), connectionInfo, null, null);
42 |
43 | if ("map".equals(methodName)) {
44 |
45 | AtomicInteger resultCount = new AtomicInteger(0);
46 |
47 | // add logic to call "listener#eachQueryResult()"
48 | return Flux.from((Publisher) invocationResult)
49 | .doOnEach(signal -> {
50 |
51 | boolean proceed = signal.isOnNext() || signal.isOnError();
52 | if (!proceed) {
53 | return;
54 | }
55 |
56 | int count = resultCount.incrementAndGet();
57 |
58 | if (signal.isOnNext()) {
59 | Object mappedResult = signal.get();
60 |
61 | this.queryExecutionInfo.setCurrentResultCount(count);
62 | this.queryExecutionInfo.setCurrentMappedResult(mappedResult);
63 | this.queryExecutionInfo.setThrowable(null);
64 | } else {
65 | // onError
66 | Throwable thrown = signal.getThrowable();
67 | this.queryExecutionInfo.setCurrentResultCount(count);
68 | this.queryExecutionInfo.setCurrentMappedResult(null);
69 | this.queryExecutionInfo.setThrowable(thrown);
70 |
71 | }
72 |
73 | this.queryExecutionInfo.setProxyEventType(ProxyEventType.EACH_QUERY_RESULT);
74 |
75 | String threadName = Thread.currentThread().getName();
76 | long threadId = Thread.currentThread().getId();
77 | this.queryExecutionInfo.setThreadName(threadName);
78 | this.queryExecutionInfo.setThreadId(threadId);
79 |
80 | // callback
81 | this.proxyConfig.getListeners().eachQueryResult(this.queryExecutionInfo);
82 |
83 | });
84 |
85 | }
86 |
87 |
88 | return invocationResult;
89 |
90 | }
91 |
92 | }
93 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/proxy/ReactiveStatementCallback.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.proxy;
2 |
3 | import io.r2dbc.spi.Result;
4 | import io.r2dbc.spi.Statement;
5 | import net.ttddyy.dsproxy.r2dbc.core.BindingValue;
6 | import net.ttddyy.dsproxy.r2dbc.core.BindingValue.NullBindingValue;
7 | import net.ttddyy.dsproxy.r2dbc.core.BindingValue.SimpleBindingValue;
8 | import net.ttddyy.dsproxy.r2dbc.core.Bindings;
9 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
10 | import net.ttddyy.dsproxy.r2dbc.core.ExecutionType;
11 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
12 | import net.ttddyy.dsproxy.r2dbc.core.QueryInfo;
13 | import org.reactivestreams.Publisher;
14 |
15 | import java.lang.reflect.Method;
16 | import java.util.ArrayList;
17 | import java.util.List;
18 | import java.util.stream.Stream;
19 |
20 | import static java.util.stream.Collectors.toList;
21 |
22 | /**
23 | * Proxy callback for {@link Statement}.
24 | *
25 | * @author Tadaya Tsuyukubo
26 | */
27 | public class ReactiveStatementCallback extends CallbackSupport {
28 |
29 | private Statement statement;
30 |
31 | private ConnectionInfo connectionInfo;
32 | private String query;
33 |
34 | private List bindings = new ArrayList<>();
35 | private int currentBindingsIndex = 0;
36 |
37 | public ReactiveStatementCallback(Statement statement, String query, ConnectionInfo connectionInfo, ProxyConfig proxyConfig) {
38 | super(proxyConfig);
39 | this.statement = statement;
40 | this.query = query;
41 | this.connectionInfo = connectionInfo;
42 | }
43 |
44 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
45 |
46 | String methodName = method.getName();
47 |
48 | if ("getTarget".equals(methodName)) {
49 | return this.statement;
50 | } else if ("getOriginalConnection".equals(methodName)) {
51 | return this.connectionInfo.getOriginalConnection();
52 | }
53 |
54 | Object result = proceedExecution(method, this.statement, args, this.proxyConfig.getListeners(), this.connectionInfo, null, null);
55 |
56 | // add, bind, bindNull, execute
57 | if ("add".equals(methodName)) {
58 | this.currentBindingsIndex++;
59 | } else if ("bind".equals(methodName) || "bindNull".equals(methodName)) {
60 |
61 | if (this.bindings.size() <= this.currentBindingsIndex) {
62 | this.bindings.add(new Bindings());
63 | }
64 | Bindings bindings = this.bindings.get(this.currentBindingsIndex);
65 |
66 | BindingValue bindingValue;
67 | if ("bind".equals(methodName)) {
68 | bindingValue = new SimpleBindingValue(args[1]);
69 | } else {
70 | bindingValue = new NullBindingValue((Class) args[1]);
71 | }
72 |
73 | if (args[0] instanceof Integer) {
74 | bindings.addIndexBinding((int) args[0], bindingValue);
75 | } else {
76 | bindings.addIdentifierBinding(args[0], bindingValue);
77 | }
78 | } else if ("execute".equals(methodName)) {
79 |
80 | // build QueryExecutionInfo TODO: improve
81 | QueryInfo queryInfo = new QueryInfo(this.query);
82 | queryInfo.getBindingsList().addAll(this.bindings);
83 | List queries = Stream.of(queryInfo).collect(toList());
84 |
85 | QueryExecutionInfo execInfo = new QueryExecutionInfo();
86 | execInfo.setType(ExecutionType.STATEMENT);
87 | execInfo.setQueries(queries);
88 | execInfo.setBindingsSize(this.bindings.size());
89 | execInfo.setMethod(method);
90 | execInfo.setMethodArgs(args);
91 | execInfo.setConnectionInfo(this.connectionInfo);
92 |
93 | // API defines "execute()" returns a publisher
94 | Publisher publisher = (Publisher) result;
95 |
96 | return interceptQueryExecution(publisher, execInfo);
97 | }
98 |
99 | return result;
100 | }
101 |
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/support/LastExecutionAwareListener.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.support;
2 |
3 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
4 | import net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener;
5 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
6 |
7 | /**
8 | * Keep the last invoked execution.
9 | *
10 | * Used for validating last execution.
11 | *
12 | * @author Tadaya Tsuyukubo
13 | */
14 | public class LastExecutionAwareListener implements ProxyExecutionListener {
15 |
16 | private QueryExecutionInfo beforeQueryExecutionInfo;
17 | private QueryExecutionInfo afterQueryExecutionInfo;
18 | private QueryExecutionInfo eachQueryResultExecutionInfo;
19 | private MethodExecutionInfo beforeMethodExecutionInfo;
20 | private MethodExecutionInfo afterMethodExecutionInfo;
21 |
22 | @Override
23 | public void beforeQuery(QueryExecutionInfo execInfo) {
24 | this.beforeQueryExecutionInfo = execInfo;
25 | }
26 |
27 | @Override
28 | public void afterQuery(QueryExecutionInfo execInfo) {
29 | this.afterQueryExecutionInfo = execInfo;
30 | }
31 |
32 | @Override
33 | public void eachQueryResult(QueryExecutionInfo execInfo) {
34 | this.eachQueryResultExecutionInfo = execInfo;
35 | }
36 |
37 | @Override
38 | public void beforeMethod(MethodExecutionInfo executionInfo) {
39 | this.beforeMethodExecutionInfo = executionInfo;
40 | }
41 |
42 | @Override
43 | public void afterMethod(MethodExecutionInfo executionInfo) {
44 | this.afterMethodExecutionInfo = executionInfo;
45 | }
46 |
47 | public QueryExecutionInfo getBeforeQueryExecutionInfo() {
48 | return beforeQueryExecutionInfo;
49 | }
50 |
51 | public QueryExecutionInfo getAfterQueryExecutionInfo() {
52 | return afterQueryExecutionInfo;
53 | }
54 |
55 | public QueryExecutionInfo getEachQueryResultExecutionInfo() {
56 | return eachQueryResultExecutionInfo;
57 | }
58 |
59 | public MethodExecutionInfo getBeforeMethodExecutionInfo() {
60 | return beforeMethodExecutionInfo;
61 | }
62 |
63 | public MethodExecutionInfo getAfterMethodExecutionInfo() {
64 | return afterMethodExecutionInfo;
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/support/LifeCycleExecutionListener.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.support;
2 |
3 | import io.r2dbc.spi.Batch;
4 | import io.r2dbc.spi.Connection;
5 | import io.r2dbc.spi.ConnectionFactory;
6 | import io.r2dbc.spi.Result;
7 | import io.r2dbc.spi.Statement;
8 | import net.ttddyy.dsproxy.r2dbc.core.ExecutionType;
9 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
10 | import net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener;
11 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
12 |
13 | import java.lang.reflect.Method;
14 |
15 | /**
16 | * Provides explicit callbacks on all SPI invocations and query executions on given {@link LifeCycleListener}.
17 | *
18 | * @author Tadaya Tsuyukubo
19 | * @see LifeCycleListener
20 | */
21 | public class LifeCycleExecutionListener implements ProxyExecutionListener {
22 |
23 | private LifeCycleListener delegate;
24 |
25 | public static LifeCycleExecutionListener of(LifeCycleListener lifeCycleListener) {
26 | return new LifeCycleExecutionListener(lifeCycleListener);
27 | }
28 |
29 | public LifeCycleExecutionListener(LifeCycleListener delegate) {
30 | this.delegate = delegate;
31 | }
32 |
33 | @Override
34 | public void beforeMethod(MethodExecutionInfo executionInfo) {
35 | this.delegate.beforeMethod(executionInfo);
36 | methodCallback(executionInfo, true);
37 | }
38 |
39 | @Override
40 | public void afterMethod(MethodExecutionInfo executionInfo) {
41 | methodCallback(executionInfo, false);
42 | this.delegate.afterMethod(executionInfo);
43 | }
44 |
45 | private void methodCallback(MethodExecutionInfo executionInfo, boolean isBefore) {
46 | Method method = executionInfo.getMethod();
47 | String methodName = method.getName();
48 | Class methodDeclaringClass = method.getDeclaringClass();
49 |
50 |
51 | if (ConnectionFactory.class.equals(methodDeclaringClass)) {
52 | // ConnectionFactory methods
53 | if ("create".equals(methodName)) {
54 | if (isBefore) {
55 | this.delegate.beforeCreateOnConnectionFactory(executionInfo);
56 | } else {
57 | this.delegate.afterCreateOnConnectionFactory(executionInfo);
58 | }
59 | } else if ("getMetadata".equals(methodName)) {
60 | if (isBefore) {
61 | this.delegate.beforeGetMetadataOnConnectionFactory(executionInfo);
62 | } else {
63 | this.delegate.afterGetMetadataOnConnectionFactory(executionInfo);
64 | }
65 | }
66 | } else if (Connection.class.equals(methodDeclaringClass)) {
67 | // Connection methods
68 | if ("beginTransaction".equals(methodName)) {
69 | if (isBefore) {
70 | this.delegate.beforeBeginTransactionOnConnection(executionInfo);
71 | } else {
72 | this.delegate.afterBeginTransactionOnConnection(executionInfo);
73 | }
74 | } else if ("close".equals(methodName)) {
75 | if (isBefore) {
76 | this.delegate.beforeCloseOnConnection(executionInfo);
77 | } else {
78 | this.delegate.afterCloseOnConnection(executionInfo);
79 | }
80 | } else if ("commitTransaction".equals(methodName)) {
81 | if (isBefore) {
82 | this.delegate.beforeCommitTransactionOnConnection(executionInfo);
83 | } else {
84 | this.delegate.afterCommitTransactionOnConnection(executionInfo);
85 | }
86 | } else if ("createBatch".equals(methodName)) {
87 | if (isBefore) {
88 | this.delegate.beforeCreateBatchOnConnection(executionInfo);
89 | } else {
90 | this.delegate.afterCreateBatchOnConnection(executionInfo);
91 | }
92 | } else if ("createSavepoint".equals(methodName)) {
93 | if (isBefore) {
94 | this.delegate.beforeCreateSavepointOnConnection(executionInfo);
95 | } else {
96 | this.delegate.afterCreateSavepointOnConnection(executionInfo);
97 | }
98 | } else if ("createStatement".equals(methodName)) {
99 | if (isBefore) {
100 | this.delegate.beforeCreateStatementOnConnection(executionInfo);
101 | } else {
102 | this.delegate.afterCreateStatementOnConnection(executionInfo);
103 | }
104 | } else if ("releaseSavepoint".equals(methodName)) {
105 | if (isBefore) {
106 | this.delegate.beforeReleaseSavepointOnConnection(executionInfo);
107 | } else {
108 | this.delegate.afterReleaseSavepointOnConnection(executionInfo);
109 | }
110 | } else if ("rollbackTransaction".equals(methodName)) {
111 | if (isBefore) {
112 | this.delegate.beforeRollbackTransactionOnConnection(executionInfo);
113 | } else {
114 | this.delegate.afterRollbackTransactionOnConnection(executionInfo);
115 | }
116 | } else if ("rollbackTransactionToSavepoint".equals(methodName)) {
117 | if (isBefore) {
118 | this.delegate.beforeRollbackTransactionToSavepointOnConnection(executionInfo);
119 | } else {
120 | this.delegate.afterRollbackTransactionToSavepointOnConnection(executionInfo);
121 | }
122 | } else if ("setTransactionIsolationLevel".equals(methodName)) {
123 | if (isBefore) {
124 | this.delegate.beforeSetTransactionIsolationLevelOnConnection(executionInfo);
125 | } else {
126 | this.delegate.afterSetTransactionIsolationLevelOnConnection(executionInfo);
127 | }
128 | }
129 | } else if (Batch.class.equals(methodDeclaringClass)) {
130 | // Batch methods
131 | if ("add".equals(methodName)) {
132 | if (isBefore) {
133 | this.delegate.beforeAddOnBatch(executionInfo);
134 | } else {
135 | this.delegate.afterAddOnBatch(executionInfo);
136 | }
137 | } else if ("execute".equals(methodName)) {
138 | if (isBefore) {
139 | this.delegate.beforeExecuteOnBatch(executionInfo);
140 | } else {
141 | this.delegate.afterExecuteOnBatch(executionInfo);
142 | }
143 | }
144 | } else if (Statement.class.equals(methodDeclaringClass)) {
145 | // Statement methods
146 | if ("add".equals(methodName)) {
147 | if (isBefore) {
148 | this.delegate.beforeAddOnStatement(executionInfo);
149 | } else {
150 | this.delegate.afterAddOnStatement(executionInfo);
151 | }
152 | } else if ("bind".equals(methodName)) {
153 | if (isBefore) {
154 | this.delegate.beforeBindOnStatement(executionInfo);
155 | } else {
156 | this.delegate.afterBindOnStatement(executionInfo);
157 | }
158 | } else if ("bindNull".equals(methodName)) {
159 | if (isBefore) {
160 | this.delegate.beforeBindNullOnStatement(executionInfo);
161 | } else {
162 | this.delegate.afterBindNullOnStatement(executionInfo);
163 | }
164 | } else if ("execute".equals(methodName)) {
165 | if (isBefore) {
166 | this.delegate.beforeExecuteOnStatement(executionInfo);
167 | } else {
168 | this.delegate.afterExecuteOnStatement(executionInfo);
169 | }
170 | }
171 | } else if (Result.class.equals(methodDeclaringClass)) {
172 | if ("getRowsUpdated".equals(methodName)) {
173 | if (isBefore) {
174 | this.delegate.beforeGetRowsUpdatedOnResult(executionInfo);
175 | } else {
176 | this.delegate.afterGetRowsUpdatedOnResult(executionInfo);
177 | }
178 | } else if ("map".equals(methodName)) {
179 | if (isBefore) {
180 | this.delegate.beforeMapOnResult(executionInfo);
181 | } else {
182 | this.delegate.afterMapOnResult(executionInfo);
183 | }
184 | }
185 | }
186 |
187 | }
188 |
189 | @Override
190 | public void beforeQuery(QueryExecutionInfo execInfo) {
191 | this.delegate.beforeQuery(execInfo);
192 | queryCallback(execInfo, true);
193 | }
194 |
195 | @Override
196 | public void afterQuery(QueryExecutionInfo execInfo) {
197 | queryCallback(execInfo, false);
198 | this.delegate.afterQuery(execInfo);
199 | }
200 |
201 | private void queryCallback(QueryExecutionInfo execInfo, boolean isBefore) {
202 | ExecutionType executionType = execInfo.getType();
203 |
204 | if (executionType == ExecutionType.BATCH) {
205 | if (isBefore) {
206 | this.delegate.beforeExecuteOnBatch(execInfo);
207 | } else {
208 | this.delegate.afterExecuteOnBatch(execInfo);
209 | }
210 | } else {
211 | if (isBefore) {
212 | this.delegate.beforeExecuteOnStatement(execInfo);
213 | } else {
214 | this.delegate.afterExecuteOnStatement(execInfo);
215 | }
216 | }
217 | }
218 |
219 | @Override
220 | public void eachQueryResult(QueryExecutionInfo execInfo) {
221 | this.delegate.onEachQueryResult(execInfo);
222 | }
223 | }
224 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/support/LifeCycleListener.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.support;
2 |
3 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
4 | import net.ttddyy.dsproxy.r2dbc.core.QueryExecutionInfo;
5 |
6 | /**
7 | * Provides callback for each SPI.
8 | *
9 | * @author Tadaya Tsuyukubo
10 | * @see LifeCycleExecutionListener
11 | */
12 | public interface LifeCycleListener {
13 |
14 | //
15 | // for ConnectionFactory
16 | //
17 |
18 | default void beforeCreateOnConnectionFactory(MethodExecutionInfo methodExecutionInfo) {
19 | }
20 |
21 | default void afterCreateOnConnectionFactory(MethodExecutionInfo methodExecutionInfo) {
22 | }
23 |
24 | default void beforeGetMetadataOnConnectionFactory(MethodExecutionInfo methodExecutionInfo) {
25 | }
26 |
27 | default void afterGetMetadataOnConnectionFactory(MethodExecutionInfo methodExecutionInfo) {
28 | }
29 |
30 | //
31 | // for Connection
32 | //
33 |
34 | default void beforeBeginTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
35 | }
36 |
37 | default void afterBeginTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
38 | }
39 |
40 | default void beforeCloseOnConnection(MethodExecutionInfo methodExecutionInfo) {
41 | }
42 |
43 | default void afterCloseOnConnection(MethodExecutionInfo methodExecutionInfo) {
44 | }
45 |
46 | default void beforeCommitTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
47 | }
48 |
49 | default void afterCommitTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
50 | }
51 |
52 | default void beforeCreateBatchOnConnection(MethodExecutionInfo methodExecutionInfo) {
53 | }
54 |
55 | default void afterCreateBatchOnConnection(MethodExecutionInfo methodExecutionInfo) {
56 | }
57 |
58 | default void beforeCreateSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
59 | }
60 |
61 | default void afterCreateSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
62 | }
63 |
64 | default void beforeCreateStatementOnConnection(MethodExecutionInfo methodExecutionInfo) {
65 | }
66 |
67 | default void afterCreateStatementOnConnection(MethodExecutionInfo methodExecutionInfo) {
68 | }
69 |
70 | default void beforeReleaseSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
71 | }
72 |
73 | default void afterReleaseSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
74 | }
75 |
76 | default void beforeRollbackTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
77 | }
78 |
79 | default void afterRollbackTransactionOnConnection(MethodExecutionInfo methodExecutionInfo) {
80 | }
81 |
82 | default void beforeRollbackTransactionToSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
83 | }
84 |
85 | default void afterRollbackTransactionToSavepointOnConnection(MethodExecutionInfo methodExecutionInfo) {
86 | }
87 |
88 | default void beforeSetTransactionIsolationLevelOnConnection(MethodExecutionInfo methodExecutionInfo) {
89 | }
90 |
91 | default void afterSetTransactionIsolationLevelOnConnection(MethodExecutionInfo methodExecutionInfo) {
92 | }
93 |
94 | //
95 | // for Batch
96 | //
97 |
98 | default void beforeAddOnBatch(MethodExecutionInfo methodExecutionInfo) {
99 | }
100 |
101 | default void afterAddOnBatch(MethodExecutionInfo methodExecutionInfo) {
102 | }
103 |
104 | default void beforeExecuteOnBatch(MethodExecutionInfo methodExecutionInfo) {
105 | }
106 |
107 | default void afterExecuteOnBatch(MethodExecutionInfo methodExecutionInfo) {
108 | }
109 |
110 | //
111 | // for Statement
112 | //
113 |
114 | default void beforeAddOnStatement(MethodExecutionInfo methodExecutionInfo) {
115 | }
116 |
117 | default void afterAddOnStatement(MethodExecutionInfo methodExecutionInfo) {
118 | }
119 |
120 | default void beforeBindOnStatement(MethodExecutionInfo methodExecutionInfo) {
121 | }
122 |
123 | default void afterBindOnStatement(MethodExecutionInfo methodExecutionInfo) {
124 | }
125 |
126 | default void beforeBindNullOnStatement(MethodExecutionInfo methodExecutionInfo) {
127 | }
128 |
129 | default void afterBindNullOnStatement(MethodExecutionInfo methodExecutionInfo) {
130 | }
131 |
132 | default void beforeExecuteOnStatement(MethodExecutionInfo methodExecutionInfo) {
133 | }
134 |
135 | default void afterExecuteOnStatement(MethodExecutionInfo methodExecutionInfo) {
136 | }
137 |
138 | //
139 | // For Result
140 | //
141 | default void beforeGetRowsUpdatedOnResult(MethodExecutionInfo methodExecutioninfo) {
142 | }
143 |
144 | default void afterGetRowsUpdatedOnResult(MethodExecutionInfo methodExecutioninfo) {
145 | }
146 |
147 | default void beforeMapOnResult(MethodExecutionInfo methodExecutioninfo) {
148 | }
149 |
150 | default void afterMapOnResult(MethodExecutionInfo methodExecutioninfo) {
151 | }
152 |
153 | //
154 | // For query execution
155 | //
156 |
157 | default void beforeExecuteOnBatch(QueryExecutionInfo queryExecutionInfo) {
158 | }
159 |
160 | default void afterExecuteOnBatch(QueryExecutionInfo queryExecutionInfo) {
161 | }
162 |
163 | default void beforeExecuteOnStatement(QueryExecutionInfo queryExecutionInfo) {
164 | }
165 |
166 | default void afterExecuteOnStatement(QueryExecutionInfo queryExecutionInfo) {
167 | }
168 |
169 | //
170 | // processing query result
171 | //
172 |
173 | default void onEachQueryResult(QueryExecutionInfo queryExecutionInfo) {
174 |
175 | }
176 |
177 | //
178 | // For every method
179 | //
180 |
181 | /**
182 | * Called at every method invocation.
183 | *
184 | * When any methods on proxied classes are called, this callback is called first. Then, corresponding
185 | * beforeXxxOnYyy callback will be called.
186 | *
187 | * Analogous to {@link net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener#beforeMethod(MethodExecutionInfo)}
188 | *
189 | * @param methodExecutionInfo method execution info
190 | */
191 | default void beforeMethod(MethodExecutionInfo methodExecutionInfo) {
192 | }
193 |
194 | /**
195 | * Called at every method invocation.
196 | *
197 | * When any methods on proxied classes are called and after actual method is invoked, corresponding
198 | * afterXxxOnYyy callback is called, then this callback method will be invoked.
199 | *
200 | * Analogous to {@link net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener#afterMethod(MethodExecutionInfo)}
201 | *
202 | * @param methodExecutionInfo method execution info
203 | */
204 | default void afterMethod(MethodExecutionInfo methodExecutionInfo) {
205 | }
206 |
207 | //
208 | // For every query
209 | //
210 |
211 | /**
212 | * Called before execution of query.
213 | *
214 | * When query is executed, this callback method is called first, then {@link #beforeExecuteOnStatement(QueryExecutionInfo)}
215 | * or {@link #beforeExecuteOnBatch(QueryExecutionInfo)} will be called.
216 | *
217 | * Analogous to {@link net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener#beforeQuery(QueryExecutionInfo)}
218 | *
219 | * @param queryExecutionInfo query execution info
220 | */
221 | default void beforeQuery(QueryExecutionInfo queryExecutionInfo) {
222 | }
223 |
224 | /**
225 | * Called after execution of query.
226 | *
227 | * When query is executed, after original method is called, then {@link #afterExecuteOnStatement(QueryExecutionInfo)}
228 | * or {@link #afterExecuteOnBatch(QueryExecutionInfo)}, then this method is invoked.
229 | *
230 | * Analogous to {@link net.ttddyy.dsproxy.r2dbc.core.ProxyExecutionListener#afterQuery(QueryExecutionInfo)}
231 | *
232 | * @param queryExecutionInfo query execution info
233 | */
234 | default void afterQuery(QueryExecutionInfo queryExecutionInfo) {
235 | }
236 |
237 | }
238 |
--------------------------------------------------------------------------------
/src/main/java/net/ttddyy/dsproxy/r2dbc/support/MethodExecutionInfoFormatter.java:
--------------------------------------------------------------------------------
1 | package net.ttddyy.dsproxy.r2dbc.support;
2 |
3 | import net.ttddyy.dsproxy.r2dbc.core.ConnectionInfo;
4 | import net.ttddyy.dsproxy.r2dbc.core.MethodExecutionInfo;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 | import java.util.concurrent.atomic.AtomicLong;
9 | import java.util.function.BiConsumer;
10 | import java.util.function.Function;
11 |
12 | /**
13 | * Convert {@link MethodExecutionInfo} to {@link String}.
14 | *
15 | * @author Tadaya Tsuyukubo
16 | */
17 | public class MethodExecutionInfoFormatter implements Function {
18 |
19 | private static final String DEFAULT_DELIMITER = " ";
20 |
21 | private List> consumers = new ArrayList<>();
22 |
23 | private AtomicLong sequenceNumber = new AtomicLong(1);
24 |
25 | // Default consumer to format the MethodExecutionInfo
26 | private BiConsumer defaultConsumer = (executionInfo, sb) -> {
27 | long seq = this.sequenceNumber.getAndIncrement();
28 | long executionTime = executionInfo.getExecuteDuration().toMillis();
29 | String targetClass = executionInfo.getTarget().getClass().getSimpleName();
30 | String methodName = executionInfo.getMethod().getName();
31 | long threadId = executionInfo.getThreadId();
32 |
33 | ConnectionInfo connectionInfo = executionInfo.getConnectionInfo();
34 |
35 | String connectionId = (connectionInfo == null || connectionInfo.getConnectionId() == null) ? "n/a" : connectionInfo.getConnectionId();
36 |
37 | sb.append(String.format("%3d: Thread:%d Connection:%s Time:%d %s#%s()",
38 | seq, threadId, connectionId, executionTime, targetClass, methodName));
39 | };
40 |
41 | private String delimiter = DEFAULT_DELIMITER;
42 |
43 |
44 | public static MethodExecutionInfoFormatter withDefault() {
45 | MethodExecutionInfoFormatter formatter = new MethodExecutionInfoFormatter();
46 | formatter.addConsumer(formatter.defaultConsumer);
47 | return formatter;
48 | }
49 |
50 | @Override
51 | public String apply(MethodExecutionInfo executionInfo) {
52 | return format(executionInfo);
53 | }
54 |
55 | public String format(MethodExecutionInfo executionInfo) {
56 |
57 | StringBuilder sb = new StringBuilder();
58 |
59 | consumers.forEach(consumer -> {
60 | consumer.accept(executionInfo, sb);
61 | sb.append(this.delimiter);
62 | });
63 |
64 | chompIfEndWith(sb, this.delimiter);
65 |
66 | return sb.toString();
67 |
68 | }
69 |
70 | public MethodExecutionInfoFormatter addConsumer(BiConsumer consumer) {
71 | this.consumers.add(consumer);
72 | return this;
73 | }
74 |
75 | // TODO: share this with QueryExecutionInfoFormatter
76 | protected void chompIfEndWith(StringBuilder sb, String s) {
77 | if (sb.length() < s.length()) {
78 | return;
79 | }
80 | final int startIndex = sb.length() - s.length();
81 | if (sb.substring(startIndex, sb.length()).equals(s)) {
82 | sb.delete(startIndex, sb.length());
83 | }
84 | }
85 |
86 |
87 | }
88 |
--------------------------------------------------------------------------------
/src/test/java/net/ttddyy/dsproxy/r2dbc/Example.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2018 the original author or authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.ttddyy.dsproxy.r2dbc;
18 |
19 | import io.r2dbc.client.R2dbc;
20 | import io.r2dbc.client.Update;
21 | import io.r2dbc.spi.Result;
22 | import org.junit.jupiter.api.AfterEach;
23 | import org.junit.jupiter.api.BeforeEach;
24 | import org.junit.jupiter.api.Test;
25 | import org.springframework.jdbc.core.JdbcOperations;
26 | import reactor.core.publisher.Flux;
27 | import reactor.core.publisher.Mono;
28 | import reactor.test.StepVerifier;
29 |
30 | import java.util.Arrays;
31 | import java.util.Collections;
32 | import java.util.List;
33 | import java.util.stream.IntStream;
34 |
35 | /**
36 | * COPY from r2dbc-client
37 | * @param
38 | */
39 | interface Example {
40 |
41 | static Mono> extractColumns(Result result) {
42 | return Flux.from(result
43 | .map((row, rowMetadata) -> row.get("value", Integer.class)))
44 | .collectList();
45 | }
46 |
47 | static Mono> extractIds(Result result) {
48 | return Flux.from(result
49 | .map((row, rowMetadata) -> row.get("id", Integer.class)))
50 | .collectList();
51 | }
52 |
53 | @Test
54 | default void batch() {
55 | getJdbcOperations().execute("INSERT INTO test VALUES (100)");
56 |
57 | getR2dbc()
58 | .withHandle(handle -> handle
59 |
60 | .createBatch()
61 | .add("INSERT INTO test VALUES(200)")
62 | .add("SELECT value FROM test")
63 | .mapResult(Mono::just))
64 |
65 | .as(StepVerifier::create)
66 | .expectNextCount(2).as("one result for each statement")
67 | .verifyComplete();
68 | }
69 |
70 |
71 | @Test
72 | default void simpleTransaction() {
73 | getJdbcOperations().execute("INSERT INTO test VALUES (100)");
74 |
75 | getR2dbc()
76 | .withHandle(handle -> handle
77 | .inTransaction(h1 -> h1
78 | .execute("INSERT INTO test VALUES ($1)", 200)))
79 | .as(StepVerifier::create)
80 | .expectNext(1).as("rows inserted")
81 | .verifyComplete();
82 | }
83 |
84 | @Test
85 | default void compoundStatement() {
86 | getJdbcOperations().execute("INSERT INTO test VALUES (100)");
87 |
88 | getR2dbc()
89 | .withHandle(handle -> handle
90 |
91 | .createQuery("SELECT value FROM test; SELECT value FROM test")
92 | .mapResult(Example::extractColumns))
93 |
94 | .as(StepVerifier::create)
95 | .expectNext(Collections.singletonList(100)).as("value from first statement")
96 | .expectNext(Collections.singletonList(100)).as("value from second statement")
97 | .verifyComplete();
98 | }
99 |
100 | @BeforeEach
101 | default void createTable() {
102 | getJdbcOperations().execute("CREATE TABLE test ( value INTEGER )");
103 | }
104 |
105 | @AfterEach
106 | default void dropTable() {
107 | getJdbcOperations().execute("DROP TABLE test");
108 | }
109 |
110 | /**
111 | * Returns the bind identifier for a given substitution.
112 | *
113 | * @param index the zero-index number of the substitution
114 | * @return the bind identifier for a given substitution
115 | */
116 | T getIdentifier(int index);
117 |
118 | /**
119 | * Returns a {@link JdbcOperations} for the connected database.
120 | *
121 | * @return a {@link JdbcOperations} for the connected database
122 | */
123 | JdbcOperations getJdbcOperations();
124 |
125 | /**
126 | * Returns the database-specific placeholder for a given substitution.
127 | *
128 | * @param index the zero-index number of the substitution
129 | * @return the database-specific placeholder for a given substitution
130 | */
131 | String getPlaceholder(int index);
132 |
133 | /**
134 | * Returns a {@link R2dbc} for the connected database.
135 | *
136 | * @return a {@link R2dbc} for the connected database
137 | */
138 | R2dbc getR2dbc();
139 |
140 | @Test
141 | default void prepareStatement() {
142 | getR2dbc()
143 | .withHandle(handle -> {
144 | Update update = handle.createUpdate(String.format("INSERT INTO test VALUES(%s)", getPlaceholder(0)));
145 |
146 | IntStream.range(0, 10)
147 | .forEach(i -> update.bind(getIdentifier(0), i).add());
148 |
149 | return update.execute();
150 | })
151 | .as(StepVerifier::create)
152 | .expectNextCount(10).as("values from insertions")
153 | .verifyComplete();
154 | }
155 |
156 | @Test
157 | default void savePoint() {
158 | getJdbcOperations().execute("INSERT INTO test VALUES (100)");
159 |
160 | getR2dbc()
161 | .withHandle(handle -> handle
162 | .inTransaction(h1 -> h1
163 | .select("SELECT value FROM test")
164 | .