在# 动态署理设计形式完成Retrofit结构这篇文章当中，主要是介绍了动态署理的运用，那么动态署理运用的场景还有哪些呢？

（1）运用动态署理，可以完成在办法履行前后参加额外的逻辑处理；例如Hook Activity的启动流程，常用在插件化的结构中，概况可见Android进阶宝典 — 插件化2（Hook启动插件中四大组件）

（2）运用动态署理，可以完成解耦，使得调用层与完成层分离，例如Retrofit结构；

（3）动态署理不需求接口的完成类，常用于IPC进程间通讯；

（4）动态署理可以解决程序的履行流程，例如反射调用某个办法，需求传入一个接口完成类，就会运用到动态署理；也是本篇文章侧重介绍的。

1 动态署理深入

首要简单看下一个动态署理的比如

private fun testProxy() {
    val proxy = Proxy.newProxyInstance(
        classLoader,
        arrayOf(IProxyInterface::class.java)
    ) { obj, method, args ->
        Log.e("TAG", "办法调用前------")
        return@newProxyInstance handleMethod()
    } as IProxyInterface
    /**调用办法*/
    val result = proxy.getName()
    Log.e("TAG", "result==>$result")
}
private fun handleMethod(): Any? {
    Log.e("TAG", "开端履行办法--")
    return "小明~"
}

当经过Proxy的newProxyInstance办法创立一个IProxyInterface的署理目标的时分，其实这个接口并没有任何完成类

interface IProxyInterface {
    fun getName(): String
}

只要一个getName办法，那么当这个署理目标调用getName()办法的时分，就会先走到InvocationHandler的办法体内部，handleMethod办法咱们可以认为是接口办法的完成，所以在办法完成之前，可以做一些前置的操作。

2022-11-26 20:25:07.960 403-403/com.lay.mvi E/TAG: 办法调用前------
2022-11-26 20:25:07.960 403-403/com.lay.mvi E/TAG: 开端履行办法--
2022-11-26 20:25:07.960 403-403/com.lay.mvi E/TAG: result==>小明~

1.1 $Proxy0

所以，当咱们创立一个接口之后，并不需求实例化该接口，而是选用动态署理的办法生成一个署理目标，然后完成调用层与完成层的分离，这样也是解耦的一种办法。

那么生成的IProxyInterface署理目标是接口吗？必定不是，由于接口不可实例化，那么生成的目标是什么呢？

经过断点，咱们发现这个目标是$Proxy0，那么这个目标是怎样生成的呢？

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);
    final Class<?>[] intfs = interfaces.clone();
    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);
    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            // BEGIN Android-removed: Excluded AccessController.doPrivileged call.
            /*
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
            */
            cons.setAccessible(true);
            // END Android-removed: Excluded AccessController.doPrivileged call.
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

其实咱们也可以看到，经过getProxyClass0办法意图便是查找或许生成一个署理的Class目标，并经过反射创立一个实体类，其实便是$Proxy0

那么调用getName办法，其实便是调用$Proxy0的getName办法，最终内部便是调用了InvocationHandler的invoke办法。

2 动态署理完成Xutils

如果没有运用过ViewBinding的同伴，可能在项目中大多都是用ButterKnife这些注入结构，那么关于这类依靠注入东西，咱们该怎么亲自完成呢？这就运用到了注解配合动态署理，这里咱们先忘掉ViewBinding。

2.1 Android特点注入

在日常的开发过程中，咱们经常需求经过findViewById获取组件，并设置点击事情；或许为页面设置一个layout布局，每个页面简直都需求设置一番，那么经过事情注入，就可以大大简化咱们的流程。

/**运行时注解，放在类上运用*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface setContentView {
    /**布局id*/
    int value();
}

那么咱们以布局注入为例，介绍一下事情是怎么被注入进去的。

@RequiresApi(api = Build.VERSION_CODES.N)
public class InjectUtils2 {
    public static void inject(Context context) {
        injectContentView(context);
    }
    private static void injectContentView(Context context) {
        /**获取布局id*/
        Class<?> aClass = context.getClass();
        try {
            setContentView setContentView = aClass.getDeclaredAnnotation(setContentView.class);
            if (setContentView == null) {
                return;
            }
            int layoutId = setContentView.value();
            /**反射获取Activity的setContentView办法*/
            Method setContentViewMethod = aClass.getMethod("setContentView", int.class);
            setContentViewMethod.setAccessible(true);
            setContentViewMethod.invoke(context, layoutId);
        } catch (Exception e) {
        }
    }
}

这里咱们选用反射的办法，判别类上方是否存在setContentView注解，如果存在，那么就反射调用Activity的setContentView办法。

这里为什么运用Java，是由于在反射的时分，如果反射的源码为Java代码，最好运用Java，不然与Kotlin的类型不匹配会导致反射失败。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface viewId {
    int value();
}

