Android Butterknife浅分析

最新推荐文章于 2022-07-29 08:24:15 发布
最新推荐文章于 2022-07-29 08:24:15 发布
阅读量932 收藏
点赞数
分类专栏： Android 技能整理 保存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013062469/article/details/52036702
版权

今天很顺利的完成了公司的任务，干嘛呢，当然是写写代码看看书了。

发现个问题，一个APP中很多次的使用了一段代码，而且这行代码还非常不好省略，这个就是findViewId()和onClick，一个app肯定有界面和按钮，有见面就有控件，有控件就有点击需求，而有这些需求和控件就必须要在Activity或者Fragment中使用这段findViewId()和onClick()，真是太烦了，现在github上大神那么多，去看看有什么好的解决办法呗。

首先我发现了thinkAndroid这个框架，这是个很好的框架，集成了很多的模块：

  • MVC模块：实现了视图和模型的分离，当然不用说
  • IOC模块：这个就是我们所需要的，下面我们会认真的去看下这个模块，他们的github上的介绍是说：完全注解方式就可以进行UI的绑定，res中的资源的读取，以及对象的初始化。
  • http模块：通过httpclient进行封装http数据请求，支持异步和同步方式加载。呃呃呃，这个什么情况，现在的Android studio上已经不支持httpclient了，要与时俱进啊大神...
  • 缓存模块：通过简单的配置及设计可以很好的实现缓存，对缓存可以随意的配置
  • 图片缓存模块：imageview加载图片的时候无需考虑图片加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象。
  • 配置器模块：可以对简易的实现配对配置的操作，目前配置文件可以支持Preference、Properties对配置进行存取。
  • 日志打印模块：可以较快的轻易的是实现日志打印，支持日志打印的扩展，目前支持对sdcard写入本地打印、以及控制台打印
  • 下载器模块:可以简单的实现多线程下载、后台下载、断点续传、对下载进行控制、如开始、暂停、删除等等。
  • 网络状态检测模块：当网络状态改变时，对其进行检测。

模块很多，上面这个东西是从他们的github上复制过来的，其他的我们不说，先看看所谓了ioc模块：

又给出例子：

    @TAInject 
    Entity entity; //目前只能对无参构造函数进行初始化
    @@TAInject(id=R.string.app_name)
    String appNameString;
    @TAInjectResource(id=R.attr.test)
    int[] test; 
    @TAInjectView(id=R.id.add);
    Button addButton;
我们分析代码可以看到这个框架是通过@TAInjectView来快速初始化控件的。

看下@TAInjectView的代码：

package com.ta.annotation;

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TAInjectView
{
	/** View的ID */
	public int id() default -1;

	/** View的单击事件 */
	public String click() default "";

	/** View的长按键事件 */
	public String longClick() default "";

	/** View的焦点改变事件 */
	public String focuschange() default "";

	/** View的手机键盘事件 */
	public String key() default "";

	/** View的触摸事件 */
	public String Touch() default "";
}

是一个注解类用RetentionPloicy.RUNTIME做修饰，而且制定了修饰的类别Field，在这里看到大神很贴心的贴上了注释，几乎包含了控件的所有操作，很是方便，看下下面这行代码：

package com.ta.util;

import java.lang.reflect.Field;

import com.ta.annotation.TAInject;
import com.ta.annotation.TAInjectResource;
import com.ta.annotation.TAInjectView;

import android.app.Activity;
import android.content.res.Resources;

public class TAInjector
{
	private static TAInjector instance;

	private TAInjector()
	{

	}

	public static TAInjector getInstance()
	{
		if (instance == null)
		{
			instance = new TAInjector();
		}
		return instance;
	}

	public void inJectAll(Activity activity)
	{
		// TODO Auto-generated method stub
		Field[] fields = activity.getClass().getDeclaredFields();
		if (fields != null && fields.length > 0)
		{
			for (Field field : fields)
			{
				if (field.isAnnotationPresent(TAInjectView.class))
				{
					injectView(activity, field);
				} else if (field.isAnnotationPresent(TAInjectResource.class))
				{
					injectResource(activity, field);
				} else if (field.isAnnotationPresent(TAInject.class))
				{
					inject(activity, field);
				}
			}
		}
	}

	private void inject(Activity activity, Field field)
	{
		// TODO Auto-generated method stub
		try
		{
			field.setAccessible(true);
			field.set(activity, field.getType().newInstance());
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}

	private void injectView(Activity activity, Field field)
	{
		// TODO Auto-generated method stub
		if (field.isAnnotationPresent(TAInjectView.class))
		{
			TAInjectView viewInject = field.getAnnotation(TAInjectView.class);
			int viewId = viewInject.id();
			try
			{
				field.setAccessible(true);
				field.set(activity, activity.findViewById(viewId));
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}
	}

	private void injectResource(Activity activity, Field field)
	{
		// TODO Auto-generated method stub
		if (field.isAnnotationPresent(TAInjectResource.class))
		{
			TAInjectResource resourceJect = field
					.getAnnotation(TAInjectResource.class);
			int resourceID = resourceJect.id();
			try
			{
				field.setAccessible(true);
				Resources resources = activity.getResources();
				String type = resources.getResourceTypeName(resourceID);
				if (type.equalsIgnoreCase("string"))
				{
					field.set(activity,
							activity.getResources().getString(resourceID));
				} else if (type.equalsIgnoreCase("drawable"))
				{
					field.set(activity,
							activity.getResources().getDrawable(resourceID));
				} else if (type.equalsIgnoreCase("layout"))
				{
					field.set(activity,
							activity.getResources().getLayout(resourceID));
				} else if (type.equalsIgnoreCase("array"))
				{
					if (field.getType().equals(int[].class))
					{
						field.set(activity, activity.getResources()
								.getIntArray(resourceID));
					} else if (field.getType().equals(String[].class))
					{
						field.set(activity, activity.getResources()
								.getStringArray(resourceID));
					} else
					{
						field.set(activity, activity.getResources()
								.getStringArray(resourceID));
					}

				} else if (type.equalsIgnoreCase("color"))
				{
					if (field.getType().equals(Integer.TYPE))
					{
						field.set(activity,
								activity.getResources().getColor(resourceID));
					} else
					{
						field.set(activity, activity.getResources()
								.getColorStateList(resourceID));
					}

				}
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}
	}

	public void inject(Activity activity)
	{
		// TODO Auto-generated method stub
		Field[] fields = activity.getClass().getDeclaredFields();
		if (fields != null && fields.length > 0)
		{
			for (Field field : fields)
			{
				if (field.isAnnotationPresent(TAInject.class))
				{
					inject(activity, field);
				}
			}
		}
	}

	public void injectView(Activity activity)
	{
		// TODO Auto-generated method stub
		Field[] fields = activity.getClass().getDeclaredFields();
		if (fields != null && fields.length > 0)
		{
			for (Field field : fields)
			{
				if (field.isAnnotationPresent(TAInjectView.class))
				{
					injectView(activity, field);
				}
			}
		}
	}

	public void injectResource(Activity activity)
	{
		// TODO Auto-generated method stub
		Field[] fields = activity.getClass().getDeclaredFields();
		if (fields != null && fields.length > 0)
		{
			for (Field field : fields)
			{
				if (field.isAnnotationPresent(TAInjectResource.class))
				{
					injectResource(activity, field);
				}
			}
		}
	}

}
这才是具体让findViewId()消失的类，一模了然的类，是一个单例模式，里面injectView，injectResource来实现具体的方法，代码不是很难理解，我就不对说了。

这个框架其实很不错的，但是看情况大神好像已经不更新这个框架了，只能放弃，看下代码好了，学学大神思路也是进步。

上面已经把大神的github给出了，有兴趣的可以点击进去看看。

看完这个之后我又开始找已经在Android studio上更新了的框架，发现了这个：Butterknife来自JakeWharton大神。

看下这个框架的实现代码：

class ExampleActivity extends Activity {
  @BindView(R.id.user) EditText username;
  @BindView(R.id.pass) EditText password;

  @BindString(R.string.login_error) String loginErrorMessage;

  @OnClick(R.id.submit) void submit() {
    // TODO call server...
  }

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
    ButterKnife.bind(this);
    // TODO Use fields...
  }
}

看到这个我就想，这就是我要找的框架。

我们接下来去分析这个的实现方法看下这个框架的代码结构：

额，很复杂的样子，看下onBindView之类的类在哪，去看下，

我们在butterknife-annotations模块找到了他们，分的非常仔细，看到名字就可以知道这个类是做什么的。我们首先找个典型的例子看下，BindView，上面的代码中表示这个类主要的是初始化控件的，我们看下这个代码：

package butterknife;

import android.support.annotation.IdRes;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.CLASS;

/**
 * Bind a field to the view for the specified ID. The view will automatically be cast to the field
 * type.
 * <pre><code>
 * {@literal @}BindView(R.id.title) TextView title;
 * </code></pre>
 */
@Retention(CLASS) @Target(FIELD)
public @interface BindView {
  /** View ID to which the field will be bound. */
  @IdRes int value();
}

不是很难哦，设置的保留策略为Class，注解用于Field上。传入一个IdRes，并且直接以value的形式进行设置。看下注解处理器的实现： 

<pre name="code" class="java">package butterknife.compiler;

@AutoService(Processor.class)
public final class ButterKnifeProcessor extends AbstractProcessor {
  static final Id NO_ID = new Id(-1);
  static final String VIEW_TYPE = "android.view.View";
  private static final String COLOR_STATE_LIST_TYPE = "android.content.res.ColorStateList";
  private static final String BITMAP_TYPE = "android.graphics.Bitmap";
  private static final String DRAWABLE_TYPE = "android.graphics.drawable.Drawable";
  private static final String TYPED_ARRAY_TYPE = "android.content.res.TypedArray";
  private static final String NULLABLE_ANNOTATION_NAME = "Nullable";
  private static final String STRING_TYPE = "java.lang.String";
  private static final String LIST_TYPE = List.class.getCanonicalName();
  private static final String R = "R";
  private static final List<Class<? extends Annotation>> LISTENERS = Arrays.asList(//
      OnCheckedChanged.class, //
      OnClick.class, //
      OnEditorAction.class, //
      OnFocusChange.class, //
      OnItemClick.class, //
      OnItemLongClick.class, //
      OnItemSelected.class, //
      OnLongClick.class, //
      OnPageChange.class, //
      OnTextChanged.class, //
      OnTouch.class //
  );

  private static final List<String> SUPPORTED_TYPES = Arrays.asList(
      "array", "attr", "bool", "color", "dimen", "drawable", "id", "integer", "string"
  );

  private Elements elementUtils;
  private Types typeUtils;
  private Filer filer;
  private Trees trees;

  private final Map<Integer, Id> symbols = new LinkedHashMap<>();

  @Override public synchronized void init(ProcessingEnvironment env) {
    super.init(env);

    elementUtils = env.getElementUtils();
    typeUtils = env.getTypeUtils();
    filer = env.getFiler();
    trees = Trees.instance(processingEnv);
  }

  @Override public Set<String> getSupportedAnnotationTypes() {
    Set<String> types = new LinkedHashSet<>();
    for (Class<? extends Annotation> annotation : getSupportedAnnotations()) {
      types.add(annotation.getCanonicalName());
    }
    return types;
  }

  private Set<Class<? extends Annotation>> getSupportedAnnotations() {
    Set<Class<? extends Annotation>> annotations = new LinkedHashSet<>();

    annotations.add(BindArray.class);
    annotations.add(BindBitmap.class);
    annotations.add(BindBool.class);
    annotations.add(BindColor.class);
    annotations.add(BindDimen.class);
    annotations.add(BindDrawable.class);
    annotations.add(BindInt.class);
    annotations.add(BindString.class);
    annotations.add(BindView.class);
    annotations.add(BindViews.class);
    annotations.addAll(LISTENERS);

    return annotations;
  }

  @Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
    //BindingClass类对象，代表生成代理类的信息
    //Map<>集合代理类对象集合
    Map<TypeElement, BindingClass> targetClassMap = findAndParseTargets(env);

    //生成代理类
    for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
      TypeElement typeElement = entry.getKey();
      BindingClass bindingClass = entry.getValue();

      for (JavaFile javaFile : bindingClass.brewJava()) {
        try {
          javaFile.writeTo(filer);
        } catch (IOException e) {
          error(typeElement, "Unable to write view binder for type %s: %s", typeElement,
              e.getMessage());
        }
      }
    }

    return true;
  }

  private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment env) {
    Map<TypeElement, BindingClass> targetClassMap = new LinkedHashMap<>();
    Set<TypeElement> erasedTargetNames = new LinkedHashSet<>();

    scanForRClasses(env);

    //通过getElementsAnnotatedWith拿到我们注解的每个元素，返回值为Map<>集合
    for (Element element : env.getElementsAnnotatedWith(BindArray.class)) {
      if (!SuperficialValidation.validateElement(element)) continue;
      try {
        parseResourceArray(element, targetClassMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindArray.class, e);
      }
    }
   //代码省略
    return targetClassMap;
  }
  //代码省略
}


 

 

代码很长只留核心代码，其他省略
 
 

嗯哼，一般的写法，继承了AbstractProcessor，并实现了public synchronized void init(ProcessingEnvironment env)，@Override public Set<String> getSupportedAnnotationTypes()  和private Set<Class<? extends Annotation>> getSupportedAnnotations()函数，在这些函数里，主要是将BindView之类的注解和注解处理器连接，一般情况下，这些函数的实现是通用的，主要是返回注解类型，返回源码版本，和初始化辅助类。处理器中还有一个非常重要的函数需要我们的实现：process()，这是核心，在我们的知道的process()函数的实现复杂有简单，其实就实现了两个功能而已：
 

 

  • 收集代理类信息使用的是getElementsAnnotatedWith函数 。返回代理类集合。
     
  • 生成咱们在使用BindView之后编译生成的代理类，想上面的例子，在MainActivity中的，我们会生成一个MainActivity_ViewBinder和MainActivity_ViewBining代理类，在Android studio的build文件夹下可以很清楚的看到这个类的存在.
 

上面的BindingClass类为生成java类的方法，通过收集到的信息，拼接完成代理类对象。
 

完成代理类对象之后，提供一个api供用户调用，ButterKnife的实现API为ButterKnife类，看下代码：
 

 

package butterknife;

public final class ButterKnife {

  //代码省略
  //传入当前对象，不管是Activity，fragment或者dialog全都行，寻找代理类
  @NonNull @UiThread
  public static Unbinder bind(@NonNull Activity target) {
    return getViewBinder(target).bind(Finder.ACTIVITY, target, target);
  }

 //代码省略
  //强制转换接口为统一接口，并调用接口提供的方法。
  @NonNull @CheckResult @UiThread
  static ViewBinder<Object> getViewBinder(@NonNull Object target) {
    Class<?> targetClass = target.getClass();
    if (debug) Log.d(TAG, "Looking up view binder for " + targetClass.getName());
    return findViewBinderForClass(targetClass);
  }

  @NonNull @CheckResult @UiThread
  private static ViewBinder<Object> findViewBinderForClass(Class<?> cls) {
    ViewBinder<Object> viewBinder = BINDERS.get(cls);
    if (viewBinder != null) {
      if (debug) Log.d(TAG, "HIT: Cached in view binder map.");
      return viewBinder;
    }
    String clsName = cls.getName();
    if (clsName.startsWith("android.") || clsName.startsWith("java.")) {
      if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
      return NOP_VIEW_BINDER;
    }
    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
    try {
      Class<?> viewBindingClass = Class.forName(clsName + "_ViewBinder");
      //noinspection unchecked
      viewBinder = (ViewBinder<Object>) viewBindingClass.newInstance();
      if (debug) Log.d(TAG, "HIT: Loaded view binder class.");
    } catch (ClassNotFoundException e) {
      if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
      viewBinder = findViewBinderForClass(cls.getSuperclass());
    } catch (InstantiationException e) {
      throw new RuntimeException("Unable to create view binder for " + clsName, e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException("Unable to create view binder for " + clsName, e);
    }
    BINDERS.put(cls, viewBinder);
    return viewBinder;
  }

  //代码省略
  /** Simpler version of {@link View#findViewById(int)} which infers the target type. */
  @SuppressWarnings({ "unchecked", "UnusedDeclaration" }) // Checked by runtime cast. Public API.
  @CheckResult
  public static <T extends View> T findById(@NonNull View view, @IdRes int id) {
    return (T) view.findViewById(id);
  }

  /** Simpler version of {@link Activity#findViewById(int)} which infers the target type. */
  @SuppressWarnings({ "unchecked", "UnusedDeclaration" }) // Checked by runtime cast. Public API.
  @CheckResult
  public static <T extends View> T findById(@NonNull Activity activity, @IdRes int id) {
    return (T) activity.findViewById(id);
  }

  /** Simpler version of {@link Dialog#findViewById(int)} which infers the target type. */
  @SuppressWarnings({ "unchecked", "UnusedDeclaration" }) // Checked by runtime cast. Public API.
  @CheckResult
  public static <T extends View> T findById(@NonNull Dialog dialog, @IdRes int id) {
    return (T) dialog.findViewById(id);
  }
}

 

