Static Call Cache

Author: nnjun

app/src/main/java/top/niunaijun/app/MainActivity.java

@@ -1,14 +1,17 @@
 package top.niunaijun.app;
 
-import androidx.appcompat.app.AppCompatActivity;
-
 import android.os.Bundle;
 import android.util.Log;
 
+import androidx.appcompat.app.AppCompatActivity;
+
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 
 import top.niunaijun.app.bean.TestReflection;
+import top.niunaijun.app.ref.BRActivityThread;
 import top.niunaijun.app.ref.BRTestReflection;
+import top.niunaijun.blackreflection.BlackReflection;
 import top.niunaijun.blackreflection.R;
 
 
@@ -19,6 +22,7 @@ public class MainActivity extends AppCompatActivity {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
+        BlackReflection.CACHE = true;
 
         TestReflection testReflection = testBConstructor();
         Class<?> classReady = BRTestReflection.getRealClass();
@@ -67,8 +71,40 @@ protected void onCreate(Bundle savedInstanceState) {
 
         // use @BParamClassName
         BRTestReflection.get().testParamClassName("i am java.lang.String", 0);
+
+        findViewById(R.id.btn_start).setOnClickListener(v -> {
+            try {
+                int count = 10000;
+                long l = System.currentTimeMillis();
+                for (int i = 0; i < count; i++) {
+                    testSystemReflection();
+                }
+                Log.d(TAG, "SystemReflection: " + (System.currentTimeMillis() - l) + "ms");
+
+                l = System.currentTimeMillis();
+                for (int i = 0; i < count; i++) {
+                    testBlackReflection();
+                }
+                Log.d(TAG, "BlackReflection: " + (System.currentTimeMillis() - l) + "ms");
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
     }
 
+    private void testSystemReflection() throws Exception {
+        Class<?> clazz = Class.forName("android.app.ActivityThread");
+        Method currentActivityThread = clazz.getDeclaredMethod("currentActivityThread");
+        currentActivityThread.setAccessible(true);
+        Object invoke = currentActivityThread.invoke(null);
+//        Log.d(TAG, "testSystemReflection: " + invoke);
+    }
+
+    private void testBlackReflection() throws Exception {
+        Object o = BRActivityThread.get().currentActivityThread();
+    }
+
+
     private TestReflection testBConstructor() {
         // test BConstructor
         TestReflection testReflection = BRTestReflection.get()._new("a");

app/src/main/java/top/niunaijun/app/ref/ActivityThread.java

@@ -0,0 +1,18 @@
+package top.niunaijun.app.ref;
+
+import top.niunaijun.blackreflection.annotation.BClassName;
+import top.niunaijun.blackreflection.annotation.BStaticMethod;
+
+/**
+ * Created by Milk on 2022/5/28.
+ * * ∧＿∧
+ * (`･ω･∥
+ * 丶　つ０
+ * しーＪ
+ * 此处无Bug
+ */
+@BClassName("android.app.ActivityThread")
+public interface ActivityThread {
+    @BStaticMethod
+    Object currentActivityThread();
+}

core/src/main/java/top/niunaijun/blackreflection/BlackReflection.java

@@ -10,6 +10,8 @@
 import java.util.WeakHashMap;
 
 import top.niunaijun.blackreflection.annotation.BClass;
+import top.niunaijun.blackreflection.annotation.BClassName;
+import top.niunaijun.blackreflection.annotation.BClassNameNotProcess;
 import top.niunaijun.blackreflection.annotation.BConstructor;
 import top.niunaijun.blackreflection.annotation.BConstructorNotProcess;
 import top.niunaijun.blackreflection.annotation.BField;
@@ -18,8 +20,6 @@
 import top.niunaijun.blackreflection.annotation.BFieldSetNotProcess;
 import top.niunaijun.blackreflection.annotation.BMethodCheckNotProcess;
 import top.niunaijun.blackreflection.annotation.BParamClass;
-import top.niunaijun.blackreflection.annotation.BClassName;
-import top.niunaijun.blackreflection.annotation.BClassNameNotProcess;
 import top.niunaijun.blackreflection.annotation.BParamClassName;
 import top.niunaijun.blackreflection.utils.Reflector;
 
@@ -36,6 +36,7 @@ public class BlackReflection {
     public static boolean DEBUG = false;
     public static boolean CACHE = false;
     private static final Map<Class<?>, Object> sProxyCache = new HashMap<>();
+    private static final Map<Class<?>, Object> sProxyWithExceptionCache = new HashMap<>();
 
     // key caller
     private static final WeakHashMap<Object, Map<Class<?>, Object>> sCallerProxyCache = new WeakHashMap<>();
@@ -163,16 +164,11 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
                 }
             });
 
-            if (CACHE) {
-                if (caller == null) {
-                    sProxyCache.put(clazz, o);
+            if (caller == null) {
+                if (withException) {
+                    sProxyWithExceptionCache.put(clazz, o);
                 } else {
-                    Map<Class<?>, Object> callerClassMap = sCallerProxyCache.get(caller);
-                    if (callerClassMap == null) {
-                        callerClassMap = new HashMap<>();
-                        sCallerProxyCache.put(caller, callerClassMap);
-                    }
-                    callerClassMap.put(clazz, o);
+                    sProxyCache.put(clazz, o);
                 }
             }
             return (T) o;
@@ -183,25 +179,16 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
     }
 
     private static <T> T getProxy(Class<T> clazz, final Object caller, boolean withException) {
-        if (!CACHE) {
-            return null;
-        }
         try {
-            if (!withException) {
-                if (caller == null) {
-                    Object o = sProxyCache.get(clazz);
-                    if (o != null) {
-                        return (T) o;
-                    }
+            if (caller == null) {
+                Object o;
+                if (withException) {
+                    o = sProxyWithExceptionCache.get(clazz);
+                } else {
+                    o = sProxyCache.get(clazz);
                 }
-                else {
-                    Map<Class<?>, Object> callerClassMap = sCallerProxyCache.get(caller);
-                    if (callerClassMap != null) {
-                        Object o = callerClassMap.get(clazz);
-                        if (o != null) {
-                            return (T) o;
-                        }
-                    }
+                if (o != null) {
+                    return (T) o;
                 }
             }
         } catch (Throwable ignore) {