Refactor: use SpringJdbcDelegate inner class and ClassUtils.isPresent guard

Replace reflection-based chain walking with direct DelegatingDataSource
and AbstractRoutingDataSource API calls. Isolate spring-jdbc references
in a private inner class so the outer class loads cleanly when spring-jdbc
is absent. ClassUtils.isPresent gates the delegate call, preserving the
original wrap-everything behaviour for non-spring-jdbc environments.

Promote spring-jdbc from test to optional scope to enable compile-time
type checking in the inner class.

Author: svisan-tek

datasource-micrometer-spring-boot/pom.xml

@@ -82,6 +82,11 @@
             <artifactId>HikariCP</artifactId>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-jdbc</artifactId>
+            <optional>true</optional>
+        </dependency>
 
         <!-- Integration test -->
         <dependency>
@@ -104,11 +109,6 @@
             <artifactId>spring-boot-micrometer-tracing-test</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-jdbc</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>com.h2database</groupId>
             <artifactId>h2</artifactId>

datasource-micrometer-spring-boot/src/main/java/net/ttddyy/observation/boot/autoconfigure/DataSourceObservationBeanPostProcessor.java

@@ -16,13 +16,6 @@
 
 package net.ttddyy.observation.boot.autoconfigure;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.Map;
-import java.util.Set;
-
 import javax.sql.DataSource;
 
 import net.ttddyy.dsproxy.listener.MethodExecutionListener;