 这个类中主要做了两件事情： 

 

  • 传入当前对象，不管是Activity，fragment或者dialog全都行，寻找我们刚才生成的代理类
  • 强制转换接口为统一接口，并调用接口提供的方法。
 

至此，一个简化版的findViewById就算是完成了，可以省略代码写控件初始化了。。。。
 
 


 
 


 
 


 
 


 
 


 

                

        

        

    

  


    

      

        

            

              
                
                  鲨鱼丶
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android 一篇讲完Crash治理之OOM及内存检测工具

				
			

			

				

					csdn_aiyang的博客
				

				

					04-03
					
					3632
					
				

			

		

		

			
				
系列推荐：

Android性能优化（一）闪退治理、卡顿优化、耗电优化、APK瘦身

Android 性能优化（二）Handler运行机制原理，源码分析

Android 性能优化（三）认识错误Error和异常Exception及栈轨迹StackTrace

Android 性能优化（四）Crash治理之路，UncaughtException

前言


性能优化第一篇中的Crash治理说过：...

			
		

	



                

              
                



	

		

			

				
					
2020年百度、阿里、腾讯、字节跳动Android高频面试题解析.pdf

				
			

			

				

					09-02
				

			

		

		

			
				
Android 开源库源码分析可以帮助理解常用库的工作原理，如 Retrofit、RxBinding、ButterKnife 等。设计模式汇总，如单例、工厂、观察者、代理等，是面试者必须掌握的软件设计原则。Gradle 是 Android 的构建工具，...

			
		

	



                


  
              

                


	

		

			

				
					
Android-ButterKnife-Injections.jar

				
			

			

				

					12-08
				

			

		

		

			
				
Aandroid Studio 4.1 ButterKnife 兼容方案
MAC：下载jar包，粘贴至 "~/Applications/Android Studio.app/Contents/plugins" 路径下，重启 AS 即可。
Windows：下载jar包，粘贴至 "C:\Users\username\AppData\Roaming\Google\AndroidStudio4.1\plugins" 路径下，重启 AS 即可。
清除报错：删除 ~/Library/Application Support/Google/AndroidStudio4.1/plugins 下报错的插件。

			
		

	





	

		

			

				
					
Android Butterknife（黄油刀） 使用方法总结

					
热门推荐

				
			

			

				

