Skip to content

Commit 13b1150

Browse files
odrotbohmodrotbohm
committed
DATACMNS-1371 - Improvements to custom implementation scanning.
CustomRepositoryImplementationDetector now works in two differend modes. If initialized with an ImplementationDetectionConfiguration, it will trigger a canonical, cached component scan for implementation types matching the configured name pattern. Individual custom implementation lookups will then select from this initially scanned set of bean definitions to pick the matching implementation class and potentially resolve ambiguities.
1 parent 3f613ff commit 13b1150

18 files changed

+734
-351
lines changed

‎src/main/java/org/springframework/data/repository/cdi/CdiRepositoryContext.java

+37-65
Original file line numberDiff line numberDiff line change
@@ -15,33 +15,26 @@
1515
*/
1616
package org.springframework.data.repository.cdi;
1717

18+
import lombok.Getter;
1819
import lombok.RequiredArgsConstructor;
1920

20-
import java.io.IOException;
21-
import java.util.Arrays;
22-
import java.util.Collections;
2321
import java.util.Optional;
2422
import java.util.stream.Stream;
2523

26-
import javax.enterprise.inject.CreationException;
2724
import javax.enterprise.inject.UnsatisfiedResolutionException;
2825

29-
import org.springframework.beans.factory.config.BeanDefinition;
3026
import org.springframework.beans.factory.support.AbstractBeanDefinition;
31-
import org.springframework.core.env.Environment;
3227
import org.springframework.core.env.StandardEnvironment;
3328
import org.springframework.core.io.ResourceLoader;
3429
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
35-
import org.springframework.core.type.ClassMetadata;
3630
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
3731
import org.springframework.core.type.classreading.MetadataReaderFactory;
38-
import org.springframework.core.type.filter.AnnotationTypeFilter;
3932
import org.springframework.core.type.filter.TypeFilter;
40-
import org.springframework.data.repository.NoRepositoryBean;
4133
import org.springframework.data.repository.config.CustomRepositoryImplementationDetector;
4234
import org.springframework.data.repository.config.FragmentMetadata;
35+
import org.springframework.data.repository.config.ImplementationDetectionConfiguration;
36+
import org.springframework.data.repository.config.ImplementationLookupConfiguration;
4337
import org.springframework.data.repository.config.RepositoryFragmentConfiguration;
44-
import org.springframework.data.repository.config.RepositoryFragmentDiscovery;
4538
import org.springframework.data.util.Optionals;
4639
import org.springframework.data.util.Streamable;
4740
import org.springframework.lang.Nullable;
@@ -61,6 +54,7 @@ public class CdiRepositoryContext {
6154
private final ClassLoader classLoader;
6255
private final CustomRepositoryImplementationDetector detector;
6356
private final MetadataReaderFactory metadataReaderFactory;
57+
private final FragmentMetadata metdata;
6458

6559
/**
6660
* Create a new {@link CdiRepositoryContext} given {@link ClassLoader} and initialize
@@ -69,16 +63,8 @@ public class CdiRepositoryContext {
6963
* @param classLoader must not be {@literal null}.
7064
*/
7165
public CdiRepositoryContext(ClassLoader classLoader) {
72-
73-
Assert.notNull(classLoader, "ClassLoader must not be null!");
74-
75-
this.classLoader = classLoader;
76-
77-
Environment environment = new StandardEnvironment();
78-
ResourceLoader resourceLoader = new PathMatchingResourcePatternResolver(classLoader);
79-
80-
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
81-
this.detector = new CustomRepositoryImplementationDetector(metadataReaderFactory, environment, resourceLoader);
66+
this(classLoader, new CustomRepositoryImplementationDetector(new StandardEnvironment(),
67+
new PathMatchingResourcePatternResolver(classLoader)));
8268
}
8369

8470
/**
@@ -97,6 +83,7 @@ public CdiRepositoryContext(ClassLoader classLoader, CustomRepositoryImplementat
9783

9884
this.classLoader = classLoader;
9985
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
86+
this.metdata = new FragmentMetadata(metadataReaderFactory);
10087
this.detector = detector;
10188
}
10289

@@ -130,14 +117,11 @@ Class<?> loadClass(String className) {
130117
Stream<RepositoryFragmentConfiguration> getRepositoryFragments(CdiRepositoryConfiguration configuration,
131118
Class<?> repositoryInterface) {
132119

133-
ClassMetadata classMetadata = getClassMetadata(metadataReaderFactory, repositoryInterface.getName());
134-
135-
RepositoryFragmentDiscovery fragmentConfiguration = new CdiRepositoryFragmentDiscovery(configuration);
120+
CdiImplementationDetectionConfiguration config = new CdiImplementationDetectionConfiguration(configuration,
121+
metadataReaderFactory);
136122

137-
return Arrays.stream(classMetadata.getInterfaceNames()) //
138-
.filter(it -> FragmentMetadata.isCandidate(it, metadataReaderFactory)) //
139-
.map(it -> FragmentMetadata.of(it, fragmentConfiguration)) //
140-
.map(this::detectRepositoryFragmentConfiguration) //
123+
return metdata.getFragmentInterfaces(repositoryInterface.getName()) //
124+
.map(it -> detectRepositoryFragmentConfiguration(it, config)) //
141125
.flatMap(Optionals::toStream);
142126
}
143127

@@ -152,26 +136,22 @@ Stream<RepositoryFragmentConfiguration> getRepositoryFragments(CdiRepositoryConf
152136
Optional<Class<?>> getCustomImplementationClass(Class<?> repositoryType,
153137
CdiRepositoryConfiguration cdiRepositoryConfiguration) {
154138

155-
String className = getCustomImplementationClassName(repositoryType, cdiRepositoryConfiguration);
139+
ImplementationDetectionConfiguration configuration = new CdiImplementationDetectionConfiguration(
140+
cdiRepositoryConfiguration, metadataReaderFactory);
141+
ImplementationLookupConfiguration lookup = configuration.forFragment(repositoryType.getName());
156142

157-
Optional<AbstractBeanDefinition> beanDefinition = detector.detectCustomImplementation( //
158-
className, //
159-
className, Collections.singleton(repositoryType.getPackage().getName()), //
160-
Collections.emptySet(), //
161-
BeanDefinition::getBeanClassName);
143+
Optional<AbstractBeanDefinition> beanDefinition = detector.detectCustomImplementation(lookup);
162144

163145
return beanDefinition.map(this::loadBeanClass);
164146
}
165147

166-
private Optional<RepositoryFragmentConfiguration> detectRepositoryFragmentConfiguration(
167-
FragmentMetadata configuration) {
148+
private Optional<RepositoryFragmentConfiguration> detectRepositoryFragmentConfiguration(String fragmentInterfaceName,
149+
CdiImplementationDetectionConfiguration config) {
168150

169-
String className = configuration.getFragmentImplementationClassName();
151+
ImplementationLookupConfiguration lookup = config.forFragment(fragmentInterfaceName);
152+
Optional<AbstractBeanDefinition> beanDefinition = detector.detectCustomImplementation(lookup);
170153

171-
Optional<AbstractBeanDefinition> beanDefinition = detector.detectCustomImplementation(className, null,
172-
configuration.getBasePackages(), configuration.getExclusions(), BeanDefinition::getBeanClassName);
173-
174-
return beanDefinition.map(bd -> new RepositoryFragmentConfiguration(configuration.getFragmentInterfaceName(), bd));
154+
return beanDefinition.map(bd -> new RepositoryFragmentConfiguration(fragmentInterfaceName, bd));
175155
}
176156

177157
@Nullable
@@ -182,45 +162,37 @@ private Class<?> loadBeanClass(AbstractBeanDefinition definition) {
182162
return beanClassName == null ? null : loadClass(beanClassName);
183163
}
184164

185-
private static ClassMetadata getClassMetadata(MetadataReaderFactory metadataReaderFactory, String className) {
186-
187-
try {
188-
return metadataReaderFactory.getMetadataReader(className).getClassMetadata();
189-
} catch (IOException e) {
190-
throw new CreationException(String.format("Cannot parse %s metadata.", className), e);
191-
}
192-
}
193-
194-
private static String getCustomImplementationClassName(Class<?> repositoryType,
195-
CdiRepositoryConfiguration cdiRepositoryConfiguration) {
196-
197-
String configuredPostfix = cdiRepositoryConfiguration.getRepositoryImplementationPostfix();
198-
Assert.hasText(configuredPostfix, "Configured repository postfix must not be null or empty!");
199-
200-
return ClassUtils.getShortName(repositoryType) + configuredPostfix;
201-
}
202-
203165
@RequiredArgsConstructor
204-
private static class CdiRepositoryFragmentDiscovery implements RepositoryFragmentDiscovery {
166+
private static class CdiImplementationDetectionConfiguration implements ImplementationDetectionConfiguration {
205167

206168
private final CdiRepositoryConfiguration configuration;
169+
private final @Getter MetadataReaderFactory metadataReaderFactory;
207170

208171
/*
209172
* (non-Javadoc)
210-
* @see org.springframework.data.repository.config.RepositoryFragmentDiscovery#getExcludeFilters()
173+
* @see org.springframework.data.repository.config.CustomRepositoryImplementationDetector.ImplementationDetectionConfiguration#getImplementationPostfix()
211174
*/
212175
@Override
213-
public Streamable<TypeFilter> getExcludeFilters() {
214-
return Streamable.of(new AnnotationTypeFilter(NoRepositoryBean.class));
176+
public String getImplementationPostfix() {
177+
return configuration.getRepositoryImplementationPostfix();
215178
}
216179

217180
/*
218181
* (non-Javadoc)
219-
* @see org.springframework.data.repository.config.RepositoryFragmentDiscovery#getRepositoryImplementationPostfix()
182+
* @see org.springframework.data.repository.config.CustomRepositoryImplementationDetector.ImplementationDetectionConfiguration#getBasePackages()
220183
*/
221184
@Override
222-
public Optional<String> getRepositoryImplementationPostfix() {
223-
return Optional.of(configuration.getRepositoryImplementationPostfix());
185+
public Streamable<String> getBasePackages() {
186+
return Streamable.empty();
187+
}
188+
189+
/*
190+
* (non-Javadoc)
191+
* @see org.springframework.data.repository.config.CustomRepositoryImplementationDetector.ImplementationDetectionConfiguration#getExcludeFilters()
192+
*/
193+
@Override
194+
public Streamable<TypeFilter> getExcludeFilters() {
195+
return Streamable.empty();
224196
}
225197
}
226198
}

‎src/main/java/org/springframework/data/repository/config/CustomRepositoryImplementationDetector.java

+62-49
Original file line numberDiff line numberDiff line change
@@ -15,29 +15,27 @@
1515
*/
1616
package org.springframework.data.repository.config;
1717

18-
import lombok.NonNull;
19-
import lombok.RequiredArgsConstructor;
20-
2118
import java.util.Collection;
2219
import java.util.Optional;
2320
import java.util.Set;
24-
import java.util.function.Function;
2521
import java.util.stream.Collectors;
2622

27-
import javax.annotation.Nullable;
28-
2923
import org.springframework.beans.factory.config.BeanDefinition;
3024
import org.springframework.beans.factory.support.AbstractBeanDefinition;
3125
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
3226
import org.springframework.core.env.Environment;
3327
import org.springframework.core.io.ResourceLoader;
34-
import org.springframework.core.type.classreading.MetadataReaderFactory;
35-
import org.springframework.core.type.filter.TypeFilter;
36-
import org.springframework.data.util.Streamable;
28+
import org.springframework.data.util.Lazy;
29+
import org.springframework.data.util.StreamUtils;
3730
import org.springframework.util.Assert;
3831

3932
/**
40-
* Detects the custom implementation for a {@link org.springframework.data.repository.Repository}
33+
* Detects the custom implementation for a {@link org.springframework.data.repository.Repository} instance. If
34+
* configured with a {@link ImplementationDetectionConfiguration} at construction time, the necessary component scan is
35+
* executed on first access, cached and its result is the filtered on every further implementation lookup according to
36+
* the given {@link ImplementationDetectionConfiguration}. If none is given initially, every invocation to
37+
* {@link #detectCustomImplementation(String, String, ImplementationDetectionConfiguration)} will issue a new component
38+
* scan.
4139
*
4240
* @author Oliver Gierke
4341
* @author Mark Paluch
@@ -46,76 +44,91 @@
4644
* @author Jens Schauder
4745
* @author Mark Paluch
4846
*/
49-
@RequiredArgsConstructor
5047
public class CustomRepositoryImplementationDetector {
5148

52-
private static final String CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN = "**/%s.class";
49+
private static final String CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN = "**/*%s.class";
5350
private static final String AMBIGUOUS_CUSTOM_IMPLEMENTATIONS = "Ambiguous custom implementations detected! Found %s but expected a single implementation!";
5451

55-
private final @NonNull MetadataReaderFactory metadataReaderFactory;
56-
private final @NonNull Environment environment;
57-
private final @NonNull ResourceLoader resourceLoader;
52+
private final Environment environment;
53+
private final ResourceLoader resourceLoader;
54+
private final Lazy<Set<BeanDefinition>> implementationCandidates;
5855

5956
/**
60-
* Tries to detect a custom implementation for a repository bean by classpath scanning.
61-
*
62-
* @param configuration the {@link RepositoryConfiguration} to consider.
63-
* @return the {@code AbstractBeanDefinition} of the custom implementation or {@literal null} if none found.
57+
* Creates a new {@link CustomRepositoryImplementationDetector} with the given {@link Environment},
58+
* {@link ResourceLoader} and {@link ImplementationDetectionConfiguration}. The latter will be registered for a
59+
* one-time component scan for implementation candidates that will the be used and filtered in all subsequent calls to
60+
* {@link #detectCustomImplementation(RepositoryConfiguration)}.
61+
*
62+
* @param environment must not be {@literal null}.
63+
* @param resourceLoader must not be {@literal null}.
64+
* @param configuration must not be {@literal null}.
65+
*/
66+
public CustomRepositoryImplementationDetector(Environment environment, ResourceLoader resourceLoader,
67+
ImplementationDetectionConfiguration configuration) {
68+
69+
Assert.notNull(environment, "Environment must not be null!");
70+
Assert.notNull(resourceLoader, "ResourceLoader must not be null!");
71+
Assert.notNull(configuration, "ImplementationDetectionConfiguration must not be null!");
72+
73+
this.environment = environment;
74+
this.resourceLoader = resourceLoader;
75+
this.implementationCandidates = Lazy.of(() -> findCandidateBeanDefinitions(configuration));
76+
}
77+
78+
/**
79+
* Creates a new {@link CustomRepositoryImplementationDetector} with the given {@link Environment} and
80+
* {@link ResourceLoader}. Calls to {@link #detectCustomImplementation(ImplementationLookupConfiguration)} will issue
81+
* scans for
82+
*
83+
* @param environment must not be {@literal null}.
84+
* @param resourceLoader must not be {@literal null}.
6485
*/
65-
@SuppressWarnings("deprecation")
66-
public Optional<AbstractBeanDefinition> detectCustomImplementation(RepositoryConfiguration<?> configuration) {
86+
public CustomRepositoryImplementationDetector(Environment environment, ResourceLoader resourceLoader) {
6787

68-
// TODO 2.0: Extract into dedicated interface for custom implementation lookup configuration.
88+
Assert.notNull(environment, "Environment must not be null!");
89+
Assert.notNull(resourceLoader, "ResourceLoader must not be null!");
6990

70-
return detectCustomImplementation( //
71-
configuration.getImplementationClassName(), //
72-
configuration.getImplementationBeanName(), //
73-
configuration.getImplementationBasePackages(), //
74-
configuration.getExcludeFilters(), //
75-
bd -> configuration.getConfigurationSource().generateBeanName(bd));
91+
this.environment = environment;
92+
this.resourceLoader = resourceLoader;
93+
this.implementationCandidates = Lazy.empty();
7694
}
7795

7896
/**
7997
* Tries to detect a custom implementation for a repository bean by classpath scanning.
8098
*
81-
* @param className must not be {@literal null}.
82-
* @param beanName may be {@literal null}
83-
* @param basePackages must not be {@literal null}.
84-
* @param excludeFilters must not be {@literal null}.
85-
* @param beanNameGenerator must not be {@literal null}.
99+
* @param lookup must not be {@literal null}.
86100
* @return the {@code AbstractBeanDefinition} of the custom implementation or {@literal null} if none found.
87101
*/
88-
public Optional<AbstractBeanDefinition> detectCustomImplementation(String className, @Nullable String beanName,
89-
Iterable<String> basePackages, Iterable<TypeFilter> excludeFilters,
90-
Function<BeanDefinition, String> beanNameGenerator) {
102+
public Optional<AbstractBeanDefinition> detectCustomImplementation(ImplementationLookupConfiguration lookup) {
91103

92-
Assert.notNull(className, "ClassName must not be null!");
93-
Assert.notNull(basePackages, "BasePackages must not be null!");
104+
Assert.notNull(lookup, "ImplementationLookupConfiguration must not be null!");
94105

95-
Set<BeanDefinition> definitions = findCandidateBeanDefinitions(className, basePackages, excludeFilters);
106+
Set<BeanDefinition> definitions = implementationCandidates.getOptional()
107+
.orElseGet(() -> findCandidateBeanDefinitions(lookup)).stream() //
108+
.filter(lookup::matches) //
109+
.collect(StreamUtils.toUnmodifiableSet());
96110

97111
return SelectionSet //
98112
.of(definitions, c -> c.isEmpty() ? Optional.empty() : throwAmbiguousCustomImplementationException(c)) //
99-
.filterIfNecessary(bd -> beanName != null && beanName.equals(beanNameGenerator.apply(bd)))//
100-
.uniqueResult().map(it -> AbstractBeanDefinition.class.cast(it));
113+
.filterIfNecessary(lookup::hasMatchingBeanName) //
114+
.uniqueResult() //
115+
.map(AbstractBeanDefinition.class::cast);
101116
}
102117

103-
Set<BeanDefinition> findCandidateBeanDefinitions(String className, Iterable<String> basePackages,
104-
Iterable<TypeFilter> excludeFilters) {
118+
private Set<BeanDefinition> findCandidateBeanDefinitions(ImplementationDetectionConfiguration config) {
105119

106-
// Build pattern to lookup implementation class
120+
String postfix = config.getImplementationPostfix();
107121

108-
// Build classpath scanner and lookup bean definition
109122
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false,
110123
environment);
111124
provider.setResourceLoader(resourceLoader);
112-
provider.setResourcePattern(String.format(CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN, className));
113-
provider.setMetadataReaderFactory(metadataReaderFactory);
125+
provider.setResourcePattern(String.format(CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN, postfix));
126+
provider.setMetadataReaderFactory(config.getMetadataReaderFactory());
114127
provider.addIncludeFilter((reader, factory) -> true);
115128

116-
excludeFilters.forEach(it -> provider.addExcludeFilter(it));
129+
config.getExcludeFilters().forEach(it -> provider.addExcludeFilter(it));
117130

118-
return Streamable.of(basePackages).stream()//
131+
return config.getBasePackages().stream()//
119132
.flatMap(it -> provider.findCandidateComponents(it).stream())//
120133
.collect(Collectors.toSet());
121134
}

0 commit comments

Comments
 (0)