From 069809505e6eec2314157b27089cba7d4633d724 Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Fri, 17 Oct 2025 19:46:42 -0700 Subject: [PATCH] Drop SharedMetadataReaderFactoryContextInitializer Closes gh-47687 --- ...tadataReaderFactoryContextInitializer.java | 12 +- ...aReaderFactoryContextInitializerTests.java | 4 +- ...ReferenceCachingMetadataReaderFactory.java | 109 ------------------ .../boot/type/classreading/package-info.java | 23 ---- ...enceCachingMetadataReaderFactoryTests.java | 69 ----------- 5 files changed, 7 insertions(+), 210 deletions(-) delete mode 100644 core/spring-boot/src/main/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactory.java delete mode 100644 core/spring-boot/src/main/java/org/springframework/boot/type/classreading/package-info.java delete mode 100644 core/spring-boot/src/test/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactoryTests.java diff --git a/core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializer.java b/core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializer.java index 69168d5198f..b302f1d47ff 100644 --- a/core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializer.java +++ b/core/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializer.java @@ -33,7 +33,6 @@ import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.beans.factory.support.RegisteredBean; -import org.springframework.boot.type.classreading.ConcurrentReferenceCachingMetadataReaderFactory; import org.springframework.context.ApplicationContextInitializer; import org.springframework.context.ApplicationListener; import org.springframework.context.ConfigurableApplicationContext; @@ -187,20 +186,19 @@ class SharedMetadataReaderFactoryContextInitializer implements /** * {@link FactoryBean} to create the shared {@link MetadataReaderFactory}. */ - static class SharedMetadataReaderFactoryBean - implements FactoryBean, ResourceLoaderAware, - ApplicationListener { + static class SharedMetadataReaderFactoryBean implements FactoryBean, + ResourceLoaderAware, ApplicationListener { @SuppressWarnings("NullAway.Init") - private ConcurrentReferenceCachingMetadataReaderFactory metadataReaderFactory; + private CachingMetadataReaderFactory metadataReaderFactory; @Override public void setResourceLoader(ResourceLoader resourceLoader) { - this.metadataReaderFactory = new ConcurrentReferenceCachingMetadataReaderFactory(resourceLoader); + this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader); } @Override - public ConcurrentReferenceCachingMetadataReaderFactory getObject() throws Exception { + public CachingMetadataReaderFactory getObject() throws Exception { return this.metadataReaderFactory; } diff --git a/core/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializerTests.java b/core/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializerTests.java index 901f56b092b..8afff2b3a47 100644 --- a/core/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializerTests.java +++ b/core/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/SharedMetadataReaderFactoryContextInitializerTests.java @@ -28,11 +28,11 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProce import org.springframework.boot.SpringApplication; import org.springframework.boot.WebApplicationType; import org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer.CachingMetadataReaderFactoryPostProcessor; -import org.springframework.boot.type.classreading.ConcurrentReferenceCachingMetadataReaderFactory; import org.springframework.context.ApplicationContextInitializer; import org.springframework.context.annotation.AnnotationConfigUtils; import org.springframework.context.annotation.ConfigurationClassPostProcessor; import org.springframework.context.support.GenericApplicationContext; +import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.test.util.ReflectionTestUtils; import static org.assertj.core.api.Assertions.assertThat; @@ -83,7 +83,7 @@ class SharedMetadataReaderFactoryContextInitializerTests { assertThat(bean).isSameAs(configurationAnnotationPostProcessor); then(configurationAnnotationPostProcessor).should() .setMetadataReaderFactory(assertArg((metadataReaderFactory) -> assertThat(metadataReaderFactory) - .isInstanceOf(ConcurrentReferenceCachingMetadataReaderFactory.class))); + .isInstanceOf(CachingMetadataReaderFactory.class))); } static class TestConfig { diff --git a/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactory.java b/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactory.java deleted file mode 100644 index 54548142edd..00000000000 --- a/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactory.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright 2012-present 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.type.classreading; - -import java.io.IOException; -import java.util.Map; - -import org.springframework.core.io.Resource; -import org.springframework.core.io.ResourceLoader; -import org.springframework.core.type.classreading.CachingMetadataReaderFactory; -import org.springframework.core.type.classreading.MetadataReader; -import org.springframework.core.type.classreading.MetadataReaderFactory; -import org.springframework.core.type.classreading.SimpleMetadataReaderFactory; -import org.springframework.util.ConcurrentReferenceHashMap; - -/** - * Caching implementation of the {@link MetadataReaderFactory} interface backed by a - * {@link ConcurrentReferenceHashMap}, caching {@link MetadataReader} per Spring - * {@link Resource} handle (i.e. per ".class" file). - * - * @author Phillip Webb - * @since 1.4.0 - * @see CachingMetadataReaderFactory - */ -public class ConcurrentReferenceCachingMetadataReaderFactory extends SimpleMetadataReaderFactory { - - private final Map classNameCache = new ConcurrentReferenceHashMap<>(); - - private final Map resourceCache = new ConcurrentReferenceHashMap<>(); - - /** - * Create a new {@link ConcurrentReferenceCachingMetadataReaderFactory} instance for - * the default class loader. - */ - public ConcurrentReferenceCachingMetadataReaderFactory() { - } - - /** - * Create a new {@link ConcurrentReferenceCachingMetadataReaderFactory} instance for - * the given resource loader. - * @param resourceLoader the Spring ResourceLoader to use (also determines the - * ClassLoader to use) - */ - public ConcurrentReferenceCachingMetadataReaderFactory(ResourceLoader resourceLoader) { - super(resourceLoader); - } - - /** - * Create a new {@link ConcurrentReferenceCachingMetadataReaderFactory} instance for - * the given class loader. - * @param classLoader the ClassLoader to use - */ - public ConcurrentReferenceCachingMetadataReaderFactory(ClassLoader classLoader) { - super(classLoader); - } - - @Override - public MetadataReader getMetadataReader(String className) throws IOException { - MetadataReader metadataReader = this.classNameCache.get(className); - if (metadataReader == null) { - metadataReader = super.getMetadataReader(className); - this.classNameCache.put(className, metadataReader); - } - return metadataReader; - } - - @Override - public MetadataReader getMetadataReader(Resource resource) throws IOException { - MetadataReader metadataReader = this.resourceCache.get(resource); - if (metadataReader == null) { - metadataReader = createMetadataReader(resource); - this.resourceCache.put(resource, metadataReader); - } - return metadataReader; - } - - /** - * Create the meta-data reader. - * @param resource the source resource. - * @return the meta-data reader - * @throws IOException on error - */ - protected MetadataReader createMetadataReader(Resource resource) throws IOException { - return super.getMetadataReader(resource); - } - - /** - * Clear the entire MetadataReader cache, removing all cached class metadata. - */ - public void clearCache() { - this.classNameCache.clear(); - this.resourceCache.clear(); - } - -} diff --git a/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/package-info.java b/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/package-info.java deleted file mode 100644 index a74ac04104f..00000000000 --- a/core/spring-boot/src/main/java/org/springframework/boot/type/classreading/package-info.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright 2012-present 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. - */ - -/** - * Support classes for reading annotation and class-level metadata. - */ -@NullMarked -package org.springframework.boot.type.classreading; - -import org.jspecify.annotations.NullMarked; diff --git a/core/spring-boot/src/test/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactoryTests.java b/core/spring-boot/src/test/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactoryTests.java deleted file mode 100644 index f25e4e5a9aa..00000000000 --- a/core/spring-boot/src/test/java/org/springframework/boot/type/classreading/ConcurrentReferenceCachingMetadataReaderFactoryTests.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright 2012-present 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.type.classreading; - -import org.junit.jupiter.api.Test; - -import org.springframework.core.io.Resource; -import org.springframework.core.type.classreading.MetadataReader; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.times; - -/** - * Tests for {@link ConcurrentReferenceCachingMetadataReaderFactory}. - * - * @author Phillip Webb - */ -class ConcurrentReferenceCachingMetadataReaderFactoryTests { - - @Test - void getMetadataReaderUsesCache() throws Exception { - TestConcurrentReferenceCachingMetadataReaderFactory factory = spy( - new TestConcurrentReferenceCachingMetadataReaderFactory()); - MetadataReader metadataReader1 = factory.getMetadataReader(getClass().getName()); - MetadataReader metadataReader2 = factory.getMetadataReader(getClass().getName()); - assertThat(metadataReader1).isSameAs(metadataReader2); - then(factory).should().createMetadataReader(any(Resource.class)); - } - - @Test - void clearResetsCache() throws Exception { - TestConcurrentReferenceCachingMetadataReaderFactory factory = spy( - new TestConcurrentReferenceCachingMetadataReaderFactory()); - MetadataReader metadataReader1 = factory.getMetadataReader(getClass().getName()); - factory.clearCache(); - MetadataReader metadataReader2 = factory.getMetadataReader(getClass().getName()); - assertThat(metadataReader1).isNotSameAs(metadataReader2); - then(factory).should(times(2)).createMetadataReader(any(Resource.class)); - } - - static class TestConcurrentReferenceCachingMetadataReaderFactory - extends ConcurrentReferenceCachingMetadataReaderFactory { - - @Override - public MetadataReader createMetadataReader(Resource resource) { - return mock(MetadataReader.class); - } - - } - -}