Java夯实基础（Android注解全解析）

我们继续我们上一节内容 Java夯实基础（注解一）往下走……

上一节呢我们介绍了什么是注解，然后还说了它的使用方法，还遗漏了一点点内容，废话不多说了哈，开撸～～～

上一节说了，定义注解的注解叫：元注解，于是我们认识了一下@Retention：

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
     String name();
     String info() default "Hello EveryBody!";
}

还有两个注解我们没有讲，那就是@Documented跟
@Target。

1、@Documented注解

此注解表示的是文档化，可以在生成doc文档的时候添加注解，也没有啥可讲的。

2、@Target注解
@Target注解表示的是一个Annotation的使用范围，例如：之前定义的MyAnnotation，可以在任意的位置上使用（因为我们没有给出其使用范围的注解）。

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE
}

范围	描述
ElementType.TYPE	只能在类或接口或枚举上使用
ElementType .METHOD	只能在方法上使用
PARAMETER	在参数上使用
CONSTRUCTOR	在构造方法上使用
LOCAL VARIABLE	在局部变量上使用
ANNOTATION TYPE	在注解上使用
PACKAGE	在包中使用
filed	在类成员变量中使用

例如我们这里的：

package com.yasin.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
     String name();
     String info() default "Hello EveryBody!";
}

@Target(ElementType.TYPE)表示在类上使用，我们的程序也是没问题的，如果我们改为@Target(ElementType.method)我们再试试：

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

我们编译器直接报错了：

好啦～到此，我们注解的基础部分就算是结束了，接下来我们来实战实战了，我们结合我们android注解来试试水，小伙伴跟紧啦～～～～！

先看看我们要实现的效果，我们在android中的findviewbyid就可以这样写了：

@ViewInject(R.id.id_tradingpwddetails_pic)
    private ImageView iv_cardImg;
    @ViewInject(R.id.id_tradingpwddetails_name)
    private TextView tv_cardName;
    @ViewInject(R.id.id_tradingpwddetails_no)
    private TextView tv_cardNo;
    @ViewInject(R.id.id_tradingpwddetails_ssv)
    private SlideSwitchView ssv_open;
    @ViewInject(R.id.id_tradingpwddetails_pwd)
    private View viewTBypWD;

我们给一个view设置点击事件就可以这样了：

/**
     * 点击事件
     */
    @OnClick({
            R.id.id_tradingpwddetails_setting,
            R.id.id_tradingpwddetails_update
    })
    public void OnClick(View view) {
        int id = view.getId();
        if (id == R.id.id_tradingpwddetails_setting) {
        } else if (id == 
        }
    }

一、ViewInject

1、首先我们定义一个叫ViewInject的注解,因为我们的注解需要用在成员变量上使用，所以我们声明Target为filed，因为我们需要在程序运行的时候用到注解，所以我们将其retention设置为runtime。

package com.yasin.annotationdemo.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by leo on 17/3/21.
 */
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
}

我们需要传入一个id，所以我们需要定义一个int类型的属性。

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

好啦～我们定义一个布局：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context="com.yasin.annotationdemo.MainActivity">

    <TextView
        android:id=@+id/id_tv_hello
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>

布局很简单，就是一个helloword，然后给了一个id。

然后就是我们的Activity了：

public class MainActivity extends AppCompatActivity {
    @ViewInject(R.id.id_tv_hello)
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

也是很简单，就是定义了一个mTextView然后使用了ViewInject注解，把id值给了textview，这样就ok了吗？？？哈哈～～太单纯了哈，我们才刚刚定义好注解，下面我们就通过反射来实现下它。

2、反射实现view的注入

我们现在是有了id跟注解了，然后我们什么时候给view注入呢？得我们告诉程序才行额，所以我们定义一个工具类叫:

/**
 * Created by leo on 17/3/21.
 */

public class AnnoUtils {

    public static void inject(Activity activity){
        //do our things
    }
}

然后我们的Activity就只需要告诉AnnoUtils什么时候给view注入就可以了：

public class MainActivity extends AppCompatActivity {
    @ViewInject(R.id.id_tv_hello)
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //开始给view注入
        AnnoUtils.inject(this);
    }
}

好啦～～ 我们下面就实现下我们AnnoUtils里面的inject方法了：

package com.yasin.annotationdemo.annotation;

import android.app.Activity;
import android.util.Log;
import android.view.View;

import java.lang.reflect.Field;

/**
 * Created by leo on 17/3/21.
 */

public class AnnoUtils {

    private static final String TAG = "AnnoUtils";

