{"id":912,"date":"2015-08-17T08:46:33","date_gmt":"2015-08-17T07:46:33","guid":{"rendered":"http:\/\/benjiweber.co.uk\/blog\/?p=912"},"modified":"2015-08-23T08:56:26","modified_gmt":"2015-08-23T07:56:26","slug":"lambda-parameter-names-with-reflection","status":"publish","type":"post","link":"https:\/\/benjiweber.co.uk\/blog\/2015\/08\/17\/lambda-parameter-names-with-reflection\/","title":{"rendered":"Lambda parameter names with reflection"},"content":{"rendered":"

Java 8 introduced a compiler flag -parameters, which makes method parameter names available at runtime with reflection. Up to now, this has not worked with lambda parameter names. However, Java 8u60 now has a fix for this bug<\/a> back-ported which makes it possible.<\/p>\n

Some uses that spring to mind (and work as of recent 8u60ea build) are doing things like hash literals<\/a><\/p>\n

\r\nMap hash = hash(\r\n    hello -> \"world\",\r\n    bob   -> bob,\r\n    bill  -> \"was here\"\r\n);\r\n\r\nassertEquals(\"world\",    hash.get(\"hello\"));\r\nassertEquals(\"bob\",      hash.get(\"bob\"));\r\nassertEquals(\"was here\", hash.get(\"bill\"));\r\n<\/pre>\n
Or just another tool for creating DSLs in Java itself. For example, look how close<\/a> to puppet’s DSL we can get now.<\/p>\n
\r\nstatic class Apache extends PuppetClass {{\r\n    file(\r\n        name -> \"\/etc\/httpd\/httpd.conf\",\r\n        source -> template(\"httpd.tpl\"),\r\n        owner -> root,\r\n        group -> root\r\n    );\r\n\r\n    cron (\r\n        name -> \"logrotate\",\r\n        command -> \"\/usr\/sbin\/logrotate\",\r\n        user -> root,\r\n        hour -> \"2\",\r\n        minute -> \"*\/10\"\r\n    );\r\n}}\r\n<\/pre>\n
Doing <\/p>\n
\r\nSystem.out.println(new Apache().toString());\r\n<\/pre>\n
Would print<\/p>\n
\r\nclass Apache {\r\n\r\n\tfile{\r\n\t\tname\t=> \"\/etc\/httpd\/httpd.conf\",\r\n\t\tsource\t=> template(httpd.tpl),\r\n\t\towner\t=> root,\r\n\t\tgroup\t=> root,\r\n\t}\r\n\tcron{\r\n\t\tname\t=> \"logrotate\",\r\n\t\tcommand\t=> \"\/usr\/sbin\/logrotate\",\r\n\t\tuser\t=> root,\r\n\t\thour\t=> \"2\",\r\n\t\tminute\t=> \"*\/10\",\r\n\t}\r\n\r\n}\r\n<\/pre>\n
The code examples for the hash literal example<\/a> and the puppet example<\/a> are on Github.<\/p>\n
They work by making use of a functional interface that extends Serializable. This makes it possible to get access to a SerializedLambda<\/a> instance, which then gives us access to the synthetic method generated for the lambda. We can then use the standard reflection API to get the parameter names.<\/p>\n
Here’s a utility MethodFinder interface<\/a> that we can extend our functional interfaces from that makes it easier.<\/p>\n
\r\npublic interface MethodFinder extends Serializable {\r\n    default SerializedLambda serialized() {\r\n        try {\r\n            Method replaceMethod = getClass().getDeclaredMethod(\"writeReplace\");\r\n            replaceMethod.setAccessible(true);\r\n            return (SerializedLambda) replaceMethod.invoke(this);\r\n        } catch (Exception e) {\r\n            throw new RuntimeException(e);\r\n        }\r\n    }\r\n\r\n    default Class getContainingClass() {\r\n        try {\r\n            String className = serialized().getImplClass().replaceAll(\"\/\", \".\");\r\n            return Class.forName(className);\r\n        } catch (Exception e) {\r\n            throw new RuntimeException(e);\r\n        }\r\n    }\r\n\r\n    default Method method() {\r\n        SerializedLambda lambda = serialized();\r\n        Class containingClass = getContainingClass();\r\n        return asList(containingClass.getDeclaredMethods())\r\n                .stream()\r\n                .filter(method -> Objects.equals(method.getName(), lambda.getImplMethodName()))\r\n                .findFirst()\r\n                .orElseThrow(UnableToGuessMethodException::new);\r\n    }\r\n\r\n    default Parameter parameter(int n) {\r\n        return method().getParameters()[n];\r\n    }\r\n\r\n    class UnableToGuessMethodException extends RuntimeException {}\r\n}\r\n<\/pre>\n
Given the above, we can create a NamedValue<\/a> type that allows a lambda to represent a mapping from a String to a value.<\/p>\n
\r\npublic interface NamedValue extends MethodFinder, Function {\r\n    default String name() {\r\n        checkParametersEnabled();\r\n        return parameter(0).getName();\r\n    }\r\n    default void checkParametersEnabled() {\r\n        if (Objects.equals(\"arg0\", parameter(0).getName())) {\r\n            throw new IllegalStateException(\"You need to compile with javac -parameters for parameter reflection to work; You also need java 8u60 or newer to use it with lambdas\");\r\n        }\r\n    }\r\n\r\n    default T value() {\r\n        return apply(name());\r\n    }\r\n}\r\n<\/pre>\n
Then we can simply ask our lambda for the name and value.<\/p>\n
\r\nNamedValue pair = five -> 5;\r\nassertEquals(\"five\", pair.name());\r\nassertEquals(5, pair.value());\r\n<\/pre>\n
See also HTML in Java<\/a> for another example use of this.<\/p>\n
I imagine there are more uses too, any ideas?<\/p>\n","protected":false},"excerpt":{"rendered":"
Java 8 introduced a compiler flag -parameters, which makes method parameter names available at runtime with reflection. Up to now, this has not worked with lambda parameter names. However, Java 8u60 now has a fix for this bug back-ported which makes it possible. Some uses that spring to mind (and work as of recent 8u60ea…  Read more »<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[8],"tags":[],"yoast_head":"\n\n\n\n\n\n\n\n\n\n\n\n