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

Allow ApplicationContextAotGenerator to generated better class names

Browse Source 
Update `ApplicationContextAotGenerator` so that it can generate class
names based on a `target` class and using the ID of the application
context. Prior to this commit, the generated class name was always
`__.BeanFactoryRegistrations`.

Closes gh-28565
This commit is contained in:
Phillip Webb
2022-06-03 16:43:13 -07:00
parent 243350054b
commit 4bd33cb6e0
9 changed files with 99 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
spring-core/src/main/java/org/springframework/aot/generate/ClassGenerator.java
View File

@@ -43,18 +43,6 @@ public interface ClassGenerator {
GeneratedClass getOrGenerateClass(JavaFileGenerator javaFileGenerator,
Class<?> target, String featureName);
/**
* Get or generate a new {@link GeneratedClass} for a given java file
* generator, target and feature name.
* @param javaFileGenerator the java file generator
* @param target the target of the newly generated class
* @param featureName the name of the feature that the generated class
* supports
* @return a {@link GeneratedClass} instance
*/
GeneratedClass getOrGenerateClass(JavaFileGenerator javaFileGenerator, String target,
String featureName);
/**
* Strategy used to generate the java file for the generated class.

48
spring-core/src/main/java/org/springframework/aot/generate/ClassNameGenerator.java
View File

@@ -21,6 +21,7 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.javapoet.ClassName;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
@@ -38,8 +39,9 @@ public final class ClassNameGenerator {
private static final String SEPARATOR = "__";
private static final String AOT_PACKAGE = "__";
private static final String AOT_PACKAGE = "__.";
private static final String AOT_FEATURE = "Aot";
private final Map<String, AtomicInteger> sequenceGenerator = new ConcurrentHashMap<>();
@@ -47,53 +49,37 @@ public final class ClassNameGenerator {
/**
* Generate a new class name for the given {@code target} /
* {@code featureName} combination.
* @param target the target of the newly generated class
* @param target the target of the newly generated class or {@code null} if
* there is not target.
* @param featureName the name of the feature that the generated class
* supports
* @return a unique generated class name
*/
public ClassName generateClassName(Class<?> target, String featureName) {
Assert.notNull(target, "'target' must not be null");
String rootName = target.getName().replace("$", "_");
return generateSequencedClassName(rootName, featureName);
}
/**
* Generate a new class name for the given {@code name} /
* {@code featureName} combination.
* @param target the target of the newly generated class. When possible,
* this should be a class name
* @param featureName the name of the feature that the generated class
* supports
* @return a unique generated class name
*/
public ClassName generateClassName(String target, String featureName) {
Assert.hasLength(target, "'target' must not be empty");
target = clean(target);
String rootName = AOT_PACKAGE + "." + ((!target.isEmpty()) ? target : "Aot");
return generateSequencedClassName(rootName, featureName);
public ClassName generateClassName(@Nullable Class<?> target, String featureName) {
Assert.hasLength(featureName, "'featureName' must not be empty");
featureName = clean(featureName);
if(target != null) {
return generateSequencedClassName(target.getName().replace("$", "_") + SEPARATOR + StringUtils.capitalize(featureName));
}
return generateSequencedClassName(AOT_PACKAGE+ featureName);
}
private String clean(String name) {
StringBuilder rootName = new StringBuilder();
StringBuilder clean = new StringBuilder();
boolean lastNotLetter = true;
for (char ch : name.toCharArray()) {
if (!Character.isLetter(ch)) {
lastNotLetter = true;
continue;
}
rootName.append(lastNotLetter ? Character.toUpperCase(ch) : ch);
clean.append(lastNotLetter ? Character.toUpperCase(ch) : ch);
lastNotLetter = false;
}
return rootName.toString();
return (!clean.isEmpty()) ? clean.toString() : AOT_FEATURE;
}
private ClassName generateSequencedClassName(String rootName, String featureName) {
Assert.hasLength(featureName, "'featureName' must not be empty");
Assert.isTrue(featureName.chars().allMatch(Character::isLetter),
"'featureName' must contain only letters");
String name = addSequence(
rootName + SEPARATOR + StringUtils.capitalize(featureName));
private ClassName generateSequencedClassName(String name) {
name = addSequence(name);
return ClassName.get(ClassUtils.getPackageName(name),
ClassUtils.getShortName(name));
}

13
spring-core/src/main/java/org/springframework/aot/generate/GeneratedClasses.java
View File

@@ -58,19 +58,6 @@ public class GeneratedClasses implements ClassGenerator {
this.classNameGenerator.generateClassName(target, featureName)));
}
@Override
public GeneratedClass getOrGenerateClass(JavaFileGenerator javaFileGenerator,
String target, String featureName) {
Assert.notNull(javaFileGenerator, "'javaFileGenerator' must not be null");
Assert.hasLength(target, "'target' must not be empty");
Assert.hasLength(featureName, "'featureName' must not be empty");
Owner owner = new Owner(javaFileGenerator, target, featureName);
return this.classes.computeIfAbsent(owner,
key -> new GeneratedClass(javaFileGenerator,
this.classNameGenerator.generateClassName(target, featureName)));
}
/**
* Write generated Spring {@code .factories} files to the given
* {@link GeneratedFiles} instance.

61
spring-core/src/test/java/org/springframework/aot/generate/ClassNameGeneratorTests.java
View File

@@ -35,18 +35,9 @@ class ClassNameGeneratorTests {
private final ClassNameGenerator generator = new ClassNameGenerator();
@Test
void generateClassNameWhenTargetClassIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(
() -> this.generator.generateClassName((Class<?>) null, "Test"))
.withMessage("'target' must not be null");
}
@Test
void generateClassNameWhenTargetStringIsEmptyThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> this.generator.generateClassName("", "Test"))
.withMessage("'target' must not be empty");
void generateClassNameWhenTargetClassIsNullUsesAotPackage() {
ClassName generated = this.generator.generateClassName((Class<?>) null, "test");
assertThat(generated).hasToString("__.Test");
}
@Test
@@ -58,17 +49,12 @@ class ClassNameGeneratorTests {
@Test
void generatedClassNameWhenFeatureIsNotAllLettersThrowsException() {
String expectedMessage = "'featureName' must contain only letters";
assertThatIllegalArgumentException().isThrownBy(
() -> this.generator.generateClassName(InputStream.class, "noway!"))
.withMessage(expectedMessage);
assertThatIllegalArgumentException().isThrownBy(
() -> this.generator.generateClassName(InputStream.class, "1WontWork"))
.withMessage(expectedMessage);
assertThatIllegalArgumentException()
.isThrownBy(
() -> this.generator.generateClassName(InputStream.class, "N0pe"))
.withMessage(expectedMessage);
assertThat(this.generator.generateClassName(InputStream.class, "name!"))
.hasToString("java.io.InputStream__Name");
assertThat(this.generator.generateClassName(InputStream.class, "1NameHere"))
.hasToString("java.io.InputStream__NameHere");
assertThat(this.generator.generateClassName(InputStream.class, "Y0pe"))
.hasToString("java.io.InputStream__YPe");
}
@Test
@@ -80,38 +66,21 @@ class ClassNameGeneratorTests {
@Test
void generateClassNameWithClassWhenInnerClassGeneratesName() {
ClassName generated = this.generator.generateClassName(TestBean.class,
"EventListener");
assertThat(generated).hasToString(
"org.springframework.aot.generate.ClassNameGeneratorTests_TestBean__EventListener");
ClassName generated = this.generator.generateClassName(TestBean.class, "EventListener");
assertThat(generated)
.hasToString("org.springframework.aot.generate.ClassNameGeneratorTests_TestBean__EventListener");
}
@Test
void generateClassWithClassWhenMultipleCallsGeneratesSequencedName() {
ClassName generated1 = this.generator.generateClassName(InputStream.class,
"bytes");
ClassName generated2 = this.generator.generateClassName(InputStream.class,
"bytes");
ClassName generated3 = this.generator.generateClassName(InputStream.class,
"bytes");
ClassName generated1 = this.generator.generateClassName(InputStream.class, "bytes");
ClassName generated2 = this.generator.generateClassName(InputStream.class, "bytes");
ClassName generated3 = this.generator.generateClassName(InputStream.class, "bytes");
assertThat(generated1).hasToString("java.io.InputStream__Bytes");
assertThat(generated2).hasToString("java.io.InputStream__Bytes1");
assertThat(generated3).hasToString("java.io.InputStream__Bytes2");
}
@Test
void generateClassNameWithStringGeneratesNameUsingOnlyLetters() {
ClassName generated = this.generator.generateClassName("my-bean--factoryStuff",
"beans");
assertThat(generated).hasToString("__.MyBeanFactoryStuff__Beans");
}
@Test
void generateClassNameWithStringWhenNoLettersGeneratesAotName() {
ClassName generated = this.generator.generateClassName("1234!@#", "beans");
assertThat(generated).hasToString("__.Aot__Beans");
}
static class TestBean {
}

30
spring-core/src/test/java/org/springframework/aot/generate/GeneratedClassesTests.java
View File

@@ -68,36 +68,12 @@ class GeneratedClassesTests {
.withMessage("'featureName' must not be empty");
}
@Test
void getOrGenerateWithStringTargetWhenJavaFileGeneratorIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> this.generatedClasses.getOrGenerateClass(null,
TestTarget.class.getName(), "test"))
.withMessage("'javaFileGenerator' must not be null");
}
@Test
void getOrGenerateWithStringTargetWhenTargetIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> this.generatedClasses
.getOrGenerateClass(JAVA_FILE_GENERATOR, (String) null, "test"))
.withMessage("'target' must not be empty");
}
@Test
void getOrGenerateWithStringTargetWhenFeatureIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> this.generatedClasses.getOrGenerateClass(
JAVA_FILE_GENERATOR, TestTarget.class.getName(), null))
.withMessage("'featureName' must not be empty");
}
@Test
void getOrGenerateWhenNewReturnsGeneratedMethod() {
GeneratedClass generatedClass1 = this.generatedClasses
.getOrGenerateClass(JAVA_FILE_GENERATOR, TestTarget.class, "one");
GeneratedClass generatedClass2 = this.generatedClasses.getOrGenerateClass(
JAVA_FILE_GENERATOR, TestTarget.class.getName(), "two");
GeneratedClass generatedClass2 = this.generatedClasses
.getOrGenerateClass(JAVA_FILE_GENERATOR, TestTarget.class, "two");
assertThat(generatedClass1).isNotNull().isNotEqualTo(generatedClass2);
assertThat(generatedClass2).isNotNull();
}
@@ -110,7 +86,7 @@ class GeneratedClassesTests {
GeneratedClass generatedClass2 = generated.getOrGenerateClass(JAVA_FILE_GENERATOR,
TestTarget.class, "one");
GeneratedClass generatedClass3 = generated.getOrGenerateClass(JAVA_FILE_GENERATOR,
TestTarget.class.getName(), "one");
TestTarget.class, "one");
GeneratedClass generatedClass4 = generated.getOrGenerateClass(JAVA_FILE_GENERATOR,
TestTarget.class, "two");
assertThat(generatedClass1).isNotNull().isSameAs(generatedClass2)