Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Generate matching structure for configuration classes

Browse Source 
This commit improves GeneratedClass to support inner classes, allowing
them to be registered by name with a type customizer, as
GeneratedClasses does for top level classes.

BeanDefinitionMethodGenerator leverages this feature to create a
matching structure for configuration classes that contain inner classes.

Closes gh-29213
This commit is contained in:
Stephane Nicoll
2022-09-28 08:55:27 +02:00
parent b1ee44f12e
commit 38d91bafce
6 changed files with 230 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
spring-core/src/main/java/org/springframework/aot/generate/GeneratedClass.java
View File

@@ -24,6 +24,7 @@ import java.util.function.Consumer;
import org.springframework.javapoet.ClassName;
import org.springframework.javapoet.JavaFile;
import org.springframework.javapoet.TypeSpec;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
@@ -36,13 +37,18 @@ import org.springframework.util.Assert;
*/
public final class GeneratedClass {
@Nullable
private final GeneratedClass enclosingClass;
private final ClassName name;
private final GeneratedMethods methods;
private final Consumer<TypeSpec.Builder> type;
private final Map<MethodName, AtomicInteger> methodNameSequenceGenerator = new ConcurrentHashMap<>();
private final Map<ClassName, GeneratedClass> declaredClasses;
private final Map<MethodName, AtomicInteger> methodNameSequenceGenerator;
/**
@@ -53,9 +59,17 @@ public final class GeneratedClass {
* @param type a {@link Consumer} used to build the type
*/
GeneratedClass(ClassName name, Consumer<TypeSpec.Builder> type) {
this(null, name, type);
}
private GeneratedClass(@Nullable GeneratedClass enclosingClass, ClassName name,
Consumer<TypeSpec.Builder> type) {
this.enclosingClass = enclosingClass;
this.name = name;
this.type = type;
this.methods = new GeneratedMethods(name, this::generateSequencedMethodName);
this.declaredClasses = new ConcurrentHashMap<>();
this.methodNameSequenceGenerator = new ConcurrentHashMap<>();
}
@@ -79,6 +93,16 @@ public final class GeneratedClass {
return (sequence > 0) ? name.toString() + sequence : name.toString();
}
/**
* Return the enclosing {@link GeneratedClass} or {@code null} if this
* instance represents a top-level class.
* @return the enclosing generated class, if any
*/
@Nullable
public GeneratedClass getEnclosingClass() {
return this.enclosingClass;
}
/**
* Return the name of the generated class.
* @return the name of the generated class
@@ -95,10 +119,33 @@ public final class GeneratedClass {
return this.methods;
}
/**
* Get or add a nested generated class with the specified name. If this method
* has previously been called with the given {@code name}, the existing class
* will be returned, otherwise a new class will be generated.
* @param name the name of the nested class
* @param type a {@link Consumer} used to build the type
* @return an existing or newly generated class whose enclosing class is this class
*/
public GeneratedClass getOrAdd(String name, Consumer<TypeSpec.Builder> type) {
ClassName className = this.name.nestedClass(name);
return this.declaredClasses.computeIfAbsent(className,
key -> new GeneratedClass(this, className, type));
}
JavaFile generateJavaFile() {
Assert.state(getEnclosingClass() == null,
"Java file cannot be generated for an inner class");
TypeSpec.Builder type = apply();
return JavaFile.builder(this.name.packageName(), type.build()).build();
}
private TypeSpec.Builder apply() {
TypeSpec.Builder type = getBuilder(this.type);
this.methods.doWithMethodSpecs(type::addMethod);
return JavaFile.builder(this.name.packageName(), type.build()).build();
this.declaredClasses.values().forEach(declaredClass ->
type.addType(declaredClass.apply().build()));
return type;
}
private TypeSpec.Builder getBuilder(Consumer<TypeSpec.Builder> type) {

63
spring-core/src/test/java/org/springframework/aot/generate/GeneratedClassTests.java
View File

@@ -18,6 +18,8 @@ package org.springframework.aot.generate;
import java.util.function.Consumer;
import javax.lang.model.element.Modifier;
import org.junit.jupiter.api.Test;
import org.springframework.javapoet.ClassName;
@@ -35,21 +37,34 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
*/
class GeneratedClassTests {
private static final ClassName TEST_CLASS_NAME = ClassName.get("com.example", "Test");
private static final Consumer<TypeSpec.Builder> emptyTypeCustomizer = type -> {};
private static final Consumer<MethodSpec.Builder> emptyMethodCustomizer = method -> {};
@Test
void getEnclosingNameOnTopLevelClassReturnsNull() {
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
assertThat(generatedClass.getEnclosingClass()).isNull();
}
@Test
void getEnclosingNameOnInnerClassReturnsParent() {
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
GeneratedClass innerGeneratedClass = generatedClass.getOrAdd("Test", emptyTypeCustomizer);
assertThat(innerGeneratedClass.getEnclosingClass()).isEqualTo(generatedClass);
}
@Test
void getNameReturnsName() {
ClassName name = ClassName.bestGuess("com.example.Test");
GeneratedClass generatedClass = new GeneratedClass(name, emptyTypeCustomizer);
assertThat(generatedClass.getName()).isSameAs(name);
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
assertThat(generatedClass.getName()).isSameAs(TEST_CLASS_NAME);
}
@Test
void reserveMethodNamesWhenNameUsedThrowsException() {
ClassName name = ClassName.bestGuess("com.example.Test");
GeneratedClass generatedClass = new GeneratedClass(name, emptyTypeCustomizer);
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
generatedClass.getMethods().add("apply", emptyMethodCustomizer);
assertThatIllegalStateException()
.isThrownBy(() -> generatedClass.reserveMethodNames("apply"));
@@ -57,8 +72,7 @@ class GeneratedClassTests {
@Test
void reserveMethodNamesReservesNames() {
ClassName name = ClassName.bestGuess("com.example.Test");
GeneratedClass generatedClass = new GeneratedClass(name, emptyTypeCustomizer);
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
generatedClass.reserveMethodNames("apply");
GeneratedMethod generatedMethod = generatedClass.getMethods().add("apply", emptyMethodCustomizer);
assertThat(generatedMethod.getName()).isEqualTo("apply1");
@@ -66,18 +80,45 @@ class GeneratedClassTests {
@Test
void generateMethodNameWhenAllEmptyPartsGeneratesSetName() {
ClassName name = ClassName.bestGuess("com.example.Test");
GeneratedClass generatedClass = new GeneratedClass(name, emptyTypeCustomizer);
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
GeneratedMethod generatedMethod = generatedClass.getMethods().add("123", emptyMethodCustomizer);
assertThat(generatedMethod.getName()).isEqualTo("$$aot");
}
@Test
void getOrAddWhenRepeatReturnsSameGeneratedClass() {
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
GeneratedClass innerGeneratedClass = generatedClass.getOrAdd("Inner", emptyTypeCustomizer);
GeneratedClass innerGeneratedClass2 = generatedClass.getOrAdd("Inner", emptyTypeCustomizer);
GeneratedClass innerGeneratedClass3 = generatedClass.getOrAdd("Inner", emptyTypeCustomizer);
assertThat(innerGeneratedClass).isSameAs(innerGeneratedClass2).isSameAs(innerGeneratedClass3);
}
@Test
void generateJavaFileIncludesGeneratedMethods() {
ClassName name = ClassName.bestGuess("com.example.Test");
GeneratedClass generatedClass = new GeneratedClass(name, emptyTypeCustomizer);
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
generatedClass.getMethods().add("test", method -> method.addJavadoc("Test Method"));
assertThat(generatedClass.generateJavaFile().toString()).contains("Test Method");
}
@Test
void generateJavaFileIncludesDeclaredClasses() {
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME);
generatedClass.getOrAdd("First", type -> type.modifiers.add(Modifier.STATIC));
generatedClass.getOrAdd("Second", type -> type.modifiers.add(Modifier.PRIVATE));
assertThat(generatedClass.generateJavaFile().toString())
.contains("static class First").contains("private class Second");
}
@Test
void generateJavaFileOnInnerClassThrowsException() {
GeneratedClass generatedClass = createGeneratedClass(TEST_CLASS_NAME)
.getOrAdd("Inner", emptyTypeCustomizer);
assertThatIllegalStateException().isThrownBy(generatedClass::generateJavaFile);
}
private static GeneratedClass createGeneratedClass(ClassName className) {
return new GeneratedClass(className, emptyTypeCustomizer);
}
}