Android Dagger (三) dependencies、Subcomponent 案例详解

古城微笑少年丶 2022-05-17 13:42 157阅读 0赞

*   *  dependencies
        
         *  举个例子
         *  Bean
         *  module
         *  component
         *  输出结果
         *  Subcomponent
            
             *  小案例图
             *  先写父类 brand
             *  bean
             *  module
         *  component
            
             *  定义子类
             *  bean
         *  module
         *  component
            
             *  运行
         *  总结
            
             *  相同点
             *  不同点

## dependencies ##

> 依赖关系

注意事项：

<table> 
 <thead> 
  <tr> 
   <th>注意事项</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>是否可以拿到 被依赖项的 所有实例？</td> 
   <td>不行，因为我们只有分享自己的实例 《被依赖项。，只分享他愿意分享的东西》</td> 
  </tr> 
  <tr> 
   <td>作用域(scope)能相同吗？</td> 
   <td>不能，ParentComponent 的生命周期 &gt;= ChildComponent 的生命周期 （例如 Activity(parent) Fragment(chid) 当然是父类更长了）</td> 
  </tr> 
  <tr> 
   <td>作用域可以是 @Singleton 吗？</td> 
   <td>不能 因为 Dagger 2 中 @Singleton 的 Component 不能依赖其他的 Component。</td> 
  </tr> 
 </tbody> 
</table>

### 举个例子 ###

![这里写图片描述][70]

汽车 跟 自行车都有自己的颜色，那么我们想要使用 同一个 Component 如何做？

### Bean ###

// 车辆颜色类
    public class VehicleColor {
        String color;
    
        public VehicleColor(String color) {
            this.color = color;
        }
    }
    
    // 汽车
    public class Car {
        String brand;
        VehicleColor color;
    
        public Car(String brand, VehicleColor color) {
            this.brand = brand;
            this.color = color;
        }
    
        public void go(){
            System.out.println(this.brand + " 开动了 颜色是 " + color.color);
        }
    }
    
    // 自行车
    public class Bike {
        VehicleColor color;
    
        public Bike(VehicleColor color) {
            this.color = color;
        }
    
        public void go(){
            System.out.println("自行车 开动了 颜色是 " + color.color);
        }
    }

### module ###

@Module
    public class ColorModule { 
    
        @Provides
        @ColorScope
        VehicleColor provideCarColor(){
            return new VehicleColor("红色");
        }
    
    }
    
    @Module
    public class CarModule { 
        @Provides
        Car provideCar(VehicleColor color){
            return new Car("大众",color);
        }
    }
    
    
    @Module
    public class BikeModule { 
        @Provides
        Bike provideCar(VehicleColor color){
            return new Bike(color);
        }
    }

### component ###

@ColorScope
    @Component(modules = ColorModule.class)
    public interface ColorComponent { 
        // 把颜色提供出来, 如果我不分享，那边其他人拿不到
        VehicleColor carColor();
    }
    
    @CarScope
    @Component(modules = CarModule.class, dependencies = ColorComponent.class)
    public interface CarComponent { 
        void inject(DemoActivity activity);
    
    }
    
    @CarScope
    @Component(modules = BikeModule.class, dependencies = ColorComponent.class)
    public interface BikeComponent { 
        void inject(BikeActivity activity);
    
    }

### 输出结果 ###

DemoActivity: 大众 开动了 颜色是 红色
    BikeActivity: 自行车 开动了 颜色是 红色

### Subcomponent ###

> 继承关系，SubComponent 称为子 Component，类似于平常说的子类。

#### 小案例图 ####

![这里写图片描述][70 1]

> 强烈建议编码顺序 先写父类 以免混乱

#### 先写父类 brand ####

#### bean ####

public class Brand {
        String name;
    
        public Brand(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Brand{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

#### module ####

//@Module(subcomponents = BikeSubComponent.class) 定义完子类再加
    public class BrandModule {
    
        @Provides
        Brand provideBrand() {
            return new Brand("奥迪");
        }
    }

### component ###

@Component(modules = BrandModule.class)
    public interface BrandComponent {
        void inject(DemoActivity activity);
    
        // 子类
    // BikeSubComponent.Builder supplyBikeSubComponentBuild();
    }

#### 定义子类 ####

#### bean ####

public class Bike {
       String color;
    
        public Bike(String color) {
            this.color = color;
        }
    
        @Override
        public String toString() {
            return "Bike{" +
                    "color='" + color + '\'' +
                    '}';
        }
    }

### module ###

@Module
    public class BikeModule { 
    
        @Provides
        Bike provideModule(){
            return new Bike("蓝色");
        }
    }

### component ###

@Subcomponent(modules = BikeModule.class)
    public interface BikeSubComponent {
    
        // 提供自己的自行车
        Bike supplyBike();
    
        @Subcomponent.Builder
        interface Builder {
            Builder bikeModule(BikeModule module);
    
            BikeSubComponent build();
        }
    }

#### 运行 ####

public class DemoActivity extends AppCompatActivity { 
        @Inject
        Brand brand;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_demo);
            BrandComponent brandComponent = DaggerBrandComponent.builder()
                    .build();
    
            brandComponent.inject(this);
    
            // 获取子类
            Bike bike = brandComponent.supplyBikeSubComponentBuild()
                    .build().supplyBike();
    
            System.out.println(brand.toString());
            System.out.println(bike.toString());
        }
    }

### 总结 ###

dependencies vs Subcomponent

#### 相同点 ####

1.  两者都能复用其他 Component 的依赖
2.  有依赖关系和继承关系的 Component 不能有相同的 Scope

#### 不同点 ####

1.  依赖关系中被依赖的 Component 必须显式地提供公开依赖实例的接口，而 SubComponent 默认继承 parent Component 的依赖。(暂时还不理解，后续查看)
2.  依赖关系会生成两个独立的 DaggerXXComponent 类，而 SubComponent 不会生成 独立的 DaggerXXComponent 类。

[70]: /images/20220517/a71c2302abbd4cc694d9fc567939f688.png
[70 1]: /images/20220517/1c31d12008914d2d89a35cceb10d58c1.png