{"id":467,"date":"2014-04-14T20:51:30","date_gmt":"2014-04-14T19:51:30","guid":{"rendered":"http:\/\/benjiweber.co.uk\/blog\/?p=467"},"modified":"2020-09-13T20:02:09","modified_gmt":"2020-09-13T19:02:09","slug":"java-forwarding-interface-pattern","status":"publish","type":"post","link":"https:\/\/benjiweber.co.uk\/blog\/2014\/04\/14\/java-forwarding-interface-pattern\/","title":{"rendered":"Java Forwarding-Interface Pattern"},"content":{"rendered":"

Java 8’s default methods on interfaces means we can implement the decorator pattern<\/a> much less verbosely. <\/p>\n

The decorator pattern allows us to add behaviour to an object without using inheritance. I often find myself using it to “extend” third party interfaces with useful additional behaviour. <\/p>\n

Let’s say we wanted to add a map method to List that allows us to convert from a list of one type to a list of another. There is already such a method on the Stream<\/a> interface, but it serves as an example<\/p>\n

We used to have to either <\/p>\n

a) Subclass a concrete List implementation and add our method (which makes re-use hard), or
\nb) Re-implement the considerably large<\/a> List interface, delegating to a wrapped List. <\/p>\n

You can ask your IDE to generate these delegate methods for you, but with a large interface like List the boilerplate tends to obscure the added behaviour.<\/p>\n
\n

\r\nclass MappingList implements List {\r\n    private List impl;\r\n\r\n    public int size() {\r\n        return impl.size();\r\n    }\r\n        \r\n    public boolean isEmpty() {\r\n        return impl.isEmpty();\r\n    }\r\n    \r\n    \/\/ Many more boilerplate methods omitted for brevity\r\n    \r\n    \/\/ The method we actually wanted to add.\r\n    public  List map(Function f) {\r\n        return list.stream().map(f).collect(Collectors.toList());\r\n    }\r\n\r\n}\r\n<\/pre>\n
Guava gave us a third option <\/p>\n
c) Extend the the Guava ForwardingList<\/a> class. Unfortunately that meant you couldn’t extend any other class.<\/p>\n
Java 8 gives us a fourth option <\/p>\n
d) We can implement the forwarding behaviour in an interface, and then add our behaviour on top. <\/p>\n
The disadvantage is you need a public method which exposes the underlying implementation. The advantages are you can keep the added behaviour separate, and it’s easier to compose them.<\/p>\n
Our decorator can now be really short – something like<\/p>\n
\r\nclass MappableList implements List, ForwardingList, Mappable {\r\n    private List impl;\r\n\r\n    public MappableList(List impl) {\r\n        this.impl = impl;\r\n    }\r\n\r\n    @Override\r\n    public List impl() {\r\n        return impl;\r\n    }\r\n}\r\n<\/pre>\n
We can use it like this<\/p>\n
\r\n\/\/ prints 3, twice.\r\nnew MappableList(asList(\"foo\", \"bar\"))\r\n    .map(s -> s.length())\r\n    .forEach(System.out::println);\r\n\r\n<\/pre>\n
The new method we added is declared in its own Mappable<T> interface which is uncluttered.<\/p>\n
\r\ninterface Mappable extends ForwardingList {\r\n\tdefault  List map(Function f) {\r\n\t\treturn impl().stream().map(f).collect(Collectors.toList());\r\n\t}\r\n}\r\n<\/pre>\n
The delegation boilerplate we can keep in its own interface, out of the way. Since it’s an interface we are free to extend other classes\/interfaces in our decorator<\/p>\n
\r\ninterface ForwardingList extends List {\r\n    List impl();\r\n\r\n    default int size() {\r\n        return impl().size();\r\n    }\r\n        \r\n    default boolean isEmpty() {\r\n        return impl().isEmpty();\r\n    }\t\r\n    \r\n    \/\/ Other methods omitted for brevity\r\n\r\n}\r\n<\/pre>\n
If we wanted to mix in some more functionality to our MappableList decorator class we could just implement another interface. In the above example we added a new method, so this time let’s modify one of the existing methods on List. Let’s make a List that always thinks it’s empty.<\/p>\n
\r\ninterface AlwaysEmpty extends ForwardingList {\r\n    default boolean isEmpty() {\r\n        return true;\r\n    }\r\n}\r\nclass MappableList implements \r\n    List, \r\n    ForwardingList, \r\n    Mappable, \r\n    AlwaysEmpty { \/\/ Mix in the new interface\r\n    \/\/ ...\r\n}\r\n<\/pre>\n
Now our list always claims it’s empty<\/p>\n
\r\n\/\/ prints true\r\nSystem.out.println(new MappableList(asList(\"foo\", \"bar\")).isEmpty());\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Java 8’s default methods on interfaces means we can implement the decorator pattern much less verbosely. The decorator pattern allows us to add behaviour to an object without using inheritance. I often find myself using it to “extend” third party interfaces with useful additional behaviour. Let’s say we wanted to add a map method to…  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\n