Preserve Connection readOnly state for defaultReadOnly DataSource

Includes DataSourceTransactionManagerTests alignment with main branch.

Closes gh-35743

Author: jhoeller

spring-jdbc/src/main/java/org/springframework/jdbc/datasource/DataSourceTransactionManager.java

@@ -126,6 +126,8 @@ public class DataSourceTransactionManager extends AbstractPlatformTransactionMan
 
 	private boolean enforceReadOnly = false;
 
+	private volatile @Nullable Boolean defaultReadOnly;
+
 
 	/**
 	 * Create a new {@code DataSourceTransactionManager} instance.
@@ -270,13 +272,18 @@ protected void doBegin(Object transaction, TransactionDefinition definition) {
 				if (logger.isDebugEnabled()) {
 					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
 				}
+				if (definition.isReadOnly()) {
+					checkDefaultReadOnly(newCon);
+				}
 				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
 			}
 
 			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
 			con = txObject.getConnectionHolder().getConnection();
 
-			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
+			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con,
+					definition.getIsolationLevel(),
+					(definition.isReadOnly() && !isDefaultReadOnly()));
 			txObject.setPreviousIsolationLevel(previousIsolationLevel);
 			txObject.setReadOnly(definition.isReadOnly());
 
@@ -381,8 +388,9 @@ protected void doCleanupAfterCompletion(Object transaction) {
 			if (txObject.isMustRestoreAutoCommit()) {
 				con.setAutoCommit(true);
 			}
-			DataSourceUtils.resetConnectionAfterTransaction(
-					con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
+			DataSourceUtils.resetConnectionAfterTransaction(con,
+					txObject.getPreviousIsolationLevel(),
+					(txObject.isReadOnly() && !isDefaultReadOnly()));
 		}
 		catch (Throwable ex) {
 			logger.debug("Could not reset JDBC Connection after transaction", ex);
@@ -399,6 +407,37 @@ protected void doCleanupAfterCompletion(Object transaction) {
 	}
 
 
+	/**
+	 * Check the default {@link Connection#isReadOnly()} flag on a freshly
+	 * obtained connection from the {@code DataSource}, assuming that the
+	 * same flag applies to all connections obtained from the given setup.
+	 * @param newCon the Connection to check
+	 * @since 6.2.13
+	 * @see #isDefaultReadOnly()
+	 */
+	private void checkDefaultReadOnly(Connection newCon) {
+		if (this.defaultReadOnly == null) {
+			try {
+				this.defaultReadOnly = newCon.isReadOnly();
+			}
+			catch (Throwable ex) {
+				logger.debug("Could not determine default JDBC Connection isReadOnly - assuming false", ex);
+				this.defaultReadOnly = false;
+			}
+		}
+	}
+
+	/**
+	 * Check whether the default read-only flag has been determined as {@code true},
+	 * assuming that all encountered connections will be read-only by default and
+	 * therefore do not need explicit {@link Connection#setReadOnly} (re)setting.
+	 * @since 6.2.13
+	 * @see #checkDefaultReadOnly(Connection)
+	 */
+	private boolean isDefaultReadOnly() {
+		return (this.defaultReadOnly == Boolean.TRUE);
+	}
+
 	/**
 	 * Prepare the transactional {@code Connection} right after transaction begin.
 	 * <p>The default implementation executes a "SET TRANSACTION READ ONLY" statement

spring-jdbc/src/main/java/org/springframework/jdbc/datasource/DataSourceUtils.java

@@ -170,19 +170,38 @@ private static Connection fetchConnection(DataSource dataSource) throws SQLExcep
 	 * @param definition the transaction definition to apply
 	 * @return the previous isolation level, if any
 	 * @throws SQLException if thrown by JDBC methods
-	 * @see #resetConnectionAfterTransaction
+	 * @see #prepareConnectionForTransaction(Connection, int, boolean)
+	 */
+	@Nullable
+	public static Integer prepareConnectionForTransaction(Connection con, @Nullable TransactionDefinition definition)
+			throws SQLException {
+
+		return prepareConnectionForTransaction(con,
+				(definition != null ? definition.getIsolationLevel() : TransactionDefinition.ISOLATION_DEFAULT),
+				(definition != null && definition.isReadOnly()));
+	}
+
+	/**
+	 * Prepare the given Connection with the given transaction semantics.
+	 * @param con the Connection to prepare
+	 * @param isolationLevel the isolation level to apply
+	 * @param setReadOnly whether to set the read-only flag
+	 * @return the previous isolation level, if any
+	 * @throws SQLException if thrown by JDBC methods
+	 * @since 6.2.13
+	 * @see #resetConnectionAfterTransaction(Connection, Integer, boolean)
 	 * @see Connection#setTransactionIsolation
 	 * @see Connection#setReadOnly
 	 */
 	@Nullable
-	public static Integer prepareConnectionForTransaction(Connection con, @Nullable TransactionDefinition definition)
+	static Integer prepareConnectionForTransaction(Connection con, int isolationLevel, boolean setReadOnly)
 			throws SQLException {
 
 		Assert.notNull(con, "No Connection specified");
 
 		boolean debugEnabled = logger.isDebugEnabled();
 		// Set read-only flag.
-		if (definition != null && definition.isReadOnly()) {
+		if (setReadOnly) {
 			try {
 				if (debugEnabled) {
 					logger.debug("Setting JDBC Connection [" + con + "] read-only");
@@ -205,15 +224,14 @@ public static Integer prepareConnectionForTransaction(Connection con, @Nullable
 
 		// Apply specific isolation level, if any.
 		Integer previousIsolationLevel = null;
-		if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
+		if (isolationLevel != TransactionDefinition.ISOLATION_DEFAULT) {
 			if (debugEnabled) {
-				logger.debug("Changing isolation level of JDBC Connection [" + con + "] to " +
-						definition.getIsolationLevel());
+				logger.debug("Changing isolation level of JDBC Connection [" + con + "] to " + isolationLevel);
 			}
 			int currentIsolation = con.getTransactionIsolation();
-			if (currentIsolation != definition.getIsolationLevel()) {
+			if (currentIsolation != isolationLevel) {
 				previousIsolationLevel = currentIsolation;
-				con.setTransactionIsolation(definition.getIsolationLevel());
+				con.setTransactionIsolation(isolationLevel);
 			}
 		}
 

spring-jdbc/src/main/java/org/springframework/jdbc/datasource/LazyConnectionDataSourceProxy.java

@@ -153,6 +153,9 @@ public LazyConnectionDataSourceProxy(DataSource targetDataSource) {
 	 */
 	public void setReadOnlyDataSource(@Nullable DataSource readOnlyDataSource) {
 		this.readOnlyDataSource = readOnlyDataSource;
+		if (getTargetDataSource() == null) {
+			setTargetDataSource(readOnlyDataSource);
+		}
 	}
 
 	/**
@@ -395,7 +398,7 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
 						return null;
 					}
 					case "isReadOnly" -> {
-						return this.readOnly;
+						return (this.readOnly || getTargetDataSource() == readOnlyDataSource);
 					}
 					case "setReadOnly" -> {
 						this.readOnly = (Boolean) args[0];