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

Allow AccessControl to determine visibility from a given type

Browse Source 
This commit adapts AccessVisibility so that it can determine if the
member or type signature is accessible from a given package. This lets
implementers figure out if reflection is necessary without assuming that
package private visibility is OK.

Closes gh-29245
This commit is contained in:
Stephane Nicoll
2022-10-03 10:49:25 +02:00
parent df58c00bf5
commit 3b2b36d0b8
19 changed files with 816 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
spring-orm/src/main/java/org/springframework/orm/jpa/support/InjectionCodeGenerator.java
View File

@@ -20,9 +20,10 @@ import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import org.springframework.aot.generate.AccessVisibility;
import org.springframework.aot.generate.AccessControl;
import org.springframework.aot.hint.ExecutableMode;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.javapoet.ClassName;
import org.springframework.javapoet.CodeBlock;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
@@ -45,11 +46,15 @@ import org.springframework.util.ReflectionUtils;
*/
class InjectionCodeGenerator {
private final ClassName targetClassName;
private final RuntimeHints hints;
InjectionCodeGenerator(RuntimeHints hints) {
InjectionCodeGenerator(ClassName targetClassName, RuntimeHints hints) {
Assert.notNull(hints, "TargetClassName must not be null");
Assert.notNull(hints, "Hints must not be null");
this.targetClassName = targetClassName;
this.hints = hints;
}
@@ -72,9 +77,8 @@ class InjectionCodeGenerator {
CodeBlock resourceToInject) {
CodeBlock.Builder code = CodeBlock.builder();
AccessVisibility visibility = AccessVisibility.forMember(field);
if (visibility == AccessVisibility.PRIVATE
|| visibility == AccessVisibility.PROTECTED) {
AccessControl accessControl = AccessControl.forMember(field);
if (!accessControl.isAccessibleFrom(this.targetClassName)) {
this.hints.reflection().registerField(field);
code.addStatement("$T field = $T.findField($T.class, $S)", Field.class,
ReflectionUtils.class, field.getDeclaringClass(), field.getName());
@@ -95,9 +99,8 @@ class InjectionCodeGenerator {
Assert.isTrue(method.getParameterCount() == 1,
"Method '" + method.getName() + "' must declare a single parameter");
CodeBlock.Builder code = CodeBlock.builder();
AccessVisibility visibility = AccessVisibility.forMember(method);
if (visibility == AccessVisibility.PRIVATE
|| visibility == AccessVisibility.PROTECTED) {
AccessControl accessControl = AccessControl.forMember(method);
if (!accessControl.isAccessibleFrom(this.targetClassName)) {
this.hints.reflection().registerMethod(method, ExecutableMode.INVOKE);
code.addStatement("$T method = $T.findMethod($T.class, $S, $T.class)",
Method.class, ReflectionUtils.class, method.getDeclaringClass(),

13
spring-orm/src/main/java/org/springframework/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.java
View File

@@ -794,16 +794,17 @@ public class PersistenceAnnotationBeanPostProcessor implements InstantiationAwar
method.addParameter(RegisteredBean.class, REGISTERED_BEAN_PARAMETER);
method.addParameter(this.target, INSTANCE_PARAMETER);
method.returns(this.target);
method.addCode(generateMethodCode(generationContext.getRuntimeHints(), generatedClass.getMethods()));
method.addCode(generateMethodCode(generationContext.getRuntimeHints(), generatedClass));
});
beanRegistrationCode.addInstancePostProcessor(generatedMethod.toMethodReference());
}
private CodeBlock generateMethodCode(RuntimeHints hints, GeneratedMethods generatedMethods) {
private CodeBlock generateMethodCode(RuntimeHints hints, GeneratedClass generatedClass) {
CodeBlock.Builder code = CodeBlock.builder();
InjectionCodeGenerator injectionCodeGenerator = new InjectionCodeGenerator(hints);
InjectionCodeGenerator injectionCodeGenerator = new InjectionCodeGenerator(
generatedClass.getName(), hints);
for (InjectedElement injectedElement : this.injectedElements) {
CodeBlock resourceToInject = generateResourceToInjectCode(generatedMethods,
CodeBlock resourceToInject = generateResourceToInjectCode(generatedClass.getMethods(),
(PersistenceElement) injectedElement);
code.add(injectionCodeGenerator.generateInjectionCode(
injectedElement.getMember(), INSTANCE_PARAMETER,
@@ -823,9 +824,9 @@ public class PersistenceAnnotationBeanPostProcessor implements InstantiationAwar
EntityManagerFactoryUtils.class, ListableBeanFactory.class,
REGISTERED_BEAN_PARAMETER, unitName);
}
String[] methodNameParts = { "get" , unitName, "EntityManager" };
String[] methodNameParts = { "get", unitName, "EntityManager" };
GeneratedMethod generatedMethod = generatedMethods.add(methodNameParts, method ->
generateGetEntityManagerMethod(method, injectedElement));
generateGetEntityManagerMethod(method, injectedElement));
return CodeBlock.of("$L($L)", generatedMethod.getName(), REGISTERED_BEAN_PARAMETER);
}

118
spring-orm/src/test/java/org/springframework/orm/jpa/support/InjectionCodeGeneratorTests.java
View File

@@ -28,10 +28,14 @@ import org.junit.jupiter.api.Test;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;
import org.springframework.beans.testfixture.beans.TestBean;
import org.springframework.beans.testfixture.beans.TestBeanWithPackagePrivateField;
import org.springframework.beans.testfixture.beans.TestBeanWithPackagePrivateMethod;
import org.springframework.beans.testfixture.beans.TestBeanWithPrivateMethod;
import org.springframework.beans.testfixture.beans.TestBeanWithPublicField;
import org.springframework.core.test.tools.CompileWithForkedClassLoader;
import org.springframework.core.test.tools.Compiled;
import org.springframework.core.test.tools.TestCompiler;
import org.springframework.javapoet.ClassName;
import org.springframework.javapoet.CodeBlock;
import org.springframework.javapoet.JavaFile;
import org.springframework.javapoet.MethodSpec;
@@ -50,17 +54,18 @@ class InjectionCodeGeneratorTests {
private static final String INSTANCE_VARIABLE = "instance";
private RuntimeHints hints = new RuntimeHints();
private static final ClassName TEST_TARGET = ClassName.get("com.example", "Test");
private InjectionCodeGenerator generator = new InjectionCodeGenerator(hints);
private final RuntimeHints hints = new RuntimeHints();
@Test
void generateCodeWhenPublicFieldInjectsValue() {
TestBeanWithPublicField bean = new TestBeanWithPublicField();
Field field = ReflectionUtils.findField(bean.getClass(), "age");
CodeBlock generatedCode = this.generator.generateInjectionCode(field, INSTANCE_VARIABLE,
CodeBlock.of("$L", 123));
testCompiledResult(generatedCode, TestBeanWithPublicField.class, (actual, compiled) -> {
ClassName targetClassName = TEST_TARGET;
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPublicField.class, (actual, compiled) -> {
TestBeanWithPublicField instance = new TestBeanWithPublicField();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
@@ -68,13 +73,45 @@ class InjectionCodeGeneratorTests {
});
}
@Test
@CompileWithForkedClassLoader
void generateCodeWhenPackagePrivateFieldInTargetPackageInjectsValue() {
TestBeanWithPackagePrivateField bean = new TestBeanWithPackagePrivateField();
Field field = ReflectionUtils.findField(bean.getClass(), "age");
ClassName targetClassName = ClassName.get(TestBeanWithPackagePrivateField.class.getPackageName(), "Test");
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPackagePrivateField.class, (actual, compiled) -> {
TestBeanWithPackagePrivateField instance = new TestBeanWithPackagePrivateField();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
assertThat(compiled.getSourceFile()).contains("instance.age = 123");
});
}
@Test
void generateCodeWhenPackagePrivateFieldInAnotherPackageUsesReflection() {
TestBeanWithPackagePrivateField bean = new TestBeanWithPackagePrivateField();
Field field = ReflectionUtils.findField(bean.getClass(), "age");
ClassName targetClassName = TEST_TARGET;
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPackagePrivateField.class, (actual, compiled) -> {
TestBeanWithPackagePrivateField instance = new TestBeanWithPackagePrivateField();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
assertThat(compiled.getSourceFile()).contains("setField(");
});
}
@Test
void generateCodeWhenPrivateFieldInjectsValueUsingReflection() {
TestBean bean = new TestBean();
Field field = ReflectionUtils.findField(bean.getClass(), "age");
CodeBlock generatedCode = this.generator.generateInjectionCode(field, INSTANCE_VARIABLE,
CodeBlock.of("$L", 123));
testCompiledResult(generatedCode, TestBean.class, (actual, compiled) -> {
ClassName targetClassName = ClassName.get(TestBean.class);
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBean.class, (actual, compiled) -> {
TestBean instance = new TestBean();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
@@ -86,7 +123,8 @@ class InjectionCodeGeneratorTests {
void generateCodeWhenPrivateFieldAddsHint() {
TestBean bean = new TestBean();
Field field = ReflectionUtils.findField(bean.getClass(), "age");
this.generator.generateInjectionCode(field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
createGenerator(TEST_TARGET).generateInjectionCode(
field, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
assertThat(RuntimeHintsPredicates.reflection().onField(TestBean.class, "age"))
.accepts(this.hints);
}
@@ -95,9 +133,10 @@ class InjectionCodeGeneratorTests {
void generateCodeWhenPublicMethodInjectsValue() {
TestBean bean = new TestBean();
Method method = ReflectionUtils.findMethod(bean.getClass(), "setAge", int.class);
CodeBlock generatedCode = this.generator.generateInjectionCode(method, INSTANCE_VARIABLE,
CodeBlock.of("$L", 123));
testCompiledResult(generatedCode, TestBean.class, (actual, compiled) -> {
ClassName targetClassName = TEST_TARGET;
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBean.class, (actual, compiled) -> {
TestBean instance = new TestBean();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
@@ -105,13 +144,45 @@ class InjectionCodeGeneratorTests {
});
}
@Test
@CompileWithForkedClassLoader
void generateCodeWhenPackagePrivateMethodInTargetPackageInjectsValue() {
TestBeanWithPackagePrivateMethod bean = new TestBeanWithPackagePrivateMethod();
Method method = ReflectionUtils.findMethod(bean.getClass(), "setAge", int.class);
ClassName targetClassName = ClassName.get(TestBeanWithPackagePrivateMethod.class);
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPackagePrivateMethod.class, (actual, compiled) -> {
TestBeanWithPackagePrivateMethod instance = new TestBeanWithPackagePrivateMethod();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
assertThat(compiled.getSourceFile()).contains("instance.setAge(");
});
}
@Test
void generateCodeWhenPackagePrivateMethodInAnotherPackageUsesReflection() {
TestBeanWithPackagePrivateMethod bean = new TestBeanWithPackagePrivateMethod();
Method method = ReflectionUtils.findMethod(bean.getClass(), "setAge", int.class);
ClassName targetClassName = TEST_TARGET;
CodeBlock generatedCode = createGenerator(targetClassName).generateInjectionCode(
method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPackagePrivateMethod.class, (actual, compiled) -> {
TestBeanWithPackagePrivateMethod instance = new TestBeanWithPackagePrivateMethod();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
assertThat(compiled.getSourceFile()).contains("invokeMethod(");
});
}
@Test
void generateCodeWhenPrivateMethodInjectsValueUsingReflection() {
TestBeanWithPrivateMethod bean = new TestBeanWithPrivateMethod();
Method method = ReflectionUtils.findMethod(bean.getClass(), "setAge", int.class);
CodeBlock generatedCode = this.generator.generateInjectionCode(method, INSTANCE_VARIABLE,
CodeBlock.of("$L", 123));
testCompiledResult(generatedCode, TestBeanWithPrivateMethod.class, (actual, compiled) -> {
ClassName targetClassName = ClassName.get(TestBeanWithPrivateMethod.class);
CodeBlock generatedCode = createGenerator(targetClassName)
.generateInjectionCode(method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
testCompiledResult(targetClassName, generatedCode, TestBeanWithPrivateMethod.class, (actual, compiled) -> {
TestBeanWithPrivateMethod instance = new TestBeanWithPrivateMethod();
actual.accept(instance);
assertThat(instance).extracting("age").isEqualTo(123);
@@ -123,26 +194,31 @@ class InjectionCodeGeneratorTests {
void generateCodeWhenPrivateMethodAddsHint() {
TestBeanWithPrivateMethod bean = new TestBeanWithPrivateMethod();
Method method = ReflectionUtils.findMethod(bean.getClass(), "setAge", int.class);
this.generator.generateInjectionCode(method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
createGenerator(TEST_TARGET).generateInjectionCode(
method, INSTANCE_VARIABLE, CodeBlock.of("$L", 123));
assertThat(RuntimeHintsPredicates.reflection()
.onMethod(TestBeanWithPrivateMethod.class, "setAge").invoke()).accepts(this.hints);
}
private InjectionCodeGenerator createGenerator(ClassName target) {
return new InjectionCodeGenerator(target, this.hints);
}
@SuppressWarnings("unchecked")
private <T> void testCompiledResult(CodeBlock generatedCode, Class<T> target,
private <T> void testCompiledResult(ClassName generatedClasName, CodeBlock generatedCode, Class<T> target,
BiConsumer<Consumer<T>, Compiled> result) {
JavaFile javaFile = createJavaFile(generatedCode, target);
JavaFile javaFile = createJavaFile(generatedClasName, generatedCode, target);
TestCompiler.forSystem().compile(javaFile::writeTo,
compiled -> result.accept(compiled.getInstance(Consumer.class), compiled));
}
private JavaFile createJavaFile(CodeBlock generatedCode, Class<?> target) {
TypeSpec.Builder builder = TypeSpec.classBuilder("Injector");
private JavaFile createJavaFile(ClassName generatedClasName, CodeBlock generatedCode, Class<?> target) {
TypeSpec.Builder builder = TypeSpec.classBuilder(generatedClasName.simpleName() + "__Injector");
builder.addModifiers(Modifier.PUBLIC);
builder.addSuperinterface(ParameterizedTypeName.get(Consumer.class, target));
builder.addMethod(MethodSpec.methodBuilder("accept").addModifiers(Modifier.PUBLIC)
.addParameter(target, INSTANCE_VARIABLE).addCode(generatedCode).build());
return JavaFile.builder("__", builder.build()).build();
return JavaFile.builder(generatedClasName.packageName(), builder.build()).build();
}
}