[关闭]
@puke3615 2016-08-18T17:29:36.000000Z 字数 7770 阅读 1047

Android注解应用

在Java中经常会用到注解，通过注解的方式可以实现很多灵活性的东西。很多优秀的框架都支持注解的方式，如Spring的中对Bean的注解，Hibernate中对POJO类的注解，Mybatis中对Mapper的注解，ButterKnife中对View的注解，Dagger中对各个Component的注解， Retrofit对Api的注解。一言以蔽之，使用注解可以让整个代码风格看起来清爽明了。

一、 传统的代码风格

activity_main.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     android:orientation="vertical">
  7.     <EditText
  8.         android:id="@+id/username"
  9.         android:layout_width="match_parent"
  10.         android:layout_height="wrap_content"
  11.         android:hint="请输入用户名.." />
  13.     <Button
  14.         android:id="@+id/submit"
  15.         android:layout_width="match_parent"
  16.         android:layout_height="wrap_content"
  17.         android:text="提交" />
  18. </LinearLayout>

很简单的一个界面，只有一个EditText和一个Button，就不过多解释了。

MainActivity.java

  1. package com.puke.annotationdemo;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Button;
  7. import android.widget.EditText;
  8. import android.widget.Toast;
  10. public class MainActivity extends Activity {
  12.     private EditText mUsername;
  13.     private Button mSubmit;
  15.     @Override
  16.     protected void onCreate(Bundle savedInstanceState) {
  17.         super.onCreate(savedInstanceState);
  18.         setContentView(R.layout.activity_main);
  19.         findView();
  20.         initListener();
  21.     }
  23.     private void findView() {
  24.         mUsername = (EditText) findViewById(R.id.username);
  25.         mSubmit = (Button) findViewById(R.id.submit);
  26.     }
  28.     private void initListener() {
  29.         mSubmit.setOnClickListener(new View.OnClickListener() {
  30.             @Override
  31.             public void onClick(View v) {
  32.                 String username = mUsername.getText().toString().trim();
  33.                 Toast.makeText(MainActivity.this, username, Toast.LENGTH_SHORT).show();
  34.             }
  35.         });
  36.     }
  38. }

我们这里要做到是用户点击提交的时候，Toast弹出EditText输入的内容，比较简单，略过~

传统的风格是这样的，这样看来也许觉得没什么问题，但是实际的开发当中我们一个页面当中包含的View，以及对应的View的一些事件回调要远远比这个繁琐。我相信一个Activity中要处理十几二十几个View也不算是什么稀奇的事情，那这样会造成什么结果呢。。。

你的属性声明会是这样的

  1. private Button mButton1;
  2. private Button mButton2;
  3. private Button mButton3;
  4. private Button mButton4;
  5. private Button mButton5;
  6. private Button mButton6;
  7. private Button mButton7;
  8. private Button mButton8;

你的findView会是这样的

  1. mButton1 = (Button) findViewById(R.id.button1);
  2. mButton2 = (Button) findViewById(R.id.button2);
  3. mButton3 = (Button) findViewById(R.id.button3);
  4. mButton4 = (Button) findViewById(R.id.button4);
  5. mButton5 = (Button) findViewById(R.id.button5);
  6. mButton6 = (Button) findViewById(R.id.button6);
  7. mButton7 = (Button) findViewById(R.id.button7);
  8. mButton8 = (Button) findViewById(R.id.button8);

你的事件监听会是这样的

  1. mButton1.setOnClickListener(new View.OnClickListener() {
  2.     @Override
  3.     public void onClick(View v) {
  5.     }
  6. });
  7. mButton2.setOnClickListener(new View.OnClickListener() {
  8.     @Override
  9.     public void onClick(View v) {
  11.     }
  12. });
  13. mButton3.setOnClickListener(new View.OnClickListener() {
  14.     @Override
  15.     public void onClick(View v) {
  17.     }
  18. });
  19. mButton4.setOnClickListener(new View.OnClickListener() {
  20.     @Override
  21.     public void onClick(View v) {
  23.     }
  24. });
  25. mButton5.setOnClickListener(new View.OnClickListener() {
  26.     @Override
  27.     public void onClick(View v) {
  29.     }
  30. });
  31. mButton6.setOnClickListener(new View.OnClickListener() {
  32.     @Override
  33.     public void onClick(View v) {
  35.     }
  36. });
  37. mButton7.setOnClickListener(new View.OnClickListener() {
  38.     @Override
  39.     public void onClick(View v) {
  41.     }
  42. });
  43. mButton8.setOnClickListener(new View.OnClickListener() {
  44.     @Override
  45.     public void onClick(View v) {
  47.     }
  48. });

