Question

我在把握依赖注入时遇到了问题（或者让我说它的好处）。因此，我决定编写两个简单的代码，一个不带DI，另一个不带DI。

所以我有A类

public class A {
    public void foo(){
        B b = new B();
        b.fooB();
    }
}

从上面的A可见，取决于B，B就是

public class B {
    public void fooB(){
        Log.e("s", "y");
    }
}

我们可以使用A like

public void do(){
    A a = new A();
    a.foo();
}

但是，据说A不应因为依赖它而简单地初始化B，但是我们应该拥有一个在两个类之间具有某种契约的服务。例如，如果我错了，请告诉我

让我们有一个BService接口

public interface BService {
    void fooB();
}

B变成DiB

public class DiB implements BService {
    @Override
    public void fooB(){
        Log.e("s", "y");
    }
}

A变成DiA

public class DiA {
    BService bService;

    public DiA(BService bService){
        this.bService = bService;
    }

    public void foo(){
        bService.fooB();
    }
}

我们可以使用A like

public void dIdo(){
        BService service = new diB();
        diA a = new diA(service);
        a.foo();
}

所以我读到DI的好处是：

可测试的代码：因为我实际上可以在JUnit（I 不想在这里发布测试以避免长时间提问）
解耦：它说如果B类发生变化，那么A就不应受影响，我无法理解，因为如果我在B类中更改fooB（）到fooB2（），我将不得不更改BService中的重写方法反过来，这意味着我将不得不在A类中对其进行更改

这两个代码似乎都可以正常工作，我无法理解一个相对于另一个的好处，只是另一个更复杂。因此，请您进一步启发我了解这个简单的A和B类所带来的好处。我没有得到什么？

Answer 1

首先，我不同意您的“据说A不应简单地初始化B，因为它依赖于它” ..因为相同的代码在.NET中对我有用

    class Program
{
    static void Main(string[] args)
    {
        A aobj = new A();
        aobj.foo();
    }
}
public class A {
    public void foo()
    {
        B bojb = new B();
        bojb.fooB();
        Console.WriteLine("From A.foo() ..");
        Console.ReadLine();
    }

}
public class B {
    public void fooB()
    {
        Console.WriteLine("From B.fooB() ..");
        Console.ReadLine();
    }
}

除此之外，猜想您对依赖注入的基础感到困惑。依赖词本身可以传达任何类的注入源。

首先，可以在类的实例中识别依赖关系，而构造函数是第一个类型。
第二，实例化对象后，在调用任何方法之前，将对属性或公共字段进行一些分配。尽管它是可选的，但是顺序是这样的。因此，第二种类型。
最后，方法注入。

建议您在结案之前阅读更多内容。

在两个简单类的上下文中进行依赖注入

1 个答案: