From 455715899d5a93f7eaee7996e5b17ba8db20e476 Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Mon, 22 Aug 2022 19:59:21 +0200 Subject: [PATCH] Infer proxy on `@Lazy`-annotated injection points This commit makes use of the new `getLazyResolutionProxyClass` on `AutowireCandidateResolver` to detect if a injection point requires a proxy. Closes gh-28980 --- .../AutowiredAnnotationBeanPostProcessor.java | 53 +++++++++- .../aot/BeanDefinitionMethodGenerator.java | 59 +++++++++++ .../ApplicationContextAotGeneratorTests.java | 99 ++++++++++++++++++- .../LazyAutowiredFieldComponent.java | 41 ++++++++ .../LazyAutowiredMethodComponent.java | 47 +++++++++ .../LazyConstructorArgumentComponent.java | 46 +++++++++ .../LazyFactoryMethodArgumentComponent.java | 46 +++++++++ 7 files changed, 387 insertions(+), 4 deletions(-) create mode 100644 spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredFieldComponent.java create mode 100644 spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredMethodComponent.java create mode 100644 spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyConstructorArgumentComponent.java create mode 100644 spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyFactoryMethodArgumentComponent.java diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java b/spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java index 1e783224d1c..9df071e8097 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java @@ -25,6 +25,7 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import java.lang.reflect.Proxy; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -70,6 +71,8 @@ import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.config.DependencyDescriptor; import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor; import org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory; +import org.springframework.beans.factory.support.AutowireCandidateResolver; +import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.beans.factory.support.LookupOverride; import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor; import org.springframework.beans.factory.support.RegisteredBean; @@ -289,7 +292,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA InjectionMetadata metadata = findInjectionMetadata(beanName, beanClass, beanDefinition); Collection autowiredElements = getAutowiredElements(metadata); if (!ObjectUtils.isEmpty(autowiredElements)) { - return new AotContribution(beanClass, autowiredElements); + return new AotContribution(beanClass, autowiredElements, getAutowireCandidateResolver()); } return null; } @@ -300,6 +303,14 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA return (Collection) metadata.getInjectedElements(); } + @Nullable + private AutowireCandidateResolver getAutowireCandidateResolver() { + if (this.beanFactory instanceof DefaultListableBeanFactory lbf) { + return lbf.getAutowireCandidateResolver(); + } + return null; + } + private InjectionMetadata findInjectionMetadata(String beanName, Class beanType, RootBeanDefinition beanDefinition) { InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null); metadata.checkConfigMembers(beanDefinition); @@ -914,10 +925,15 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA private final Collection autowiredElements; + @Nullable + private final AutowireCandidateResolver candidateResolver; + + AotContribution(Class target, Collection autowiredElements, + @Nullable AutowireCandidateResolver candidateResolver) { - AotContribution(Class target, Collection autowiredElements) { this.target = target; this.autowiredElements = autowiredElements; + this.candidateResolver = candidateResolver; } @@ -940,6 +956,10 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA }); beanRegistrationCode.addInstancePostProcessor( MethodReference.ofStatic(generatedClass.getName(), generateMethod.getName())); + + if (this.candidateResolver != null) { + registerHints(generationContext.getRuntimeHints()); + } } private CodeBlock generateMethodCode(RuntimeHints hints) { @@ -1023,6 +1043,35 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA return code.build(); } + private void registerHints(RuntimeHints runtimeHints) { + this.autowiredElements.forEach(autowiredElement -> { + boolean required = autowiredElement.required; + Member member = autowiredElement.getMember(); + if (member instanceof Field field) { + DependencyDescriptor dependencyDescriptor = new DependencyDescriptor( + field, required); + registerProxyIfNecessary(runtimeHints, dependencyDescriptor); + } + if (member instanceof Method method) { + Class[] parameterTypes = method.getParameterTypes(); + for (int i = 0; i < parameterTypes.length; i++) { + MethodParameter methodParam = new MethodParameter(method, i); + DependencyDescriptor dependencyDescriptor = new DependencyDescriptor( + methodParam, required); + registerProxyIfNecessary(runtimeHints, dependencyDescriptor); + } + } + }); + } + + private void registerProxyIfNecessary(RuntimeHints runtimeHints, DependencyDescriptor dependencyDescriptor) { + Class proxyType = this.candidateResolver + .getLazyResolutionProxyClass(dependencyDescriptor, null); + if (proxyType != null && Proxy.isProxyClass(proxyType)) { + runtimeHints.proxies().registerJdkProxy(proxyType.getInterfaces()); + } + } + } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/aot/BeanDefinitionMethodGenerator.java b/spring-beans/src/main/java/org/springframework/beans/factory/aot/BeanDefinitionMethodGenerator.java index 1245f75a162..8f08985b792 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/aot/BeanDefinitionMethodGenerator.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/aot/BeanDefinitionMethodGenerator.java @@ -16,7 +16,10 @@ package org.springframework.beans.factory.aot; +import java.lang.reflect.Constructor; import java.lang.reflect.Executable; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; import java.util.List; import javax.lang.model.element.Modifier; @@ -26,8 +29,13 @@ import org.springframework.aot.generate.GeneratedMethod; import org.springframework.aot.generate.GeneratedMethods; import org.springframework.aot.generate.GenerationContext; import org.springframework.aot.generate.MethodReference; +import org.springframework.aot.hint.RuntimeHints; import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.config.DependencyDescriptor; +import org.springframework.beans.factory.support.AutowireCandidateResolver; +import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.beans.factory.support.RegisteredBean; +import org.springframework.core.MethodParameter; import org.springframework.javapoet.ClassName; import org.springframework.lang.Nullable; import org.springframework.util.StringUtils; @@ -83,6 +91,7 @@ class BeanDefinitionMethodGenerator { MethodReference generateBeanDefinitionMethod(GenerationContext generationContext, BeanRegistrationsCode beanRegistrationsCode) { + registerRuntimeHintsIfNecessary(generationContext.getRuntimeHints()); BeanRegistrationCodeFragments codeFragments = getCodeFragments(generationContext, beanRegistrationsCode); Class target = codeFragments.getTarget(this.registeredBean, @@ -166,4 +175,54 @@ class BeanDefinitionMethodGenerator { return StringUtils.uncapitalize(beanName); } + private void registerRuntimeHintsIfNecessary(RuntimeHints runtimeHints) { + if (this.registeredBean.getBeanFactory() instanceof DefaultListableBeanFactory dlbf) { + ProxyRuntimeHintsRegistrar registrar = new ProxyRuntimeHintsRegistrar(dlbf.getAutowireCandidateResolver()); + if (this.constructorOrFactoryMethod instanceof Method method) { + registrar.registerRuntimeHints(runtimeHints, method); + } + else if (this.constructorOrFactoryMethod instanceof Constructor constructor) { + registrar.registerRuntimeHints(runtimeHints, constructor); + } + } + } + + private static class ProxyRuntimeHintsRegistrar { + + private final AutowireCandidateResolver candidateResolver; + + public ProxyRuntimeHintsRegistrar(AutowireCandidateResolver candidateResolver) { + this.candidateResolver = candidateResolver; + } + + public void registerRuntimeHints(RuntimeHints runtimeHints, Method method) { + Class[] parameterTypes = method.getParameterTypes(); + for (int i = 0; i < parameterTypes.length; i++) { + MethodParameter methodParam = new MethodParameter(method, i); + DependencyDescriptor dependencyDescriptor = new DependencyDescriptor( + methodParam, true); + registerProxyIfNecessary(runtimeHints, dependencyDescriptor); + } + } + + public void registerRuntimeHints(RuntimeHints runtimeHints, Constructor constructor) { + Class[] parameterTypes = constructor.getParameterTypes(); + for (int i = 0; i < parameterTypes.length; i++) { + MethodParameter methodParam = new MethodParameter(constructor, i); + DependencyDescriptor dependencyDescriptor = new DependencyDescriptor( + methodParam, true); + registerProxyIfNecessary(runtimeHints, dependencyDescriptor); + } + } + + private void registerProxyIfNecessary(RuntimeHints runtimeHints, DependencyDescriptor dependencyDescriptor) { + Class proxyType = this.candidateResolver + .getLazyResolutionProxyClass(dependencyDescriptor, null); + if (proxyType != null && Proxy.isProxyClass(proxyType)) { + runtimeHints.proxies().registerJdkProxy(proxyType.getInterfaces()); + } + } + + } + } diff --git a/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java b/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java index a85c2d80db7..1a8ab04b3aa 100644 --- a/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java +++ b/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java @@ -17,12 +17,15 @@ package org.springframework.context.aot; import java.io.IOException; +import java.lang.reflect.Proxy; import java.util.function.BiConsumer; import org.junit.jupiter.api.Test; import org.springframework.aot.generate.GeneratedFiles.Kind; +import org.springframework.aot.generate.GenerationContext; import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.TypeReference; import org.springframework.aot.hint.predicate.RuntimeHintsPredicates; import org.springframework.aot.test.generator.compile.Compiled; @@ -44,11 +47,18 @@ import org.springframework.context.ApplicationContextInitializer; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.AnnotationConfigUtils; import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor; +import org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver; import org.springframework.context.support.GenericApplicationContext; import org.springframework.context.testfixture.context.generator.SimpleComponent; import org.springframework.context.testfixture.context.generator.annotation.AutowiredComponent; import org.springframework.context.testfixture.context.generator.annotation.CglibConfiguration; import org.springframework.context.testfixture.context.generator.annotation.InitDestroyComponent; +import org.springframework.context.testfixture.context.generator.annotation.LazyAutowiredFieldComponent; +import org.springframework.context.testfixture.context.generator.annotation.LazyAutowiredMethodComponent; +import org.springframework.context.testfixture.context.generator.annotation.LazyConstructorArgumentComponent; +import org.springframework.context.testfixture.context.generator.annotation.LazyFactoryMethodArgumentComponent; +import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; import org.springframework.core.testfixture.aot.generate.TestGenerationContext; import static org.assertj.core.api.Assertions.assertThat; @@ -93,6 +103,87 @@ class ApplicationContextAotGeneratorTests { }); } + @Test + void processAheadOfTimeWhenHasLazyAutowiringOnField() { + testAutowiredComponent(LazyAutowiredFieldComponent.class, (bean, generationContext) -> { + Environment environment = bean.getEnvironment(); + assertThat(environment).isInstanceOf(Proxy.class); + ResourceLoader resourceLoader = bean.getResourceLoader(); + assertThat(resourceLoader).isNotInstanceOf(Proxy.class); + RuntimeHints runtimeHints = generationContext.getRuntimeHints(); + assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( + environment.getClass().getInterfaces()))); + + }); + } + + @Test + void processAheadOfTimeWhenHasLazyAutowiringOnMethod() { + testAutowiredComponent(LazyAutowiredMethodComponent.class, (bean, generationContext) -> { + Environment environment = bean.getEnvironment(); + assertThat(environment).isNotInstanceOf(Proxy.class); + ResourceLoader resourceLoader = bean.getResourceLoader(); + assertThat(resourceLoader).isInstanceOf(Proxy.class); + RuntimeHints runtimeHints = generationContext.getRuntimeHints(); + assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( + resourceLoader.getClass().getInterfaces()))); + }); + } + + @Test + void processAheadOfTimeWhenHasLazyAutowiringOnConstructor() { + testAutowiredComponent(LazyConstructorArgumentComponent.class, (bean, generationContext) -> { + Environment environment = bean.getEnvironment(); + assertThat(environment).isInstanceOf(Proxy.class); + ResourceLoader resourceLoader = bean.getResourceLoader(); + assertThat(resourceLoader).isNotInstanceOf(Proxy.class); + RuntimeHints runtimeHints = generationContext.getRuntimeHints(); + assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( + environment.getClass().getInterfaces()))); + }); + } + + @Test + void processAheadOfTimeWhenHasLazyAutowiringOnFactoryMethod() { + RootBeanDefinition bd = new RootBeanDefinition(LazyFactoryMethodArgumentComponent.class); + bd.setFactoryMethodName("of"); + testAutowiredComponent(LazyFactoryMethodArgumentComponent.class, bd, (bean, generationContext) -> { + Environment environment = bean.getEnvironment(); + assertThat(environment).isInstanceOf(Proxy.class); + ResourceLoader resourceLoader = bean.getResourceLoader(); + assertThat(resourceLoader).isNotInstanceOf(Proxy.class); + RuntimeHints runtimeHints = generationContext.getRuntimeHints(); + assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( + environment.getClass().getInterfaces()))); + }); + } + + private void testAutowiredComponent(Class type, BiConsumer assertions) { + testAutowiredComponent(type, new RootBeanDefinition(type), assertions); + } + + private void testAutowiredComponent(Class type, RootBeanDefinition beanDefinition, + BiConsumer assertions) { + GenericApplicationContext applicationContext = new GenericApplicationContext(); + applicationContext.getDefaultListableBeanFactory().setAutowireCandidateResolver( + new ContextAnnotationAutowireCandidateResolver()); + applicationContext.registerBeanDefinition(AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME, + BeanDefinitionBuilder + .rootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class) + .setRole(BeanDefinition.ROLE_INFRASTRUCTURE).getBeanDefinition()); + applicationContext.registerBeanDefinition("testComponent", beanDefinition); + TestGenerationContext generationContext = processAheadOfTime(applicationContext); + testCompiledResult(generationContext, (initializer, compiled) -> { + GenericApplicationContext freshApplicationContext = toFreshApplicationContext(initializer); + assertThat(freshApplicationContext.getBeanDefinitionNames()).containsOnly("testComponent"); + assertions.accept(freshApplicationContext.getBean("testComponent", type), generationContext); + }); + } + @Test void processAheadOfTimeWhenHasInitDestroyMethods() { GenericApplicationContext applicationContext = new GenericApplicationContext(); @@ -189,10 +280,14 @@ class ApplicationContextAotGeneratorTests { return generationContext; } - @SuppressWarnings({ "rawtypes", "unchecked" }) private void testCompiledResult(GenericApplicationContext applicationContext, BiConsumer, Compiled> result) { - TestGenerationContext generationContext = processAheadOfTime(applicationContext); + testCompiledResult(processAheadOfTime(applicationContext), result); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private void testCompiledResult(TestGenerationContext generationContext, + BiConsumer, Compiled> result) { TestCompiler.forSystem().withFiles(generationContext.getGeneratedFiles()).compile(compiled -> result.accept(compiled.getInstance(ApplicationContextInitializer.class), compiled)); } diff --git a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredFieldComponent.java b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredFieldComponent.java new file mode 100644 index 00000000000..cd65c14b0de --- /dev/null +++ b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredFieldComponent.java @@ -0,0 +1,41 @@ +/* + * Copyright 2002-2022 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.context.testfixture.context.generator.annotation; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Lazy; +import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; + +public class LazyAutowiredFieldComponent { + + @Lazy + @Autowired + private Environment environment; + + @Autowired + private ResourceLoader resourceLoader; + + public Environment getEnvironment() { + return this.environment; + } + + + public ResourceLoader getResourceLoader() { + return this.resourceLoader; + } +} diff --git a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredMethodComponent.java b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredMethodComponent.java new file mode 100644 index 00000000000..b10d26a0ab9 --- /dev/null +++ b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyAutowiredMethodComponent.java @@ -0,0 +1,47 @@ +/* + * Copyright 2002-2022 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.context.testfixture.context.generator.annotation; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Lazy; +import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; + +public class LazyAutowiredMethodComponent { + + private Environment environment; + + private ResourceLoader resourceLoader; + + @Autowired + public void setEnvironment(Environment environment) { + this.environment = environment; + } + + public Environment getEnvironment() { + return this.environment; + } + + @Autowired + public void setResourceLoader(@Lazy ResourceLoader resourceLoader) { + this.resourceLoader = resourceLoader; + } + + public ResourceLoader getResourceLoader() { + return this.resourceLoader; + } +} diff --git a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyConstructorArgumentComponent.java b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyConstructorArgumentComponent.java new file mode 100644 index 00000000000..6da3e9cfec6 --- /dev/null +++ b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyConstructorArgumentComponent.java @@ -0,0 +1,46 @@ +/* + * Copyright 2002-2022 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.context.testfixture.context.generator.annotation; + +import org.springframework.context.annotation.Lazy; +import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; + +/** + * + * @author Stephane Nicoll + */ +public class LazyConstructorArgumentComponent { + + private final Environment environment; + + private final ResourceLoader resourceLoader; + + public LazyConstructorArgumentComponent(@Lazy Environment environment, ResourceLoader resourceLoader) { + this.environment = environment; + this.resourceLoader = resourceLoader; + } + + public Environment getEnvironment() { + return this.environment; + } + + public ResourceLoader getResourceLoader() { + return this.resourceLoader; + } + +} diff --git a/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyFactoryMethodArgumentComponent.java b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyFactoryMethodArgumentComponent.java new file mode 100644 index 00000000000..221ddad9c70 --- /dev/null +++ b/spring-context/src/testFixtures/java/org/springframework/context/testfixture/context/generator/annotation/LazyFactoryMethodArgumentComponent.java @@ -0,0 +1,46 @@ +/* + * Copyright 2002-2022 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.context.testfixture.context.generator.annotation; + +import org.springframework.context.annotation.Lazy; +import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; + +public class LazyFactoryMethodArgumentComponent { + + private final Environment environment; + + private final ResourceLoader resourceLoader; + + LazyFactoryMethodArgumentComponent(Environment environment, ResourceLoader resourceLoader) { + this.environment = environment; + this.resourceLoader = resourceLoader; + } + + public static LazyFactoryMethodArgumentComponent of(@Lazy Environment environment, ResourceLoader resourceLoader) { + return new LazyFactoryMethodArgumentComponent(environment, resourceLoader); + } + + public Environment getEnvironment() { + return this.environment; + } + + public ResourceLoader getResourceLoader() { + return this.resourceLoader; + } + +}