说到Android依赖注入框架，网上比较推崇的是google维护的Dagger2框架，使用依赖注入可以带来以下好处：
1、依赖的注入和配置独立于组件之外。2、因为对象是在一个独立、不耦合的地方初始化，所以当注入抽象方法的时候，我们只需要修改对象的实现方法，而不用大改代码库。3、依赖可以注入到一个组件中：我们可以注入这些依赖的模拟实现，这样使得测试更加简单。Dagger2可以免去在每个使用类的地方都使用构造函数构造一个实例，使用@Inject注解可实现类实例的依赖注入，依赖的构建分别支持@Provide、@module注解，用于构建自定义的类和第三方类，并使用@Scope注解来声明依赖的作用域，可以跟acitvity的声明周期绑定在一起，在需要的地方自动实现单例模式。写到此处可见Dagger2框架提供的功能很强大，可以帮助我们的代码进行很好的解耦，但是如果把他实施到具体的项目当中，你会发现事情并没有想象中那么便利，而且我们的工作量增加了：

应用中每个页面的需要依赖注入的地方都需要写一份模板代码来实现，比较繁琐。而且如果我们的项目是多module工程，需要创建很多Component类，不能放到library中去实现，因为这会涉及到module工程循环引用的问题。我们平时开发的工作量主要来源于业务需求，需要创建很多新的页面，这时候不仅仅要考虑代码怎么做到低耦合，代码的高内聚也是很重要的，这有助于减少代码量和测试的工作量。由此想到是否可以把依赖注入的过程放到Activity或者Fragment的基类中去实现，比如将MVP代码框架里面的presenter放到基类中去注入，我们去实现每个具体的页面的时候去扩展这个基类即可，不需要再在每个扩展类中去写这些模板代码。
RoboGuice是一种比Dagger使用更简易的依赖注入框架，他不需要定义各种Component注射器，直接通过 RoboGuice.getInjector()就可以拿到注射器，支持视图、资源、系统服务、对象等注入，并且可以通过注解来实现单例模式，基本能实现dagger提供的功能，非常适合MVP框架，可以在Activity或者Fragment的基类去实现presenter的注入：


笔者非常推荐大家使用这套框架！
如果项目使用kotlin语言则有更多的选择，kodein框架是一个不错的选择：


只要在你的Module中绑定需要的实例构造方法，在需要用到该实例的页面通过by instance()的调用去实现依赖的检索：


更多用法可以上官网查看：
github demo


转载于:https://juejin.im/post/5cd7b55cf265da036902b54e

App开发日报 2015-05-19

@好东西传送门 出品, 过刊见 http://app.memect.com

订阅：给 hao@memect.com 发封空信， 标题: 订阅App开发日报

可点击加长版13条 http://app.memect.com/archive/2015-05-19/long.html

Android依赖注入框架Dagger2详解

@开发技术前线

关键词：Android, IDE, 代码

《Dagger2详解》 [1] ， 分享给大家，多谢 佳君 [2] 的翻译。《如何清除Android Studio下载的远程aar缓存》 [3] ，也是一篇有用的文章，扩散起来吧！ @Android笔记 @好东西传送门 @慕课网Android学习小组 @developerWorks

[1] https://github.com/bboyfeiyu/android-tech-frontier/tree/master/issue-11/%E8%AF%A6%E8%A7%A3Dagger2

[2] https://github.com/xianjiajun

[3] http://www.devtf.cn/?p=479

使用Swift开发WatchKit

@CocoaChina

关键词：iOS, IDE, Swift, Watch, 课程

【使用Swift开发WatchKit（part 1）：马上开始】WatchKit是Apple的新架构，用来开发Apple Watch app，与Xcode 6.2 一起发布。这个WatchKit教程中，你将使用Swift创建你的第一个WatchKit app。具体地说，你将下载一个比特币价格跟踪app，然后开发一款配套使用的Watch app。 [1]

[1] http://www.cocoachina.com/swift/20150519/11860.html 



自己动手写一个iOS网络请求库

@吕文翰_JohnLui

关键词：iOS, 代码

分享：自己动手写一个 iOS 网络请求库（一）—— NSURLSession 初探 文章地址： [1] 开源项目： [2]

[1] http://lvwenhan.com/ios/454.html 

[2] https://github.com/johnlui/Pitaya



iOS异步图片加载优化与常用开源库分析

@SegmentFault

关键词：iOS

《iOS 异步图片加载优化与常用开源库分析》 作者 luoyibu [1]