关于控件的注入，类似于ViewBinding

private static void injectView(Context context) {
    Class<?> aClass = context.getClass();
    try {
        Field[] declaredFields = aClass.getDeclaredFields();
        if (declaredFields.length == 0) {
            return;
        }
        for (Field field : declaredFields) {
            /**判别当前特点是否包含viewId注解*/
            viewId viewId = field.getDeclaredAnnotation(viewId.class);
            if (viewId != null) {
                /**获取id值*/
                int id = viewId.value();
                /**履行findViewById操作*/
                Method findViewById = aClass.getMethod("findViewById", int.class);
                findViewById.setAccessible(true);
                field.setAccessible(true);
                field.set(context, findViewById.invoke(context, id));
            }
        }
    } catch (Exception e) {
        Log.e("TAG","exp===>"+e.getMessage());
    }
}

详细的运用如下

@setContentView(R.layout.activity_splash)
class SplashActivity : BaseActivity() {
    @viewId(R.id.tv_music)
    private var tv_music: TextView? = null
    override fun initView() {
        JUCTest.test()
        Singleton.getInstance().increment()
        testProxy()
        tv_music?.setOnClickListener {
            Toast.makeText(this, "点击了", Toast.LENGTH_SHORT).show()
        }
    }

2.2 动态署理完成事情注入

前面咱们介绍了布局的注入以及特点的注入，其实这两个事情仍是很简单的，经过反射赋值即可。可是如果是一个点击事情，就不是单纯的赋值了，就需求运用到动态署理了。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnClick {
    int[] value();
}

关于Android的事情来说有许多种，像点击事情、长按事情、滑动事情等等，如果仅仅像上面的注解一样，只要一个id，显然是不行的。

拿点击事情来说，需求三要素：setOnClickListener、OnClickListener目标、回调onClick

tv_music?.setOnClickListener {
    Toast.makeText(this, "点击了", Toast.LENGTH_SHORT).show()
}

那么这些可以放在注解中，在调用的时分传入，可是关于用户来说，必定只需求传入id就可以了，而不需求在外层传一堆杂乱无章的东西

@OnClick(value = [R.id.tv_music],function="setOnClickListener",......)
private fun clickButton() {
}

那么这些操作就需求在注解内部处理。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface EventBase {
    /**设置监听的类型，例如setOnClickListener、setOnTouchListener......*/
    String listenerSetter();
    /**匿名内部类类型，例如OnClickListener.class*/
    Class<?> listenerType();
    /**回调办法*/
    String callbackMethod();
}

这里首要界说了一个注解的基类，里面界说了事情的三要素，意图便是给上层注解供给完成类似于承继的办法。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@EventBase(listenerSetter = "setOnClickListener", listenerType = View.OnClickListener.class, callbackMethod = "onClick")
public @interface OnClick {
    int[] value();
}

接下来就可以经过反射获取办法上的注解

private static void injectClick(Context context) {
    Class<?> aClass = context.getClass();
    try {
        Method[] methods = aClass.getDeclaredMethods();
        if (methods.length == 0) {
            return;
        }
        /**处理单击事情*/
        for (Method method : methods) {
            Annotation[] annotations = method.getDeclaredAnnotations();
            if (annotations.length > 0) {
                for (Annotation annotation : annotations) {
                    EventBase eventBase = annotation.annotationType().getAnnotation(EventBase.class);
                    if (eventBase == null) {
                        continue;
                    }
                    /**拿到事情三要素*/
                    String listenerSetter = eventBase.listenerSetter();
                    Class<?> listenerType = eventBase.listenerType();
                    String callbackMethod = eventBase.callbackMethod();
                    /**拿到注解中传入的id*/
                    Method values = annotation.getClass().getDeclaredMethod("values");
                    values.setAccessible(true);
                    int[] componentIds = (int[]) values.invoke(annotation);
                    for (int id : componentIds) {
                        /**反射获取到这个id对应的组件*/
                        Method findViewById = aClass.getMethod("findViewById", int.class);
                        findViewById.setAccessible(true);
                        View view = (View) findViewById.invoke(context, id);
                        /**反射获取事情办法，留意这里类型是动态的*/
                        Method setListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);
                        /**履行这个事情*/
                        setListenerMethod.setAccessible(true);
                        setListenerMethod.invoke(view, buildProxyInstance(listenerType, context, method));
                    }
                }
            }
        }
    } catch (Exception e) {
        Log.e("TAG", "injectClick exp===>" + e.getMessage());
    }
}
/**
 * 依据listener类型创立动态署理目标
 * 
 */
private static Object buildProxyInstance(Class<?> listenerType, Context context, Method callbackMethod) {
    return Proxy.newProxyInstance(listenerType.getClassLoader(), new Class<?>[]{listenerType}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Log.e("TAG", "调用前处理--");
            callbackMethod.setAccessible(true);
            return callbackMethod.invoke(context);
        }
    });
}

