框架依赖注入和普通依赖注入_依赖注入快速入门：它是什么，以及何时使用它...

框架依赖注入和普通依赖注入

by Bhavya Karia

通过Bhavya Karia

介绍 (Introduction)

In software engineering, dependency injection is a technique whereby one object (or static method) supplies the dependencies of another object. A dependency is an object that can be used (a service).

在软件工程中 ， 依赖注入是一种技术，通过该技术，一个对象(或静态方法)可以提供另一对象的依赖关系。 依赖项是可以使用的对象( 服务 )。

That’s the Wikipedia definition but still, but it’s not particularly easy to understand. So let’s understand it better.

那是Wikipedia的定义，但仍然不是很容易理解。 因此，让我们更好地了解它。

Before understanding what it means in programming, let’s first see what it means in general as it will help us understand the concept better.

在理解编程的含义之前，让我们首先了解一下它的总体含义，因为它可以帮助我们更好地理解该概念。

Dependency or dependent means relying on something for support. Like if I say we are relying too much on mobile phones than it means we are dependent on them.

依赖或依赖是指依靠某种东西来获得支持。 就像我说过，我们对手机的依赖程度过高，这意味着我们对手机的依赖程度高。

So before getting to dependency injections, first let’s understand what a dependency in programming means.

因此，在进行依赖注入之前，首先让我们了解编程中的依赖意味着什么。

When class A uses some functionality of class B, then its said that class A has a dependency of class B.

当类A使用类B的某些功能时，则表示类A具有类B的依赖项。

In Java, before we can use methods of other classes, we first need to create the object of that class (i.e. class A needs to create an instance of class B).

在Java中，在使用其他类的方法之前，我们首先需要创建该类的对象(即，类A需要创建类B的实例)。

So, transferring the task of creating the object to someone else and directly using the dependency is called dependency injection.

因此，将创建对象的任务转移给其他人并直接使用依赖项的过程称为依赖项注入。

为什么要使用依赖注入？ (Why should I use dependency injection?)

Let’s say we have a car class which contains various objects such as wheels, engine, etc.

假设我们有一个car类，其中包含各种对象，例如车轮，引擎等。

Here the car class is responsible for creating all the dependency objects. Now, what if we decide to ditch MRFWheels in the future and want to use Yokohama Wheels?

汽车类在这里负责创建所有依赖项对象。 现在，如果我们决定将来放弃MRFWheels ，并希望使用横滨车轮，该怎么办？

We will need to recreate the car object with a new Yokohama dependency. But when using dependency injection (DI), we can change the Wheels at runtime (because dependencies can be injected at runtime rather than at compile time).

我们将需要使用新的横滨依赖关系来重新创建汽车对象。 但是，当使用依赖项注入(DI)时，我们可以在运行时更改Wheels(因为可以在运行时而不是在编译时注入依赖项)。

You can think of DI as the middleman in our code who does all the work of creating the preferred wheels object and providing it to the Car class.

您可以将DI视为我们代码中的中间人，他负责创建首选的wheel对象并将其提供给Car类的所有工作。

It makes our Car class independent from creating the objects of Wheels, Battery, etc.

它使我们的Car类独立于创建Wheels，Battery等对象。

基本上有三种类型的依赖项注入： (There are basically three types of dependency injection:)

1. constructor injection: the dependencies are provided through a class constructor.

   构造函数注入：依赖关系是通过类构造函数提供的。

2. setter injection: the client exposes a setter method that the injector uses to inject the dependency.

   setter注入：客户端公开了setter方法，注入程序用于注入依赖项。

3. interface injection: the dependency provides an injector method that will inject the dependency into any client passed to it. Clients must implement an interface that exposes a setter method that accepts the dependency.

   接口注入：依赖项提供了一个注入器方法，该方法会将依赖项注入到传递给它的任何客户端中。 客户端必须实现一个接口，该接口公开一个接受依赖项的setter方法 。

So now its the dependency injection’s responsibility to:

因此，现在依赖注入的职责是：

1. Create the objects
   创建对象
2. Know which classes require those objects
   了解哪些类需要这些对象
3. And provide them all those objects
   并提供所有这些对象

If there is any change in objects, then DI looks into it and it should not concern the class using those objects. This way if the objects change in the future, then its DI’s responsibility to provide the appropriate objects to the class.

如果对象有任何更改，则DI会对其进行调查，并且它不应该涉及使用这些对象的类。 这样，如果对象在将来发生变化，则其DI负责为类提供适当的对象。

控制反转-DI背后的概念 (Inversion of control —the concept behind DI)

This states that a class should not configure its dependencies statically but should be configured by some other class from outside.

这说明一个类不应静态配置其依赖项，而应由其他一些类从外部进行配置。

It is the fifth principle of S.O.L.I.D — the five basic principles of object-oriented programming and design by Uncle Bob — which states that a class should depend on abstraction and not upon concretions (in simple terms, hard-coded).