					Sahara_Savage
				

				

					09-07
					
					8万+
					
				

			

		

		

			
				
转载请标明出处：http://blog.csdn.net/donkor_/article/details/77879630

前言： 
ButterKnife是一个专注于Android系统的View注入框架,以前总是要写很多findViewById来找到View对象，有了ButterKnife可以很轻松的省去这些步骤。是大神JakeWharton的力作，目前使用很广。最重要的一点，使用Butter...

			
		

	



		

			
		



	

		

			

				
					
android之ButterKnife

				
			

			

				

					weixin_44575660的博客
				

				

					04-28
					
					383
					
				

			

		

		

			
				
简介
Bufferknife是注解中相对简单易懂的很不错的开源框架

（1）强大的View绑定和Click事件处理功能，简化代码，提高开发效率
（2）方便的处理Adapter里的ViewHolder绑定问题
（3）运行时不会影响APP效率，实用配置方便
（4）代码清晰，可读性强
下载插件
1、双击shift键打开，搜索框，输入plugins，点击打开
2、在搜索框输入ButterKnife搜索，找...

			
		

	





	

		

			

				
					
Android--Butterknife

				
			

			

				

					Sim的博客
				

				

					07-14
					
					237
					
				

			

		

		

			
				
1 简介
ButterKnife是一个专注于Android系统的View注入框架（Github地址）。
以前总是要写很多findViewById来找到View对象，有了ButterKnife可以很轻松的省去这些步骤。是大神JakeWharton的力作，目前使用很广。
使用ButterKnife对性能基本没有损失，因为ButterKnife用到的注解并不是在运行时反射的，而是在编译的时候生成新的class。
项目集成起来也是特别方便，使用起来也是特别简单。



2 依赖和混淆规则
implementatio

			
		

	





	

		

			

				
					
Android - Butterknife

				
			

			

				

					金溪的博客
				

				

					10-23
					
					261
					
				

			

		

		

			
				
概述

ButterKnife是一个专专注于Android系统的View注入框架，使用ButterKnife对性能基本没有损失，因为ButterKnife用到的注解并不是在运行时反射的，而是在编译的时候生成新的class.

ButterKnife的注册与绑定

1、在Activity中绑定ButterKnife

由于每次都要在Activity中的onCreate绑定Activity，所以个人建...

			
		

	





	

		

			

				
					
sundy深入浅出部分源码 、android

				
			

			

				

					03-04
				

			

		

		

			
				
【标题】"sundy深入浅出部分源码 、android" 涉及的知识点主要集中在Android开发和源码分析两个领域，Sundy大师的教程是这个主题的关键资源。在这个教程中，Sundy可能深入讲解了Android应用开发的核心概念和技术，...

			
		

	





	

		

			

				
					
android studio cookbook

				
			

			

				

					11-26
				

			

		

		

			
				
 - **插件安装与使用**：推荐并介绍一些实用的Android Studio插件，如Lombok、 ButterKnife Zelezny等。  - **快捷键设置**：掌握常用的快捷键，提高开发效率。  7. **热修复与即时运行**  - **Instant Run**：实时...

			
		

	





	

		

			

				
					
Android butterknife

				
			

			

				

					明耀的博客
				

				

					11-26
					
					213
					
				

			

		

		

			
				
buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.1"
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'

        // NOTE: Do not place your app

			
		

	





	

		

			

				
					
Android-ButterKnife-Plugin-Plus.jar（兼容idea、AndroidStudio 4.x）

				
			

			

				

