Added methods simpleCall(), simpleSet() and callWithClass

README.md

@@ -214,9 +214,36 @@ val str = OkReflect
 
 
 
-### 11. Simply set field or call method
+### 11. Call method with class info
 
 ```java
+// Java
+Class classes[] = {String.class, Byte.class};
+Object args[] = {"Tom", null};
+String name = OkReflect.on(TestClass.class)
+                .create()
+                .callWithClass("setData2", classes, args)
+                .get("name");
+```
+
+```kotlin
+// Kotlin
+val classes = arrayOf<Class<*>>(String::class.java, Byte::class.javaObjectType)
+val args = arrayOf<Any?>("Tom", null)
+val name = OkReflect.on(TestClass::class.java)
+            .create()
+            .callWithClass("setData2", classes, *args)
+            .get<String?>("name")
+```
+
+
+
+
+
+### 12. Simply set field or call method
+
+```java
+// Java
 TestClass testClass = new TestClass();
 String nameFromeMethod = OkReflect.on(testClass)
                 .simpleCall("getName");
@@ -225,9 +252,19 @@ String name = OkReflect.on(testClass)
                 .simpleSet("name", "Tom");
 ```
 
+```kotlin
+// Kotlin
+val testClass = TestClass()
+val nameFromMethod = OkReflect.on(testClass)
+            .simpleCall<String>("getName")
+
+val name = OkReflect.on(testClass)
+            .simpleSet<String>("name", "Tom")
+```
+
 
 
-### 12. Use dynamic proxy
+### 13. Use dynamic proxy
 
 ```Java
 // First step of using dynamic proxy: declare the interface
@@ -254,6 +291,8 @@ val substring = OkReflect.on("java.lang.String")
 
 ### 
 
+
+
 ## Configuration
 ### Gradle
 ```groovy

README_CN.md

@@ -4,6 +4,8 @@
 
 OkReflect 是一个封装了 Java 反射操作的工具。
 
+[OkReflect 介绍](https://www.jianshu.com/p/7ffc22eee6cc)
+
 ## 用法
 
 ### 1. 使用类名创建类
@@ -211,9 +213,38 @@ val str = OkReflect
             .get<String>()
 ```
 
-### 11. 只修改字段或调用方法
+
+
+### 11. 调用方法并传入实参类型信息
+
+```java
+// Java
+Class classes[] = {String.class, Byte.class};
+Object args[] = {"Tom", null};
+String name = OkReflect.on(TestClass.class)
+                .create()
+                .callWithClass("setData2", classes, args)
+                .get("name");
+```
+
+```kotlin
+// Kotlin
+val classes = arrayOf<Class<*>>(String::class.java, Byte::class.javaObjectType)
+val args = arrayOf<Any?>("Tom", null)
+val name = OkReflect.on(TestClass::class.java)
+            .create()
+            .callWithClass("setData2", classes, *args)
+            .get<String?>("name")
+```
+
+
+
+
+
+### 12. 纯设置字段或调用方法
 
 ```java
+// Java
 TestClass testClass = new TestClass();
 String nameFromeMethod = OkReflect.on(testClass)
                 .simpleCall("getName");
@@ -222,8 +253,21 @@ String name = OkReflect.on(testClass)
                 .simpleSet("name", "Tom");
 ```
 
+```kotlin
+// Kotlin
+val testClass = TestClass()
+val nameFromMethod = OkReflect.on(testClass)
+            .simpleCall<String>("getName")
+
+val name = OkReflect.on(testClass)
+            .simpleSet<String>("name", "Tom")
+```
+
+
+
+
 
-### 12. 动态代理
+### 13. 动态代理
 
 ```Java
 // First step of using dynamic proxy: declare the interface

src/main/kotlin/okreflect/MethodCall.kt

@@ -3,4 +3,4 @@ package okreflect
 class MethodCall(val methodName: String,
                  var classes: Array<Class<*>>?,
                  val callWithInstance: Boolean,
-                 val args: Array<out Any>)
+                 val args: Array<out Any?>)

