作家
登录

Java 8 Lambda:模拟Mixin实现类多重继承

作者: 来源: 2012-08-18 11:20:12 阅读 我要评论

Java 8 开始出现,带来一个全新特性:使用 Lambda 表达式 (JSR-335) 进行函数式编程。今天我们要讨论的是 Lambda 的其中一部分:虚拟扩展方法,也叫做公共辩护(defender)方法。该特性可以让你在接口定义中提供方法的默认实现。例如你可以为已有的接口(如 List 和 Map)声明一个方法定义,这样其他开发者就无需重新实现这些方法,有点像抽象类,但实际却是接口。当然,Java 8 理论上还是兼容已有的库。

虚拟扩展方法为 Java 带来了多重继承的特性,尽管该团队声称与多重继承不同,虚拟扩展方法被限制用于行为继承。或许通过这个特性你可以看到了多重继承的影子。但你还是可以模拟实例状态的继承。我将在接下来的文章详细描述 Java 8 中通过 mixin 混入实现状态的继承。

什么是混入 mixin?

混入是一种组合的抽象类,主要用于多继承上下文中为一个类添加多个服务,多重继承将多个 mixin 组合成你的类。例如,如果你有一个类表示“马”,你可以实例化这个类来创建一个“马”的实例,然后通过继承像“车库”和“花园”来扩展它,使用 Scala 的写法就是:

  1. val myHouse = new House with Garage with Garden 

从 mixin 继承并不是一个特定的规范,这只是用来将各种功能添加到已有类的方法。在 OOP 中,有了 mixin,你就有通过它来提升类的可读性。

例如在 Python 的  socketserver 模块中就有使用 mixin 的方法,在这里,mixin 帮助 4 个基于不同 Socket 的 服务,包括支持多进程的 UDP 和 TCP 服务以及支持多线程的 UDP 和 TCP 服务。

  1. class ForkingUDPServer(ForkingMixIn, UDPServer): pass  
  2. class ForkingTCPServer(ForkingMixIn, TCPServer): pass  
  3. class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass  
  4. class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass 

什么是虚拟扩展方法?

Java 8 将引入虚拟扩展方法的概念,也叫 public defender method. 让我们姑且把这个概念简化为 VEM。

VEM 旨在为 Java 接口提供默认的方法定义,你可以用它在已有的接口中添加新的方法定义,例如 Java 里的集合 API。这样类似 Hibernate 这样的第三方库无需重复实现这些集合 API 的所有方法,因为已经提供了一些默认方法。