    public static void inject(Activity activity) {
        if (activity == null) return;
        try {
            //获取当前activity的镜像
            Class<?> clazz = activity.getClass();
            //获取当前activity中所有的字段
            Field[] fields = clazz.getDeclaredFields();
            //开始遍历所有的字段
            if (fields != null && fields.length > 0) {
                for (Field field : fields) {
                    //判断当前字段是否支持该注解
                    if (field.isAnnotationPresent(ViewInject.class)) {
                        //获取ViewInject注解对象
                        ViewInject annotation = field.getAnnotation(ViewInject.class);
                        if (annotation != null) {
                            int id = annotation.value();
                            View view = activity.findViewById(id);
                            if (view != null) {
                                //把view赋给字段filed
                                field.setAccessible(true);
                                field.set(activity, view);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, e.getMessage());
        }
    }
}

我们修改一下我们的mTextView的内容：

public class MainActivity extends AppCompatActivity {
    @ViewInject(R.id.id_tv_hello)
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //开始给view注入
        AnnoUtils.inject(this);
        mTextView.setText("hello yasin!");
    }
}

可以看到，我们没有findviewbyid然后就直接使用mTextView。

运行效果：

好啦～ 我们的findviewbyid已经用我们的注解方式干掉了，然后我们实现一下点击事件：

二、点击事件的注入

知道了如果去注入findview，那么onclick事件无非就是把注解加载method上，那么问题来了，我们都知道，我们给一个view设置点击事件的时候是这样的：

mTextView3.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });

我们需要实现的结果：

/**
     * 点击事件
     */
    @OnClick({
            R.id.id_tradingpwddetails_setting,
            R.id.id_tradingpwddetails_update
    })
    public void OnClick(View view) {
        int id = view.getId();
        if (id == R.id.id_tradingpwddetails_setting) {
        } else if (id == 
        }
    }

要让系统调我们的OnClick方法，我们该怎么做呢？？？

三、认识动态代理模式

在此之前呢，我们了解java中的一种设计模式（动态代理模式），听起来有点高大上哦，让我们来认识一下它吧，感觉自己好多天都没剪头发了，等我先去剪个头发哈～～～

于是我们创建一个主题叫Subject:

package com.yasin.proxy;

public interface Subject {
    void beforeHaircut();
    void afterHaircut();
    void haircut(String opt);
}

然后我们具体的去实现下它：
HairCut.java：

package com.yasin.proxy;

public class HairCut implements Subject{

    @Override
    public void beforeHaircut() {
        // TODO Auto-generated method stub
        System.out.println(我觉得我应该要去剪个头发了～～～);
    }

    @Override
    public void afterHaircut() {
        // TODO Auto-generated method stub
        System.out.println(嗯嗯！！帅呆了～～);
    }

    @Override
    public void haircut(String opt) {
        System.out.println(opt);
    }
}

既然是剪头发对吧，我们得有一个理发师：

HairDresserHandler.java:

package com.yasin.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class HairDresserHandler implements InvocationHandler{
    private Subject subject;

    public HairDresserHandler(Subject subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        subject.beforeHaircut();
        Object obj=method.invoke(subject, args);
        subject.afterHaircut();
        return obj;
    }
}

理发师肯定得问要剪啥样子的头发的对吧，所以我们传递一个
subject个给理发师。

然后我们就可以去剪头发啦～～～

我们创建一个测试类：

package com.yasin.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        //谁要去剪头发
        Subject subject=new HairCut();
        //指定一个理发师
        InvocationHandler handler=new HairDresserHandler(subject);
        //理发师拿出剪刀
        Subject proxySubject = (Subject)Proxy.newProxyInstance(subject.getClass().getClassLoader(), 
                new Class[]{Subject.class},handler);
        //理发师咔咔咔剪完啦
        proxySubject.haircut(小伙子，头发剪完了，30块！);
    }
}

然后我们运行代码：

console打印：

我觉得我应该要去剪个头发了～～～
小伙子，头发剪完了，30块！
嗯嗯！！帅呆了～～

好啦～～ 终于剪了个头发回来了，下面我们回到我们的代码，如何让系统调onClick方法的时候，调用我们写的xxxClick方法呢？

我们在测试类中调用了剪头发方法：

//理发师咔咔咔剪完啦
        proxySubject.haircut("小伙子，头发剪完了，30块！");

这里就相当于系统调用onClickListener的onClick方法，然后我们只需要在真正剪头发（也就是理发师的invoke方法中）调用一下我们的xxxClick方法就可以了，可能有点抽象哈，下面我们来实现一下。

@Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        subject.beforeHaircut();
        Object obj=method.invoke(subject, args);
        subject.afterHaircut();
        return obj;
    }

我们开动了：

OnClick.java:

package com.yasin.annotationdemo.annotation;

import android.view.View;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by leo on 17/3/21.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnClick {
    int[]value();
    String listenerSetter() default setOnClickListener;
    Class listenerType() default View.OnClickListener.class;
    String methodName() default onClick;
}