[1] http://segmentfault.com/a/1190000002776279?utm_source=Weibo&utm_medium=shareLink&utm_campaign=socialShare



SwiftLint:Swift编码规范工具

@汤圣罡

关键词：iOS, Swift, 代码

SwiftLint - 写 Swift 必备的神器。 [1]

[1] https://github.com/realm/SwiftLint

概述

在开发的过程中.我们都需要用到很多对象,在使用之前都需要初始化.如果这个对象需要在多处被使用,那么在每个地方都要写相同的代码,而且当我们需要改变其中某个类的功能的时候,就需要更改大量的代码

不仅麻烦,而且容易出错.这时候就体现了依赖注入的好处,如果还不太明白什么是依赖注入,请参考: 依赖注入，Dagger就是一款依赖注入框架



Dagger

dagger的用途就是 你不用初始化对象,达到成员变量申明就能用.dagger通过依赖注入构建对象图表,降低了程序的耦合性.

通过inject()方法自动注入所有对象，完成自动的初始化。 

Dagger使用 @Inject 注释的构造函数 创建类对象。 当请求构建新的类对象时， Dagger 将自动获取相应的参数， 并调用构造函数。



 class  A{
        @Inject
        public A() {        
        }
    }



public class MainActivity extends Activity {  
    @Inject A a;  
}  

以上面的代码为例,在Activity中实例化A的对象,只需要@Inject 即可,dagger会自动找到被标记的构造函数并调用来获取实例. 

如果构造函数中包含有参数.需要这个参数的构造函数也有@Inject标记.或者可以通过@Provides 标记来获取实例



官方示例

dagger 官方示例采用了煮咖啡来讲解dagger的工作原理.



class Thermosiphon implements Pump {
  private final Heater heater;

  @Inject
  Thermosiphon(Heater heater) {
    this.heater = heater;
  }

  @Override public void pump() {
    if (heater.isHot()) {
      System.out.println("=> => pumping => =>");
    }
  }
}

这里提供了一个Pump 实现类的注入入口.同时又依赖于Heater



class CoffeeMaker {
  @Inject Lazy<Heater> heater; // Don't want to create a possibly costly heater until we need it.
  @Inject Pump pump;

  public void brew() {
    heater.get().on();
    pump.pump();
    System.out.println(" [_]P coffee! [_]P ");
    heater.get().off();
  }
}

获取Heater对象， 并注入到成员变量heater，同时获取Pump对象并注入到成员变量pump。 

pump 的依赖上面已经标注,那么我们来看一下heater的实现



class ElectricHeater implements Heater {
  boolean heating;

  @Override public void on() {
    System.out.println("~ ~ ~ heating ~ ~ ~");
    this.heating = true;
  }

  @Override public void off() {
    this.heating = false;
  }

  @Override public boolean isHot() {
    return heating;
  }
}

可以看到 heater中是没有@Inject 标记的.

注意:类中含有@Inject注释的成员变量， 却没有@Inject注释的构造函数时， Dagger将使用类的默认构造函数。若类中缺少@Inject注释， 该类是不能由Dagger创建的。 

Dagger 通过构造相应类型的对象来实现依赖关系,那么heater是怎么引入的呢,上面我们说过还有一种方式那就是通过@Provides 标记



自定义依赖(Provides)

构造方法进行@Inject注解是很好用的实现依赖的途径，然而它并不适用于所有情况

接口类型不能被构造(接口当然不能构造对象)
第三方的类不能被注释构造(第三方的类显然不能加入@Inject注释， 当然也不能被Dagger构造.)
可配置的对象必须被配置好(有些类需要灵活的初始化配置,而不是使用一个单一的构造函数)
对那些使用@Inject效率极低或者awkward的情况,dagger使用了@Provides来实现依赖关系,我们来看一下heater的provide方法



@Provides @Singleton Heater provideHeater() {
    return new ElectricHeater();
  }

Dagger支持单例，实现方式也十分简单,通过注解@Singleton,对象只会被初始化一次，之后的每次都会被直接注入相同的对象。

同样，@Provides注解的方法如果含有参数，它的所有参数也要保证能够被Dagger获取到。



 @Provides Pump providePump(Thermosiphon pump) {
    return pump;
  }



Module

所有的@Provides函数必须属于一个Module。这些Module类使用@Module注释。

通常情况下， 约定@Provides函数以provide作为前缀， @Module类以Module作为后缀。