下面是如何在接口中定义方法的示例:

  1. public interface Collection<T> extends Iterable<T> {  
  2.     <R> Collection<R> filter(Predicate<T> p)  
  3.         default { return Collections.<T>filter(this, p); }  
  4.  

Java 8 对混入的模拟

现在我们来通过 VEM 实现一个混入效果,不过事先警告的是:请不要在工作中使用!

下面的实现不是线程安全的,而且还可能存在内存泄露问题,这取决于你在类中定义的 hashCode 和 equals 方法,这也是另外一个缺点,我将在后面讨论这个问题。

首先我们定义一个接口(模拟状态Bean)并提供方法的默认定义:

  1. public interface SwitchableMixin {  
  2.     boolean isActivated() default { return Switchables.isActivated(this); }  
  3.     void setActivated(boolean activated) default { Switchables.setActivated(this, activated); }  

然后我们定义一个工具类,包含一个 Map 实例来保存实例和状态的关联,状态通过工具类中的私有的嵌套类代表:

  1. public final class Switchables {  
  2.  
  3.     private static final Map<SwitchableMixin, SwitchableDeviceState> SWITCH_STATES = new HashMap<>();  
  4.  
  5.     public static boolean isActivated(SwitchableMixin device) {  
  6.         SwitchableDeviceState state = SWITCH_STATES.get(device);  
  7.         return state != null && state.activated;  
  8.     }  
  9.  
  10.     public static void setActivated(SwitchableMixin device, boolean activated) {  
  11.         SwitchableDeviceState state = SWITCH_STATES.get(device);  
  12.         if (state == null) {  
  13.             state = new SwitchableDeviceState();  
  14.             SWITCH_STATES.put(device, state);  
  15.         }  
  16.         state.activated = activated;  
  17.     }  
  18.  
  19.     private static class SwitchableDeviceState {  
  20.         private boolean activated;  
  21.     }  
  22.  

这里是一个使用用例,突出了状态的继承:

  1. private static class Device {}  
  2. private static class DeviceA extends Device implements SwitchableMixin {}  
  3. private static class DeviceB extends Device implements SwitchableMixin {} 
  1. DeviceA a = new DeviceA();  
  2. DeviceB b = new DeviceB();  
  3. a.setActivated(true);  
  4. assertThat(a.isActivated()).isTrue();  
  5. assertThat(b.isActivated()).isFalse(); 

“完全不同的东西”

上面的实现跑起来似乎挺正常的,但 Oracle 的 Java 语言架构师 Brian Goetz 向我提出一个疑问说当前实现是无法工作的(假设线程安全和内存泄露问题已解决)

  1. interface FakeBrokenMixin {  
  2.     static Map<FakeBrokenMixin, String> backingMap  
  3.         = Collections.synchronizedMap(new WeakHashMap<FakeBrokenMixin, String>());  
  4.  
  5.     String getName() default { return backingMap.get(this); }  
  6.     void setName(String name) default { backingMap.put(this, name); }  
  7. }  
  8.  
  9. interface X extends Runnable, FakeBrokenMixin {}  
  10.  
  11. X makeX() { return () -> { System.out.println("X"); }; }  
  12.  
  13.     X x1 = makeX();  
  14.     X x2 = makeX();  
  15.     x1.setName("x1");  
  16.     x2.setName("x2");  
  17.  
  18.     System.out.println(x1.getName());  
  19.     System.out.println(x2.getName()); 

你猜这段代码执行后会显示什么结果呢?

疑问的解决

第一眼看去,这个实现的代码没有问题。X 是一个只包含一个方法的接口,因为 getName 和 setName 已经有了默认的定义,但 Runable 接口的 run 方法没有定义,因此我们可通过 lambda 表达式来生成 X 的实例,然后提供 run 方法的实现,就像 makeX 那样。因此,你希望这个程序执行后显示的结果是:

  1. x1  
  2. x2 

如果你删掉 getName 方法的调用,那么执行结果变成:

  1. MyTest$1@30ae8764 
  2. MyTest$1@123acf34 

这两行显示出 makeX 方法的执行来自两个不同的实例,而这时当前 OpenJDK 8 生成的(这里我使用的是 OpenJDK 8 24.0-b07).

不管怎样,当前的 OpenJDK 8 并不能反映最终的 Java 8 的行为,为了解决这个问题,你需要使用特殊参数 -XDlambdaToMethod 来运行 javac 命令,在使用了这个参数后,运行结果变成:

  1. x2  
  2. x2 

如果不调用 getName 方法,则显示:

  1. MyTest$$Lambda$1@5506d4ea 
  2. MyTest$$Lambda$1@5506d4ea 

每个调用 makeX 方法似乎都是来自相同匿名内部类的一个单例实例,如果观察包含编译后的 java class 文件的目录,会发现并没有一个名为 MyTestClass$$Lambda$1.class 的文件。

因为在编译时,lambda 表达式并没有经过完整的翻译,事实上这个翻译过程是在编译和运行时完成的,javac 编译器将 lambda 表达式变成 JVM 新增的指令 invokedynamic (JSR292)。这个指令包含所有必须的关于在运行时执行 lambda 表达式的元信息。包括要调用的方法名、输入输出类型以及一个名为 bootstrap 的方法。bootstrap 方法用于定义接收此方法调用的实例,一旦 JVM 执行了 invokedynamic 指令,JVM 就会在特定的 bootstrap 上调用 lambda 元工厂方法 (lambda metafactory method)。 

再回到刚才那个疑问中,lambda 表达式转成了一个私有的静态方法,() -> { System.out.println("X"); } 被转到了 MyTest:

  1. private static void lambda$0() {  
  2.     System.out.println("X");  

如果你用 javap 反编译器并使用 -private 参数就可以看到这个方法,你也可以使用 -c 参数来查看更加完整的转换。

当你运行程序时,JVM 会调用 lambda metafactory method 来尝试阐释 invokedynamic 指令。在我们的例子中,首次调用 makeX 时,lambda metafactory method 生成一个 X 的实例并动态链接 run 方法到 lambda$0 方法. X 的实例接下来被存储在内存中,当第二次调用 makeX 时就直接从内存中读取这个实例,因此你第二次调用的实例跟第一次是一样的。

修复了吗?有解决办法吗?

目前尚无这个问题直接的修复或者是解决办法。尽管 Oracle 的 Java 8 计划默认激活 -XDlambdaToMethod 参数,因为这个参数并不是 JVM 规范的一部分,因此不同供应商和 JVM 的实现是不同的。对一个 lambda 表达式而言,你唯一能期望的就是在类中实现你的接口方法。

其他的方法

到此为止,尽管我们对 mixin 的模仿并不能兼容 Java 8,但还是可能通过多继承和委派为已有的类添加多个服务。这个方法就是 virtual field pattern (虚拟字段模式).

所以来看看我们的 Switchable.

  1. interface Switchable {    boolean isActive();  
  2.     void setActive(boolean active);  

我们需要一个基于 Switchable 的接口,并提供一个附加的抽象方法返回 Switchable 的实现。集成的方法包含默认的定义,它们使用 getter 来转换到 Switchable 实现的调用:

  1. public interface SwitchableView extends Switchable {  
  2.     Switchable getSwitchable();  
  3.     boolean isActive() default { return getSwitchable().isActive(); }  
  4.     void setActive(boolean active) default { getSwitchable().setActive(active); }  

接下来,我们创建一个完整的 Switchable 实现:

  1. public class SwitchableImpl implements Switchable {  
  2.     private boolean active;  
  3.     @Override 
  4.     public boolean isActive() {  
  5.         return active;  
  6.     }  
  7.     @Override 
  8.     public void setActive(boolean active) {  
  9.         this.active = active;  
  10.     }  

这里是我们使用虚拟字段模式的例子:

  1. public class Device {}  
  2. public class DeviceA extends Device implements SwitchableView {  
  3.     private Switchable switchable = new SwitchableImpl();  
  4.     @Override 
  5.     public Switchable getSwitchable() {  
  6.         return switchable;  
  7.     }  
  8. }  
  9. public class DeviceB extends Device implements SwitchableView {  
  10.     private Switchable switchable = new SwitchableImpl();  
  11.     @Override 
  12.     public Switchable getSwitchable() {  
  13.         return switchable;  
  14.     }  
  1. DeviceA a = new DeviceA();DeviceB b = new DeviceB();  
  2. a.setActive(true);  
  3. assertThat(a.isActive()).isTrue();  
  4. assertThat(b.isActive()).isFalse(); 

结论

在这篇文章中,我们使用了两种方法通过 Java 8 的虚拟扩展方法为类增加多个服务。第一个方法使用一个 Map 来存储实例状态,这个方法很危险,因为不是线程安全而且存在内存泄露问题,这完全依赖于不同的 JVM 对 Java 语言的实现。另外一个方法是使用虚拟字段模式,通过一个抽象的 getter 来返回最终的实现实例。第二种方法更加独立而且更加安全。

虚拟扩展方法是 Java 的新特性,本文主要介绍的是多重继承的实现,详细你会有更深入的研究以及应用于其他方面,别忘了跟大家分享。

原文链接:http://www.oschina.net/question/12_65077

【编辑推荐】

  1. Java 8的Lambda表达式
  2. Java 8各版本发布具体时间公布
  3. Java 8新功能详细解读
  4. Java和.NET开发过程中的一些不同
  5. 用Java实现的日志切割清理工具

  推荐阅读

  如何掌握程序语言

学习程序语言是每个程序员的必经之路。可是这个世界上有太多的程序语言,每一种都号称具有最新的“特性”。所以程序员的苦恼就在于总是需要学习各种稀奇古怪的语言,而且必须紧跟“潮流”,否则>>>详细阅读


本文标题:Java 8 Lambda:模拟Mixin实现类多重继承

地址:http://www.17bianji.com/kaifa2/Java/11814.html

关键词: 探索发现

乐购科技部分新闻及文章转载自互联网,供读者交流和学习,若有涉及作者版权等问题请及时与我们联系,以便更正、删除或按规定办理。感谢所有提供资讯的网站,欢迎各类媒体与乐购科技进行文章共享合作。

网友点评
自媒体专栏

评论

热度

精彩导读
栏目ID=71的表不存在(操作类型=0)