例子举得不怎么恰当，但是足以说明随着业务代码的不断扩大，这些看上去的”无脑操作“也会让我们广大coder变得愈加的不耐烦，而且会使得我们的类变得庞大而臃肿。

那么，接下来我们就通过注解的方式来搞一发~

二、 注解的编码风格

我们打算使用注解的方式实现

  1. xml的配置
  2. View的注入
  3. 点击事件的绑定

接下来就是具体实现逻辑

  1. 首先我们先定义一个Bind注解
  1. package com.puke.annotationdemo;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. /**
  9.  * @author zijiao
  10.  * @version 16/8/18
  11.  */
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
  14. public @interface Bind {
  15.     int value() default 0;
  16. }
  1. 然后写Bind注解对应的注解处理器
  1. package com.puke.annotationdemo;
  3. import android.app.Activity;
  4. import android.view.View;
  6. import java.lang.reflect.Field;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.lang.reflect.Method;
  10. /**
  11.  * @author zijiao
  12.  * @version 16/8/18
  13.  */
  14. public class BindHandler {
  16.     /**
  17.      * 处理对Activity的注解
  18.      *
  19.      * @param activity 目标Activity
  20.      */
  21.     public static void handleBind(Activity activity) {
  22.         Class cls = activity.getClass();
  23.         handleSetContentView(activity);
  24.         handleFindView(cls.getDeclaredFields(), activity);
  25.         handleClickEvent(cls.getDeclaredMethods(), activity);
  26.     }
  28.     //绑定xml布局
  29.     private static void handleSetContentView(Activity activity) {
  30.         Class<?> cls = activity.getClass();
  31.         if (cls.isAnnotationPresent(Bind.class)) {
  32.             //Activity中加入Bind注解时取出注解配置
  33.             Bind bind = cls.getAnnotation(Bind.class);
  34.             int layout = bind.value();
  35.             if (layout != 0) {
  36.                 activity.setContentView(layout);
  37.             }
  38.         }
  39.     }
  41.     //View的注入
  42.     private static void handleFindView(Field[] declaredFields, Activity activity) {
  43.         if (declaredFields == null || declaredFields.length == 0) {
  44.             return;
  45.         }
  46.         for (Field field : declaredFields) {
  47.             //找到被Bind注解且是View的所有属性
  48.             if (field.isAnnotationPresent(Bind.class) && View.class.isAssignableFrom(field.getType())) {
  49.                 Bind bind = field.getAnnotation(Bind.class);
  50.                 int id = bind.value();
  51.                 if (id != 0) {
  52.                     View view = activity.findViewById(id);
  53.                     field.setAccessible(true);
  54.                     try {
  55.                         //直接通过反射set进去
  56.                         field.set(activity, view);
  57.                     } catch (IllegalAccessException e) {
  58.                         e.printStackTrace();
  59.                     }
  60.                 }
  61.             }
  62.         }
  63.     }
  65.     //点击事件的绑定
  66.     private static void handleClickEvent(Method[] declaredMethods, final Activity activity) {
  67.         if (declaredMethods == null || declaredMethods.length == 0) {
  68.             return;
  69.         }
  70.         for (final Method method : declaredMethods) {
  71.             //找到被Bind注解且无参的所有方法（注意这里限制无参是为了与下面调用method.invoke(activity)的无参保持一致）
  72.             if (method.isAnnotationPresent(Bind.class) && method.getParameterTypes().length == 0) {
  73.                 Bind bind = method.getAnnotation(Bind.class);
  74.                 int id = bind.value();
  75.                 if (id != 0) {
  76.                     activity.findViewById(id).setOnClickListener(new View.OnClickListener() {
  77.                         @Override
  78.                         public void onClick(View v) {
  79.                             try {
  80.                                 method.invoke(activity);
  81.                             } catch (IllegalAccessException e) {
  82.                                 e.printStackTrace();
  83.                             } catch (InvocationTargetException e) {
  84.                                 e.printStackTrace();
  85.                             }
  86.                         }
  87.                     });
  88.                 }
  89.             }
  90.         }
  91.     }
  93. }

