root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 15 Packages Projects Releases Wiki Activity

Merge branch '2.3.x' 

Closes gh-22874
This commit is contained in:
Stephane Nicoll 2020-08-11 13:40:21 +02:00
parent 13cd429c60 dc4de06b35
commit 5bd69fcd61
7 changed files with 127 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java vendored
View File

@ -28,6 +28,7 @@ import org.springframework.util.Assert;
* @author Phillip Webb
* @author Eddú Meléndez
*/
@SuppressWarnings("deprecation")
final class CacheConfigurations {
private static final Map<CacheType, Class<?>> MAPPINGS;

6
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CouchbaseCacheConfiguration.java vendored
View File

@ -21,6 +21,7 @@ import java.util.List;
import com.couchbase.client.java.Cluster;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.cache.CacheProperties.Couchbase;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@ -39,16 +40,20 @@ import org.springframework.util.ObjectUtils;
*
* @author Stephane Nicoll
* @since 1.4.0
* @deprecated since 2.3.3 as this class is not intended for public use. It will be made
* package-private in a future release
*/
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Cluster.class, CouchbaseClientFactory.class, CouchbaseCacheManager.class })
@ConditionalOnMissingBean(CacheManager.class)
@ConditionalOnSingleCandidate(CouchbaseClientFactory.class)
@Conditional(CacheCondition.class)
@Deprecated
public class CouchbaseCacheConfiguration {
@Bean
public CouchbaseCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers customizers,
ObjectProvider<CouchbaseCacheManagerBuilderCustomizer> couchbaseCacheManagerBuilderCustomizers,
CouchbaseClientFactory clientFactory) {
List<String> cacheNames = cacheProperties.getCacheNames();
CouchbaseCacheManagerBuilder builder = CouchbaseCacheManager.builder(clientFactory);
@ -62,6 +67,7 @@ public class CouchbaseCacheConfiguration {
if (!ObjectUtils.isEmpty(cacheNames)) {
builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
}
couchbaseCacheManagerBuilderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
CouchbaseCacheManager cacheManager = builder.build();
return customizers.customize(cacheManager);
}

39
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CouchbaseCacheManagerBuilderCustomizer.java vendored Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright 2012-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.autoconfigure.cache;
import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
import org.springframework.data.couchbase.cache.CouchbaseCacheManager.CouchbaseCacheManagerBuilder;
/**
* Callback interface that can be implemented by beans wishing to customize the
* {@link CouchbaseCacheManagerBuilder} before it is used to build the auto-configured
* {@link CouchbaseCacheManager}.
*
* @author Stephane Nicoll
* @since 2.3.3
*/
@FunctionalInterface
public interface CouchbaseCacheManagerBuilderCustomizer {
/**
* Customize the {@link CouchbaseCacheManagerBuilder}.
* @param builder the builder to customize
*/
void customize(CouchbaseCacheManagerBuilder builder);
}

33
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java vendored
View File

@ -65,6 +65,7 @@ import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.data.couchbase.CouchbaseClientFactory;
import org.springframework.data.couchbase.cache.CouchbaseCache;
import org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration;
import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
@ -196,7 +197,7 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
@Test
void couchbaseCacheExplicit() {
this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
.withPropertyValues("spring.cache.type=couchbase").run((context) -> {
CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
@ -205,14 +206,14 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
@Test
void couchbaseCacheWithCustomizers() {
this.contextRunner.withUserConfiguration(CouchbaseCacheAndCustomizersConfiguration.class)
this.contextRunner.withUserConfiguration(CouchbaseWithCustomizersConfiguration.class)
.withPropertyValues("spring.cache.type=couchbase")
.run(verifyCustomizers("allCacheManagerCustomizer", "couchbaseCacheManagerCustomizer"));
}
@Test
void couchbaseCacheExplicitWithCaches() {
this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar")
.run((context) -> {
@ -226,7 +227,7 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
@Test
void couchbaseCacheExplicitWithTtl() {
this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames=foo,bar",
"spring.cache.couchbase.expiration=2000")
.run((context) -> {
@ -238,6 +239,20 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
});
}
@Test
void couchbaseCacheWithCouchbaseCacheManagerBuilderCustomizer() {
this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
.withPropertyValues("spring.cache.type=couchbase", "spring.cache.couchbase.expiration=15s")
.withBean(CouchbaseCacheManagerBuilderCustomizer.class, () -> (builder) -> builder.cacheDefaults(
CouchbaseCacheConfiguration.defaultCacheConfig().entryExpiry(java.time.Duration.ofSeconds(10))))
.run((context) -> {
CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
CouchbaseCacheConfiguration couchbaseCacheConfiguration = getDefaultCouchbaseCacheConfiguration(
cacheManager);
assertThat(couchbaseCacheConfiguration.getExpiry()).isEqualTo(java.time.Duration.ofSeconds(10));
});
}
@Test
void redisCacheExplicit() {
this.contextRunner.withUserConfiguration(RedisConfiguration.class)
@ -668,6 +683,10 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isEqualTo(1L);
}
private CouchbaseCacheConfiguration getDefaultCouchbaseCacheConfiguration(CouchbaseCacheManager cacheManager) {
return (CouchbaseCacheConfiguration) ReflectionTestUtils.getField(cacheManager, "defaultCacheConfig");
}
private RedisCacheConfiguration getDefaultRedisCacheConfiguration(RedisCacheManager cacheManager) {
return (RedisCacheConfiguration) ReflectionTestUtils.getField(cacheManager, "defaultCacheConfig");
}
@ -721,7 +740,7 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
@Configuration(proxyBeanMethods = false)
@EnableCaching
static class CouchbaseCacheConfiguration {
static class CouchbaseConfiguration {
@Bean
CouchbaseClientFactory couchbaseClientFactory() {
@ -731,8 +750,8 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
}
@Configuration(proxyBeanMethods = false)
@Import({ CouchbaseCacheConfiguration.class, CacheManagerCustomizersConfiguration.class })
static class CouchbaseCacheAndCustomizersConfiguration {
@Import({ CouchbaseConfiguration.class, CacheManagerCustomizersConfiguration.class })
static class CouchbaseWithCustomizersConfiguration {
}

1
spring-boot-project/spring-boot-docs/build.gradle
View File

@ -80,6 +80,7 @@ dependencies {
implementation("org.springframework:spring-test")
implementation("org.springframework:spring-web")
implementation("org.springframework:spring-webflux")
implementation("org.springframework.data:spring-data-couchbase")
implementation("org.springframework.data:spring-data-redis")
implementation("org.springframework.data:spring-data-r2dbc")
implementation("org.springframework.kafka:spring-kafka")

39
spring-boot-project/spring-boot-docs/src/docs/asciidoc/spring-boot-features.adoc
View File

@ -5163,49 +5163,24 @@ See https://github.com/infinispan/infinispan-spring-boot[Infinispan's documentat
[[boot-features-caching-provider-couchbase]]
==== Couchbase
If the https://www.couchbase.com/[Couchbase] Java client and the `couchbase-spring-cache` implementation are available and Couchbase is <<boot-features-couchbase,configured>>, a `CouchbaseCacheManager` is auto-configured.
It is also possible to create additional caches on startup by setting the configprop:spring.cache.cache-names[] property.
These caches operate on the `Bucket` that was auto-configured.
You can _also_ create additional caches on another `Bucket` by using the customizer.
Assume you need two caches (`cache1` and `cache2`) on the "main" `Bucket` and one (`cache3`) cache with a custom time to live of 2 seconds on the "`another`" `Bucket`.
You can create the first two caches through configuration, as follows:
If Spring Data Couchbase is available and Couchbase is <<boot-features-couchbase,configured>>, a `CouchbaseCacheManager` is auto-configured.
It is possible to create additional caches on startup by setting the configprop:spring.cache.cache-names[] property and cache defaults can be configured by using `spring.cache.couchbase.*` properties.
For instance, the following configuration creates `cache1` and `cache2` caches with an entry _expiration_ of 10 minutes:
[source,properties,indent=0,configprops]
----
spring.cache.cache-names=cache1,cache2
spring.cache.couchbase.expiration=10m
----
Then you can define a `@Configuration` class to configure the extra `Bucket` and the `cache3` cache, as follows:
If you need more control over the configuration, consider registering a `CouchbaseCacheManagerBuilderCustomizer` bean.
The following example shows a customizer that configures a specific entry expiration for `cache1` and `cache2`:
[source,java,indent=0]
----
@Configuration(proxyBeanMethods = false)
public class CouchbaseCacheConfiguration {
private final Cluster cluster;
public CouchbaseCacheConfiguration(Cluster cluster) {
this.cluster = cluster;
}
@Bean
public Bucket anotherBucket() {
return this.cluster.openBucket("another", "secret");
}
@Bean
public CacheManagerCustomizer<CouchbaseCacheManager> cacheManagerCustomizer() {
return c -> {
c.prepareCache("cache3", CacheBuilder.newInstance(anotherBucket())
.withExpiration(2));
};
}
}
include::{code-examples}/cache/CouchbaseCacheManagerCustomizationExample.java[tag=configuration]
----
This sample configuration reuses the `Cluster` that was created through auto-configuration.
[[boot-features-caching-provider-redis]]

47
spring-boot-project/spring-boot-docs/src/main/java/org/springframework/boot/docs/cache/CouchbaseCacheManagerCustomizationExample.java vendored Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.docs.cache;
import java.time.Duration;
import org.springframework.boot.autoconfigure.cache.CouchbaseCacheManagerBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration;
/**
* An example how to customize {@code CouchbaseCacheManagerBuilder} via
* {@code CouchbaseCacheManagerBuilderCustomizer}.
*
* @author Dmytro Nosan
*/
@Configuration(proxyBeanMethods = false)
public class CouchbaseCacheManagerCustomizationExample {
// tag::configuration[]
@Bean
public CouchbaseCacheManagerBuilderCustomizer myCouchbaseCacheManagerBuilderCustomizer() {
return (builder) -> builder
.withCacheConfiguration("cache1",
CouchbaseCacheConfiguration.defaultCacheConfig().entryExpiry(Duration.ofSeconds(10)))
.withCacheConfiguration("cache2",
CouchbaseCacheConfiguration.defaultCacheConfig().entryExpiry(Duration.ofMinutes(1)));
}
// end::configuration[]
}