这里经过反射获取时，完全是依据listenerSetter特点动态查找，而不是写死一个办法，这种办法运用起来具备扩展性。

public interface OnClickListener {
    /**
     * Called when a view has been clicked.
     *
     * @param v The view that was clicked.
     */
    void onClick(View v);
}

由于这里选用的是动态署理的办法，动态创立一个OnClickListener目标，并作为setOnclickListener办法的参数传入进去，所以当onClick履行的时分，会走到InvocationHandler的invoke办法中，在这里履行了应用层的办法。

@OnClick(values = [R.id.tv_music])
private fun clickButton() {
    Toast.makeText(this, "点击了", Toast.LENGTH_SHORT).show()
}

2.3 组件化依靠注入

如果在项目中运用到组件化的同伴可能有遇到这样的问题，两个模块需求通讯，一般选用的是模块依靠直接通讯

这种办法其实是不可行的，由于不管是模块化仍是组件化，这种办法会使得两个模块间耦合十分严重，两个模块应该相对独立，并向下承继，所以在下层需求有一个module专门负责依靠注入。

由于一切的事务模块会向下依靠，因此在:base:ioc库中会创立与事务相关的署理接口。

# :base:ioc module
interface ILoginDelegate {
    fun openLoginActivity(context: Context, src: (Intent.() -> Unit)? = null)
}

已然有接口出现，那么就会有对应的完成类，该完成类是在登录模块中完成的。

# login module
class LoginDelegateImpl : ILoginDelegate{
    override fun openLoginActivity(context: Context, src: (Intent.() -> Unit)?) {
        val intent = Intent()
        if (src != null){
            intent.src()
        }
        intent.setClass(context,LoginActivity::class.java)
        context.startActivity(intent)
    }
}

所以登录模块需求向ioc模块注入这个完成类，其中比较简单的办法便是经过接口名与完成类名存储在一个Map中，当恣意一个模块想要调用时，只需求拿到接口名就可以得到注入的完成类。

object InjectUtils {
    /**接口名与完成类名一一对应的map*/
    private val routerMap: MutableMap<String, String> by lazy {
        mutableMapOf()
    }
    /**接口名与完成类的一一对应*/
    private val implMap: MutableMap<String, WeakReference<*>> by lazy {
        mutableMapOf()
    }
    /**注册*/
    fun inject(interfaceName: String, implName: String) {
        if (routerMap.containsKey(interfaceName) || routerMap.containsValue(interfaceName)) {
            return
        }
        routerMap[interfaceName] = implName
    }
    /**获取完成类*/
    fun <T> getApiService(clazz: Class<T>): T? {
        try {
            val weakInstance = implMap[clazz.name]
            if (weakInstance != null) {
                val instance = weakInstance.get()
                if (instance != null) {
                    return instance as T
                }
            }
            /**如果实例为空，需求新建一个完成类*/
            val implName = routerMap[clazz.name]
            val instance = Class.forName(implName).newInstance()
            implMap[clazz.name] = WeakReference(instance)
            return instance as T
        } catch (e: Exception) {
            Log.i("InjectUtils", "error==>${e.message}")
            return null
        }
    }
}

例如在news模块想要跳转到登录，首要需求全局注入

InjectUtils.inject(ILoginDelegate::class.java.name, LoginDelegateImpl::class.java.name)

然后在任何一个模块中都可以拿到这个实例。

InjectUtils.getApiService(ILoginDelegate::class.java)?.openLoginActivity(this)

其实想要完成这种注入办法有许多，像经过注解润饰这个完成类，配合注解处理器全局扫描就可以少一部自己手动存储的这一步，便是APT的思路；还有便是Dagger2或许Hilt完成的隔离层架构，相同也是一种办法。总归想要完成模块解耦，依靠注入是必须的。

Android进阶宝典 — IOC依赖注入框架原理

1 动态署理深入

1.1 $Proxy0

2 动态署理完成Xutils

2.1 Android特点注入

2.2 动态署理完成事情注入

2.3 组件化依靠注入

作者信息

Android进阶宝典 — IOC依赖注入框架原理

1 动态署理深入

1.1 $Proxy0

2 动态署理完成Xutils

2.1 Android特点注入

2.2 动态署理完成事情注入

2.3 组件化依靠注入

相关文章

用chatGpt 扩展Glide支持腾讯libpag PAG 动效图片

️🔥️🔥️🔥 最新的kt+jetpack+Coroutine打造的Android MVVM开发框架

2022年都快结束了，还有人不会安卓录屏？在安卓上录制屏幕的的实现方式

Android | 彻底理解 OkHttp 代理与路由

作者信息