代理处理类（理发师）
ViewHandler.java:

package com.yasin.annotationdemo.annotation;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * Created by leo on 17/3/21.
 */

public class ViewHandler implements InvocationHandler {
    private Object object;
    private Method mMethod;
    private String methodName;
    public ViewHandler(Object object,Method method,String methodName){
        this.object=object;
        this.mMethod=method;
        this.methodName=methodName;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //当系统调用onclick方法的时候，我们就调用我们在activity中定义的方法
        if(method.getName().equals(methodName)){
            Object obj = mMethod.invoke(object, args);
            return obj;
        }
        return null;
    }
}

然后就是我们的：
AnnoUtils.java:

package com.yasin.annotationdemo.annotation;

import android.app.Activity;
import android.util.Log;
import android.view.View;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by leo on 17/3/21.
 */

public class AnnoUtils {

    private static final String TAG = "AnnoUtils";

    public static void inject(Activity activity) {
        if (activity == null) return;
        try {
            //获取当前activity的镜像
            Class<?> clazz = activity.getClass();
            //获取当前activity中所有的字段
            Field[] fields = clazz.getDeclaredFields();
            //开始遍历所有的字段
            if (fields != null && fields.length > 0) {
                for (Field field : fields) {
                    //判断当前字段是否支持该注解
                    if (field.isAnnotationPresent(ViewInject.class)) {
                        //获取ViewInject注解对象
                        ViewInject annotation = field.getAnnotation(ViewInject.class);
                        if (annotation != null) {
                            int id = annotation.value();
                            View view = activity.findViewById(id);
                            if (view != null) {
                                //把view赋给字段filed
                                field.setAccessible(true);
                                field.set(activity, view);
                            }
                        }
                    }
                }
            }

            //获取activity中所有的方法
            Method[] methods=clazz.getDeclaredMethods();
            if(methods!=null&&methods.length>0){
                //遍历所有的方法
                for (Method method:methods) {
                    //找到带有OnClick注解标记的方法
                    if(method.isAnnotationPresent(OnClick.class)){
                        OnClick annotation=method.getAnnotation(OnClick.class);
                        //获取所有的id
                        int[] ids = annotation.value();
                        //遍历所有的id
                        for (int id: ids) {
                            //找到相应的view
                            View view=activity.findViewById(id);
                            if(view!=null){
                                method.setAccessible(true);
                                //获取onclicklistener镜像
                                Class<?> listenerType = annotation.listenerType();
                                //获取view中的setOnClickListener方法名字
                                String listenerSetter = annotation.listenerSetter();
                                //系统调用onClick方法名
                                String methodName = annotation.methodName();
                                //创建代理对象帮助类
                                ViewHandler handler=new ViewHandler(activity,method,methodName);
                                //获取onClickListener代理对象
                                Object onClickListener=Proxy.newProxyInstance(listenerType.getClassLoader(), new Class<?>[]{listenerType}, handler);
                                //获取view的setOnClickListener方法
                                Method setOnListenerMethod = view.getClass().getMethod(listenerSetter, listenerType);
                                //实现setOnClickListener方法
                                setOnListenerMethod.invoke(view,onClickListener);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, e.getMessage());
        }
    }
}

最后测试我们的代码：

package com.yasin.annotationdemo;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.yasin.annotationdemo.annotation.AnnoUtils;
import com.yasin.annotationdemo.annotation.OnClick;
import com.yasin.annotationdemo.annotation.ViewInject;

public class MainActivity extends Activity {
    @ViewInject(R.id.id_tv_hello)
    private TextView mTextView;
    @ViewInject(R.id.id_tv_hello2)
    private TextView mTextView2;
    @ViewInject(R.id.id_tv_hello3)
    private TextView mTextView3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //开始给view注入
        AnnoUtils.inject(this);
        mTextView.setText(hello yasin!);
        mTextView2.setText(hello yasin2!);
        mTextView3.setText(hello yasin3!);

    }
    @OnClick({R.id.id_tv_hello,R.id.id_tv_hello2,R.id.id_tv_hello3})
    public void onClick(View view){
        TextView tv= (TextView) view;
        Toast.makeText(this,tv.getText().toString(),Toast.LENGTH_SHORT).show();
    }
}

然后运行代码：

好啦～～～本节还是有点长啊，不过我们还是实现了我们的效果，我们一篇博客写下来，感觉注解太tm爽了，有木有？？？
但是呢？我们可以看到我们写的代码，其中的判断跟遍历很是很多的，与其这样一个一个找，还不如在activity中定义好都不用找，所以考虑到程序的性能等方面，还是不推荐大家使用注解的。
最后附上项目的github链接：

https://github.com/913453448/AnnotationDemo