					03-11
				

			

		

		

			
				
用于从活动/片段/适配器中的选定布局XML生成ButterKnife注入的插件。
添加基于Android ButterKnife Zelezny（版本1.6.0-SNAPSHOT）的一些新功能。

			
		

	





	

		

			

				
					
Android使用ButterKnife

				
			

			

				

					好女绪的博客
				

				

					12-26
					
					316
					
				

			

		

		

			
				
Android使用ButterKnife
参考资料：

Android Butterknife使用方法总结
Android Studio3.0更新之路（遇坑必入）
AndroidStudio3.1.2 报错：Could not get unknown property ‘packageForR’ for task ':app:processDebugResour
ButterKnife官方文档

...

			
		

	





	

		

			

				
					
Android:butterKnife(黄油刀的简单使用

				
			

			

				

					qq_54348654的博客
				

				

					07-29
					
					1028
					
				

			

		

		

			
				
butterKnife（黄油刀的简单使用

			
		

	





	

		

			

				
					
安卓“小试牛刀”：ButterKnife——牛油刀

				
			

			

				

					m0_46579394的博客
				

				

					03-24
					
					5301
					
				

			

		

		

			
				
android牛油刀大解析冲冲冲！

			
		

	





	

		

			

				
					
android ButterKnife 使用

				
			

			

				

					turuihao123的博客
				

				

					03-24
					
					203
					
				

			

		

		

			
				
在Activity中ButterKnife.bind(this);必须在setContentView();之后，且父类bind绑定后，子类不需要再bind
在Fragment中ButterKnife.bind(this, view);
在Adapter中ButterKnife.bind(this, view);
属性布局不能使用private、static修饰
------------------...

			
		

	





	

		

			

				
					
安卓“小试牛刀”：ButterKnife——牛油刀（2）

				
			

			

				

					m0_46579394的博客
				

				

					07-04
					
					498
					
				

			

		

		

			
				
android牛油刀（2）

			
		

	





	

		

			

				
					
AndroidStudio中使用ButterKnife注解

				
			

			

				

					姿含的博客
				

				

					06-06
					
					7105
					
				

			

		

		

			
				
在网上有看见这么叫的ButterKnife,也有看见BufferKnife这么叫的.对于菜鸟的我,早已mb.
那我们一起来看在AndroidStudio中如何使用这个偷懒插件Android Butterknife Zelezny
一:创建一个新项目MyApplication
找到如下图所示图标Settings











输入ButterKnife 找到

			
		

	





	

		

			

				
					
Android ButterKnife使用

				
			

			

				

					IT_默
				

				

					06-24
					
					1529
					
				

			

		

		

			
				
Butter Knife:Android的字段和方法绑定视图使用注解处理为您生成样板代码。
消除findViewById调用使用@FindView字段。
使用@FindViews集团多个视图列表。操作都是用行动,setter方法或属性。
消除匿名内部类与@OnClick听众通过注释方法等等。
写这篇blog的时候我用的是Butter Knife5.1.1版本，现在最新的Butter Knife应该是

			
		

	





	

		

			

				
					
Android Butterknife使用

				
			

			

				

					ZeroyiQ的博客
				

				

					09-21
					
					575
					
				

			

		

		

			
				
目录前言Butter Knife简介资源绑定非 Activity 中绑定View 列表
前言

目前写大创的东西，做Android方面的coding。在参考学长写的项目的时候，看见了这个 butterKnife 框架。想到当初他们有推荐过，目前也确实需要，所以就边学边用了。参考Android Butter Knife 框架——最好用的View注入和官方文档。本人英语较渣，欢迎有余力的同学也去看看官...

			
		

	





	

		

			

				
					
Android Studio卸载Android ButterKnife Zelezny

					
最新发布

				
			

			

				

					12-04
				

			

		

		

			
				
你可以按照以下步骤卸载Android ButterKnife Zelezny插件：  1. 打开Android Studio，点击菜单栏的“File”选项，选择“Settings”进入设置界面。 2. 在设置界面中，选择“Plugins”选项，找到“Android ButterKnife...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值