Proper access to default methods of interfaces through reflection in Java 8, 9, 10
Translator's note: the development of the CUBA framework generates a large number of R & D projects. During one such project, it turned out that we need to call the default interface methods from the proxy classes. Stumbled upon a very useful article, it seems to me that the experience outlined in it will be at least interesting, as much as possible — useful to a wide circle of developers.
When it comes to accessing the default methods of interfaces in Java through reflection, googling does not help much. For example, a StackOverflow solution only works in certain situations and not on all versions of Java.
In this article, various approaches to calling the default methods of interfaces through reflection will be considered; this may be necessary, for example, when creating proxy classes.
')
TL; DR If you can not wait, then all the ways to call the default methods described in this article are available at this link , and this problem has already been solved in our jOOR library.
The useful API java.lang.reflect.Proxy has been around for a long time, with its help we can do cool things, for example:
This code simply prints:
In this example, we created a proxy instance that implements the Duck interface API using InvocationHandler , which, in essence, is just a lambda called for each method of the Duck interface.
The interesting thing will start when we want to add the implementation of the method to the interface and delegate the call to this method:
Most likely, you want to write this code:
But this will only generate a long stack of nested exceptions (and this is not associated with a call to the implementation of the method in the interface, so it is simply forbidden to do):
Not very helpful.
So, Google search gives us that you need to use the MethodHandles API . Well, let's try!
Cool, it seems that earned!
… but no.
The interface from the example above was neatly arranged so that the calling code had private access to it, i.e. The interface has been nested in the calling class. And what if we have a non-nested interface?
Almost the same code no longer works. We get the exception IllegalAccessException:
Garbage out. If you google more, you can find the following solution, which gains access to the internals of MethodHandles.Lookup through reflection.
And, cheers, we get:
We did it on JDK 8. How about JDK 9 or 10?
Opachki. This is what happens by default . If we run the program with the flag -
Well, then we get (and rightly so!):
One of the goals of the Jigsaw project was precisely to prevent such hacks. So, which solution is better? It?
Great, it works in Java 9 and 10, but what about Java 8?
Are you kidding me, huh?
So, we have a solution (hack) that works in Java 8, but not in 9 and 10, and there is a solution that works in 9 and 10, but not in 8
Well, I just tried to run different code on different JDKs. The following class tries all of the above combinations. It is also available as a GIST here .
Compile the code using JDK 9 or 10 (because the JDK 9+ API: MethodHandles.privateLookupIn () is required), but you need to compile with the command below so that you can run the class on JDK 8:
Conclusion of the above program:
Java 8
Java 9
Java 10
To understand all this is a bit complicated.
Honestly, this is a bit confusing. A suitable meme for this:
Rafael Winterhalter (by ByteBuddy) said that the “real” fix will be in the revised version of the Proxy API:
I'm not sure that this will solve all the problems, but you really need to make sure that the developer does not worry about all of the above.
And it is clear that this article is not complete, for example, it was not tested, whether these approaches will work if Duck is imported from another module:
... and this will be the topic of the next article.
If you are using jOOR (our library for the reflection API, it’s here ), then version 0.9.8 will include a fix for this: github.com/jOOQ/jOOR/issues/49
Fix simply uses the Reflection API hack approach in Java 8 or MethodHandles.priLateLookupIn () for Java 9+. You can write:
When it comes to accessing the default methods of interfaces in Java through reflection, googling does not help much. For example, a StackOverflow solution only works in certain situations and not on all versions of Java.
In this article, various approaches to calling the default methods of interfaces through reflection will be considered; this may be necessary, for example, when creating proxy classes.
')
TL; DR If you can not wait, then all the ways to call the default methods described in this article are available at this link , and this problem has already been solved in our jOOR library.
Proxy interfaces with default methods
The useful API java.lang.reflect.Proxy has been around for a long time, with its help we can do cool things, for example:
import java.lang.reflect.Proxy; public class ProxyDemo { interface Duck { void quack(); } public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { System.out.println("Quack"); return null; } ); duck.quack(); } } This code simply prints:
Quack In this example, we created a proxy instance that implements the Duck interface API using InvocationHandler , which, in essence, is just a lambda called for each method of the Duck interface.
The interesting thing will start when we want to add the implementation of the method to the interface and delegate the call to this method:
interface Duck { default void quack() { System.out.println("Quack"); } } Most likely, you want to write this code:
import java.lang.reflect.Proxy; public class ProxyDemo { interface Duck { default void quack() { System.out.println("Quack"); } } public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { method.invoke(proxy); return null; } ); duck.quack(); } } But this will only generate a long stack of nested exceptions (and this is not associated with a call to the implementation of the method in the interface, so it is simply forbidden to do):
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) at ProxyDemo.main(ProxyDemo.java:20) Caused by: java.lang.reflect.InvocationTargetException at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at ProxyDemo.lambda$0(ProxyDemo.java:15) ... 2 more Caused by: java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) ... 7 more Caused by: java.lang.reflect.InvocationTargetException at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at ProxyDemo.lambda$0(ProxyDemo.java:15) ... 8 more Caused by: java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) ... 13 more Caused by: java.lang.reflect.InvocationTargetException at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at ProxyDemo.lambda$0(ProxyDemo.java:15) ... 14 more Caused by: java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) ... 19 more ... ... ... goes on forever Not very helpful.
Using the Method Handles API
So, Google search gives us that you need to use the MethodHandles API . Well, let's try!
import java.lang.invoke.MethodHandles; import java.lang.reflect.Proxy; public class ProxyDemo { interface Duck { default void quack() { System.out.println("Quack"); } } public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { MethodHandles .lookup() .in(Duck.class) .unreflectSpecial(method, Duck.class) .bindTo(proxy) .invokeWithArguments(); return null; } ); duck.quack(); } } Cool, it seems that earned!
Quack … but no.
Calling an interface method with no private access
The interface from the example above was neatly arranged so that the calling code had private access to it, i.e. The interface has been nested in the calling class. And what if we have a non-nested interface?
import java.lang.invoke.MethodHandles; import java.lang.reflect.Proxy; interface Duck { default void quack() { System.out.println("Quack"); } } public class ProxyDemo { public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { MethodHandles .lookup() .in(Duck.class) .unreflectSpecial(method, Duck.class) .bindTo(proxy) .invokeWithArguments(); return null; } ); duck.quack(); } } Almost the same code no longer works. We get the exception IllegalAccessException:
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) at ProxyDemo.main(ProxyDemo.java:26) Caused by: java.lang.IllegalAccessException: no private access for invokespecial: interface Duck, from Duck/package at java.lang.invoke.MemberName.makeAccessException(MemberName.java:850) at java.lang.invoke.MethodHandles$Lookup.checkSpecialCaller(MethodHandles.java:1572) at java.lang.invoke.MethodHandles$Lookup.unreflectSpecial(MethodHandles.java:1231) at ProxyDemo.lambda$0(ProxyDemo.java:19) ... 2 more Garbage out. If you google more, you can find the following solution, which gains access to the internals of MethodHandles.Lookup through reflection.
import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Constructor; import java.lang.reflect.Proxy; interface Duck { default void quack() { System.out.println("Quack"); } } public class ProxyDemo { public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { Constructor<Lookup> constructor = Lookup.class .getDeclaredConstructor(Class.class); constructor.setAccessible(true); constructor.newInstance(Duck.class) .in(Duck.class) .unreflectSpecial(method, Duck.class) .bindTo(proxy) .invokeWithArguments(); return null; } ); duck.quack(); } } And, cheers, we get:
Quack We did it on JDK 8. How about JDK 9 or 10?
WARNING: An illegal reflective access operation has occurred WARNING: Illegal reflective access by ProxyDemo (file:/C:/Users/lukas/workspace/playground/target/classes/) to constructor java.lang.invoke.MethodHandles$Lookup(java.lang.Class) WARNING: Please consider reporting this to the maintainers of ProxyDemo WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations WARNING: All illegal access operations will be denied in a future release Quack Opachki. This is what happens by default . If we run the program with the flag -
--illegal-access=deny : java --illegal-access=deny ProxyDemo Well, then we get (and rightly so!):
Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make java.lang.invoke.MethodHandles$Lookup(java.lang.Class) accessible: module java.base does not "opens java.lang.invoke" to unnamed module @357246de at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:337) at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:281) at java.base/java.lang.reflect.Constructor.checkCanSetAccessible(Constructor.java:192) at java.base/java.lang.reflect.Constructor.setAccessible(Constructor.java:185) at ProxyDemo.lambda$0(ProxyDemo.java:18) at $Proxy0.quack(Unknown Source) at ProxyDemo.main(ProxyDemo.java:28) One of the goals of the Jigsaw project was precisely to prevent such hacks. So, which solution is better? It?
import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.Proxy; interface Duck { default void quack() { System.out.println("Quack"); } } public class ProxyDemo { public static void main(String[] a) { Duck duck = (Duck) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { Duck.class }, (proxy, method, args) -> { MethodHandles.lookup() .findSpecial( Duck.class, "quack", MethodType.methodType( void.class, new Class[0]), Duck.class) .bindTo(proxy) .invokeWithArguments(); return null; } ); duck.quack(); } } Quack Great, it works in Java 9 and 10, but what about Java 8?
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException at $Proxy0.quack(Unknown Source) at ProxyDemo.main(ProxyDemo.java:25) Caused by: java.lang.IllegalAccessException: no private access for invokespecial: interface Duck, from ProxyDemo at java.lang.invoke.MemberName.makeAccessException(MemberName.java:850) at java.lang.invoke.MethodHandles$Lookup.checkSpecialCaller(MethodHandles.java:1572) at java.lang.invoke.MethodHandles$Lookup.findSpecial(MethodHandles.java:1002) at ProxyDemo.lambda$0(ProxyDemo.java:18) ... 2 more Are you kidding me, huh?
So, we have a solution (hack) that works in Java 8, but not in 9 and 10, and there is a solution that works in 9 and 10, but not in 8
Deeper research
Well, I just tried to run different code on different JDKs. The following class tries all of the above combinations. It is also available as a GIST here .
Compile the code using JDK 9 or 10 (because the JDK 9+ API: MethodHandles.privateLookupIn () is required), but you need to compile with the command below so that you can run the class on JDK 8:
javac -source 1.8 -target 1.8 CallDefaultMethodThroughReflection.java import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.lang.reflect.Proxy; interface PrivateInaccessible { default void quack() { System.out.println(" -> PrivateInaccessible.quack()"); } } public class CallDefaultMethodThroughReflection { interface PrivateAccessible { default void quack() { System.out.println(" -> PrivateAccessible.quack()"); } } public static void main(String[] args) { System.out.println("PrivateAccessible"); System.out.println("-----------------"); System.out.println(); proxy(PrivateAccessible.class).quack(); System.out.println(); System.out.println("PrivateInaccessible"); System.out.println("-------------------"); System.out.println(); proxy(PrivateInaccessible.class).quack(); } private static void quack(Lookup lookup, Class<?> type, Object proxy) { System.out.println("Lookup.in(type).unreflectSpecial(...)"); try { lookup.in(type) .unreflectSpecial(type.getMethod("quack"), type) .bindTo(proxy) .invokeWithArguments(); } catch (Throwable e) { System.out.println(" -> " + e.getClass() + ": " + e.getMessage()); } System.out.println("Lookup.findSpecial(...)"); try { lookup.findSpecial(type, "quack", MethodType.methodType(void.class, new Class[0]), type) .bindTo(proxy) .invokeWithArguments(); } catch (Throwable e) { System.out.println(" -> " + e.getClass() + ": " + e.getMessage()); } } @SuppressWarnings("unchecked") private static <T> T proxy(Class<T> type) { return (T) Proxy.newProxyInstance( Thread.currentThread().getContextClassLoader(), new Class[] { type }, (Object proxy, Method method, Object[] arguments) -> { System.out.println("MethodHandles.lookup()"); quack(MethodHandles.lookup(), type, proxy); try { System.out.println(); System.out.println("Lookup(Class)"); Constructor<Lookup> constructor = Lookup.class.getDeclaredConstructor(Class.class); constructor.setAccessible(true); constructor.newInstance(type); quack(constructor.newInstance(type), type, proxy); } catch (Exception e) { System.out.println(" -> " + e.getClass() + ": " + e.getMessage()); } try { System.out.println(); System.out.println("MethodHandles.privateLookupIn()"); quack(MethodHandles.privateLookupIn(type, MethodHandles.lookup()), type, proxy); } catch (Error e) { System.out.println(" -> " + e.getClass() + ": " + e.getMessage()); } return null; } ); } } Conclusion of the above program:
Java 8
$ java -version java version "1.8.0_141" Java(TM) SE Runtime Environment (build 1.8.0_141-b15) Java HotSpot(TM) 64-Bit Server VM (build 25.141-b15, mixed mode) $ java CallDefaultMethodThroughReflection PrivateAccessible ----------------- MethodHandles.lookup() Lookup.in(type).unreflectSpecial(...) -> PrivateAccessible.quack() Lookup.findSpecial(...) -> class java.lang.IllegalAccessException: no private access for invokespecial: interface CallDefaultMethodThroughReflection$PrivateAccessible, from CallDefaultMethodThroughReflection Lookup(Class) Lookup.in(type).unreflectSpecial(...) -> PrivateAccessible.quack() Lookup.findSpecial(...) -> PrivateAccessible.quack() MethodHandles.privateLookupIn() -> class java.lang.NoSuchMethodError: java.lang.invoke.MethodHandles.privateLookupIn(Ljava/lang/Class;Ljava/lang/invoke/MethodHandles$Lookup;)Ljava/lang/invoke/MethodHandles$Lookup; PrivateInaccessible ------------------- MethodHandles.lookup() Lookup.in(type).unreflectSpecial(...) -> class java.lang.IllegalAccessException: no private access for invokespecial: interface PrivateInaccessible, from PrivateInaccessible/package Lookup.findSpecial(...) -> class java.lang.IllegalAccessException: no private access for invokespecial: interface PrivateInaccessible, from CallDefaultMethodThroughReflection Lookup(Class) Lookup.in(type).unreflectSpecial(...) -> PrivateInaccessible.quack() Lookup.findSpecial(...) -> PrivateInaccessible.quack() MethodHandles.privateLookupIn() -> class java.lang.NoSuchMethodError: java.lang.invoke.MethodHandles.privateLookupIn(Ljava/lang/Class;Ljava/lang/invoke/MethodHandles$Lookup;)Ljava/lang/invoke/MethodHandles$Lookup; Java 9
$ java -version java version "9.0.4" Java(TM) SE Runtime Environment (build 9.0.4+11) Java HotSpot(TM) 64-Bit Server VM (build 9.0.4+11, mixed mode) $ java --illegal-access=deny CallDefaultMethodThroughReflection PrivateAccessible ----------------- MethodHandles.lookup() Lookup.in(type).unreflectSpecial(...) -> PrivateAccessible.quack() Lookup.findSpecial(...) -> PrivateAccessible.quack() Lookup(Class) -> class java.lang.reflect.InaccessibleObjectException: Unable to make java.lang.invoke.MethodHandles$Lookup(java.lang.Class) accessible: module java.base does not "opens java.lang.invoke" to unnamed module @30c7da1e MethodHandles.privateLookupIn() Lookup.in(type).unreflectSpecial(...) -> PrivateAccessible.quack() Lookup.findSpecial(...) -> PrivateAccessible.quack() PrivateInaccessible ------------------- MethodHandles.lookup() Lookup.in(type).unreflectSpecial(...) -> class java.lang.IllegalAccessException: no private access for invokespecial: interface PrivateInaccessible, from PrivateInaccessible/package (unnamed module @30c7da1e) Lookup.findSpecial(...) -> PrivateInaccessible.quack() Lookup(Class) -> class java.lang.reflect.InaccessibleObjectException: Unable to make java.lang.invoke.MethodHandles$Lookup(java.lang.Class) accessible: module java.base does not "opens java.lang.invoke" to unnamed module @30c7da1e MethodHandles.privateLookupIn() Lookup.in(type).unreflectSpecial(...) -> PrivateInaccessible.quack() Lookup.findSpecial(...) -> PrivateInaccessible.quack() Java 10
$ java -version java version "10" 2018-03-20 Java(TM) SE Runtime Environment 18.3 (build 10+46) Java HotSpot(TM) 64-Bit Server VM 18.3 (build 10+46, mixed mode) $ java --illegal-access=deny CallDefaultMethodThroughReflection ... , Java 9 Conclusion
To understand all this is a bit complicated.
- In Java 8, the best working approach is a hack that fits inside the JDK through access to the package-private constructor of the
Lookupclass. This is the only way to uniformly invoke interface methods with both private access and non-private access from any class. - In Java 9 and 10, the best way is to use
Lookup.findSpecial()(does not work in Java 8) orMethodHandles.privateLookupIn()(the method does not exist in Java 8). The latter approach should be used if the interface is in another module. This module should provide an interface for calling from the outside.
Honestly, this is a bit confusing. A suitable meme for this:
Rafael Winterhalter (by ByteBuddy) said that the “real” fix will be in the revised version of the Proxy API:
Transfer
Lukas Eder : “You don’t know the reason why you decided not to allow this to happen anymore? Or just missed it (probably not)? ”
Rafael Winterhalter : “There is no reason. This is a side effect of the Java security model for the Lookup class from MethodHandle. Ideally, in the proxy interfaces there should be such a Lookup provided as an argument ( constructor - comment ), but this was not considered. I have unsuccessfully offered a similar extension for the class file transformation API. ”
Rafael Winterhalter : “There is no reason. This is a side effect of the Java security model for the Lookup class from MethodHandle. Ideally, in the proxy interfaces there should be such a Lookup provided as an argument ( constructor - comment ), but this was not considered. I have unsuccessfully offered a similar extension for the class file transformation API. ”
I'm not sure that this will solve all the problems, but you really need to make sure that the developer does not worry about all of the above.
And it is clear that this article is not complete, for example, it was not tested, whether these approaches will work if Duck is imported from another module:
Transfer
JOOQ : title and article link
Rafael Winterhalter : “Have you tried putting Duck into a module that exports, but does not open, an interface package? I bet your Java 9+ solution won't work if the module path is used. ”
Rafael Winterhalter : “Have you tried putting Duck into a module that exports, but does not open, an interface package? I bet your Java 9+ solution won't work if the module path is used. ”
... and this will be the topic of the next article.
Using jOOR
If you are using jOOR (our library for the reflection API, it’s here ), then version 0.9.8 will include a fix for this: github.com/jOOQ/jOOR/issues/49
Fix simply uses the Reflection API hack approach in Java 8 or MethodHandles.priLateLookupIn () for Java 9+. You can write:
Reflect.on(new Object()).as(PrivateAccessible.class).quack(); Reflect.on(new Object()).as(PrivateInaccessible.class).quack(); Source: https://habr.com/ru/post/421413/
All Articles