IOC是什么

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
当然我这里先学习依赖注入，常见的比如，Dragger2,Butterknife,xutils3等等用依赖注入，一个注解就写入了很多的代码，很炫。当然我这里的初探，只是考虑方法实现，性能层面的我们一步步来。

@ContentView注解

首先我们实现一个ContentView注解

我们这里先看看我们平常加载一个ContentView是如何实现的

public class BaseActivity extends AppCompatActivity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_ioc_test);
    setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
    }
}

image

一个很简单的 Hello World!，系统生成的，不用在意Toolbar.

首先分析我们要注解的方法setContentView(int)，明显需要传入一个int

@Target(ElementType.TYPE) //元素种类 接口、类、枚举、注解
@Retention(RetentionPolicy.RUNTIME) //保留策略 注解会在class字节码文件中存在，在运行时
//可以通过反射获取到 @Target:注解的作用目标
public @interface ContentView {
    //参数
    int value();
}

我们给了一个value的参数，来表示我们传入的布局 R.layout.activity_ioc_test

然后在我们的BaseActivity中加入我们的注入类

public class BaseActivity extends AppCompatActivity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Inject.init(this);
//        setContentView(R.layout.activity_ioc_test);
    setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
    }
}

setContentView(int)是我们需要注解的方法，我这里先干掉他

然后是我们简单的Activiy

@ContentView(R.layout.activity_ioc_test)
public class IocTestActivity extends BaseActivity{

}

（不要问我为啥加个Base,习惯了。。。）

好，到我们主戏了，看看我们的Inject类

class Inject {

    public static void init(Activity activity) {
        //布局注入
        initContentView(activity);
        //控件注入
        initViews(activity);
        //事件注入
        initEvents(activity);
   }
}

（哎哟，不好意思透露了这篇文章接下来的内容，）
很简单的一个类，包含了一个静态方法

OK，布局注入

private static void initContentView(Activity activity) {
    final Class<? extends Activity> clazz = activity.getClass();
    ContentView contentView=clazz.getAnnotation(ContentView.class);
    if (contentView!=null){
        //注解的值 R.layout.activity_ioc_test
        final int layoutId = contentView.value();
        try {
            //获取指定方法，setContentView(int)
            final Method method = clazz.getMethod("setContentView", int.class);
            //执行方法
            method.invoke(activity,layoutId);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

通过我们的clazz拿到我们的Annotation，获取我们传入的layoutId,然后通过反射得到方法，将我们的layoutId参数传入，最后执行。
总结一下整个流程，获取类——>注解——>注解的值——>获取指定的方法——>执行方法
看看我们效果图：

image

没有任何问题。

@ViewInject注解

这一节，我们尝试写一个View注解，我们目的注解上图所示的一个Button 跟一个TextView，先看看我们平常的处理方式

@ContentView(R.layout.activity_ioc_test)
public class IocTestActivity extends BaseActivity{
private Button btn;
private TextView tvHello;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    btn=findViewById(R.id.button2);
    tvHello=findViewById(R.id.tvHello);
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            tvHello.setText("Hi gays!");
            }
        });
    }
}

image

效果是一个很简单点击替换文字

分析一下，我们的注解是要替代findViewById(int)这个方法，那么现在我们定义个方法

@Target(ElementType.FIELD) //字段、枚举的常量
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();
}

接下来是实现initViews(activity)这个方法

private static void initViews(Activity activity) {
    //获取类
    final Class<? extends Activity> clazz = activity.getClass();
    //获取所有属性
    final Field[] fields = clazz.getDeclaredFields();
    //遍历所有属性
    for (Field field : fields) {
        //每个属性的注解
        final ViewInject viewInject=field.getAnnotation(ViewInject.class);
        //不是每个属性都有注解
        if (viewInject!=null){
            //每个属性注解，R.id.button2
            final int viewId= viewInject.value();
            try {
                //获取指定方法，findViewById(int)
                final Method method = clazz.getMethod("findViewById", int.class);
                final Object view = method.invoke(activity, viewId);
                //注意！！判断如果是私有的，就设置成可访问
                if (!field.isAccessible()) field.setAccessible(true);
                field.set(activity,view);
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

关键步骤我都已经添加了注释，大家可以稍微看看

好，我们看看使用

@ContentView(R.layout.activity_ioc_test)
public class IocTestActivity extends BaseActivity{
@ViewInject(R.id.button2)
private Button btn;
@ViewInject(R.id.tvHello)
private TextView tvHello;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
//        btn=findViewById(R.id.button2);
//        tvHello=findViewById(R.id.tvHello);
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            tvHello.setText("Hi gays!");
            }
        });

    }
}

然后看看我们的效果

image

OK,完全达到了我们预期的效果，总结一下来说：

获得类——>获取所有属性——>遍历属性——>每个属性的注解——>获取指定的方法——>执行方法

事件的注解

