xUtils3源码分析之-----view注解

古城微笑少年丶 2022-05-28 00:53 203阅读 0赞

--------------------

> 利用工作之外的时间终于看完了xutils3的所有模块的源码，以此博客来记录自己的分析过程，在此约定半年之后重新分析xUtils3源码对比该系列博客看看自己有没有新的突破。

[1. xUtils3源码解析之—–image][1. xUtils3_image]  
[2. xUtils3源码解析之—–Http(s)][2. xUtils3_Http_s]  
[3. xUtils3源码分析之—–DB(ORM)][3. xUtils3_DB_ORM]  
[4. xUtils3源码分析之—–view注解][4. xUtils3_view]

# 基本使用方法 #

> 1.初始化xUtils3;

x.Ext.init(this);

> 2.Activity或者fragment里面注入

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        x.view().inject(this);  // 注入
    }

> 3.在具体的类里面设置布局文件，ViewInject注解得到布局里的view，Event注解设置view的事件

@ContentView(R.layout.activity_main)  // 设置布局文件
    public class MainActivity extends BaseActivity {
    
        @ViewInject(R.id.container)  // 设置viewId
        private ViewPager mViewPager;
    
        @ViewInject(R.id.toolbar)
        private Toolbar toolbar;
    
        @Event(R.id.btn_test_db) // 通过viewId绑定默认的点击事件
        private void onTestDbClick(View view) {
        }
    }

# view注解源码解析 #

## 初始化xUtils3都做了些什么工作？ ##

x.Ext.init(this); // Ext是x类的内部静态类

> 通过调用x类里面的一个静态Ext类的init(Application app)方法，然后该方法里调用TaskControllerImpl的静态方法registerIntance(), registerIntance方法里双重校验锁实例化TaskControllerImpl, 最后调用Ext.setTaskController(instance)把TaskControllerImpl对象保存到Ext静态类里;

public static void init(Application app) {
            TaskControllerImpl.registerInstance();
            if (Ext.app == null) {
                Ext.app = app;
            }
    }
    
    org.xutils.common.task.TaskControllerImpl类：
    
     public static void registerInstance() {
        if (instance == null) {
            synchronized (TaskController.class) {
                if (instance == null) {
                    instance = new TaskControllerImpl();
                }
            }
        }
        x.Ext.setTaskController(instance);
    }

## 在activity里面使用view注入源码解析 ##

> 1.在某个activity里面注入, x.view()方法如果静态类Ext的viewInjector为空，则通过ViewInjectorImpl的静态方法registerInstance创建一个ViewInjectorImpl实例并保存到Ext静态类里跟上面一样的套路；

x.view().inject(this);

public static ViewInjector view() {
        if (Ext.viewInjector == null) {
            ViewInjectorImpl.registerInstance();
        }
        return Ext.viewInjector;
    }
    
    org.xutils.view.ViewInjectorImpl类：
    
    public static void registerInstance() {
        if (instance == null) {
            synchronized (lock) {
                if (instance == null) {
                    instance = new ViewInjectorImpl();
                }
            }
        }
        x.Ext.setViewInjector(instance);
    }

> 2.由1接着执行ViewInjectorImpl.inject(Activity activity)方法, 该方法首先得到实例的类，然后通过findContentView(class)方法递归（自身到父类）得到ContentView注解，然后获取ContentView.value()也就是布局文件的Id，id符合要求后会通过反射执行系统的setContentView方法;

@Override
    public void inject(Activity activity) {
        //获取Activity的ContentView的注解
        Class<?> handlerType = activity.getClass();
        try {
            ContentView contentView = findContentView(handlerType);
            if (contentView != null) {
                int viewId = contentView.value();
                if (viewId > 0) {
                    Method setContentViewMethod = handlerType.getMethod("setContentView", int.class);
                    setContentViewMethod.invoke(activity, viewId);
                }
            }
        } catch (Throwable ex) {
            LogUtil.e(ex.getMessage(), ex);
        }
    
        injectObject(activity, handlerType, new ViewFinder(activity));
    }
    
    
    private static ContentView findContentView(Class<?> thisCls) {
        if (thisCls == null || IGNORED.contains(thisCls)) {
            return null;
        }
        ContentView contentView = thisCls.getAnnotation(ContentView.class);
        if (contentView == null) {
            return findContentView(thisCls.getSuperclass());
        }
        return contentView;
    }

> 3.由2设置好了布局文件后会通过injectObject(activity, handlerType, new ViewFinder(activity))方法注入一些view和事件,首先是得到所有的属性，然后遍历属性符合要求的属性通过 ViewInject viewInject = field.getAnnotation(ViewInject.class)得到ViewInject注解，然后通过finder.findViewById(viewInject.value(), viewInject.parentId())得到view对象，最后将view跟属性Field绑定;

