Java 8 開始出現,帶來一個全新特性:使用 Lambda 表達式 (JSR-335) 進行函數式編程。今天我們要討論的是 Lambda 的其中一部分:虛擬擴展方法,也叫做公共辯護(defender)方法。該特性可以讓你在接口定義中提供方法的默認實現。例如你可以為已有的接口(如 List 和 Map)聲明一個方法定義,這樣其他開發者就無需重新實現這些方法,有點像抽象類,但實際卻是接口。當然,Java 8 理論上還是兼容已有的庫。
虛擬擴展方法為 Java 帶來了多重繼承的特性,盡管該團隊聲稱與多重繼承不同,虛擬擴展方法被限制用於行為繼承。或許通過這個特性你可以看到了多重繼承的影子。但你還是可以模擬實例狀態的繼承。我將在接下來的文章詳細描述 Java 8 中通過 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
4
class
ThreadingUDPServer(ThreadingMixIn, UDPServer):
pass
5
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
3
<R> Collection<R> filter(Predicate<T> p)
4
default
{
return
Collections.<T>filter(
this
, p); }
5
6
}
現在我們來通過 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); }
4
}
然後我們定義一個工具類,包含一個 Map 實例來保存實例和狀態的關聯,狀態通過工具類中的私有的嵌套類代表:
01
public
final
class
Switchables {
02
03
private
static
final
Map<SwitchableMixin, SwitchableDeviceState> SWITCH_STATES =
new
HashMap<>();
04
05
public
static
boolean
isActivated(SwitchableMixin device) {
06
SwitchableDeviceState state = SWITCH_STATES.get(device);
07
return
state !=
null
&& state.activated;
08
}
09
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
23
}
這裡是一個使用用例,突出了狀態的繼承:
1
private
static
class
Device {}
2
3
private
static
class
DeviceA
extends
Device
implements
SwitchableMixin {}
4
5
private
static
class
DeviceB
extends
Device
implements
SwitchableMixin {}
1
DeviceA a = new DeviceA();
2
DeviceB b = new DeviceB();
3
4
a.setActivated(true);
5
6
assertThat(a.isActivated()).isTrue();
7
assertThat(b.isActivated()).isFalse();
上面的實現跑起來似乎挺正常的,但 Oracle 的 Java 語言架構師 Brian Goetz 向我提出一個疑問說當前實現是無法工作的(假設線程安全和內存洩露問題已解決)
01
interface
FakeBrokenMixin {
02
static
Map<FakeBrokenMixin, String> backingMap
03
= Collections.synchronizedMap(
new
WeakHashMap<FakeBrokenMixin, String>());
04
05
String getName()
default
{
return
backingMap.get(
this
); }
06
void
setName(String name)
default
{ backingMap.put(
this
, name); }
07
}
08
09
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"
);
3
}
如果你用 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);
3
}
我們需要一個基於 Switchable 的接口,並提供一個附加的抽象方法返回 Switchable 的實現。集成的方法包含默認的定義,它們使用 getter 來轉換到 Switchable 實現的調用:
1
public
interface
SwitchableView
extends
Switchable {
2
Switchable getSwitchable();
3
4
5
boolean
isActive()
default
{
return
getSwitchable().isActive(); }
6
void
setActive(
boolean
active)
default
{ getSwitchable().setActive(active); }
7
}
接下來,我們創建一個完整的 Switchable 實現:
01
public
class
SwitchableImpl
implements
Switchable {
02
03
04
private
boolean
active;
05
06
07
@Override
08
public
boolean
isActive() {
09
return
active;
10
}
11
12
13
@Override
14
public
void
setActive(
boolean
active) {
15
this
.active = active;
16
}
17
}
這裡是我們使用虛擬字段模式的例子:
01
public
class
Device {}
02
03
04
public
class
DeviceA
extends
Device
implements
SwitchableView {
05
private
Switchable switchable =
new
SwitchableImpl();
06
07
08
@Override
09
public
Switchable getSwitchable() {
10
return
switchable;
11
}
12
}
13
14
15
public
class
DeviceB
extends
Device
implements
SwitchableView {
16
private
Switchable switchable =
new
SwitchableImpl();
17
18
19
@Override
20
public
Switchable getSwitchable() {
21
return
switchable;
22
}
23
}
1
DeviceA a =
new
DeviceA();DeviceB b =
new
DeviceB();
2
3
a.setActive(
true
);
4
5
assertThat(a.isActive()).isTrue();
6
assertThat(b.isActive()).isFalse();
在這篇文章中,我們使用了兩種方法通過 Java 8 的虛擬擴展方法為類增加多個服務。第一個方法使用一個 Map 來存儲實例狀態,這個方法很危險,因為不是線程安全而且存在內存洩露問題,這完全依賴於不同的 JVM 對 Java 語言的實現。另外一個方法是使用虛擬字段模式,通過一個抽象的 getter 來返回最終的實現實例。第二種方法更加獨立而且更加安全。
虛擬擴展方法是 Java 的新特性,本文主要介紹的是多重繼承的實現,詳細你會有更深入的研究以及應用於其他方面,別忘了跟大家分享。
英文原文, OSCHINA原創翻譯