为什么是dagger2？我们可以手动创建所需的类对象和注入

Question

我是从https://developer.安卓.com/training/dependency-injection知道安卓依赖注入的。没有dagger2，我们可以创建如下对象并使用它（构造函数注入）。使用匕首2有什么意义？设计模式的好处在于将以下好处归档

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

但我的问题是，没有匕首-2，我们也能做到这一点。那我们要用匕首2做什么呢

Without 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();

    }
}

With 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无关，这是一个通用的东西）来帮助您管理依赖项的意义所在