好了，到了这一步，我们的注解工作算是结束了，代码相对有点多，但这个是一劳永逸的。

  1. 接下来就是对注解的使用了
  1. package com.puke.annotationdemo;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Button;
  7. import android.widget.EditText;
  8. import android.widget.Toast;
  10. @Bind(R.layout.activity_main)
  11. public class MainActivity extends Activity {
  13.     @Bind(R.id.username)
  14.     private EditText mUsername;
  15.     @Bind(R.id.submit)
  16.     private Button mSubmit;
  18.     @Override
  19.     protected void onCreate(Bundle savedInstanceState) {
  20.         super.onCreate(savedInstanceState);
  21.         BindHandler.handleBind(this);
  22.     }
  24.     @Bind(R.id.submit)
  25.     public void submit() {
  26.         String username = mUsername.getText().toString().trim();
  27.         Toast.makeText(MainActivity.this, username, Toast.LENGTH_SHORT).show();
  28.     }
  30. }

Run一下，完美运行~

我们这里可以看到，使用注解之后

setContentView方法没了

findViewById方法没了

setOnClickListener方法没了

MainActivity整个类减肥了

所有的所有，都让注解处理器一手承包了。而我们要做的是什么，要做的是真正应该由coder做的事情，在对应的地方加上对应的注解配置就ok了。

然后我们可以回过头看一下Bind这个注解，细心的同学可能发现注解声明value()的时候理论上来讲不应该有一个default为0的默认值。原因很简单啊，因为就目前的使用场景来看，无论注入一个layout还是一个id都不会为0，那这里干嘛还要再写一个default 0呢，直接不要default可以限制业务方的使用，强约束业务方一旦使用注解就必须要在注解里面set一个值进来。这里我要说明一下，我们写注解就是为了方便使用，快速开发，既然要懒，我们就懒到家，干脆就让我们的注解处理器能在业务方没有在Bind中注入值的时候也能生效。

就是要实现下面这种效果:

  1. package com.puke.annotationdemo;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Button;
  7. import android.widget.EditText;
  8. import android.widget.Toast;
  10. @Bind
  11. public class MainActivity extends Activity {
  13.     @Bind
  14.     private EditText mUsername;
  15.     @Bind
  16.     private Button mSubmit;
  18.     @Override
  19.     protected void onCreate(Bundle savedInstanceState) {
  20.         super.onCreate(savedInstanceState);
  21.         BindHandler.handleBind(this);
  22.     }
  24.     @Bind
  25.     public void submit() {
  26.         String username = mUsername.getText().toString().trim();
  27.         Toast.makeText(MainActivity.this, username, Toast.LENGTH_SHORT).show();
  28.     }
  30. }

这样一来，只需要几个全裸的注解一顿狂注之后，就完事了。后面这种的实现方式我这里就不写了，大致说一下思路，注解处理器要制定类名—layout，属性名—id，方法名—id，这样一套转换标准出来，然后注解处理器的处理逻辑是先看业务方有没有手动注入，没有手动注入的情况（也就是前面提到的default 0）下，注解处理器再按照这套标准利用反射来取出对应的R类的对应资源值，只要找到对应的资源值，就和手动注入处理结果的完全一样。

三、 一些问题

每当一种事物出现时，只要不是太极端，总会有人拥护，也有人异议。单单站在coder的角度，这种注解的方式给我带来的好处是显而易见的，算是治愈代码密集恐惧症的偏方了。

但是值得深思的是，这里大量使用了反射，在Java中反射的性能问题总是尴尬的不要不要的。虽然jdk每次升级时基本上都在对反射进行优化，但是毕竟是反射，纯理论上讲，它确实没有直接的方法调用高效。

当然针对这个问题，我也有见过这样一种说法，假如我们对所谓”高效“的时间容忍度是1000t(t为一个时间粒度单位)，直接方法调用耗时是1t，反射是50 - 200t。也就是说，反射是耗性能，是不效率，但是这个也只是相对与直接方法调用而言的，而还远远没达到我们对性能指标的容忍值。

我曾经也在高效开发和反射性能消耗之间纠结很久，在这里就不去过多评价，仁者见仁，智者见智了~

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注