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 560d0784b0..00072d0a67 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 @@ -838,7 +838,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA boolean isRequired = isRequired(element); Member member = element.getMember(); analyzeMember(contribution, member); - contribution.statements().addStatement(this.generator.writeInjection(member, isRequired)); + contribution.statements().addStatement(this.generator.generateInjection(member, isRequired)); }); } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanParameterGenerator.java b/spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanParameterGenerator.java index dccc5b660f..9e7e6dc71b 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanParameterGenerator.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanParameterGenerator.java @@ -43,7 +43,7 @@ import org.springframework.lang.Nullable; import org.springframework.util.ObjectUtils; /** - * Support for writing parameters. + * Support for generating parameters. * * @author Stephane Nicoll * @since 6.0 @@ -52,16 +52,16 @@ public final class BeanParameterGenerator { private final ResolvableTypeGenerator typeGenerator = new ResolvableTypeGenerator(); - private final BiConsumer innerBeanDefinitionWriter; + private final BiConsumer innerBeanDefinitionGenerator; /** - * Create an instance with the callback to use to write an inner bean + * Create an instance with the callback to use to generate an inner bean * definition. - * @param innerBeanDefinitionWriter the inner bean definition writer + * @param innerBeanDefinitionGenerator the inner bean definition generator */ - public BeanParameterGenerator(BiConsumer innerBeanDefinitionWriter) { - this.innerBeanDefinitionWriter = innerBeanDefinitionWriter; + public BeanParameterGenerator(BiConsumer innerBeanDefinitionGenerator) { + this.innerBeanDefinitionGenerator = innerBeanDefinitionGenerator; } /** @@ -75,39 +75,39 @@ public final class BeanParameterGenerator { /** - * Write the specified parameter {@code value}. + * Generate the specified parameter {@code value}. * @param value the value of the parameter * @return the value of the parameter */ - public CodeBlock writeParameterValue(@Nullable Object value) { - return writeParameterValue(value, () -> ResolvableType.forInstance(value)); + public CodeBlock generateParameterValue(@Nullable Object value) { + return generateParameterValue(value, () -> ResolvableType.forInstance(value)); } /** - * Write the specified parameter {@code value}. + * Generate the specified parameter {@code value}. * @param value the value of the parameter * @param parameterType the type of the parameter * @return the value of the parameter */ - public CodeBlock writeParameterValue(@Nullable Object value, Supplier parameterType) { + public CodeBlock generateParameterValue(@Nullable Object value, Supplier parameterType) { Builder code = CodeBlock.builder(); - writeParameterValue(code, value, parameterType); + generateParameterValue(code, value, parameterType); return code.build(); } /** - * Write the parameter types of the specified {@link Executable}. + * Generate the parameter types of the specified {@link Executable}. * @param executable the executable * @return the parameter types of the executable as a comma separated list */ - public CodeBlock writeExecutableParameterTypes(Executable executable) { + public CodeBlock generateExecutableParameterTypes(Executable executable) { Class[] parameterTypes = Arrays.stream(executable.getParameters()) .map(Parameter::getType).toArray(Class[]::new); return CodeBlock.of(Arrays.stream(parameterTypes).map(d -> "$T.class") .collect(Collectors.joining(", ")), (Object[]) parameterTypes); } - private void writeParameterValue(Builder code, @Nullable Object value, Supplier parameterTypeSupplier) { + private void generateParameterValue(Builder code, @Nullable Object value, Supplier parameterTypeSupplier) { if (value == null) { code.add("null"); return; @@ -115,7 +115,7 @@ public final class BeanParameterGenerator { ResolvableType parameterType = parameterTypeSupplier.get(); if (parameterType.isArray()) { code.add("new $T { ", parameterType.toClass()); - code.add(writeAll(Arrays.asList(ObjectUtils.toObjectArray(value)), + code.add(generateAll(Arrays.asList(ObjectUtils.toObjectArray(value)), item -> parameterType.getComponentType())); code.add(" }"); } @@ -127,7 +127,7 @@ public final class BeanParameterGenerator { Class listType = (value instanceof ManagedList ? ManagedList.class : List.class); code.add("$T.of(", listType); ResolvableType collectionType = parameterType.as(List.class).getGenerics()[0]; - code.add(writeAll(list, item -> collectionType)); + code.add(generateAll(list, item -> collectionType)); code.add(")"); } } @@ -139,7 +139,7 @@ public final class BeanParameterGenerator { Class setType = (value instanceof ManagedSet ? ManagedSet.class : Set.class); code.add("$T.of(", setType); ResolvableType collectionType = parameterType.as(Set.class).getGenerics()[0]; - code.add(writeAll(set, item -> collectionType)); + code.add(generateAll(set, item -> collectionType)); code.add(")"); } } @@ -151,7 +151,7 @@ public final class BeanParameterGenerator { parameters.add(mapKey); parameters.add(mapValue); }); - code.add(writeAll(parameters, ResolvableType::forInstance)); + code.add(generateAll(parameters, ResolvableType::forInstance)); code.add(")"); } } @@ -175,7 +175,7 @@ public final class BeanParameterGenerator { code.add(this.typeGenerator.generateTypeFor((ResolvableType) value)); } else if (value instanceof BeanDefinition) { - this.innerBeanDefinitionWriter.accept((BeanDefinition) value, code); + this.innerBeanDefinitionGenerator.accept((BeanDefinition) value, code); } else if (value instanceof BeanReference) { code.add("new $T($S)", RuntimeBeanReference.class, ((BeanReference) value).getBeanName()); @@ -185,10 +185,10 @@ public final class BeanParameterGenerator { } } - private CodeBlock writeAll(Iterable items, Function elementType) { + private CodeBlock generateAll(Iterable items, Function elementType) { MultiCodeBlock multi = new MultiCodeBlock(); items.forEach(item -> multi.add(code -> - writeParameterValue(code, item, () -> elementType.apply(item)))); + generateParameterValue(code, item, () -> elementType.apply(item)))); return multi.join(", "); } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/generator/DefaultBeanInstantiationGenerator.java b/spring-beans/src/main/java/org/springframework/beans/factory/generator/DefaultBeanInstantiationGenerator.java index 147f74a239..e8e57d1396 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/generator/DefaultBeanInstantiationGenerator.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/generator/DefaultBeanInstantiationGenerator.java @@ -33,7 +33,7 @@ import org.springframework.javapoet.CodeBlock; import org.springframework.util.ClassUtils; /** - * Write the necessary statements to instantiate a bean. + * Generate the necessary statements to instantiate a bean. * * @author Stephane Nicoll * @see BeanInstantiationContribution @@ -64,18 +64,18 @@ class DefaultBeanInstantiationGenerator { * @return a code contribution that provides an initialized bean instance */ public CodeContribution generateBeanInstantiation(RuntimeHints runtimeHints) { - DefaultCodeContribution contribution = new DefaultCodeContribution(runtimeHints); - contribution.protectedAccess().analyze(this.instanceCreator, this.beanInstanceOptions); + DefaultCodeContribution codeContribution = new DefaultCodeContribution(runtimeHints); + codeContribution.protectedAccess().analyze(this.instanceCreator, this.beanInstanceOptions); if (this.instanceCreator instanceof Constructor constructor) { - writeBeanInstantiation(contribution, constructor); + generateBeanInstantiation(codeContribution, constructor); } else if (this.instanceCreator instanceof Method method) { - writeBeanInstantiation(contribution, method); + generateBeanInstantiation(codeContribution, method); } - return contribution; + return codeContribution; } - private void writeBeanInstantiation(CodeContribution contribution, Constructor constructor) { + private void generateBeanInstantiation(CodeContribution codeContribution, Constructor constructor) { Class declaringType = ClassUtils.getUserClass(constructor.getDeclaringClass()); boolean innerClass = isInnerClass(declaringType); boolean multiStatements = !this.contributions.isEmpty(); @@ -96,24 +96,24 @@ class DefaultBeanInstantiationGenerator { code.add("$T::new", declaringType); } } - contribution.statements().addStatement(code.build()); + codeContribution.statements().addStatement(code.build()); return; } - contribution.runtimeHints().reflection().registerConstructor(constructor, + codeContribution.runtimeHints().reflection().registerConstructor(constructor, hint -> hint.withMode(ExecutableMode.INTROSPECT)); code.add("(instanceContext) ->"); branch(multiStatements, () -> code.beginControlFlow(""), () -> code.add(" ")); if (multiStatements) { code.add("$T bean = ", declaringType); } - code.add(this.injectionGenerator.writeInstantiation(constructor)); - contribution.statements().addStatement(code.build()); + code.add(this.injectionGenerator.generateInstantiation(constructor)); + codeContribution.statements().addStatement(code.build()); if (multiStatements) { - for (BeanInstantiationContribution contributor : this.contributions) { - contributor.applyTo(contribution); + for (BeanInstantiationContribution contribution : this.contributions) { + contribution.applyTo(codeContribution); } - contribution.statements().addStatement("return bean") + codeContribution.statements().addStatement("return bean") .add(codeBlock -> codeBlock.unindent().add("}")); } } @@ -122,9 +122,9 @@ class DefaultBeanInstantiationGenerator { return type.isMemberClass() && !Modifier.isStatic(type.getModifiers()); } - private void writeBeanInstantiation(CodeContribution contribution, Method method) { + private void generateBeanInstantiation(CodeContribution codeContribution, Method method) { // Factory method can be introspected - contribution.runtimeHints().reflection().registerMethod(method, + codeContribution.runtimeHints().reflection().registerMethod(method, hint -> hint.withMode(ExecutableMode.INTROSPECT)); List> parameterTypes = new ArrayList<>(Arrays.asList(method.getParameterTypes())); boolean multiStatements = !this.contributions.isEmpty(); @@ -137,7 +137,7 @@ class DefaultBeanInstantiationGenerator { () -> code.add("$T", declaringType), () -> code.add("beanFactory.getBean($T.class)", declaringType)); code.add(".$L()", method.getName()); - contribution.statements().addStatement(code.build()); + codeContribution.statements().addStatement(code.build()); return; } code.add("(instanceContext) ->"); @@ -145,13 +145,13 @@ class DefaultBeanInstantiationGenerator { if (multiStatements) { code.add("$T bean = ", method.getReturnType()); } - code.add(this.injectionGenerator.writeInstantiation(method)); - contribution.statements().addStatement(code.build()); + code.add(this.injectionGenerator.generateInstantiation(method)); + codeContribution.statements().addStatement(code.build()); if (multiStatements) { - for (BeanInstantiationContribution contributor : this.contributions) { - contributor.applyTo(contribution); + for (BeanInstantiationContribution contribution : this.contributions) { + contribution.applyTo(codeContribution); } - contribution.statements().addStatement("return bean") + codeContribution.statements().addStatement("return bean") .add(codeBlock -> codeBlock.unindent().add("}")); } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/generator/InjectionGenerator.java b/spring-beans/src/main/java/org/springframework/beans/factory/generator/InjectionGenerator.java index ce8c94818d..a658ee6aa0 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/generator/InjectionGenerator.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/generator/InjectionGenerator.java @@ -37,8 +37,8 @@ import org.springframework.util.ClassUtils; import org.springframework.util.ReflectionUtils; /** - * Generate the necessary code to {@link #writeInstantiation(Executable) - * create a bean instance} or {@link #writeInjection(Member, boolean) + * Generate the necessary code to {@link #generateInstantiation(Executable) + * create a bean instance} or {@link #generateInjection(Member, boolean) * inject dependencies}. *

* The generator assumes a number of variables to be accessible: @@ -63,37 +63,37 @@ public class InjectionGenerator { /** - * Write the necessary code to instantiate an object using the specified + * Generate the necessary code to instantiate an object using the specified * {@link Executable}. The code is suitable to be assigned to a variable * or used as a {@literal return} statement. * @param creator the executable to invoke to create an instance of the * requested object * @return the code to instantiate an object using the specified executable */ - public CodeBlock writeInstantiation(Executable creator) { + public CodeBlock generateInstantiation(Executable creator) { if (creator instanceof Constructor constructor) { - return write(constructor); + return generateConstructorInstantiation(constructor); } if (creator instanceof Method method) { - return writeMethodInstantiation(method); + return generateMethodInstantiation(method); } throw new IllegalArgumentException("Could not handle creator " + creator); } /** - * Write the code to inject a value resolved by {@link BeanInstanceContext} + * Generate the code to inject a value resolved by {@link BeanInstanceContext} * in the specified {@link Member}. * @param member the field or method to inject * @param required whether the value is required * @return a statement that injects a value to the specified member * @see #getProtectedAccessInjectionOptions(Member) */ - public CodeBlock writeInjection(Member member, boolean required) { + public CodeBlock generateInjection(Member member, boolean required) { if (member instanceof Method method) { - return writeMethodInjection(method, required); + return generateMethodInjection(method, required); } if (member instanceof Field field) { - return writeFieldInjection(field, required); + return generateFieldInjection(field, required); } throw new IllegalArgumentException("Could not handle member " + member); } @@ -115,7 +115,7 @@ public class InjectionGenerator { throw new IllegalArgumentException("Could not handle member " + member); } - private CodeBlock write(Constructor creator) { + private CodeBlock generateConstructorInstantiation(Constructor creator) { Builder code = CodeBlock.builder(); Class declaringType = ClassUtils.getUserClass(creator.getDeclaringClass()); boolean innerClass = isInnerClass(declaringType); @@ -162,7 +162,7 @@ public class InjectionGenerator { return type.isMemberClass() && !Modifier.isStatic(type.getModifiers()); } - private CodeBlock writeMethodInstantiation(Method injectionPoint) { + private CodeBlock generateMethodInstantiation(Method injectionPoint) { if (injectionPoint.getParameterCount() == 0) { Builder code = CodeBlock.builder(); Class declaringType = injectionPoint.getDeclaringClass(); @@ -175,10 +175,10 @@ public class InjectionGenerator { code.add(".$L()", injectionPoint.getName()); return code.build(); } - return write(injectionPoint, code -> code.add(".create(beanFactory, (attributes) ->"), true); + return generateMethodInvocation(injectionPoint, code -> code.add(".create(beanFactory, (attributes) ->"), true); } - private CodeBlock writeMethodInjection(Method injectionPoint, boolean required) { + private CodeBlock generateMethodInjection(Method injectionPoint, boolean required) { Consumer attributesResolver = code -> { if (required) { code.add(".invoke(beanFactory, (attributes) ->"); @@ -187,15 +187,15 @@ public class InjectionGenerator { code.add(".resolve(beanFactory, false).ifResolved((attributes) ->"); } }; - return write(injectionPoint, attributesResolver, false); + return generateMethodInvocation(injectionPoint, attributesResolver, false); } - private CodeBlock write(Method injectionPoint, Consumer attributesResolver, boolean instantiation) { + private CodeBlock generateMethodInvocation(Method injectionPoint, Consumer attributesResolver, boolean instantiation) { Builder code = CodeBlock.builder(); code.add("instanceContext"); if (!instantiation) { code.add(".method($S, ", injectionPoint.getName()); - code.add(this.parameterGenerator.writeExecutableParameterTypes(injectionPoint)); + code.add(this.parameterGenerator.generateExecutableParameterTypes(injectionPoint)); code.add(")\n").indent().indent(); } attributesResolver.accept(code); @@ -222,7 +222,7 @@ public class InjectionGenerator { return code.build(); } - CodeBlock writeFieldInjection(Field injectionPoint, boolean required) { + CodeBlock generateFieldInjection(Field injectionPoint, boolean required) { Builder code = CodeBlock.builder(); code.add("instanceContext.field($S, $T.class", injectionPoint.getName(), injectionPoint.getType()); code.add(")\n").indent().indent(); diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/generator/BeanParameterGeneratorTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/generator/BeanParameterGeneratorTests.java index 8e85c3cdf0..34dfea0e14 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/generator/BeanParameterGeneratorTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/generator/BeanParameterGeneratorTests.java @@ -41,6 +41,7 @@ import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.core.ResolvableType; import org.springframework.core.io.ResourceLoader; import org.springframework.javapoet.support.CodeSnippet; +import org.springframework.lang.Nullable; import org.springframework.util.ReflectionUtils; import static org.assertj.core.api.Assertions.assertThat; @@ -59,21 +60,21 @@ class BeanParameterGeneratorTests { private final BeanParameterGenerator generator = new BeanParameterGenerator(); @Test - void writeCharArray() { + void generateCharArray() { char[] value = new char[] { 'v', 'a', 'l', 'u', 'e' }; - assertThat(write(value, ResolvableType.forArrayComponent(ResolvableType.forClass(char.class)))) + assertThat(generate(value, ResolvableType.forArrayComponent(ResolvableType.forClass(char.class)))) .isEqualTo("new char[] { 'v', 'a', 'l', 'u', 'e' }"); } @Test - void writeStringArray() { + void generateStringArray() { String[] value = new String[] { "a", "test" }; - assertThat(write(value, ResolvableType.forArrayComponent(ResolvableType.forClass(String.class)))) + assertThat(generate(value, ResolvableType.forArrayComponent(ResolvableType.forClass(String.class)))) .isEqualTo("new String[] { \"a\", \"test\" }"); } @Test - void writeStringList() { + void generateStringList() { List value = List.of("a", "test"); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class)); assertThat(code.getSnippet()).isEqualTo( @@ -82,7 +83,7 @@ class BeanParameterGeneratorTests { } @Test - void writeStringManagedList() { + void generateStringManagedList() { ManagedList value = ManagedList.of("a", "test"); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class)); assertThat(code.getSnippet()).isEqualTo( @@ -91,7 +92,7 @@ class BeanParameterGeneratorTests { } @Test - void writeEmptyList() { + void generateEmptyList() { List value = List.of(); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class)); assertThat(code.getSnippet()).isEqualTo("Collections.emptyList()"); @@ -99,7 +100,7 @@ class BeanParameterGeneratorTests { } @Test - void writeStringSet() { + void generateStringSet() { Set value = Set.of("a", "test"); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class)); assertThat(code.getSnippet()).startsWith("Set.of(").contains("a").contains("test"); @@ -107,7 +108,7 @@ class BeanParameterGeneratorTests { } @Test - void writeStringManagedSet() { + void generateStringManagedSet() { Set value = ManagedSet.of("a", "test"); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class)); assertThat(code.getSnippet()).isEqualTo( @@ -116,7 +117,7 @@ class BeanParameterGeneratorTests { } @Test - void writeEmptySet() { + void generateEmptySet() { Set value = Set.of(); CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class)); assertThat(code.getSnippet()).isEqualTo("Collections.emptySet()"); @@ -124,39 +125,39 @@ class BeanParameterGeneratorTests { } @Test - void writeMap() { + void generateMap() { Map value = new LinkedHashMap<>(); value.put("name", "Hello"); value.put("counter", 42); - assertThat(write(value)).isEqualTo("Map.of(\"name\", \"Hello\", \"counter\", 42)"); + assertThat(generate(value)).isEqualTo("Map.of(\"name\", \"Hello\", \"counter\", 42)"); } @Test - void writeMapWithEnum() { + void generateMapWithEnum() { Map value = new HashMap<>(); value.put("unit", ChronoUnit.DAYS); - assertThat(write(value)).isEqualTo("Map.of(\"unit\", ChronoUnit.DAYS)"); + assertThat(generate(value)).isEqualTo("Map.of(\"unit\", ChronoUnit.DAYS)"); } @Test - void writeEmptyMap() { - assertThat(write(Map.of())).isEqualTo("Map.of()"); + void generateEmptyMap() { + assertThat(generate(Map.of())).isEqualTo("Map.of()"); } @Test - void writeString() { - assertThat(write("test", ResolvableType.forClass(String.class))).isEqualTo("\"test\""); + void generateString() { + assertThat(generate("test", ResolvableType.forClass(String.class))).isEqualTo("\"test\""); } @Test - void writeCharEscapeBackslash() { - assertThat(write('\\', ResolvableType.forType(char.class))).isEqualTo("'\\\\'"); + void generateCharEscapeBackslash() { + assertThat(generate('\\', ResolvableType.forType(char.class))).isEqualTo("'\\\\'"); } @ParameterizedTest @MethodSource("primitiveValues") - void writePrimitiveValue(Object value, String parameter) { - assertThat(write(value, ResolvableType.forClass(value.getClass()))).isEqualTo(parameter); + void generatePrimitiveValue(Object value, String parameter) { + assertThat(generate(value, ResolvableType.forClass(value.getClass()))).isEqualTo(parameter); } private static Stream primitiveValues() { @@ -166,87 +167,88 @@ class BeanParameterGeneratorTests { } @Test - void writeEnum() { - assertThat(write(ChronoUnit.DAYS, ResolvableType.forClass(ChronoUnit.class))) + void generateEnum() { + assertThat(generate(ChronoUnit.DAYS, ResolvableType.forClass(ChronoUnit.class))) .isEqualTo("ChronoUnit.DAYS"); } @Test - void writeClass() { - assertThat(write(Integer.class, ResolvableType.forClass(Class.class))) + void generateClass() { + assertThat(generate(Integer.class, ResolvableType.forClass(Class.class))) .isEqualTo("Integer.class"); } @Test - void writeResolvableType() { + void generateResolvableType() { ResolvableType type = ResolvableType.forClassWithGenerics(Consumer.class, Integer.class); - assertThat(write(type, type)) + assertThat(generate(type, type)) .isEqualTo("ResolvableType.forClassWithGenerics(Consumer.class, Integer.class)"); } @Test - void writeExecutableParameterTypesWithConstructor() { + void generateExecutableParameterTypesWithConstructor() { Constructor constructor = TestSample.class.getDeclaredConstructors()[0]; - assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(constructor))) + assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(constructor))) .isEqualTo("String.class, ResourceLoader.class"); } @Test - void writeExecutableParameterTypesWithNoArgConstructor() { + void generateExecutableParameterTypesWithNoArgConstructor() { Constructor constructor = BeanParameterGeneratorTests.class.getDeclaredConstructors()[0]; - assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(constructor))) + assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(constructor))) .isEmpty(); } @Test - void writeExecutableParameterTypesWithMethod() { + void generateExecutableParameterTypesWithMethod() { Method method = ReflectionUtils.findMethod(TestSample.class, "createBean", String.class, Integer.class); - assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(method))) + assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(method))) .isEqualTo("String.class, Integer.class"); } @Test - void writeNull() { - assertThat(write(null)).isEqualTo("null"); + void generateNull() { + assertThat(generate(null)).isEqualTo("null"); } @Test - void writeBeanReference() { + void generateBeanReference() { BeanReference beanReference = mock(BeanReference.class); given(beanReference.getBeanName()).willReturn("testBean"); - assertThat(write(beanReference)).isEqualTo("new RuntimeBeanReference(\"testBean\")"); + assertThat(generate(beanReference)).isEqualTo("new RuntimeBeanReference(\"testBean\")"); } @Test - void writeBeanDefinitionCallsConsumer() { + void generateBeanDefinitionCallsConsumer() { BeanParameterGenerator customGenerator = new BeanParameterGenerator( ((beanDefinition, builder) -> builder.add("test"))); - assertThat(CodeSnippet.process(customGenerator.writeParameterValue(new RootBeanDefinition()))).isEqualTo("test"); + assertThat(CodeSnippet.process(customGenerator.generateParameterValue( + new RootBeanDefinition()))).isEqualTo("test"); } @Test - void writeBeanDefinitionWithoutConsumerFails() { + void generateBeanDefinitionWithoutConsumerFails() { BeanParameterGenerator customGenerator = new BeanParameterGenerator(); assertThatIllegalStateException().isThrownBy(() -> customGenerator - .writeParameterValue(new RootBeanDefinition())); + .generateParameterValue(new RootBeanDefinition())); } @Test - void writeUnsupportedParameter() { - assertThatIllegalArgumentException().isThrownBy(() -> write(new StringWriter())) + void generateUnsupportedParameter() { + assertThatIllegalArgumentException().isThrownBy(() -> generate(new StringWriter())) .withMessageContaining(StringWriter.class.getName()); } - private String write(Object value) { - return CodeSnippet.process(this.generator.writeParameterValue(value)); + private String generate(@Nullable Object value) { + return CodeSnippet.process(this.generator.generateParameterValue(value)); } - private String write(Object value, ResolvableType resolvableType) { + private String generate(Object value, ResolvableType resolvableType) { return codeSnippet(value, resolvableType).getSnippet(); } private CodeSnippet codeSnippet(Object value, ResolvableType resolvableType) { - return CodeSnippet.of(this.generator.writeParameterValue(value, () -> resolvableType)); + return CodeSnippet.of(this.generator.generateParameterValue(value, () -> resolvableType)); } diff --git a/spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java b/spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java index e782db598b..d3c073bf52 100644 --- a/spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java +++ b/spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java @@ -45,119 +45,119 @@ class InjectionGeneratorTests { private final ProtectedAccess protectedAccess = new ProtectedAccess(); @Test - void writeInstantiationForConstructorWithNoArgUseShortcut() { + void generateInstantiationForConstructorWithNoArgUseShortcut() { Constructor constructor = SimpleBean.class.getDeclaredConstructors()[0]; - assertThat(writeInstantiation(constructor).lines()) + assertThat(generateInstantiation(constructor).lines()) .containsExactly("new InjectionGeneratorTests.SimpleBean()"); } @Test - void writeInstantiationForConstructorWithNonGenericParameter() { + void generateInstantiationForConstructorWithNonGenericParameter() { Constructor constructor = SimpleConstructorBean.class.getDeclaredConstructors()[0]; - assertThat(writeInstantiation(constructor).lines()).containsExactly( + assertThat(generateInstantiation(constructor).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.SimpleConstructorBean(attributes.get(0), attributes.get(1)))"); } @Test - void writeInstantiationForConstructorWithGenericParameter() { + void generateInstantiationForConstructorWithGenericParameter() { Constructor constructor = GenericConstructorBean.class.getDeclaredConstructors()[0]; - assertThat(writeInstantiation(constructor).lines()).containsExactly( + assertThat(generateInstantiation(constructor).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.GenericConstructorBean(attributes.get(0)))"); } @Test - void writeInstantiationForAmbiguousConstructor() throws Exception { + void generateInstantiationForAmbiguousConstructor() throws Exception { Constructor constructor = AmbiguousConstructorBean.class.getDeclaredConstructor(String.class, Number.class); - assertThat(writeInstantiation(constructor).lines()).containsExactly( + assertThat(generateInstantiation(constructor).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.AmbiguousConstructorBean(attributes.get(0, String.class), attributes.get(1, Number.class)))"); } @Test - void writeInstantiationForConstructorInInnerClass() { + void generateInstantiationForConstructorInInnerClass() { Constructor constructor = InnerClass.class.getDeclaredConstructors()[0]; - assertThat(writeInstantiation(constructor).lines()).containsExactly( + assertThat(generateInstantiation(constructor).lines()).containsExactly( "beanFactory.getBean(InjectionGeneratorTests.SimpleConstructorBean.class).new InnerClass()"); } @Test - void writeInstantiationForMethodWithNoArgUseShortcut() { - assertThat(writeInstantiation(method(SimpleBean.class, "name")).lines()).containsExactly( + void generateInstantiationForMethodWithNoArgUseShortcut() { + assertThat(generateInstantiation(method(SimpleBean.class, "name")).lines()).containsExactly( "beanFactory.getBean(InjectionGeneratorTests.SimpleBean.class).name()"); } @Test - void writeInstantiationForStaticMethodWithNoArgUseShortcut() { - assertThat(writeInstantiation(method(SimpleBean.class, "number")).lines()).containsExactly( + void generateInstantiationForStaticMethodWithNoArgUseShortcut() { + assertThat(generateInstantiation(method(SimpleBean.class, "number")).lines()).containsExactly( "InjectionGeneratorTests.SimpleBean.number()"); } @Test - void writeInstantiationForMethodWithNonGenericParameter() { - assertThat(writeInstantiation(method(SampleBean.class, "source", Integer.class)).lines()).containsExactly( + void generateInstantiationForMethodWithNonGenericParameter() { + assertThat(generateInstantiation(method(SampleBean.class, "source", Integer.class)).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> beanFactory.getBean(InjectionGeneratorTests.SampleBean.class).source(attributes.get(0)))"); } @Test - void writeInstantiationForStaticMethodWithNonGenericParameter() { - assertThat(writeInstantiation(method(SampleBean.class, "staticSource", Integer.class)).lines()).containsExactly( + void generateInstantiationForStaticMethodWithNonGenericParameter() { + assertThat(generateInstantiation(method(SampleBean.class, "staticSource", Integer.class)).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> InjectionGeneratorTests.SampleBean.staticSource(attributes.get(0)))"); } @Test - void writeInstantiationForMethodWithGenericParameters() { - assertThat(writeInstantiation(method(SampleBean.class, "source", ObjectProvider.class)).lines()).containsExactly( + void generateInstantiationForMethodWithGenericParameters() { + assertThat(generateInstantiation(method(SampleBean.class, "source", ObjectProvider.class)).lines()).containsExactly( "instanceContext.create(beanFactory, (attributes) -> beanFactory.getBean(InjectionGeneratorTests.SampleBean.class).source(attributes.get(0)))"); } @Test - void writeInjectionForUnsupportedMember() { - assertThatIllegalArgumentException().isThrownBy(() -> writeInjection(mock(Member.class), false)); + void generateInjectionForUnsupportedMember() { + assertThatIllegalArgumentException().isThrownBy(() -> generateInjection(mock(Member.class), false)); } @Test - void writeInjectionForNonRequiredMethodWithNonGenericParameters() { + void generateInjectionForNonRequiredMethodWithNonGenericParameters() { Method method = method(SampleBean.class, "sourceAndCounter", String.class, Integer.class); - assertThat(writeInjection(method, false)).isEqualTo(""" + assertThat(generateInjection(method, false)).isEqualTo(""" instanceContext.method("sourceAndCounter", String.class, Integer.class) .resolve(beanFactory, false).ifResolved((attributes) -> bean.sourceAndCounter(attributes.get(0), attributes.get(1)))"""); } @Test - void writeInjectionForRequiredMethodWithGenericParameter() { + void generateInjectionForRequiredMethodWithGenericParameter() { Method method = method(SampleBean.class, "nameAndCounter", String.class, ObjectProvider.class); - assertThat(writeInjection(method, true)).isEqualTo(""" + assertThat(generateInjection(method, true)).isEqualTo(""" instanceContext.method("nameAndCounter", String.class, ObjectProvider.class) .invoke(beanFactory, (attributes) -> bean.nameAndCounter(attributes.get(0), attributes.get(1)))"""); } @Test - void writeInjectionForNonRequiredMethodWithGenericParameter() { + void generateInjectionForNonRequiredMethodWithGenericParameter() { Method method = method(SampleBean.class, "nameAndCounter", String.class, ObjectProvider.class); - assertThat(writeInjection(method, false)).isEqualTo(""" + assertThat(generateInjection(method, false)).isEqualTo(""" instanceContext.method("nameAndCounter", String.class, ObjectProvider.class) .resolve(beanFactory, false).ifResolved((attributes) -> bean.nameAndCounter(attributes.get(0), attributes.get(1)))"""); } @Test - void writeInjectionForRequiredField() { + void generateInjectionForRequiredField() { Field field = field(SampleBean.class, "counter"); - assertThat(writeInjection(field, true)).isEqualTo(""" + assertThat(generateInjection(field, true)).isEqualTo(""" instanceContext.field("counter", Integer.class) .invoke(beanFactory, (attributes) -> bean.counter = attributes.get(0))"""); } @Test - void writeInjectionForNonRequiredField() { + void generateInjectionForNonRequiredField() { Field field = field(SampleBean.class, "counter"); - assertThat(writeInjection(field, false)).isEqualTo(""" + assertThat(generateInjection(field, false)).isEqualTo(""" instanceContext.field("counter", Integer.class) .resolve(beanFactory, false).ifResolved((attributes) -> bean.counter = attributes.get(0))"""); } @Test - void writeInjectionForRequiredPrivateField() { + void generateInjectionForRequiredPrivateField() { Field field = field(SampleBean.class, "source"); - assertThat(writeInjection(field, true)).isEqualTo(""" + assertThat(generateInjection(field, true)).isEqualTo(""" instanceContext.field("source", String.class) .invoke(beanFactory, (attributes) -> { Field sourceField = ReflectionUtils.findField(InjectionGeneratorTests.SampleBean.class, "source", String.class); @@ -215,12 +215,12 @@ class InjectionGeneratorTests { return field; } - private String writeInstantiation(Executable creator) { - return CodeSnippet.process(code -> code.add(new InjectionGenerator().writeInstantiation(creator))); + private String generateInstantiation(Executable creator) { + return CodeSnippet.process(code -> code.add(new InjectionGenerator().generateInstantiation(creator))); } - private String writeInjection(Member member, boolean required) { - return CodeSnippet.process(code -> code.add(new InjectionGenerator().writeInjection(member, required))); + private String generateInjection(Member member, boolean required) { + return CodeSnippet.process(code -> code.add(new InjectionGenerator().generateInjection(member, required))); } private void analyzeProtectedAccess(Member member) {