src/main/kotlin/okreflect/OkReflect.kt

@@ -174,15 +174,15 @@ class OkReflect {
      * The method will be called when [get] method called.
      * The method will be call with the instance.
      */
-    fun call(methodName: String, classes: Array<Class<*>>?, vararg args: Any): OkReflect {
+    fun callWithClass(methodName: String, classes: Array<Class<*>>?, vararg args: Any?): OkReflect {
         return realCall(true,methodName, classes, *args)
     }
 
     /**
      * @See [call]
      */
     fun call(methodName: String, vararg args: Any): OkReflect {
-        return call(methodName, null, *args)
+        return callWithClass(methodName, null, *args)
     }
 
     /**
@@ -228,7 +228,7 @@ class OkReflect {
         callWithInstance: Boolean = true,
         methodName: String,
         classes: Array<Class<*>>?,
-        vararg args: Any
+        vararg args: Any?
     ): OkReflect {
         if (methodCallList == null) {
             methodCallList = ArrayList()

src/test/java/UseCaseTest.java

@@ -241,7 +241,7 @@ public void testCallMethodWithVoidParameter() {
         Object args[] = {"Tom", null};
         String name = OkReflect.on(TestClass.class)
                 .create()
-                .call("setData2", classes, args)
+                .callWithClass("setData2", classes, args)
                 .get("name");
         assert name.equals("Tom");
     }
@@ -254,8 +254,8 @@ public void testCallMethodsWithVoidParameter() {
         Object args2[] = {"Bingo", null};
         TestClass instance = OkReflect.on(TestClass.class)
                 .create()
-                .call("setData2", classes1, args1)
-                .call("setData3", classes2, args2)
+                .callWithClass("setData2", classes1, args1)
+                .callWithClass("setData3", classes2, args2)
                 .get();
 
         String name = OkReflect.on(instance)

src/test/kotlin/KotlinUseCaseTest.kt

@@ -6,7 +6,6 @@ import org.junit.rules.ExpectedException
 
 import java.lang.invoke.MethodHandle
 import java.lang.invoke.MethodHandles
-import java.lang.reflect.Field
 import java.lang.reflect.Method
 
 
@@ -15,8 +14,6 @@ import java.lang.reflect.Method
  */
 class KotlinUseCaseTest {
 
-    internal var expectedException = ExpectedException.none()
-
     @Test
     fun testCreateClassWithClassName() {
         val str = OkReflect.on("java.lang.String")
@@ -34,12 +31,13 @@ class KotlinUseCaseTest {
     }
 
     @Test
-    fun testGetFieldFromSuperClass() {
-        val testClass = TestClass("Alex")
+    fun testSetAndGetFieldFromSuperClass() {
+        val testClass = TestClass()
         val superName = OkReflect.on(SuperTestClass::class.java)
             .with(testClass)
+            .set("superName", "Tom")
             .get<String>("superName")
-        assert(superName == "Alex")
+        assert(superName == "Tom")
     }
 
     @Test
@@ -50,6 +48,8 @@ class KotlinUseCaseTest {
         Assert.assertTrue(name == "Tom")
     }
 
+    internal var expectedException = ExpectedException.none()
+
     @Test(expected = NullPointerException::class)
     fun testNotCallCreateException() {
         val str = OkReflect
@@ -90,13 +90,16 @@ class KotlinUseCaseTest {
         Assert.assertEquals(str, "Hello world")
     }
 
+    // 10. Handle the exception with callback
     @Test
     fun testNotCallCreateErrorCallback() {
         val str = OkReflect
             .on("java.lang.String")
-            .error {
-                assert(it.toString().contains("you have to call create()"))
-            }
+            .error(object : OkReflect.OkReflectErrorCallback {
+                override fun onError(e: Exception) {
+                    assert(e.toString().contains("you have to call create()"))
+                }
+            })
             .get<String>()
     }
 
@@ -172,6 +175,7 @@ class KotlinUseCaseTest {
         assert(clazz == TestClass::class.java)
     }
 
+    // 9. Get and set static field value of the class
     @Test
     fun testSetStaticField() {
         val finalField = OkReflect.on("TestClass")
@@ -227,6 +231,61 @@ class KotlinUseCaseTest {
         assert(name == "Tom")
     }
 
+    @Test
+    fun testCallMethodWithVoidParameter() {
+        val classes = arrayOf<Class<*>>(String::class.java, Byte::class.javaObjectType)
+        val args = arrayOf<Any?>("Tom", null)
+        val name = OkReflect.on(TestClass::class.java)
+            .create()
+            .callWithClass("setData2", classes, *args)
+            .get<String?>("name")
+        assert(name == "Tom")
+    }
+
+    @Test
+    fun testCallMethodsWithVoidParameter() {
+        val classes1 = arrayOf<Class<*>>(String::class.java, Byte::class.java)
+        val classes2 = arrayOf<Class<*>>(String::class.java, Char::class.java)
+        val args1 = arrayOf<Any?>("Tom", null)
+        val args2 = arrayOf<Any?>("Bingo", null)
+        val instance = OkReflect.on(TestClass::class.java)
+            .create()
+            .callWithClass("setData2", classes1, *args1)
+            .callWithClass("setData3", classes2, *args2)
+            .get<TestClass>()
+
+        val name = OkReflect.on(instance!!)
+            .get<String>("name")
+        val nickname = OkReflect.on(instance!!)
+            .get<String>("nickname")
+
+        assert(name == "Tom" && nickname == "Bingo")
+    }
+
+    @Test
+    fun testGetResult() {
+        val testClass = TestClass()
+        val name = OkReflect.on(testClass)
+            .call("getName")
+            .getResult<String>()
+        assert(name == "default")
+    }
+
+    @Test
+    fun testSimpleCall() {
+        val testClass = TestClass()
+        val name = OkReflect.on(testClass)
+            .simpleCall<String>("getName")
+        assert(name == "default")
+    }
+
+    @Test
+    fun testSimpleSet() {
+        val testClass = TestClass()
+        val name = OkReflect.on(testClass)
+            .simpleSet<String>("name", "Tom")
+        assert(name == "Tom")
+    }
 
     @Ignore
     @Test
@@ -237,5 +296,35 @@ class KotlinUseCaseTest {
         assert(finalField == "changed")
     }
 
+    @Ignore
+    @Test
+    fun testChangeParameterTypeByMethodHandle() {
+        val originTypes = arrayOf<Class<*>>(String::class.java, Char::class.java)
+        val newTypes = arrayOf<Class<*>>(String::class.java, Char::class.java)
+        try {
+            val method = TestClass::class.java.getDeclaredMethod("setData3", *originTypes)
+            method.isAccessible = true
+            val methodHandle = MethodHandles.lookup().unreflect(method)
+            val filter = getFilter(originTypes, newTypes)
+            MethodHandles.filterArguments(methodHandle, 2, filter)
+            println("")
+        } catch (e: NoSuchMethodException) {
+            e.printStackTrace()
+        } catch (e: IllegalAccessException) {
+            e.printStackTrace()
+        }
+
+    }
+
+    @Throws(IllegalAccessException::class, NoSuchMethodException::class)
+    private fun getFilter(originTypes: Array<Class<*>>, newTypes: Array<Class<*>>): MethodHandle {
+        var filterMethod: Method? = TestClass::class.java.getDeclaredMethod("setData3", *originTypes)
+        filterMethod = OkReflect.on(filterMethod!!)
+            .set("parameterTypes", newTypes)
+            .get<Method>()
+        filterMethod!!.isAccessible = true
+        return MethodHandles.lookup().unreflect(filterMethod)
+    }
+
 
 }