JDK 8 - Lambda - Reflection issues

[Pavel Bucek]

just for the sake of correctness - WholeMessageHandler<T> does not need 
to have Class<T> genericParam field and constructor param - anonymous 
class which just wraps the lambda expression is good enough.

On 13/03/14 09:56, Pavel Bucek wrote:
> Hi Remi,
>
> thanks! I suspected that it would not be possible, but it is always 
> better to have the confirmation.
>
> My context is slightly different, but the consequences are similar 
> like with the jackson library. Seems a little unfortunate to have the 
> possibility to use lambdas even on places where it cannot work - my 
> guess is that this will become one of most frequent question on some 
> mailing lists..
>
> (you don't really need to read further)
>
> I'm working on JSR 356 - Java API for WebSocket implementation and 
> there is an interface:
>
> interface MessageHandler.Whole<T> extends MessageHandler {
>     void onMessage(T message);
> }
>
> And then there is a Session object, which has method "void 
> addMessageHandler(MessageHandler handler);". Obvious common use of 
> this method is:
>
> session.addMessageHandler(new MessageHandler.Whole<String>() {
>     @Override
>         public void onMessage(String message) {
>             // ...
>         }
> });
>
> I can see my IDE automatically offers me to transform this to lambda 
> expression (this is actually what worries me a little, because all 
> users will see that and do it - because why not - it seems to be 
> equivalent with anonymous class). When this suggestion is accepted, 
> previous statement is transformed into:
>
> session.addMessageHandler((MessageHandler.Whole<String>) message -> {
>     // ...
> });
>
> which looks prettier, but just does not work and cannot work :/ I 
> guess we could provide wrapper class, something like:
>
>     public static class WholeMessageHandler<T> implements 
> MessageHandler.Whole<T> {
>
>         private final Class<T> genericParam;
>         private final MessageHandler.Whole<T> wholeMessageHandler;
>
>         protected WholeMessageHandler(Class<T> genericParam, 
> MessageHandler.Whole<T> wholeMessageHandler) {
>             this.genericParam = genericParam;
>             this.wholeMessageHandler = wholeMessageHandler;
>         }
>
>         public Class<T> getGenericParam() {
>             return genericParam;
>         }
>
>         @Override
>         public void onMessage(T message) {
>             wholeMessageHandler.onMessage(message);
>         }
>     }
>
> and then, when user would want to use lambdas, do it with help of that 
> class:
>
> session.addMessageHandler(new WholeMessageHandler<Main>(Main.class, 
> param -> System.out.println("234")));
>
> so I can do this like a workaround, but anyway, the initial 
> recommendation of the IDE is bad enough to cause us lots of mailing 
> list traffic and explanations why is not possible to use lambda in 
> "native" fashion. Anyway - I'm not describing my pain just to share my 
> pain - if anyone have any suggestions how this can be solved, I'm all 
> ears; any reply would be greatly appreciated.
>
> Thanks!
> Pavel
>
>
> On 12/03/14 19:42, Remi Forax wrote:
>> On 03/12/2014 07:12 PM, Pavel Bucek wrote:
>>> Hello all,
>>>
>>> I have an issue with getting generic parameter when using lambdas. I 
>>> can get the type when using anonymous classes.
>>>
>>> code sample will be more descriptive than anything I would say, so.. :
>>>
>>> public class Main {
>>>
>>>     public static interface A<T> {
>>>         public void method(T param);
>>>     }
>>>
>>>     public static void main(String[] args) {
>>>
>>>         final A<Main> anonClass = new A<Main>() {
>>>             @Override
>>>             public void method(Main param) {
>>>                 System.out.println("234");
>>>             }
>>>         };
>>>
>>>         final A<Main> lambda = param -> System.out.println("234");
>>>
>>>         //following does not help.
>>>         // final A<Main> lambda = (A<Main>)param -> 
>>> System.out.println("234");
>>>
>>>
>>>         // output: Main.Main$A<Main>
>>>         System.out.println("$ " + 
>>> anonClass.getClass().getGenericInterfaces()[0]);
>>>
>>>         // output: interface Main$A          ### generic type info 
>>> is already lost (no <Main>)
>>>         System.out.println("# " + 
>>> lambda.getClass().getGenericInterfaces()[0]);
>>>
>>>         // parameterized type from annon class
>>>         final Type t = 
>>> ((ParameterizedType)anonClass.getClass().getGenericInterfaces()[0]).getActualTypeArguments()[0];
>>>         System.out.println("$ " + t);
>>>
>>>         // parameterized type from lambda
>>>         System.out.println("# " + "???");
>>>     }
>>> }
>>>
>>> I was not able to find any useful documentation or article about 
>>> this, so sorry if this is something common - feel free to RTM me 
>>> (with relevant link please).
>>>
>>> Thanks and regards,
>>> Pavel
>>
>> As you have seen a lambda is not an anonymous class :)
>>
>> A non-serializable lambda is more lightweight than an anonymous class 
>> so the generic information that are transmitted from the bytecode to 
>> the runtime (the lambda metafactory) are not kept inside the lambda 
>> class (a lambda class may be shared by several different lambdas).
>>
>> A serializable lambda keep these information because you need them to 
>> deserialize a lambda but they are not publicly available
>> The current implementation encoded them in the bytecode and this 
>> bytecode is not publicly available so unless you serialize the lambda 
>> and serialize it by hand, you can not have access to these information.
>>
>> So you can not use a lambda with frameworks like Jackson that use the 
>> TypeReference idiom,
>> you can still use an anonymous class for that :)
>>
>> cheers,
>> Rémi
>>
>>
>>
>
>
>