|
| 1 | +# Dynamic proxies on Substrate VM |
| 2 | + |
| 3 | +Java dynamic proxies, implemented by `java.lang.reflect.Proxy`, provide a mechanism which enables object level access control by routing all method invocations through a `java.lang.reflect.InvocationHandler`. Dynamic proxy classes are generated from a list of interfaces. |
| 4 | + |
| 5 | +Substrate VM doesn't provide machinery for generating and interpreting bytecodes at run time. Therefore all dynamic proxy classes need to be generated at native image build time |
| 6 | + |
| 7 | + |
| 8 | +# Automatic detection |
| 9 | +Substrate VM employs a simple static analysis that detects calls to `java.lang.reflect.Proxy.newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)` and `java.lang.reflect.Proxy.getProxyClass(ClassLoader, Class<?>[])` and tries to determine the list of interfaces that define dynamic proxies automatically. Given the list of interfaces then Substrate VM generates the proxy classes at image build time and adds them to the native image heap. In addition to generating the dynamic proxy class the constructor of the generated class that takes a `java.lang.reflect.InvocationHandler` argument, i.e., the one reflectively invoked by `java.lang.reflect.Proxy.newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)`, is registered for reflection so that dynamic proxy instances can be allocated at run time. |
| 10 | + |
| 11 | +The analysis is limited to situations where the list of interfaces comes from a constant array or an array that is allocated in the same method. For example in the code snippets bellow the dynamic proxy interfaces can be determined automatically. |
| 12 | + |
| 13 | +### Static final array: |
| 14 | + |
| 15 | +``` |
| 16 | +class ProxyFactory { |
| 17 | +
|
| 18 | + private static final Class<?>[] interfaces = new Class<?>[]{java.util.Comparator.class}; |
| 19 | +
|
| 20 | + static Comparator createProxyInstanceFromConstantArray() { |
| 21 | + ClassLoader classLoader = ProxyFactory.class.getClassLoader(); |
| 22 | + InvocationHandler handler = new ProxyInvocationHandler(); |
| 23 | + return (Comparator) Proxy.newProxyInstance(classLoader, interfaces, handler); |
| 24 | + } |
| 25 | +} |
| 26 | +``` |
| 27 | +Note: The analysis operates on Graal graphs and not source code. Therefore the following ways to declare and populate an array are equivalent from the point of view of the analysis: |
| 28 | + |
| 29 | +``` |
| 30 | +private static final Class<?>[] interfacesArrayPreInitialized = new Class<?>[]{java.util.Comparator.class}; |
| 31 | +``` |
| 32 | + |
| 33 | +``` |
| 34 | +private static final Class<?>[] interfacesArrayLiteral = {java.util.Comparator.class}; |
| 35 | +``` |
| 36 | + |
| 37 | +``` |
| 38 | +private static final Class<?>[] interfacesArrayPostInitialized = new Class<?>[1]; |
| 39 | +static { |
| 40 | + interfacesArrayPostInitialized[0] = java.util.Comparator.class; |
| 41 | +} |
| 42 | +``` |
| 43 | +However, in Java there are no immutable arrays. Even if the array is declared as `static final` its contents can change later on. The simple analysis that we employ here doesn't track further changes to the array. |
| 44 | + |
| 45 | +### New array: |
| 46 | + |
| 47 | +``` |
| 48 | +class ProxyFactory { |
| 49 | +
|
| 50 | + static Comparator createProxyInstanceFromNewArray() { |
| 51 | + ClassLoader classLoader = ProxyFactory.class.getClassLoader(); |
| 52 | + InvocationHandler handler = new ProxyInvocationHandler(); |
| 53 | + Class<?>[] interfaces = new Class<?>[]{java.util.Comparator.class}; |
| 54 | + return (Comparator) Proxy.newProxyInstance(classLoader, interfaces, handler); |
| 55 | + } |
| 56 | +} |
| 57 | +``` |
| 58 | + |
| 59 | +Note: Just like with constant arrays, the following ways to declare and populate an array are equivalent from the point of view of the analysis: |
| 60 | +``` |
| 61 | +Class<?>[] interfaces = new Class<?>[]{java.util.Comparator.class}; |
| 62 | +``` |
| 63 | + |
| 64 | +``` |
| 65 | +Class<?>[] interfaces = new Class<?>[1]; |
| 66 | +interfaces[0] = Question.class; |
| 67 | +``` |
| 68 | + |
| 69 | +``` |
| 70 | +Class<?>[] interfaces = {java.util.Comparator.class}; |
| 71 | +``` |
| 72 | + |
| 73 | +The static analysis covers code patterns most frequently used to define dynamic proxy classes. For the exceptional cases where the analysis cannot discover the interface array there is also a manual dynamic proxy configuration mechanism. |
| 74 | + |
| 75 | +# Manual configuration |
| 76 | +Dynamic proxy classes can be generated at native image build time by specifying the list of interfaces that they implement. Substrate VM provides two options for this purpose: `-H:DynamicProxyConfigurationFiles=<comma-separated-config-files>` and `-H:DynamicProxyConfigurationResources=<comma-separated-config-resources>`. |
| 77 | + |
| 78 | +These options accept JSON files whose structure is an array of arrays of fully qualified interface names. |
| 79 | + |
| 80 | +Example: |
| 81 | + |
| 82 | +``` |
| 83 | +[ |
| 84 | + ["java.lang.AutoCloseable", "java.util.Comparator"], |
| 85 | + ["java.util.Comparator"], |
| 86 | + ["java.util.List"] |
| 87 | +] |
| 88 | +``` |
| 89 | + |
| 90 | +The `java.lang.reflect.Proxy` API also allows creation of a dynamic proxy that doesn't implement any user provided interfaces. Therefore the following is a valid configuration: |
| 91 | + |
| 92 | +``` |
| 93 | +[ |
| 94 | + [] |
| 95 | +] |
| 96 | +``` |
| 97 | + |
| 98 | +In this case the generated dynamic proxy class only implements `java.lang.reflect.Proxy`. |
| 99 | + |
| 100 | +# Dynamic proxy classes in static initializers |
| 101 | + |
| 102 | +Dynamic proxy classes and instances of dynamic proxy classes that are defined in static initializers can be accessed at runtime without any special handling. This is possible since the static initializers are executed at native image build time. For example this will work: |
| 103 | + |
| 104 | +``` |
| 105 | +private final static Comparator proxyInstance; |
| 106 | +private final static Class<?> proxyClass; |
| 107 | +static { |
| 108 | + ClassLoader classLoader = ProxyFactory.class.getClassLoader(); |
| 109 | + InvocationHandler handler = new ProxyInvocationHandler(); |
| 110 | + Class<?>[] interfaces = {java.util.Comparator.class}; |
| 111 | + proxyInstance = (Comparator) Proxy.newProxyInstance(classLoader, interfaces, handler); |
| 112 | + proxyClass = Proxy.getProxyClass(classLoader, interfaces); |
| 113 | +} |
| 114 | +``` |
0 commit comments