TextView mTextView；
mTextView=(TextView) findViewById(R.id.mTextView);
mTextView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
});作为一名Android程序员，对于上面这种机械化的代码你一定写到想吐了，或许多数时候你只是copy ,paste,然后再改一改，完了你可能又会觉得这种代码毫无营养，写得实在没劲。俗话说：“不会偷懒的程序员不是好程序员”，今天我们就来探讨下如何偷懒。
到这里可能你已经知道我要说的是什么了，是的，我要说的就是android中的IOC框架，这类框架中比较早的有：Afinal，Xutils，目前开发者中呼声比较高的有Android Annotations，ButterKnife，Dagger，RoboGuice等。我在这里就简单介绍下比较有代表性的Android Annotations和ButterKnife。
什么是IOC？
Inversion of Control，英文缩写为IOC，字面翻译：控制反转。什么意思呢？就是一个类里面需要用到很多个成员变量，传统的写法，你要用这些成员变量，那么你就new 出来用呗！IOC的原则是：NO，我们不要new，这样耦合度太高，你配置个xml文件，里面标明哪个类，里面用了哪些成员变量，等待加载这个类的时候，我帮你注入（new）进去；当然了，你又会觉得，写个配置文件，卧槽，这多麻烦。于是乎，又出现了另一种方案，得~你嫌配置文件麻烦，那用注解呗~在你需要注入的成员变量上面加个注解，例如：@Inject，这样就行了，你总不能说这么个单词麻烦吧。当然了，有了配置文件和注解，那么怎么注入呢？其实就是把字符串类路径变成类么，这个时候需要用到反射。
什么是反射？
首先Java语言并不是一种动态编程语言，而为了使语言更灵活，JAVA引入了反射机制。 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
什么是注解？
JAVA1.5之后引入的注解和反射，注解的实现依赖于反射。JAVA中的注解是一种继承自接口java.lang.annotation.Annotation的特殊接口。那么接口怎么能够设置属性呢？简单来说就是JAVA通过动态代理的方式为你生成了一个实现了接口Annotation的实例，然后对该代理实例的属性赋值，这样就可以在程序运行时（如果将注解设置为运行时可见的话）通过反射获取到注解的配置信息。说的通俗一点，注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记。程序可以利用JAVA的反射机制来了解你的类及各种元素上有无何种标记，针对不同的标记，就去做相应的事件。标记可以加在包，类，方法，方法的参数以及成员变量上。
以上算是背景介绍吧，也正是基于以上需求和实现原理，一大波Android IOC框架应运而生。我们先来看第一个：Android Annotations。我们先比较下常规写法和Annotations写法的代码。
常规写法
先随便来一段吧~~
public class MainActivity extends Activity {
TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView) findViewById(R.id.text);
textView.setText("test");
textView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent = new Intent(this, ChildActivity.class);
startActivity(intent);
}
});
}
}Android Annotations写法
@EActivity(R.layout.activity_main)
public class MainActivity extends Activity {
@ViewById(R.id.text)
TextView textView;
@AfterViews
public void init() {
textView.setText("annotations test");
}
@Click(R.id.text)
void buttonClick() {
Intent intent = new Intent(this,ChildActivity_.class);
startActivity(intent);
}
}就是这么简单
Android Annotations就这么写？可能你会问，oncreat()去哪了，这可是执行入口，你又会担心setContentView()呢，布局怎么加载？看上面的代码第一行@EActivity(R.layout.activity_main)，就这一句全搞定，同时也不需要搞一大堆findViewById，不需要搞一大推setOnClickListener。Android Annotations能干的事可远不止这些，Http请求，开启线程，事件绑定等等都可以通过一个注解标记搞定。
其他语法举例
色值 @ColorRes
@ColorRes(R.color.backgroundColor)
int someColor;
@ColorRes
int backgroundColor;动画 @AnimationRes
@AnimationRes(R.anim.fadein)
XmlResourceParser xmlResAnim;
@AnimationRes
Animation fadein;自定义View @EViewGroup
@EViewGroup(R.layout.title_with_subtitle)
public class TitleWithSubtitle extends RelativeLayout {
@ViewById
protected TextView title, subtitle;
public TitleWithSubtitle(Context context, AttributeSet attrs) {
super(context, attrs);
}
public void setTexts(String titleText, String subTitleText) {
title.setText(titleText);
subtitle.setText(subTitleText);
}
}HttpClient @HttpsClient
@HttpsClient
HttpClient httpsClient;UiThread @UiThread
void myMethod() {
doInUiThread("hello", 100);
}
@UiThread
void doInUiThread(String aParam, long anotherParam) {
[...]
}怎么实现的？
Android Annotations的实现原理其实很简单。它会使用标准的Java注解处理工具自动添加一个额外的编译步骤生成的源代码。其实就是生成一个原有类的子类，这个子类才是真正运行用的类。例如上面代码使用@EActivity注解的MainActivity，将生成这个MainActivity的一个子类，它的名字是“MainActivity_”。该子类重载一些方法（例如onCreate（）），通过委托方式调用了activity的相关方法。所以这里有个大坑，所有Activity的相关操作都要操作其子类，例如 AndroidManifest.xml中类名要写成android:name=".MainActivity_"，开启MainActivity要写成 startActivity(new Intent(this, MainActivity_.class));下面是上文中AndroidAnnotations方式写法的MainActivity的子类MainActivity_，我贴出来大家随便感受下。
public final class MainActivity_
extends MainActivity
implements HasViews, OnViewChangedListener
{
private final OnViewChangedNotifier onViewChangedNotifier_ = new OnViewChangedNotifier();
@Override
public void onCreate(Bundle savedInstanceState) {
OnViewChangedNotifier previousNotifier = OnViewChangedNotifier.replaceNotifier(onViewChangedNotifier_);
init_(savedInstanceState);
super.onCreate(savedInstanceState);
OnViewChangedNotifier.replaceNotifier(previousNotifier);
setContentView(layout.activity_main);
}
private void init_(Bundle savedInstanceState) {
OnViewChangedNotifier.registerOnViewChangedListener(this);
}
@Override
public void setContentView(int layoutResID) {
super.setContentView(layoutResID);
onViewChangedNotifier_.notifyViewChanged(this);
}
@Override
public void setContentView(View view, LayoutParams params) {
super.setContentView(view, params);
onViewChangedNotifier_.notifyViewChanged(this);
}
@Override
public void setContentView(View view) {
super.setContentView(view);
onViewChangedNotifier_.notifyViewChanged(this);
}
public static MainActivity_.IntentBuilder_ intent(Context context) {
return new MainActivity_.IntentBuilder_(context);
}
public static MainActivity_.IntentBuilder_ intent(Fragment supportFragment) {
return new MainActivity_.IntentBuilder_(supportFragment);
}
@Override
public void onViewChanged(HasViews hasViews) {
textView = ((TextView) hasViews.findViewById(id.text));
if (textView!= null) {
textView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
MainActivity_.this.buttonClick();
}
}
);
}
init();
}
public static class IntentBuilder_
extends ActivityIntentBuilder<MainActivity_.IntentBuilder_>
{
private Fragment fragmentSupport_;
public IntentBuilder_(Context context) {
super(context, MainActivity_.class);
}
public IntentBuilder_(Fragment fragment) {
super(fragment.getActivity(), MainActivity_.class);
fragmentSupport_ = fragment;
}
@Override
public void startForResult(int requestCode) {
if (fragmentSupport_!= null) {
fragmentSupport_.startActivityForResult(intent, requestCode);
} else {
if (context instanceof Activity) {
Activity activity = ((Activity) context);
ActivityCompat.startActivityForResult(activity, intent, requestCode, lastOptions);
} else {
context.startActivity(intent);
}
}
}
}
}ButterKnife
再说说ButterKnife吧，其实原理和Android Annotations差不多，只是一些写法和细节上有略微差别，最主要一点是没有Android Annotations的坑，Android Studio上有个ButterKnife的插件，这个插件提供的炫酷技能几乎是一键搞定findViewById和setOnClickListener，基于此ButterKnife被很多开发者所推崇，我们还是简单对比下代码吧。
常规写法
public class MainActivity extends Activity {
TextView textView;
ListView listView;
ListViewAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView) findViewById(R.id.text);
listView = (ListView) findViewById(R.id.ListView);
textView.setText("test");
adapter = new ListViewAdapter(MainActivity.this);
listView.setAdapter(adapter);
textView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
text.setText("你点击了按钮");
}
});
}
class ListViewAdapter extends BaseAdapter {
private Context mContext;
public ListViewAdapter(Context context) {
mContext = context;
}
@Override
public int getCount() {
// TODO Auto-generated method stub
return 1000;
}
@Override
public Object getItem(int position) {
// TODO Auto-generated method stub
return position;
}
@Override
public long getItemId(int position) {
// TODO Auto-generated method stub
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
if (convertView == null) {
holder = new ViewHolder();
LayoutInflater layoutInflater = ((Activity) mContext)
.getLayoutInflater();
convertView = layoutInflater.inflate(R.layout.list_item,
parent, false);
holder.imageview = (ImageView) convertView
.findViewById(R.id.headshow);
holder.textview0 = (TextView) convertView
.findViewById(R.id.name);
holder.textview1 = (TextView) convertView
.findViewById(R.id.text);
convertView.setTag(convertView);
} else {
convertView = (View) convertView.getTag();
}
holder.textview0.setText("star");
holder.textview1.setText("test");
return convertView;
}
}
static class ViewHolder {
ImageView imageview;
TextView textview0;
TextView textview1;
}
}ButterKnife写法
public class MainActivity extends Activity {
@InjectView(R.id.text)
TextView text;
@InjectView(R.id.ListView)
ListView listView;
ListViewAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.inject(this);
adapter = new ListViewAdapter(MainActivity.this);
listView.setAdapter(adapter);
text.setText("ButterKnife test");
}
@OnClick(R.id.text)
void onClick() {
text.setText("你点击了按钮");
}
class ListViewAdapter extends BaseAdapter {
private Context mContext;
public ListViewAdapter(Context context) {
mContext = context;
}
@Override
public int getCount() {
// TODO Auto-generated method stub
return 1000;
}
@Override
public Object getItem(int position) {
// TODO Auto-generated method stub
return position;
}
@Override
public long getItemId(int position) {
// TODO Auto-generated method stub
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
if (convertView == null) {
LayoutInflater layoutInflater = ((Activity) mContext)
.getLayoutInflater();
convertView = layoutInflater.inflate(
R.layout.list_item, parent, false);
holder = new ViewHolder(convertView);
convertView.setTag(convertView);
} else {
convertView = (View) convertView.getTag();
}
holder.textview0.setText("butterknife");
holder.textview1.setText("test");
return convertView;
}
}
static class ViewHolder {
@InjectView(R.id.headshow)
ImageView imageview;
@InjectView(R.id.name)
TextView textview0;
@InjectView(R.id.text)
TextView textview1;
public ViewHolder(View view) {
ButterKnife.inject(this, view);
}
}
}整体写法与Android Annotations类似，实现原理上ButterKnife的实现也是在编译的过程中生成了另外一个类来帮我们完成一些基本操作，以上面的代码为例，生成了一个名为MainActivity
ButterKnife其他语法列举
资源注入
class ExampleActivity extends Activity {
@BindString(R.string.title) String title;
@BindDrawable(R.drawable.graphic) Drawable graphic;
@BindColor(R.color.red) int red;
@BindDimen(R.dimen.spacer) Float spacer;
// ...
}Fragment注入
public class FancyFragment extends Fragment {
@InjectView(R.id.button1) Button button1;
@InjectView(R.id.button2) Button button2;
@Override View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fancy_fragment, container, false);
ButterKnife.inject(this, view);
// TODO Use "injected" views...
return view;
}
}回调函数注入
// 带有 Button 参数
@OnClick(R.id.submit)
public void sayHi(Button button) {
button.setText("Hello!");
}
// 不带参数
@OnClick(R.id.submit)
public void submit() {
// TODO submit data to server...
}
// 同时注入多个 View 事件
@OnClick({ R.id.door1, R.id.door2, R.id.door3 })
public void pickDoor(DoorView door) {
if (door.hasPrizeBehind()) {
Toast.makeText(this, "You win!", LENGTH_SHORT).show();
} else {
Toast.makeText(this, "Try again", LENGTH_SHORT).show();
}
}性能如何
关于IOC框架的基本写法和实现原理，通过上面两个例子，相信大家都已经有所了解。但是前面已经说了IOC的注解机制是依赖JAVA的反射，可能很多开发者都会嗤之以鼻：反射会影响性能。在早期的JAVA语言中反射是会带来不小的性能消耗，而随着语言自身的进步和完善，到了现在情况有所好转。但我们移动设备的性能，不比后台服务器拥有充足的内存和运算能力。当大量的使用注解的时候，会不会对APP造成什么不良的影响，会不会影响到APP的执行性能？在这里先明确的声明，上述框架不会给APP带来任何副作用，相反它强大易用的api能为你带来前所未有的编程体验。
上述框架的实现，都是通过使用jdk 1.6引入的JavaAnnotation Processing Tool，在编译器中加了一层额外的自动编译步骤，用来生成基于你源码的代码。运行期运行的其实就是这个二次编译的代码，实际上反射注解这一过程是在编译期完成的，而并不会影响Runtime。所以上述IOC框架并不会影响到APP得性能。简单的做了几组测试，分别用Android Annotations，ButterKnife，以及常规写法写了同样实现的代码，然后打印代码执行时间。每组大概跑200次，然后计算代码执行的平均耗时，发现三组数据基本是在同一个水平上，并不能判断孰优孰劣。
IDE集成方法
不管是Eclipse还是Android Studio都可以很方便的集成上述框架，而且资源包很小，具体方法大家网上找一找，我就不再列出具体步骤了。从网上偷了张ButterKnife的插件技能图，大家随便感受下。
既然此类框架如此炫酷高效，那么我们是否应该大肆推崇，广泛采用呢。这个具体还是根据自己的项目实际情况来定吧，据我小范围了解，目前部分大厂出品的部分应用并未采用此类框架，最后我们还是来看看此类框架的优缺点吧。
在Android中使用IOC框架让代码更清爽
控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对角编程的法则来削减计算机程序的耦合问题，也是轻量级的spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。
通俗点讲什么是IOC呢？
很久很久以前，我们创建某件物品都是用双手在流水线上创建的，当我们有了机器后，这个机器就替代了人，帮助人创造物品，这个过程倒置了反转。在Android中，你获取控件，都需要自己手动获取，那么反转过来顾名思义就是程序自动获取控件。
相信在系统学习过Java Web的Spring框架的人对IOC应该一点也不陌生，那你们知道在android中怎么应用吗，这可能设及的知识有点多，包括反射，Java注解类，设计模式之代理模式等知识。下面我将演示怎么运行IOC来获取控件，设置回调方法的应用。
1.在Android中获取控件
我们知道，Android手机界面的所有布局都配置在资源文件XML中，如果想要获取某个布局，一般情况下，我们是使用如下方法获取的：
setContentView(R.layout.activity_main);
现在我们来颠覆你对这个的应用，下面来看看应用IOC框架是怎么获取这个应用的。
①首先我们创建我们的注解类ContentView。
在Android Studio的创建流程如下：
㈠点击包名创建类
㈡选中注解类并创建
㈢与一个方法，获取等下传进来的ID
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface ContentView { int value(); }
@Target表示注解可以用于什么地方，这里用于类，其他参数如：FILED(成员)，METHOD(方法)，PACKAGE(包)，ANNOTATION_TYPE（注解的注解），CONSTRUCTOR（构造函数），PARAMETER（参数），LOCAL_VARIABLE（局部变更）
@Retention什么时候加载注解类，一般都是RetentionPolicy.RUNTIME运行的时候。
②新建一个注入工具类InjectUtils.class：
public class InjectUtils { public static final String ACTIVITY_MAIN_CONTENTVIEW="setContentView"; /** * 注入所有 * @param activity */ public static void injectAll(Activity activity){ injectContentView(activity); } /** * 注入ContentView * @param activity */ public static void injectContentView(Activity activity){ Class<? extends Activity> clazz = activity.getClass();//获取该类信息 ContentView contentView = clazz.getAnnotation(ContentView.class);//获取该类ContentView的注解 //如果有注解 if(contentView!=null){ int viewId=contentView.value();//获取注解类参数 try { Method method=clazz.getMethod(ACTIVITY_MAIN_CONTENTVIEW,int.class);//获取该方法的信息 method.setAccessible(true);//获取该方法的访问权限 method.invoke(activity,viewId);//调用该方法的，并设置该方法参数 } catch (Exception e) { e.printStackTrace(); } } } }
注解虽然详细，有可能不写点，有的人理解method.invoke有点困难。下面我来解释一下。
method.invoke(activity,viewId);你可能这样理解，activity调用了method设置了viewID，如果还不够形象，看方法下面：
setContentView.invoke(MainActivity.this,R.layout.activity_main)这样虽然不伦不类，但是你应该理解了，就是invoke的第一个参数调用method方法，该方法的参数就是invoke的第二个参数。
获取注解类的参数，如下代码中：
@ContentView(R.layout.activity_main) public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); InjectUtils.injectAll(MainActivity.this); } }
@ContentView(R.layout.activity_main)中的R.layout.activity_main的值。然后用调用工具类调用设置其setContentView方法，这样布局文件就加载进来了。
运行后得到如下图所示：
2.用IOC加载控件
相信大家加载控件的方法，基本上都是千篇一律，如下所示：
this.but=(Button)findViewById(R.id.but);
假如现在有N个控件，估计你整个屏幕都被控件包围，写其他代码还需要滑动滚动条。这样是不是重复劳动是不是不值得？
下面我们来使用IOC框架来获取控件。
①创建注解类InjectControl，代码如下：
@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface InjectControl { int value(); }
相信经过上面的介绍，这个很容易理解。
②在MainActivity配置注解类。
代码如下：
@InjectControl(value = R.id.content) private TextView content; @InjectControl(value = R.id.myBut1) private Button myBut1; @InjectControl(value = R.id.myBut2) private Button myBut2;
③最后就是注入所有控件。
代码在InjectUtils中，如下：
public static final String ACTIVITY_MAIN_FINDVIEWBYID="findViewById"; /** *注入控件 * @param activity */ public static void injectControl(Activity activity){ Class<? extends Activity> clazz = activity.getClass();//获取该类信息 Field[] fields=clazz.getDeclaredFields();//获致所有成员变更 for (Field field:fields) { InjectControl injectControl = field.getAnnotation(InjectControl.class); if(injectControl!=null){ int viewId=injectControl.value(); try { Method method=clazz.getMethod(ACTIVITY_MAIN_FINDVIEWBYID, int.class); method.setAccessible(true); field.setAccessible(true); Object object=method.invoke(activity, viewId); field.set(activity,object); } catch (Exception e) { e.printStackTrace(); } } } }
这里几点需要解释一下，为什么用getDeclaredFields()获取成员变更，不用getFields()，因为getFields只能获取类中公有的成员变量，如果要获取包括私有的成员变量，就需要使用上面的方法，而我们定义的都是私有，故必须使用该方法，
这里调用了再次invoke的方法，一次是方法调用的，一次是成员变量调用的，为什么这样设计，因为，这里必须用二步才能完成。
我们就算直接调用findViewById也是两步，首先我们要调用this.findViewById()等到View后才赋值给某个变量，虽然看上去只有一条语句，但是却是两个部分。同理，我们必须调用activity.findViewById()方法获取到View后，才能把View赋值给field。所以这里有两步。
为了验证代码，我在MainActivity的onCreate()方法里面加入了如下代码：
if(myBut1!=null && myBut2!=null){ Toast.makeText(this,"按钮已经获取到了",Toast.LENGTH_SHORT).show(); }
运行结果如下：
其他的上面的解释了，这里就不在叙述了。下面难点来了。
3.给按钮设置点击监听事件
平常我们给按钮设置监听事件的代码如下：
this.myBut2.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { } });
马上颠覆你的所见，步骤如下：
①创建注解类InjectOnClick。
代码如下：
@Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface InjectOnClick { int[] value(); }
你会发现，少了什么对吗？没错，接口类型，需要实现的方法，以及要调用设置的方法，这就需要下面第二步。
②设置注解类的注解类OnClickEvent。
代码如下：
@Target(ElementType.ANNOTATION_TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface OnClickEvent { Class<?> listenerType();//接口类型 String listenerSetter();//设置的方法 String methodName();//接口里面要实现的方法 }
修改InjectOnClick:
@Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @OnClickEvent(listenerType = View.OnClickListener.class,listenerSetter = "setOnClickListener",methodName = "onClick") public @interface InjectOnClick { int[] value(); }
③在MainActivity里设置注解。
代码如下：
@InjectOnClick({R.id.myBut1,R.id.myBut2}) public void setButtonOnClickListener(View view){ switch (view.getId()){ case R.id.myBut1: Toast.makeText(this,"你好",Toast.LENGTH_SHORT).show(); break; case R.id.myBut2: Toast.makeText(this,"我很帅",Toast.LENGTH_SHORT).show(); break; default: break; } }
④注入点击事件
代码在InjectUtils中，如下：
/** * 注入点击事件 * @param activity */ public static void injectOnClickListener(Activity activity){ Class<? extends Activity> clazz = activity.getClass(); Method[] methods= clazz.getMethods();//获取所有声明为公有的方法 for (Method method:methods){//遍历所有公有方法 Annotation[] annotations = method.getAnnotations();//获取该公有方法的所有注解 for (Annotation annotation:annotations){//遍历所有注解 Class<? extends Annotation> annotationType = annotation.annotationType();//获取具体的注解类 OnClickEvent onClickEvent = annotationType.getAnnotation(OnClickEvent.class);//取出注解的onClickEvent注解 if(onClickEvent!=null){//如果不为空 try { Method valueMethod=annotationType.getDeclaredMethod("value");//获取注解InjectOnClick的value方法 int[] viewIds= (int[]) valueMethod.invoke(annotation,null);//获取控件值 Class<?> listenerType = onClickEvent.listenerType();//获取接口类型 String listenerSetter = onClickEvent.listenerSetter();//获取set方法 String methodName = onClickEvent.methodName();//获取接口需要实现的方法 MyInvocationHandler handler=new MyInvocationHandler(activity);//自己实现的代码，负责调用 handler.setMethodMap(methodName,method);//设置方法及设置方法 Object object= Proxy.newProxyInstance(listenerType.getClassLoader(),new Class<?>[]{listenerType},handler);//创建动态代理对象类 for (int viewId:viewIds){//遍历要设置监听的控件 View view=activity.findViewById(viewId);//获取该控件 Method m=view.getClass().getMethod(listenerSetter, listenerType);//获取方法 m.invoke(view,object);//调用方法 } } catch (Exception e) { e.printStackTrace(); } } } } }
虽然注解很详细，但还是有必要说明一下：
㈠关于因为我们用的是Java的动态代理，每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法invoke方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指代我们所代理的那个真实对象
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
㈡Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是newProxyInstance这个方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
㈢getFields()与getDeclaredFields()区别:getFields()只能访问类中声明为公有的字段,私有的字段它无法访问，能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关，不能访问从其它类继承来的方法
getMethods()与getDeclaredMethods()区别:getMethods()只能访问类中声明为公有的方法,私有的方法它无法访问,能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关,不能访问从其它类继承来的方法
我们实现的InvocationHandler接口，代码如下：
public class MyInvocationHandler implements InvocationHandler { private Object object; private Map<String, Method> methodMap = new HashMap<String, Method>(1); public MyInvocationHandler(Object object) { this.object = object; } public void setMethodMap(String name, Method method) { this.methodMap.put(name, method); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (object != null) { String name = method.getName(); method= this.methodMap.get(name); if (method != null) { return method.invoke(object, args); } } return null; } }
这就不用我过多的注释了，因为，大部分代码与前面的并无不同，代理顾名思义就是帮你调用一些方法。
其代码难点就在这个代理里面，其他的代码与上面获取布局，控件一样，唯一不同的是这个代码用到了注释的注释，嵌套层级有点多，所以用到了许两层For循环，时间复杂度可能增加一个数量级，但这在手机上也是可以忽略不计的。
把方法加入InjectUtils的injectAll中。
/** * 注入所有 * @param activity */ public static void injectAll(Activity activity){ injectContentView(activity); injectControl(activity); injectOnClickListener(activity); }
运行效果如下：
4.看一下代码有多简洁
代码如下：
@ContentView(R.layout.activity_main) public class MainActivity extends AppCompatActivity { @InjectControl(value = R.id.content) private TextView content; @InjectControl(value = R.id.myBut1) private Button myBut1; @InjectControl(value = R.id.myBut2) private Button myBut2; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); InjectUtils.injectAll(MainActivity.this); } @InjectOnClick({R.id.myBut1,R.id.myBut2}) public void setButtonOnClickListener(View view){ switch (view.getId()){ case R.id.myBut1: Toast.makeText(this,"你好",Toast.LENGTH_SHORT).show(); break; case R.id.myBut2: Toast.makeText(this,"我很帅",Toast.LENGTH_SHORT).show(); break; default: break; } } }
可能有的人会问，我用一句findViewById或者一句setOnClickListener就可以解决的事，没事给自己找这复杂的代码写，我是不是有病啊。可是你忽略了一点，一但我将这个代码打包，这代码就可能复用到我所有的项目中，如果，你只开发小项目或一个项目，这样写确实不划算，但是如果你总是换项目就算不换，增加新界面的时候，总是需要写findViewById,那么当累计的一定的数量时，这样写是一定节省很多时间的。
147
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