我们看看一个事件的组成：

btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            tvHello.setText("Hi gays!");
        }
    });

这是一个很常见的点击事件，我们可以看到他分为了3个部分：

第一部分：监听的方法名setOnClickListener(listener)

第二部分：监听的对象OnClickListener

第三部分：回调的方法名onClick(View v)

说这个之前，我们先讨论一下什么是AOP思想。AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低。
在本例中我要用到AOP拦截本应该执行的onXXXClick()方法，而去执行我们的自定义的show方法

先定义一个base annotation

@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventBase {
    //监听方法名
    String methodName();
    //监听对象
    Class<?> listenerType();
    //回调方法名
    String callBackListener();
}

对应我们分析的3个部分

再来声明我们布局id

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

这次我们分析的是onClick方法，所以我们都使用OnClick作为示例

然后是实现initEvents(activity)方法

private static void initEvents(Activity activity) {
    //获取类
    final Class<? extends Activity> clazz = activity.getClass();
    //获取类的所有方法
    final Method[] methods = clazz.getMethods();
    //遍历方法
    for (Method method : methods) {
        //获取每个方法的多个注解
        final Annotation[] annotations = method.getAnnotations();
        //遍历所有注解
        for (Annotation annotation : annotations) {
            //获取Onclick注解上的注解类
            final Class<? extends Annotation> annotationType = annotation.annotationType();
            if (annotationType != null) {
                //获取EventBase注解
                final EventBase eventBase = annotationType.getAnnotation(EventBase.class);
                if (eventBase != null) {
                    //获取3大成员
                    final String methodName = eventBase.methodName();
                    final Class<?> aClass = eventBase.listenerType();
                    final String listener = eventBase.callBackListener();
                    //获取注解的值，执行方法再获取注解的值
                    try {
                        final Method declaredMethod = annotationType.getDeclaredMethod("value");
                        final int[] values = (int[]) declaredMethod.invoke(annotation);
                        final ListenerInvocationHandler handler = new ListenerInvocationHandler(activity);
                        handler.addMethod(listener,method);
                        final Object obj = Proxy.newProxyInstance(aClass.getClassLoader(), new Class[]{aClass}, handler);
                        //遍历注解的值
                        for (int value : values) {
                            //获取当前activity的view
                            final View view = activity.findViewById(value);
                            //获取指定方法
                            final Method setter = view.getClass().getMethod(methodName, aClass);
                            //执行方法
                            setter.invoke(view, obj);
                        }
                    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

这里我们要用到动态代理来获得我们的onClick方法执行，

class ListenerInvocationHandler implements InvocationHandler {
//存放对象
private WeakReference<Object> handlerRef;
//存放代理方法
private final HashMap<String,Method> methodHashMap=new HashMap<>(1);

public ListenerInvocationHandler(Object handlerRef) {
    this.handlerRef = new WeakReference<Object>(handlerRef);
}
public void addMethod(String name,Method method){
    methodHashMap.put(name,method);
}
public Object getHandler(){
    return handlerRef.get();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        final Object handler = handlerRef.get();
        if (handler!=null){
            final String eventMethod = method.getName();
            final Method method1 = methodHashMap.get(eventMethod);
            if (method1!=null){
                return method1.invoke(handler,args);
            }else {
                return method.invoke(proxy,args);
            }
        }
    return null;
    }
}

再看看使用

@ContentView(R.layout.activity_ioc_test)
public class IocTestActivity extends BaseActivity{
    @ViewInject(R.id.button2)
    private Button btn;
    @ViewInject(R.id.tvHello)
    private TextView tvHello;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    //        btn=findViewById(R.id.button2);
    //        tvHello=findViewById(R.id.tvHello);
    //        btn.setOnClickListener(new View.OnClickListener() {
    //            @Override
    //            public void onClick(View v) {
    //                tvHello.setText("Hi gays!");
    //            }
    //        });

    }
@OnClickEvent(R.id.button2)
public void show(View view){
    tvHello.setText("Hi gays!");
    }
}

总结

使用注解可以让我们再平常的开发中省略很多代码，更加方便我们再工作之余找一点小 事情做，封装得越好，实现得就越快。整个代码整理下来，我们可以看到，其实注解方式也不是特别难理解。当然我们这个初探的方式在效率上可能比一些成名的框架稍微差一点，但是我们也可以试着优化一下。

//获取3大成员
 ...
 final Class<?> aClass = eventBase.listenerType();
 ...
 final String name = clazz.getName();
 if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {
        continue;
 }
 ...

我们知道现在这个要注解的类不包含系统原生的，我们在遍历的时候就可以直接跳过。关于优化可以看看xUtils3等这些框架，开源的高star框架一般都经过了检测，优化的较好。但是还是那句话，别人的东西还是别人的东西，如果更新了，可能会对我们的项目造成影响，但是自己写的框架，很容易就能够把握。