这是SOLID的第五项原则- Bob叔叔提出的面向对象编程和设计的五项基本原则-指出类应该依赖抽象而不是具体(简单地说，就是硬编码)。

According to the principles, a class should concentrate on fulfilling its responsibilities and not on creating objects that it requires to fulfill those responsibilities. And that’s where dependency injection comes into play: it provides the class with the required objects.

根据这些原则，一个班级应该专注于履行职责，而不是创建履行职责所需要的对象。 这就是依赖注入起作用的地方：它为类提供了所需的对象。

Note: If you want to learn about SOLID principles by Uncle Bob then you can head to this link.

注意：如果您想了解Bob叔叔的SOLID原理，则可以转到此链接 。

使用DI的好处 (Benefits of using DI)

1. Helps in Unit testing.
   帮助进行单元测试。
2. Boiler plate code is reduced, as initializing of dependencies is done by the injector component.
   由于依赖关系的初始化是由喷油器组件完成的，因此减少了锅炉板代码。
3. Extending the application becomes easier.
   扩展应用程序变得更加容易。
4. Helps to enable loose coupling, which is important in application programming.
   帮助实现松耦合，这在应用程序编程中很重要。

DI的缺点 (Disadvantages of DI)

1. It’s a bit complex to learn, and if overused can lead to management issues and other problems.
   学习起来有点复杂，如果使用过度会导致管理问题和其他问题。
2. Many compile time errors are pushed to run-time.
   许多编译时错误被推送到运行时。
3. Dependency injection frameworks are implemented with reflection or dynamic programming. This can hinder use of IDE automation, such as “find references”, “show call hierarchy” and safe refactoring.
   依赖注入框架是通过反射或动态编程实现的。 这可能会妨碍IDE自动化的使用，例如“查找引用”，“显示调用层次结构”和安全重构。

You can implement dependency injection on your own (Pure Vanilla) or use third-party libraries or frameworks.

您可以自己(纯Vanilla)实现依赖项注入，也可以使用第三方库或框架。

实现DI的库和框架 (Libraries and Frameworks that implement DI)

• Spring (Java)

  Spring (Java)

• Google Guice (Java)

  Google Guice (Java)

• Dagger (Java and Android)

  匕首 (Java和Android)

• Castle Windsor (.NET)

  温莎城堡 (.NET)

• Unity(.NET)

  Unity (.NET)

To learn more about dependency injection, you can check out the below resources:

要了解有关依赖项注入的更多信息，您可以查看以下资源：

Java Dependency Injection — DI Design Pattern Example Tutorial — JournalDev

Java依赖注入— DI设计模式示例教程— JournalDev

Using dependency injection in Java — Introduction — Tutorial — Vogella

在Java中使用依赖注入—简介—教程— Vogella

Inversion of Control Containers and the Dependency Injection pattern — Martin Fowler

控制容器的反转和依赖注入模式— Martin Fowler

Hope it helps!

希望能帮助到你！

If you liked the article and want to read more amazing articles, then do follow me here (Bhavya Karia) and show your support as it motivates me to write more.

如果您喜欢这篇文章并想精彩的文章，请在这里关注我( Bhavya Karia )，并表达您的支持，因为它激发了我写更多文章的动力。

If you have any questions or feedback for me than let’s connect on LinkedIn, Twitter , Facebook.

如果您对我有任何疑问或反馈，请让我们在LinkedIn， Twitter， Facebook上进行连接 。

编辑1： (Edit 1:)

Thanks to Sergey Ufocoder now this article has been converted into the Russian language. My Russian friends and who all can read the Russian language do give it a read.

感谢Sergey Ufocoder，现在这篇文章已被转换成俄语。 我的俄罗斯朋友以及所有人都可以读俄文的确可以读一读。

Link to the article

链接到文章

Also, if you want to apply DI in JavaScript and are looking for a library then Jo Surikat suggests that you give a try to his library.

另外，如果您想在JavaScript中应用DI并正在寻找一个库，那么Jo Surikat建议您尝试一下他的库。

Di-Ninja

忍者

One more awesome DI library in JavaScript was suggested by Nicolas Froidure.

Nicolas Froidure提出了JavaScript中另一个很棒的DI库。

knifecycle

刀轮

编辑2： (Edit 2:)

If you are a PHP developer then don’t worry, got you all covered as well. Gordon Forsythe recommended this amazing library which you all might want to try out.

如果您是PHP开发人员，那么请不要担心，也涵盖了所有方面。 Gordon Forsythe推荐了这个令人惊叹的库，您可能想尝试一下。

auryn

奥林

Thanks for all the kind words that I have been receiving. Do share the article so that more and more people can be benefited.

感谢您收到的所有客气话。 一定要分享文章，以便使越来越多的人受益。

If you learnt even a thing or two, please share this story!

如果您只学会了一两件事，请分享这个故事！

翻译自: https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/

框架依赖注入和普通依赖注入