diff --git a/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc b/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc index 4112a918a47..bf2ba81cc76 100644 --- a/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc +++ b/framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc @@ -501,8 +501,8 @@ extend from it, your sub-class inherits a `setDataSource(..)` method from the Regardless of which of the above template initialization styles you choose to use (or not), it is seldom necessary to create a new instance of a `JdbcTemplate` class each time you want to run SQL. Once configured, a `JdbcTemplate` instance is thread-safe. -If your application accesses multiple -databases, you may want multiple `JdbcTemplate` instances, which requires multiple `DataSources` and, subsequently, multiple differently +If your application accesses multiple databases, you may want multiple `JdbcTemplate` +instances, which requires multiple `DataSources` and, subsequently, multiple differently configured `JdbcTemplate` instances. @@ -531,11 +531,8 @@ Java:: } public int countOfActorsByFirstName(String firstName) { - - String sql = "select count(*) from T_ACTOR where first_name = :first_name"; - + String sql = "select count(*) from t_actor where first_name = :first_name"; SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName); - return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class); } ---- @@ -547,7 +544,7 @@ Kotlin:: private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource) fun countOfActorsByFirstName(firstName: String): Int { - val sql = "select count(*) from T_ACTOR where first_name = :first_name" + val sql = "select count(*) from t_actor where first_name = :first_name" val namedParameters = MapSqlParameterSource("first_name", firstName) return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!! } @@ -579,12 +576,9 @@ Java:: } public int countOfActorsByFirstName(String firstName) { - - String sql = "select count(*) from T_ACTOR where first_name = :first_name"; - + String sql = "select count(*) from t_actor where first_name = :first_name"; Map namedParameters = Collections.singletonMap("first_name", firstName); - - return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class); + return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class); } ---- @@ -596,7 +590,7 @@ Kotlin:: private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource) fun countOfActorsByFirstName(firstName: String): Int { - val sql = "select count(*) from T_ACTOR where first_name = :first_name" + val sql = "select count(*) from t_actor where first_name = :first_name" val namedParameters = mapOf("first_name" to firstName) return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!! } @@ -644,7 +638,6 @@ Java:: } // setters omitted... - } ---- @@ -673,12 +666,9 @@ Java:: } public int countOfActors(Actor exampleActor) { - // notice how the named parameters match the properties of the above 'Actor' class - String sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName"; - + String sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName"; SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor); - return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class); } ---- @@ -694,7 +684,7 @@ Kotlin:: fun countOfActors(exampleActor: Actor): Int { // notice how the named parameters match the properties of the above 'Actor' class - val sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName" + val sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName" val namedParameters = BeanPropertySqlParameterSource(exampleActor) return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!! } @@ -707,8 +697,8 @@ functionality that is present only in the `JdbcTemplate` class, you can use the `getJdbcOperations()` method to access the wrapped `JdbcTemplate` through the `JdbcOperations` interface. -See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate` Best Practices] for guidelines on using the -`NamedParameterJdbcTemplate` class in the context of an application. +See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate` Best Practices] +for guidelines on using the `NamedParameterJdbcTemplate` class in the context of an application. [[jdbc-SQLExceptionTranslator]] diff --git a/framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc b/framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc index f4114765cbf..1e9b9135941 100644 --- a/framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc +++ b/framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc @@ -98,9 +98,9 @@ through its `key` attribute. You can use xref:core/expressions.adoc[SpEL] to pic arguments of interest (or their nested properties), perform operations, or even invoke arbitrary methods without having to write any code or implement any interface. This is the recommended approach over the -xref:integration/cache/annotations.adoc#cache-annotations-cacheable-default-key[default generator], since methods tend to be -quite different in signatures as the code base grows. While the default strategy might -work for some methods, it rarely works for all methods. +xref:integration/cache/annotations.adoc#cache-annotations-cacheable-default-key[default generator], +since methods tend to be quite different in signatures as the code base grows. While the +default strategy might work for some methods, it rarely works for all methods. The following examples use various SpEL declarations (if you are not familiar with SpEL, do yourself a favor and read xref:core/expressions.adoc[Spring Expression Language]): @@ -137,9 +137,8 @@ that specifies both results in an exception. [[cache-annotations-cacheable-default-cache-resolver]] === Default Cache Resolution -The caching abstraction uses a simple `CacheResolver` that -retrieves the caches defined at the operation level by using the configured -`CacheManager`. +The caching abstraction uses a simple `CacheResolver` that retrieves the caches +defined at the operation level by using the configured `CacheManager`. To provide a different default cache resolver, you need to implement the `org.springframework.cache.interceptor.CacheResolver` interface. @@ -160,12 +159,11 @@ For applications that work with several cache managers, you can set the ---- <1> Specifying `anotherCacheManager`. - You can also replace the `CacheResolver` entirely in a fashion similar to that of -replacing xref:integration/cache/annotations.adoc#cache-annotations-cacheable-key[key generation]. The resolution is -requested for every cache operation, letting the implementation actually resolve -the caches to use based on runtime arguments. The following example shows how to -specify a `CacheResolver`: +replacing xref:integration/cache/annotations.adoc#cache-annotations-cacheable-key[key generation]. +The resolution is requested for every cache operation, letting the implementation +actually resolve the caches to use based on runtime arguments. The following example +shows how to specify a `CacheResolver`: [source,java,indent=0,subs="verbatim,quotes"] ---- @@ -174,7 +172,6 @@ specify a `CacheResolver`: ---- <1> Specifying the `CacheResolver`. - [NOTE] ==== Since Spring 4.1, the `value` attribute of the cache annotations are no longer @@ -229,7 +226,6 @@ argument `name` has a length shorter than 32: ---- <1> Setting a condition on `@Cacheable`. - In addition to the `condition` parameter, you can use the `unless` parameter to veto the adding of a value to the cache. Unlike `condition`, `unless` expressions are evaluated after the method has been invoked. To expand on the previous example, perhaps we only @@ -242,7 +238,6 @@ want to cache paperback books, as the following example does: ---- <1> Using the `unless` attribute to block hardbacks. - The cache abstraction supports `java.util.Optional` return types. If an `Optional` value is _present_, it will be stored in the associated cache. If an `Optional` value is not present, `null` will be stored in the associated cache. `#result` always refers to the @@ -344,7 +339,7 @@ confirm the exclusion. [[cache-annotations-evict]] -== The `@CacheEvict` annotation +== The `@CacheEvict` Annotation The cache abstraction allows not just population of a cache store but also eviction. This process is useful for removing stale or unused data from the cache. As opposed to @@ -402,7 +397,7 @@ The following example uses two `@CacheEvict` annotations: [[cache-annotations-config]] -== The `@CacheConfig` annotation +== The `@CacheConfig` Annotation So far, we have seen that caching operations offer many customization options and that you can set these options for each operation. However, some of the customization options diff --git a/spring-r2dbc/src/main/java/org/springframework/r2dbc/core/DefaultDatabaseClient.java b/spring-r2dbc/src/main/java/org/springframework/r2dbc/core/DefaultDatabaseClient.java index ab5caa746d5..8c75690eb19 100644 --- a/spring-r2dbc/src/main/java/org/springframework/r2dbc/core/DefaultDatabaseClient.java +++ b/spring-r2dbc/src/main/java/org/springframework/r2dbc/core/DefaultDatabaseClient.java @@ -163,8 +163,7 @@ final class DefaultDatabaseClient implements DatabaseClient { /** * Release the {@link Connection}. * @param connection to close. - * @return a {@link Publisher} that completes successfully when the connection is - * closed + * @return a {@link Publisher} that completes successfully when the connection is closed */ private Publisher closeConnection(Connection connection) { return ConnectionFactoryUtils.currentConnectionFactory(