@SuppressWarnings("ConstantConditions")
    private static void injectObject(Object handler, Class<?> handlerType, ViewFinder finder) {
    
        if (handlerType == null || IGNORED.contains(handlerType)) {
            return;
        }
    
        // 从父类到子类递归
        injectObject(handler, handlerType.getSuperclass(), finder);
    
        // inject view
        Field[] fields = handlerType.getDeclaredFields();
        if (fields != null && fields.length > 0) {
            for (Field field : fields) {
    
                Class<?> fieldType = field.getType();
                if (
                /* 不注入静态字段 */     Modifier.isStatic(field.getModifiers()) ||
                /* 不注入final字段 */    Modifier.isFinal(field.getModifiers()) ||
                /* 不注入基本类型字段 */  fieldType.isPrimitive() ||
                /* 不注入数组类型字段 */  fieldType.isArray()) {
                    continue;
                }
    
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            if (viewInject != null) {
                try {
                      View view = finder.findViewById(viewInject.value(), viewInject.parentId());
                      if (view != null) {
                            field.setAccessible(true);
                            field.set(handler, view);
                      } else {
                            throw new RuntimeException("Invalid @ViewInject for "
                                    + handlerType.getSimpleName() + "." + field.getName());
                      }
                    } catch (Throwable ex) {
                        LogUtil.e(ex.getMessage(), ex);
                    }
                }
            }
        } // end inject view
    
        // inject event
        Method[] methods = handlerType.getDeclaredMethods();
        if (methods != null && methods.length > 0) {
            for (Method method : methods) {
    
                if (Modifier.isStatic(method.getModifiers())
                        || !Modifier.isPrivate(method.getModifiers())) {
                    continue;
                }
    
                //检查当前方法是否是event注解的方法
                Event event = method.getAnnotation(Event.class);
                if (event != null) {
                    try {
                        // id参数
                        int[] values = event.value();
                        int[] parentIds = event.parentId();
                        int parentIdsLen = parentIds == null ? 0 : parentIds.length;
                        //循环所有id，生成ViewInfo并添加代理反射
                        for (int i = 0; i < values.length; i++) {
                            int value = values[i];
                            if (value > 0) {
                                ViewInfo info = new ViewInfo();
                                info.value = value;
                                info.parentId = parentIdsLen > i ? parentIds[i] : 0;
                                method.setAccessible(true);
                                EventListenerManager.addEventMethod(finder, info, event, handler, method);
                            }
                        }
                    } catch (Throwable ex) {
                        LogUtil.e(ex.getMessage(), ex);
                    }
                }
            }
        } // end inject event
    }

**org.xutils.view.ViewFinder类：**

public View findViewById(int id, int pid) {
        View pView = null;
        if (pid > 0) {
            pView = this.findViewById(pid);
        }
    
        View view = null;
        if (pView != null) {
            view = pView.findViewById(id);
        } else {
            view = this.findViewById(id);
        }
        return view;
    }

> 4.由3注入完view之后，再注入事件，通过反射得到所有的DeclaredMethods，然后遍历首先排除静态方法，非Private方法，然后获取到含有注解Event的方法，通过获取到的Event注解再得到它的value(int\[\])（view的id）属性，然后遍历所有的viewIds，生成ViewInfo并通过EventListenerManager.addEventMethod()代理反射;

// inject event
        Method[] methods = handlerType.getDeclaredMethods();
        if (methods != null && methods.length > 0) {
            for (Method method : methods) {
    
                if (Modifier.isStatic(method.getModifiers())
                        || !Modifier.isPrivate(method.getModifiers())) {
                    continue;
                }
    
                //检查当前方法是否是event注解的方法
                Event event = method.getAnnotation(Event.class);
                if (event != null) {
                    try {
                        // id参数
                        int[] values = event.value();
                        int[] parentIds = event.parentId();
                        int parentIdsLen = parentIds == null ? 0 : parentIds.length;
                        //循环所有id，生成ViewInfo并添加代理反射
                        for (int i = 0; i < values.length; i++) {
                            int value = values[i];
                            if (value > 0) {
                                ViewInfo info = new ViewInfo();
                                info.value = value;
                                info.parentId = parentIdsLen > i ? parentIds[i] : 0;
                                method.setAccessible(true);
                                EventListenerManager.addEventMethod(finder, info, event, handler, method);
                            }
                        }
                    } catch (Throwable ex) {
                        LogUtil.e(ex.getMessage(), ex);
                    }
                }
            }
        } // end inject event

