“依赖注入”不就是指使用参数化构造函数和公共setter吗？

James Shore的文章展示了以下示例进行比较。

没有依赖注入的构造函数：公共类示例｛私有数据库Thingie myDatabase；public Example（）｛myDatabase=新数据库Thingie（）；} public void doStuff（）｛... myDatabase.getData（）；... } } 具有依赖注入的构造函数：公共类示例｛私有数据库Thingie myDatabase；公共示例（DatabaseThingie使用ThisDatabaseReplace）｛myDatabase=改用此数据库；}public void doStuff（）｛... myDatabase.getData（）；... } }

我知道已经有很多答案，但我发现这非常有用：http://tutorials.jenkov.com/dependency-injection/index.html

无相关性：

public class MyDao {

  protected DataSource dataSource = new DataSourceImpl(
    "driver", "url", "user", "password");

  //data access methods...
  public Person readPerson(int primaryKey) {...}     
}

附属国：

public class MyDao {

  protected DataSource dataSource = null;

  public MyDao(String driver, String url, String user, String password) {
    this.dataSource = new DataSourceImpl(driver, url, user, password);
  }

  //data access methods...
  public Person readPerson(int primaryKey) {...}
}

注意DataSourceImpl实例化是如何移动到构造函数中的。构造函数接受四个参数，即DataSourceImpl所需的四个值。虽然MyDao类仍然依赖于这四个值，但它本身不再满足这些依赖关系。它们由创建MyDao实例的任何类提供。

依赖注入是解决“依赖混淆”需求的一种可能方案。依赖性混淆是一种将“明显”性质从向需要依赖性的类提供依赖性的过程中去除的方法，因此在某种程度上混淆了向所述类提供所述依赖性。这不一定是坏事。事实上，通过混淆向类提供依赖项的方式，类外部的某个东西负责创建依赖项，这意味着在各种情况下，可以向类提供不同的依赖项实现，而不需要对类进行任何更改。这对于在生产和测试模式之间切换非常有用（例如，使用“模拟”服务依赖）。

不幸的是，糟糕的部分是，有些人认为你需要一个专门的框架来进行依赖性混淆，如果你选择不使用特定的框架来做，那么你在某种程度上就是一个“低级”程序员。另一个非常令人不安的神话是，依赖性注入是实现依赖性混淆的唯一方法。这显然是历史性的，显然是100%错误的，但你很难说服一些人，依赖项注入可以替代依赖项混淆需求。

多年来，程序员们已经了解了依赖性混淆的需求，在考虑依赖性注入之前和之后，许多替代解决方案都已经发展起来。有工厂模式，但也有许多使用ThreadLocal的选项，其中不需要对特定实例进行注入-依赖关系被有效地注入到线程中，这样做的好处是使对象（通过方便的静态getter方法）可用于任何需要它的类，而无需向需要它的类别添加注释并设置复杂的XML“粘合”以实现这一点。当持久性需要依赖项（JPA/JDO或其他）时，它允许您更容易地实现“跨持久性”，并且域模型和业务模型类完全由POJO组成（即没有特定于框架的/锁定在注释中的）。

“依赖注入”不就是指使用参数化构造函数和公共setter吗？

James Shore的文章展示了以下示例进行比较。

没有依赖注入的构造函数：公共类示例｛私有数据库Thingie myDatabase；public Example（）｛myDatabase=新数据库Thingie（）；} public void doStuff（）｛... myDatabase.getData（）；... } } 具有依赖注入的构造函数：公共类示例｛私有数据库Thingie myDatabase；公共示例（DatabaseThingie使用ThisDatabaseReplace）｛myDatabase=改用此数据库；}public void doStuff（）｛... myDatabase.getData（）；... } }

我们可以实现依赖注入来了解它：

class Injector {
  constructor() {
    this.dependencies = {};
    this.register = (key, value) => {
      this.dependencies[key] = value;
    };
  }
  resolve(...args) {
    let func = null;
    let deps = null;
    let scope = null;
    const self = this;
    if (typeof args[0] === 'string') {
      func = args[1];
      deps = args[0].replace(/ /g, '').split(',');
      scope = args[2] || {};
    } else {
      func = args[0];
      deps = func.toString().match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1].replace(/ /g, '').split(',');
      scope = args[1] || {};
    }
    return (...args) => {
      func.apply(scope || {}, deps.map(dep => self.dependencies[dep] && dep != '' ? self.dependencies[dep] : args.shift()));
    }
  }
}

injector = new Injector();

injector.register('module1', () => { console.log('hello') });
injector.register('module2', () => { console.log('world') });

var doSomething1 = injector.resolve(function (module1, module2, other) {
  module1();
  module2();
  console.log(other);
});
doSomething1("Other");

console.log('--------')

var doSomething2 = injector.resolve('module1,module2,', function (a, b, c) {
  a();
  b();
  console.log(c);
});
doSomething2("Other");

以上是javascript的实现

DI是真实对象之间实际交互的方式，而不需要一个对象负责另一个对象的存在。应平等对待对象。它们都是对象。任何人都不应该表现得像一个创造者。这就是你如何公正对待你的目标。

简单示例：

如果你需要医生，你只需去找一位（现有的）医生。你不会考虑从头开始创建一个医生来帮助你。他已经存在，他可能为你或其他对象服务。无论你（一个物体）是否需要他，他都有权存在，因为他的目的是为一个或多个物体服务。决定他的存在的是全能的上帝，而不是自然选择。因此，DI的一个优点是避免在整个宇宙（即应用程序）的生命周期中创建无用的冗余对象。