Kotlin: Несоответствие типов аргументов при передаче Array в качестве параметра vararg - PullRequest
Новая
       21

Kotlin: Несоответствие типов аргументов при передаче Array в качестве параметра vararg

0 голосов
/ 29 августа 2018

У меня простой интерфейс и его реализация: 

interface Iface {
    fun doSomething(s: String)
}

class IfaceImpl : Iface {
    override fun doSomething(s: String) {
        println("Doing the job, s = $s")
    }
}

Кроме того, есть два идентичных (по крайней мере, я не могу определить разницу) обработчика вызова, один в Java и один в Kotlin: 

public class JavaHandler implements InvocationHandler {
    private final Iface target;

    public JavaHandler(Iface target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Java handler works");
        return method.invoke(target, args);
    }
}

class KotlinHandler(private val target: Iface) : InvocationHandler {
    override fun invoke(proxy: Any?, method: Method?, args: Array<out Any>?): Any {
        println("Kotlin proxy works")
        return method!!.invoke(target, args)
    }
}

Они оба просто выводят некоторую строку и затем вызывают метод для цели.

Наконец, вот код, который я запускаю: 

fun main(args: Array<String>) {
    val target = IfaceImpl()
    target.doSomething("one")

    val javaProxy = newProxy(JavaHandler(target))
    javaProxy.doSomething("two")

    val kotlinProxy = newProxy(KotlinHandler(target))
    kotlinProxy.doSomething("three")
}

fun newProxy(handler: InvocationHandler): Iface {
    return Proxy.newProxyInstance(Iface::class.java.classLoader, arrayOf(Iface::class.java), handler) as Iface
}

Создает два java-прокси, используя оба обработчика вызовов, и пытается их использовать.

Обработчик Java работает нормально, а обработчик Kotlin - нет. Вывод следующий: 

Doing the job, s = one
Java handler works
Doing the job, s = two
Kotlin proxy works
Exception in thread "main" java.lang.IllegalArgumentException: argument type mismatch
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at KotlinHandler.invoke(KotlinHandler.kt:12)
    at com.sun.proxy.$Proxy0.doSomething(Unknown Source)
    at TestKt.main(Test.kt:17)

Я вижу с помощью отладчика, что в обоих случаях args состоит из 1 элемента, и это java.lang.Integer экземпляр.

Интересно то, что если метод имеет 0 параметров, сообщение об ошибке будет другим: 

Exception in thread "main" java.lang.IllegalArgumentException: wrong number of arguments
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

В таком случае null передается как параметр args (что разрешено в javadocs для вызовов без параметров).

Я что-то не так делаю? Или это ошибка?

Мой build.gradle имеет следующее: 

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.2.61'
}

1 Ответ

0 голосов
/ 29 августа 2018

ОБНОВЛЕНИЕ: В новых версиях Kotlin вы можете использовать args.orEmpty() вместо args ?: emptyArray()

TL; DR

Вы не можете передать args, но вам нужно использовать *(args ?: emptyArray()), потому что Method.invoke не ожидает массив, а параметр с переменным числом.

См. этот ответ для получения дополнительной информации

То, как я нашел актуальную проблему

Я посмотрел на сгенерированный байт-код, для Kotlin я получил следующее: 

override fun invoke(proxy : Any?, method : Method, args : Array<Any>?) : Any?
{
    println("Kotlin proxy works")
    return method.invoke(target, args)
}

public java.lang.Object invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]);
Code:
   0: aload_2
   1: ldc           #12                 // String method
   3: invokestatic  #18                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
   6: ldc           #20                 // String Kotlin proxy works
   8: astore        4
  10: getstatic     #26                 // Field java/lang/System.out:Ljava/io/PrintStream;
  13: aload         4
  15: invokevirtual #32                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
  18: aload_2
  19: aload_0
  20: getfield      #36                 // Field target:LIface;
  23: iconst_1
  24: anewarray     #4                  // class java/lang/Object
  27: dup
  28: iconst_0
  29: aload_3
  30: aastore
  31: invokevirtual #41                 // Method java/lang/reflect/Method.invoke:(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;
  34: areturn

Теперь, как вы можете видеть, Kotlin манипулирует параметром args - фактически он создает новый массив. Java этого не делает (также пропускает нулевые проверки): 

public Object invoke(Object proxy, Method method, Object args[]) throws Throwable
{
    System.out.println("Java handler works");
    return method.invoke(target, args);
}

public java.lang.Object invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) throws java.lang.Throwable;
Code:
   0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
   3: ldc           #4                  // String Java handler works
   5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8: aload_2
   9: aload_0
  10: getfield      #2                  // Field target:LIface;
  13: aload_3
  14: invokevirtual #6                  // Method java/lang/reflect/Method.invoke:(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;
  17: areturn

Теперь давайте перехватим массив actall. Я создал метод в коде Java, чтобы выступать в качестве посредника: 

public static Object invoke0(Iface target, Method method, Object args[]) throws Throwable
{
    System.out.println("Invoking method with " + java.util.Arrays.toString(args));
    return method.invoke(target, args);
}

Выполните это как с Java, так и с Kotlin - , и это будет работать .

Теперь, в чем разница? Да, мы ожидаем Object[], но Method.invoke занимает Object....

Измените нашего посредника на Object..., и мы получим сообщение об ошибке вместе с выводом: 

Invoking method with [[Ljava.lang.Object;@4b67cf4d]

Очевидно, мы не передаем Object[], а Object[][], что означает несоответствие типов!

...