Java通用Singleton工厂模式

Question

我有一段时间在理解下面的导体。以下是一个编译但抛出异常的代码片段

Exception in thread "main" java.lang.ClassCastException: 
TestGenericSingleton$$Lambda$1/303563356 cannot be cast to 
TestGenericSingleton$IntegerConsumer
at TestGenericSingleton.main(TestGenericSingleton.java:23)

import java.util.function.Consumer;
public class TestGenericSingleton 
{
static final Consumer<Object> NOOP_SINGLETON = t -> {System.out.println("NOOP Consumer accepting " + t);};

@SuppressWarnings("unchecked")
static <R extends Consumer<T>, T> R noopConsumer() 
{
return (R)NOOP_SINGLETON;
}

static interface IntegerConsumer extends Consumer<Integer> {};

public static void main(String[] argv) 
{
Consumer<Boolean> cb = noopConsumer();
cb.accept(true);

IntegerConsumer ic = t -> {System.out.println("NOOP Consumer2 accepting " + t);} ;
ic.accept(3);

ic = noopConsumer();
ic.accept(3);
System.out.println("Done");
}
}

让我困惑的是，Java编译器可以从第20行的lambda中生成一个合适的IntegerConsumer兼容对象，但之前构造的非通用lambda不能使用，因为它在第8行构造为singleton。这是因为第20行上的lambda有一个可具体化的Consumer子类型，它立即适合IntegerConsumer引用的类型，而第10行上强制转换的lambda在运行时不能强制转换为Consumer的真实子类型吗？但是，第8行的泛型有界类型声明难道不应该考虑到这一点吗？非常感谢您的帮助！

Answer 1

不能使用

我们将删除lambda并了解异常的根本原因。让我们考虑下面这个更简单的例子。

public class TestGenericObject {
static final Object NOOP_SINGLETON = new Object();
static <R extends Object> R noopConsumer() {
return (R) NOOP_SINGLETON;
}
public static void main(String[] argv) {
Object cb = noopConsumer();
Integer ic = noopConsumer(); // Throws java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.Integer
}
}

例外情况是合理的。NOOP_SINGLETON的实际类型是Object，但我们正试图将其强制转换为Integer。这与尝试Integer ic = (Integer) new Object()相同。在您的情况下，由于同样的原因，您不能将Consumer<Object>类型强制转换为IntegerConsumer。

---

一个有趣的观察结果是，异常没有在noopConsumer()中抛出，而是在main()中抛出
以下是方法noopConsumer的javap -v -c的输出

... // Removed lines for clarity
static <R extends java.lang.Object> R noopConsumer();
...
Code:
stack=1, locals=0, args_size=0
0: getstatic     #2                  // Field NOOP_SINGLETON:Ljava/lang/Object;
3: areturn

您可以看到不存在用于强制转换的操作代码。但对于main()

public static void main(java.lang.String[]);
Code:
stack=1, locals=3, args_size=1
0: invokestatic  #3                  // Method noopConsumer:()Ljava/lang/Object;
3: astore_1
4: invokestatic  #3                  // Method noopConsumer:()Ljava/lang/Object;
7: checkcast     #4                  // class java/lang/Integer
10: astore_2
11: return

在7:checkcast #4行，它检查返回的类型是否为Integer。这种行为有两个原因

1. 在noopConsumer()中，R的下界是Object，NOOP_SINGLETON也是Object类型。因此，在类型擦除后，铸件是多余的并被移除
2. main()进行强制转换检查的原因再次是由于类型擦除。如链接中所述，如果需要，将在类型擦除期间插入类型铸造

---

返回Lambdas。Lambdas使用invokedynamic操作码在运行时生成代码。这和这是很好的资源，可以更好地了解运行时的lambda处理。对于以下代码，

public static void main(String[] argv) {
Consumer<Object> NOOP_SINGLETON = t -> {System.out.println("NOOP Consumer accepting " + t);};
TestGenericSingleton.IntegerConsumer ic = t -> {System.out.println("NOOP Consumer2 accepting " + t);} ;
}

让我们分析字节码。

public static void main(java.lang.String[]);
...
Code:
stack=1, locals=3, args_size=1
0: invokedynamic #2,  0              // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
5: astore_1
6: invokedynamic #3,  0              // InvokeDynamic #1:accept:()Lcom/TestGenericSingleton$IntegerConsumer;
11: astore_2
12: return

invokedynamic将两种不同的预期类型Ljava/util/function/Consumer和()Lcom/TestGenericSingleton$IntegerConsumer传递给LambdaMetafactory.metafactory((。
因此，尽管Lambda中的代码t -> {System.out.println("NOOP Consumer accepting " + t);}相同，但它们是两种不同类型。

---

为了总结，lambda是在运行时构建的，返回的实例将具有声明中指定的类型。因此，NOOP_SINGLETON是Consumer类型，ic是IntegerConsumer类型。从类型Consumer到IntegerConsumer的转换将失败，原因与Integer ic = (Integer)new Object()相同。