@@ -38,6 +31,9 @@
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.jdbc.datasource.DelegatingDataSource;
+import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
+import org.springframework.util.ClassUtils;
 
 /**
  * A {@link BeanPostProcessor} to instrument {@link DataSource} beans.
@@ -46,11 +42,9 @@
  */
 public class DataSourceObservationBeanPostProcessor implements BeanPostProcessor {
 
-	/**
-	 * Tracks datasource instances (pre-proxy) that this post-processor has already
-	 * instrumented, so routing/delegating wrappers referencing them can be skipped.
-	 */
-	private final Set<DataSource> proxiedDataSources = Collections.newSetFromMap(new IdentityHashMap<>());
+	static final boolean SPRING_JDBC_PRESENT = ClassUtils.isPresent(
+			"org.springframework.jdbc.datasource.DelegatingDataSource",
+			DataSourceObservationBeanPostProcessor.class.getClassLoader());
 
 	private final ObjectProvider<JdbcProperties> jdbcPropertiesProvider;
 
@@ -106,15 +100,12 @@ public Object postProcessAfterInitialization(Object bean, String beanName) throw
 			this.proxyDataSourceBuilderCustomizers.orderedStream()
 				.forEach(customizer -> customizer.customize(builder, dataSource, beanName, dataSourceName));
 			DataSourceType dataSourceType = getJdbcProperties().getDatasourceProxy().getType();
-			Object proxy;
 			if (dataSourceType == DataSourceType.PROXY || dataSourceType == DataSourceType.SPRING_PROXY) {
-				proxy = builder.buildProxy();
+				return builder.buildProxy();
 			}
 			else {
-				proxy = builder.build();
+				return builder.build();
 			}
-			this.proxiedDataSources.add(dataSource);
-			return proxy;
 		}
 		else {
 			return bean;
@@ -123,60 +114,18 @@ public Object postProcessAfterInitialization(Object bean, String beanName) throw
 
 	/**
 	 * Returns {@code true} if {@code ds} is a routing or delegating wrapper whose chain
-	 * contains a datasource that this post-processor has already instrumented. Detected
-	 * via reflection to avoid a compile-time dependency on spring-jdbc.
+	 * contains a datasource already instrumented by datasource-proxy.
 	 *
-	 * <p>Two common patterns are checked:
-	 * <ul>
-	 * <li>{@code getTargetDataSource()} — covers {@code DelegatingDataSource} (e.g.
-	 * {@code LazyConnectionDataSourceProxy})</li>
-	 * <li>{@code resolvedDataSources} field — covers {@code AbstractRoutingDataSource}
-	 * subclasses</li>
-	 * </ul>
+	 * <p>When {@code spring-jdbc} is absent the check is skipped and returns {@code false},
+	 * preserving the pre-existing behaviour of wrapping all datasource beans.
 	 */
-	private boolean containsAlreadyProxiedTarget(DataSource ds) {
-		// DelegatingDataSource pattern: getTargetDataSource()
-		try {
-			Method m = ds.getClass().getMethod("getTargetDataSource");
-			Object target = m.invoke(ds);
-			if (target instanceof DataSource targetDs) {
-				return this.proxiedDataSources.contains(targetDs) || isProxyJdbcObject(targetDs)
-						|| containsAlreadyProxiedTarget(targetDs);
-			}
-		}
-		catch (ReflectiveOperationException ignored) {
-		}
-
-		// AbstractRoutingDataSource pattern: resolvedDataSources field
-		Class<?> cls = ds.getClass();
-		while (cls != null && cls != Object.class) {
-			try {
-				Field f = cls.getDeclaredField("resolvedDataSources");
-				f.setAccessible(true);
-				@SuppressWarnings("unchecked")
-				Map<Object, DataSource> resolved = (Map<Object, DataSource>) f.get(ds);
-				if (resolved != null) {
-					return resolved.values()
-						.stream()
-						.anyMatch(t -> this.proxiedDataSources.contains(t) || isProxyJdbcObject(t)
-								|| containsAlreadyProxiedTarget(t));
-				}
-				break;
-			}
-			catch (NoSuchFieldException e) {
-				cls = cls.getSuperclass();
-			}
-			catch (IllegalAccessException ignored) {
-				break;
-			}
+	private static boolean containsAlreadyProxiedTarget(DataSource ds) {
+		if (SPRING_JDBC_PRESENT) {
+			return SpringJdbcDelegate.containsProxiedTarget(ds);
 		}
 		return false;
 	}
 
-	private static boolean isProxyJdbcObject(DataSource ds) {
-		return ds instanceof ProxyJdbcObject;
-	}
-
 	private DataSourceProxyBuilderConfigurer getConfigurer() {
 		if (this.dataSourceProxyBuilderConfigurer == null) {
 			this.dataSourceProxyBuilderConfigurer = new DataSourceProxyBuilderConfigurer(getJdbcProperties(),
@@ -198,4 +147,30 @@ private JdbcProperties getJdbcProperties() {
 		return this.jdbcPropertiesProvider.getObject();
 	}
 
+	/**
+	 * Isolated in a separate class so that the JVM only loads it when
+	 * {@code spring-jdbc} is actually on the classpath. If it were inlined in the
+	 * outer class, the mere presence of {@link DelegatingDataSource} and
+	 * {@link AbstractRoutingDataSource} in the constant pool would cause a
+	 * {@link NoClassDefFoundError} at class-load time when {@code spring-jdbc} is absent.
+	 */
+	private static final class SpringJdbcDelegate {
+
+		static boolean containsProxiedTarget(final DataSource ds) {
+			if (ds instanceof DelegatingDataSource delegating) {
+				final DataSource target = delegating.getTargetDataSource();
+				return target != null
+						&& (target instanceof ProxyJdbcObject || containsProxiedTarget(target));
+			}
+			if (ds instanceof AbstractRoutingDataSource routing) {
+				return routing.getResolvedDataSources()
+					.values()
+					.stream()
+					.anyMatch(target -> target instanceof ProxyJdbcObject || containsProxiedTarget(target));
+			}
+			return false;
+		}
+
+	}
+
 }

datasource-micrometer-spring-boot/src/test/java/net/ttddyy/observation/boot/autoconfigure/DataSourceObservationBeanPostProcessorTests.java

@@ -16,7 +16,11 @@
 
 package net.ttddyy.observation.boot.autoconfigure;
 
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
 import java.sql.Connection;
+import java.util.Arrays;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Stream;
@@ -189,6 +193,46 @@ else if (type == DataSourceType.CONCRETE) {
 		}
 	}
 
+	@Test
+	void springJdbcPresentIsTrueWhenSpringJdbcOnClasspath() {
+		// Package-private access — no reflection needed
+		assertThat(DataSourceObservationBeanPostProcessor.SPRING_JDBC_PRESENT).isTrue();
+	}
+
+	@Test
+	void springJdbcPresentIsFalseWhenSpringJdbcAbsent() throws Exception {
+		// Build URLs from the current classpath so we can reload the class fresh
+		URL[] urls = Arrays.stream(System.getProperty("java.class.path").split(File.pathSeparator))
+			.map(entry -> {
+				try {
+					return new File(entry).toURI().toURL();
+				}
+				catch (Exception ex) {
+					throw new RuntimeException(ex);
+				}
+			})
+			.toArray(URL[]::new);
+
+		// null parent → bootstrap classloader only; our URLs cover the rest.
+		// The filter makes spring-jdbc invisible so ClassUtils.isPresent returns false
+		// and SPRING_JDBC_PRESENT is set to false when the class is loaded fresh.
+		try (URLClassLoader isolatedLoader = new URLClassLoader(urls, null) {
+			@Override
+			public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+				if (name.startsWith("org.springframework.jdbc.datasource")) {
+					throw new ClassNotFoundException(name);
+				}
+				return super.loadClass(name, resolve);
+			}
+		}) {
+			Class<?> processorClass = isolatedLoader
+				.loadClass("net.ttddyy.observation.boot.autoconfigure.DataSourceObservationBeanPostProcessor");
+			java.lang.reflect.Field field = processorClass.getDeclaredField("SPRING_JDBC_PRESENT");
+			field.setAccessible(true);
+			assertThat(field.get(null)).isEqualTo(false);
+		}
+	}
+
 	@Test
 	void delegatingDataSourceWrappingAlreadyProxiedTargetIsSkipped() throws Exception {
 		setupProcessorForProxying();
@@ -278,6 +322,31 @@ void independentDataSourceIsStillProxied() throws Exception {
 		assertThat(secondResult).isInstanceOf(ProxyJdbcObject.class);
 	}
 
+	@Test
+	void routingDatasourceWithUnproxiedTargetsIsStillProxied() throws Exception {
+		// When targets are plain (not ProxyJdbcObject), the routing wrapper itself
+		// must be proxied. This covers the fallback when spring-jdbc is absent
+		// (SPRING_JDBC_PRESENT=false → containsAlreadyProxiedTarget always returns false)
+		// and the normal case where the routing datasource is processed before its targets.
+		setupProcessorForProxying();
+
+		final DataSource physicalRw = mockPhysicalDataSource();
+		final DataSource physicalRo = mockPhysicalDataSource();
+
+		final AbstractRoutingDataSource router = new AbstractRoutingDataSource() {
+			@Override
+			protected Object determineCurrentLookupKey() {
+				return "rw";
+			}
+		};
+		router.setTargetDataSources(Map.of("rw", physicalRw, "ro", physicalRo));
+		router.setDefaultTargetDataSource(physicalRw);
+		router.afterPropertiesSet();
+
+		final Object result = this.processor.postProcessAfterInitialization(router, "actualDataSource");
+		assertThat(result).isInstanceOf(ProxyJdbcObject.class);
+	}
+
 	private void setupProcessorForProxying() {
 		JdbcProperties jdbcProperties = new JdbcProperties();
 		given(this.jdbcPropertiesProvider.getObject()).willReturn(jdbcProperties);