ButterKnife和dagger2

ButterKnife

注于Android系统的View注入框架,当一个布局十分复杂时,需要引入执行大量的findViewById代码来找到View的对象,有了ButterKnife可以很轻松的省去这些步骤。是大神JakeWharton的力作，目前使用很广。最重要的一点，使用ButterKnife对性能基本没有损失，因为ButterKnife用到的注解并不是在运行时反射的，而是在编译的时候生成新的class。项目集成起来也是特别方便，使用起来也是特别简单。

https://github.com/JakeWharton/butterknife

ButterKnife的优势

1.强大的View绑定事件和资源文件的绑定
2.使用的便捷性上，剔除了原始绑定时候的复杂性
3.由于大多数的注解都是在编译期，所以不会影响程序运行的效率
4.代码清晰，可读性相对来说要强很多

ButterKnife的使用

导入依赖：classpath 'com.jakewharton:butterknife-gradle-plugin:10.0.0’在项目的build.gradle 中添加如下代码：

buildscript {
  repositories {        
     google()      
     jcenter()
     }
     dependencies {        
        classpath 'com.android.tools.build:gradle:3.4.2'        
        classpath 'com.jakewharton:butterknife-gradle-plugin:10.0.0'      
        // NOTE: Do not place your application dependencies here; they belong        
        // in the individual module build.gradle files   
       }
  }

在module的build.gradle中添加如下代码

apply plugin: 'com.android.application'
apply plugin:'com.jakewharton.butterknife'//添加这一行
//依赖
implementation 'com.jakewharton:butterknife:10.0.0'  
annotationProcessor 'com.jakewharton:butterknife-compiler:10.0.0'

1.ButterKnife注解添加

  @BindView(R.id.btn1)    
  Button btn1;
  @BindView(R.id.tv1)    
  TextView tv;

2.在onCreate方法中绑定

@Overrideprotected void onCreate(Bundle savedInstanceState) {   
 super.onCreate(savedInstanceState);  
   setContentView(R.layout.activity_main);
       ButterKnife.bind(this);    
       getSupportFragmentManager().beginTransaction().add(R.id.fram1,new MyFragment()).commit();
       }

3.单独创建点击事件方法,使用@OnClick({R.id.tv1,R.id.btn1})注解,括号中的数组指明的是哪个组件响应点击

@OnClick({R.id.tv1,R.id.btn1})
public void Onclick(View view){
	switch(view.getId()){
	case R.id.tv1:
		 tv.setText("终于点到了");            
		 break;
	 case R.id.btn1:
		 Intent intent = new Intent(this,Main2Activity.class);            
		 startActivity(intent);            
		 break;
	}
}

4.Fragment中使用绑定方法不同，并且需要在onDestroyView中解绑

Unbinder unbinder;
@BindView(R.id.btn2)Button but2;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.frazgmentlayout1,container,false); 
    unbinder= ButterKnife.bind(this,view);    
    return view;
 }
/** 
* onDestroyView中进行解绑操作 
* */
@Override
public void onDestroyView() {    
super.onDestroyView();    
unbinder.unbind();
}

ButterKnife插件的添加可以快速绑定

下载插件 ButterKnife

dagger2

Dagger2是什么?

Dagger2是Dagger的升级版，是一个依赖注入框架,第一代由大名鼎鼎的Square公司共享出来，第二代则是由谷歌接手后推出的，现在由Google接手维护.

依赖

依赖是指某个模块A要实现某个功能需要其他模块B。最原始也最简单的的方式是在模块内new一个B的对象出来，这样会造成B的构造函数修改，需要修改A中的代码，两者耦合度非常高。

依赖注入

依赖注入是不在A中去创建 B的实例，而是让上层调用者注入一个B的对象，这样可以让模块A不再因为B的构造方法的修改而改变
举个例子:

public class ClassA{ 
       private ClassB b        
       public ClassA(ClassB b){ 
              this.b = b       
       }    
}

这里ClassA的构造函数里传了一个参数ClassB,随着后续业务增加也许又需要传入ClassC,ClassD.试想一下如果一个工程中有5个文件使用了ClassA那是不是要改5个文件?这既不符合开闭原则, 也太不软工了.这个时候大杀器Dagger2就该出场了.

public class ClassA{
@inject       
private ClassB b       
public ClassA(){    
   
	}    
}

通过注解的方式将ClassB b注入到ClassA中, 可以灵活配置ClassA的属性而不影响其他文件对ClassA的使用.

dagger2导依赖

implementation"com.google.dagger:dagger:2.16"
annotationProcessor"com.google.dagger:dagger-compiler:2.16"

dagger2基本使用

1.创建注入提供者类
2.提供者创建构造方法
3.给构造方法添加@Inject注解，表明对外提供依赖，并写个方法

public class Utils1 {
    @Inject    
    //提供给其他类使用    
    public Utils1(){    
    }    
    public void show(){
            Log.e("########","utils1---show");
           }
    }

 4.在接收注解方创建提供注解类的对象并添加@Inject注解，表明这个对象需要注入

@Inject      
  //使用其他类
  Utils1 utils1;

5.创建注解的桥梁，或者叫注入者。注入者是一个接口，需要用@Component注解，并且提供一个方法用来表示向谁注入。

@Component
//提供桥梁public interface Utils1Compont {
    void inject(Main2Activity main2Activity);
    }

6.注意到这里可以锤了
7.锤过之后如果不报错可以在build中找到如下内容

8. 在调用类中加载Dagger，然后就可以调用了
DaggerUtils1Compont.builder().build().inject(this);

dagger2基本使用2

跟上个方法大致一样
但是不创建单个类了，在这里要创建一个仓库类，用来存放需要使用的类，
这里需要用@Module来注解表示这是仓库

@Module
public class UserModule {
    public UserModule() {
    }
    @Provides    
    public Utils1 useUtils() {           
       Log.e("######","仓库show");        
       return new Utils1();    
    }
 }

带仓库的dagger也需要一个接口桥梁，
这个桥梁注解需要参数@Component(modules={UserModule.class})

@Component(modules={UserModule.class})
public interface Utils1CompontWithModule {
//提供桥梁
void injectWithmodule(MainActivity mainActivity);
}

完成以上操作 仍然是锤一下
在调用类中加载Dagger，然后就可以调用了，加载Dagger时需要将仓库带入

DaggerUtils1CompontWithModule.builder().userModule(new UserModule()).build().injectWithmodule(this);