> 5.由4 看看EventListenerManager的静态方法addEventMethod都做了些什么工作：首先通过ViewFinder.findViewByInfo方法得到相应的view对象，然后生成动态代理实例listener,这里会用了一个双key(ViewInfo listenerType)缓存的集合，通过view.getClass().getMethod(listenerSetter, listenerType)得到Method实例(setOnclickListener)然后method.invoke()执行这个方法会执行之前得到的动态代理实例listener.invoke(…)方法；

**org.xutils.view.EventListenerManager;类**

public static void addEventMethod(
            //根据页面或view holder生成的ViewFinder
            ViewFinder finder,
            //根据当前注解ID生成的ViewInfo
            ViewInfo info,
            //注解对象
            Event event,
            //页面或view holder对象
            Object handler,
            //当前注解方法
            Method method) {
        try {
            View view = finder.findViewByInfo(info);
    
            if (view != null) {
                // 注解中定义的接口，比如Event注解默认的接口为View.OnClickListener
                Class<?> listenerType = event.type();
                // 默认为空，注解接口对应的Set方法，比如setOnClickListener方法
                String listenerSetter = event.setter();
                if (TextUtils.isEmpty(listenerSetter)) {
                    listenerSetter = "set" + listenerType.getSimpleName();
                }
    
    
                String methodName = event.method();
    
                boolean addNewMethod = false;
                /*
                    根据View的ID和当前的接口类型获取已经缓存的接口实例对象，
                    比如根据View.id和View.OnClickListener.class两个键获取这个View的OnClickListener对象
                 */
                Object listener = listenerCache.get(info, listenerType);
                DynamicHandler dynamicHandler = null;
                /*
                    如果接口实例对象不为空
                    获取接口对象对应的动态代理对象
                    如果动态代理对象的handler和当前handler相同
                    则为动态代理对象添加代理方法
                 */
                if (listener != null) {
                    dynamicHandler = (DynamicHandler) Proxy.getInvocationHandler(listener);
                    addNewMethod = handler.equals(dynamicHandler.getHandler());
                    if (addNewMethod) {
                        dynamicHandler.addMethod(methodName, method);
                    }
                }
    
                // 如果还没有注册此代理
                if (!addNewMethod) {
    
                    dynamicHandler = new DynamicHandler(handler);
    
                    dynamicHandler.addMethod(methodName, method);
    
                    // 生成的代理对象实例，比如View.OnClickListener的实例对象
                    listener = Proxy.newProxyInstance(
                            listenerType.getClassLoader(),
                            new Class<?>[]{listenerType},
                            dynamicHandler);
    
                    listenerCache.put(info, listenerType, listener);
                }
    
                Method setEventListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);
                setEventListenerMethod.invoke(view, listener);
            }
        } catch (Throwable ex) {
            LogUtil.e(ex.getMessage(), ex);
        }
    }

> 6.由5执行到listener动态代理实例的invoke方法里，首先拦截了系统的toString()方法，当view执行了点击onClick(View view)就会对应执行method.invoke(handler, args)，method 是5保存的用户自定义的方法，最终完成执行。

@Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Log.d("yw", method + ": method " + args + ":args" + " " + DynamicHandler.class.getSimpleName());
            Object handler = handlerRef.get();
            if (handler != null) {
    
                String eventMethod = method.getName();
                if ("toString".equals(eventMethod)) {
                    return DynamicHandler.class.getSimpleName();
                }
    
                method = methodMap.get(eventMethod);
                if (method == null && methodMap.size() == 1) {
                    for (Map.Entry<String, Method> entry : methodMap.entrySet()) {
                        if (TextUtils.isEmpty(entry.getKey())) {
                            method = entry.getValue();
                        }
                        break;
                    }
                }
    
                if (method != null) {
    
                    if (AVOID_QUICK_EVENT_SET.contains(eventMethod)) {
                        long timeSpan = System.currentTimeMillis() - lastClickTime;
                        if (timeSpan < QUICK_EVENT_TIME_SPAN) {
                            LogUtil.d("onClick cancelled: " + timeSpan);
                            return null;
                        }
                        lastClickTime = System.currentTimeMillis();
                    }
    
                    try {
                        return method.invoke(handler, args);
                    } catch (Throwable ex) {
                        throw new RuntimeException("invoke method error:" +
                                handler.getClass().getName() + "#" + method.getName(), ex);
                    }
                } else {
                    LogUtil.w("method not impl: " + eventMethod + "(" + handler.getClass().getSimpleName() + ")");
                }
            }
            return null;
        }
    }

[1. xUtils3_image]: https://blog.csdn.net/yang_yang1994/article/details/79834439
[2. xUtils3_Http_s]: https://blog.csdn.net/yang_yang1994/article/details/79832655
[3. xUtils3_DB_ORM]: https://blog.csdn.net/yang_yang1994/article/details/79764372
[4. xUtils3_view]: https://blog.csdn.net/yang_yang1994/article/details/79705454