为什么是匕首2？我们可以手动创建所需的类对象并注入

Question

我从 https://developer.android.com/training/dependency-injection 了解到 Android 依赖注入。事情是没有 dagger2 我们可以像下面这样创建对象并使用它（构造函数注入）。使用 Dagger2 有什么意义？设计模式的好处存档以下好处

1. 易于测试
2. 代码的可重用性
3. 易于重构

但我的问题是没有 Dagger-2 我们也可以做到这一点。那我们应该用 Dagger2 做什么呢？

没有 Dagger2

引擎

public class Engine {

    public Engine()
    {

    }
}

车轮

public class Wheels {

    public Wheels()
    {

    }
}

汽车

public class Car {
    private static final String TAG = "Car";

    private Engine engine;
    private Wheels wheels;

    public Car(Engine engine,Wheels wheels)
    {
        this.engine=engine;
        this.wheels=wheels;
    }

    public void drive()
    {
        Log.d(TAG, "driving");
    }


}

MainActivity.class

public class MainActivity extends AppCompatActivity {

    private Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

//        Engine engine=new Engine();
//        Wheels wheels=new Wheels();

        car=new Car(new Engine(),new Wheels());

        car.drive();

    }
}

使用 Dagger-2

引擎

public class Engine {
    
    @Inject
    public Engine()
    {

    }
}

车轮

public class Wheels {

    @Inject
    public Wheels()
    {

    }
}

汽车

public class Car {
    private static final String TAG = "Car";

    private Engine engine;
    private Wheels wheels;

    @Inject
    public Car(Engine engine,Wheels wheels)
    {
        this.engine=engine;
        this.wheels=wheels;
    }

    public void drive()
    {
        Log.d(TAG, "driving");
    }


}

汽车组件

@component
public interface CarComponent{
   Car getCar();
}

MainActivity.class

public class MainActivity extends AppCompatActivity {

    private Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CarComponent carComponent=DaggerCarComponent.create();
        carComponent.getCar();
        car.drive();

    }
}

Answer 1

从你自己的例子来看，应该很明显了：

 @Override
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    car=new Car(new Engine(),new Wheels());

    car.drive();
}

所以在这里，每次您想要获得汽车的实例时，都必须创建一个 Engine 的新实例和一个 Wheels 的新实例。所以让我们考虑一下：

如果汽车现在需要一个新组件作为参数会怎样？

您必须将此依赖项添加到汽车对象的每次创建中。

car=new Car(new Engine(),new Wheels(), new Foo()); <-- you'll be doing this throughout your entire project.

让我们考虑一下如果您的依赖项本身具有依赖项会发生什么：

car=new Car(new Engine("some value", "another value"),new Wheels(SomeComplicatedObjectWithMoreDependencies()));

因此，在创建所需的对象之前，您最终必须创建大量依赖项，并且您将在项目中的任何地方，每次都这样做，这就是使用依赖项的重点注入/反转框架（这与 dagger 没有任何关系，这是一个通用的东西） - 帮助您管理您的依赖关系。