精华内容
下载资源
问答
  • Android依赖注入框架选型

    千次阅读 2019-05-24 04:53:40
    说到Android依赖注入框架,网上比较推崇的是google维护的Dagger2框架,使用依赖注入可以带来以下好处: 1、依赖的注入和配置独立于组件之外。2、因为对象是在一个独立、不耦合的地方初始化,所以当注入抽象方法的...

    说到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

    展开全文
  • 1. Android依赖注入框架Dagger2详解 2. 使用Swift开发WatchKit 3. 自己动手写一个iOS网络请求库 4. iOS异步图片加载优化与常用开源库分析 5. SwiftLint:Swift编码规范工具

    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 html

    使用Swift开发WatchKit


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

    @吕文翰_JohnLui

    关键词:iOS, 代码

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

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

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

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


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

    @SegmentFault

    关键词:iOS

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

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

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


    SwiftLint:Swift编码规范工具

    @汤圣罡

    关键词:iOS, Swift, 代码

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

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

    展开全文
  • 在开发的过程中....这时候就体现了依赖注入的好处,如果还不太明白什么是依赖注入,请参考: 依赖注入daggerdagger的用途就是 你不用初始化对象,达到成员变量申明就能用.dagger通过依赖注入构建对象图

    概述

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

    不仅麻烦,而且容易出错.这时候就体现了依赖注入的好处,如果还不太明白什么是依赖注入,请参考: 依赖注入,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是为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

    展开全文
  • AndroidAnnotations是一个能够让你快速进行Android开发的开源框架,它能让你专注于真正重要的地方。使代码更加精简,使项目更容易维护。相比原生的Android App代码量,几乎可以少一半。 用...
  • 依赖注入 面向对象编程的一种设计模式,目的是为了降低程序中类与类之间的依赖引起的耦合。 在Java中,依赖注入有 通过接口注入 通过set方法注入 通过构造方法注入 通过注解注入 Dagger2 官网 为...
  • Android 依赖注入框架RoboGuice

    千次阅读 2015-05-01 17:34:26
    Dependency injection 大大降低了类之间的依赖性,可以通过annotation描述类之间的依赖性,避免了直接调用类似的构造函数或是使用Factory来参加所需的类,从而降低类或模块之间的耦合性,以提高代码重用并增强代码的...
  • Android 依赖注入框架 Dagger2使用

    千次阅读 2016-06-15 08:00:03
    前言Dagger 2这个匕首确实很难上手,上手后又比较难瞬间掌握,可以这么说,刚...它毕竟是一个依赖注入DI框架,Spring在服务器开发中起到的作用相信它也能。在了解使用前,先了解概念,什么是控制反转,什么是依赖注入
  • ButterKnife 是出自Android大神JakeWharton之手的一个开源库,它的作用就是通过注解绑定视图的方法,从而简化代码量。 题外话: Java中Spring提供ioc的功能,而且Spring的HttpInvoker可以实现直接调用后端的对象。...
  • 我期望在后面使用依赖注入框架,但是现在这种框架很多,不知道哪个最好?需要考察的是: 1、使用方便 2、性能 3、混淆代码不会出现不良反应等 期望大家推荐,谢谢。
  • BufferKnife作为框架式编程的重要组成部分,使用BufferKnife能够极大的精简View层面的代码量,并为MVP/MVC方式提供辅助。 一、配置 compile 'com.jakewharton:butterknife:(insert latest version)' annotation...
  • 依赖注入(DependencyInjection):在类A中要用到一个B的对象(依赖),需要通过新建B的实例或其他一些主动的方式来获取对象,然后才能调用。而通过外部的方式自动将B的对象分配给A(注入),实现相对被动的获取对象,...
  • :打开Android studio --->File(页面左上角)--->Setting--->Plugins--->搜索栏目中搜索:ButterKnife,在搜索结果中,选择 Android ButterKnife Zelenzny (下载量多且星星比较多的那个),下载完毕后,重启...
  • 转载并修改自,天天博客 ...http://frogermcs.github.io/dependency-injection-with-dagger-2-the-api/关于Dagger2的作用,以及依赖注入就不做介绍了,下面这边文章介绍的很好: http://frogermc
  • 目录 一:Dagger2是什么? 二:为什么要有Dagger2 三:Dagger2如何使用 ... (2) 模块之间的依赖关系 (3) @Named注解使用 (4) @Singleton注解 (5)自定义Scoped (6)Subcompone...
  • 最近调研了Android平台可以使用的依赖注入框架。发现现在常用的有四种。Dagger、Butter Knife、RoboGuice、Android Annotations。经过一系列的比较,最后我们的选择 的范围缩小到Dagger、Butter Knife这2个框架...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,144
精华内容 457
关键字:

android依赖注入框架