@Module(
    injects = CoffeeApp.class,
    includes = PumpModule.class
)
class DripCoffeeModule {
  @Provides @Singleton Heater provideHeater() {
    return new ElectricHeater();
  }
}

注意: 

所有含有依赖注入的类,都必须显示申明在Module 中
一个Module中所有@Provides方法的参数都必须在这个Module中提供相应的@Provides方法， 

或者在@Module注解后添加“complete = false”注明这是一个不完整Module（即它会被其他Module所扩展）
一个Module中所有的@Provides方法都要被它声明的注入对象所使用，或者在@Module注解后添加“library = ture”注明（即它是为了扩展其他Module而存在的）
ps:



@Module(complete = false, library = true)
class PumpModule {
  @Provides Pump providePump(Thermosiphon pump) {
    return pump;
  }
}

这个Module就是为了扩展DripCoffeeModule而存在的,上面的injects选项使得可以在编译的过程中检查对象图表是有有效



ObjectGraph(对象图表)

@Inject 和 @Provides 注释的类构建了一个对象图表。这些对象与对象之间通过依赖关系相互关联。 

通过函数ObjectGraph.create()获取这个对象图表, 这个函数可以接受一个或多个Module作为参数



public class CoffeeApp implements Runnable {
  @Inject CoffeeMaker coffeeMaker;

  @Override public void run() {
    coffeeMaker.brew();
  }

  public static void main(String[] args) {
    ObjectGraph objectGraph = ObjectGraph.create(new DripCoffeeModule());
    CoffeeApp coffeeApp = objectGraph.get(CoffeeApp.class);
    coffeeApp.run();
  }
}

这里面直接通过objectGraph.get(CoffeeApp.class) 来获取CoffeeApp 的实例,而我们的对象图表中并没有被引导注入 

需要在Module中显示的申明,上面 injects = CoffeeApp.class, 就是这个作用



LAZY INJECTIONS(懒加载)


  
Sometimes you need an object to be instantiated lazily. For any binding T, you can create a Lazy which defers instantiation until the first call to Lazy’s get() method. If T is a singleton, then Lazy will be the same instance for all injections within the ObjectGraph.


懒加载, 等到调用的时候才注入



class GridingCoffeeMaker {
  @Inject Lazy<Grinder> lazyGrinder;

  public void brew() {
    while (needsGrinding()) {
      // Grinder created once on first call to .get() and cached.
      lazyGrinder.get().grind();
    }
  }
}



PROVIDER INJECTIONS(提供者注入 )


  
Sometimes you need multiple instances to be returned instead of just injecting a single value. While you have several options (Factories, Builders, etc.) one option is to inject a Provider instead of just T. A Provider creates a new instance of T each time .get() is called.


有些情况下， 你需要多个对象实例， 而不是仅仅注入一个对象实例。这时你可以利用Provider实现， 每次调用Provider的get()函数将返回新的的对象实例。



class BigCoffeeMaker {
  @Inject Provider<Filter> filterProvider;

  public void brew(int numberOfPots) {
    ...
    for (int p = 0; p < numberOfPots; p++) {
      maker.addFilter(filterProvider.get()); //new filter every time.
      maker.addCoffee(...);
      maker.percolate();
      ...
    }
  }
}



QUALIFIERS(限定符)

区分不能通过类型来获取具体依赖的情况



@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {
  String value() default "";
}

我们的Module



@Provides @Named("hot plate") Heater provideHotPlateHeater() {
  return new ElectricHeater(70);
}

@Provides @Named("water") Heater provideWaterHeater() {
  return new ElectricHeater(93);
}

@Inject 引用,就是通过新增一个新注解,来获取我们想要的实例



class ExpensiveCoffeeMaker {
  @Inject @Named("water") Heater waterHeater;
  @Inject @Named("hot plate") Heater hotPlateHeater;
  ...
}

参考:

Dagger——Android上的依赖注入框架 
Dagger - 快速依赖注入器(for android and java) (1) 
Dagger官方文档 
Android Dagger依赖注入框架浅析

简述：

Dagger是为Android和Java平台提供的一个完全静态的，在编译时进行依赖注入的框架，原来是由Square公司维护，现在由Google维护。https://www.cnblogs.com/all88/p/5788556.html

开源项目U2020

U2020是Jack Wharton牵头完成的关于Dagger的使用例子。

github地址：https://github.com/JakeWharton/u2020

A sample Android app which showcases advanced usage of Dagger among other open source libraries.

https://www.youtube.com/watch?v=0XHx9jtxIxU