Dependency injection (original) (raw)

About DBpedia

Vkládání závislostí (anglicky Dependency injection (DI)) je v objektově orientovaném programování technika pro vkládání závislostí mezi jednotlivými komponentami programu tak, aby jedna komponenta mohla používat druhou, aniž by na ni měla v době sestavování programu referenci. Dependency injection lze chápat jako novější název pro Inversion of Control (IoC), ale v užším významu.[zdroj?] Jedná se o konkrétní techniku IoC.

thumbnail

Property Value
dbo:abstract Vkládání závislostí (anglicky Dependency injection (DI)) je v objektově orientovaném programování technika pro vkládání závislostí mezi jednotlivými komponentami programu tak, aby jedna komponenta mohla používat druhou, aniž by na ni měla v době sestavování programu referenci. Dependency injection lze chápat jako novější název pro Inversion of Control (IoC), ale v užším významu.[zdroj?] Jedná se o konkrétní techniku IoC. (cs) في هندسة البرمجيات، يعد حقن التبعية (بالإنجليزية: dependency injection)‏ تقنية يتلقى فيها كائن كائنات أخرى يعتمد عليها. تسمى هذه الكائنات الأخرى التبعيات. في العلاقة النموذجية «باستخدام» يسمى الكائن المتلقي عميل (بالإنجليزية: Client)‏ ويسمى الكائن الذي تم تمريره (أي تم حقنه) خدمة (بالإنجليزية: Service)‏. يمكن أن يكون الكود الذي ينقل الخدمة إلى العميل أنواعًا كثيرة ويسمى الحاقن. بدلاً من تحديد العميل للخدمة التي سيستخدمها، يخبر الحاقن العميل بالخدمة التي سيستخدمها. تشير «الحقن» إلى تمرير التبعية (خدمة) إلى الكائن (العميل) الذي قد يستخدمها. الخدمة تصبح جزءاً من حالة العميل. يعد تمرير الخدمة إلى العميل، بدلاً من السماح للعميل ببناء الخدمة أو العثور عليها، شرطاً أساسياً للنمط. النية من حقن التبعية هو تحقيق فصل الاهتمامات الخاصة بالبناء واستخدام الكائنات. يمكن أن يؤدي ذلك إلى زيادة إمكانية القراءة وإعادة استخدام الكود. حقن التبعية هو شكل من أشكال التقنية الأوسع لعكس التحكم. لا يجب على العميل الذي يريد استدعاء بعض الخدمات معرفة كيفية إنشاء هذه الخدمات. بدلاً من ذلك، يفوض العميل مسؤولية توفير خدماته للكود الخارجي (الحاقن). لا يُسمح للعميل باستدعاء كود الحاقن ؛ الحاقن هو الذي يبني الخدمات. ثم يقوم الحاقن بحقن (تمرير) الخدمات في العميل التي قد تكون موجودة بالفعل أو قد يتم بناؤها بواسطة الحاقن. ثم يستخدم العميل الخدمات. هذا يعني أن العميل لا يحتاج إلى معرفة الحاقن، وكيفية إنشاء الخدمات، أو حتى الخدمات الفعلية التي يستخدمها. يحتاج العميل فقط إلى معرفة الواجهات الجوهرية للخدمات لأن هذه تحدد كيفية استخدام العميل للخدمات. وهذا يفصل مسؤولية «الاستخدام» (بالإنجليزية: "use")‏ عن مسؤولية «البناء» (بالإنجليزية: "construction")‏. (ar) Als Dependency Injection (DI, englisch dependency ‚Abhängigkeit‘ und injection ‚Injektion‘, deutsch Abhängigkeitsinjektion oder Einbringen von Abhängigkeiten) wird in der objektorientierten Programmierung ein Entwurfsmuster bezeichnet, welches die Abhängigkeiten eines Objekts zur Laufzeit reglementiert: Benötigt ein Objekt beispielsweise bei seiner Initialisierung ein anderes Objekt, ist diese Abhängigkeit an einem zentralen Ort hinterlegt – es wird also nicht vom initialisierten Objekt selbst erzeugt. (de) In software engineering, dependency injection is a design pattern in which an object or function receives other objects or functions that it depends on. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services. Instead, the receiving 'client' (object or function) is provided with its dependencies by external code (an 'injector'), which it is not aware of. Dependency injection helps by making implicit dependencies explicit and helps solve the following problems: * How can a class be independent from the creation of the objects it depends on? * How can an application, and the objects it uses support different configurations? * How can the behavior of a piece of code be changed without editing it directly? In addition, dependency injection is used for keeping code in-line with the dependency inversion principle. Fundamentally, dependency injection consists of passing parameters to a method. Because the client does not build or find the service itself, it typically only needs to declare the interfaces of the services it uses, rather than their concrete implementations. This makes it easier to change which services are actually used at runtime, especially in statically-typed languages where changing the underlying objects would otherwise require re-compiling the source code. An example of inversion of control without dependency injection is the template method pattern, where polymorphism is achieved through subclassing. In contrast, dependency injection implements inversion of control through composition, and is often similar to the strategy pattern. A difference is that the strategy pattern is intended for dependencies that are interchangeable throughout an object's lifetime, whereas with dependency injection typically only a single instance of a dependency is used. (en) En informática, inyección de dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase la que cree dichos objetos. Esos objetos cumplen contratos que necesitan nuestras clases para poder funcionar (de ahí el concepto de dependencia). Nuestras clases no crean los objetos que necesitan, sino que se los suministra otra clase 'contenedora' que inyectará la implementación deseada a nuestro contrato.​ En otras palabras, se trata de un patrón de diseño que se encarga de extraer la responsabilidad de la creación de instancias de un componente para delegarla en otro. El término fue acuñado por primera vez por Martin Fowler. (es) L'injection de dépendances (dependency injection en anglais) est un mécanisme qui permet d'implémenter le principe de l'inversion de contrôle. Il consiste à créer dynamiquement (injecter) les dépendances entre les différents objets en s'appuyant sur une description (fichier de configuration ou métadonnées) ou de manière programmatique. Ainsi les dépendances entre composants logiciels ne sont plus exprimées dans le code de manière statique mais déterminées dynamiquement à l'exécution. (fr) 依存性の注入（いぞんせいのちゅうにゅう、英: Dependency injection）とは、あるオブジェクトや関数が、依存する他のオブジェクトや関数を受け取るデザインパターンである。英語の頭文字からDIと略される。DIは制御の反転の一種で、オブジェクトの作成と利用について関心の分離を行い、疎結合なプログラムを実現することを目的としている。 dependencyを「依存性」と訳すのは本来の意味 から外れているため「依存オブジェクト注入」の用語を採用する文献も複数存在する。 (ja) Dependency injection (DI) è un design pattern della Programmazione orientata agli oggetti il cui scopo è quello di semplificare lo sviluppo e migliorare la testabilità di software di grandi dimensioni. Per utilizzare tale design pattern è sufficiente dichiarare le dipendenze di cui un componente necessita (dette anche interface contract). Quando il componente verrà istanziato, un iniettore si prenderà carico di risolvere le dipendenze (attuando dunque l'inversione del controllo). Se è la prima volta che si tenta di risolvere una dipendenza l'injector istanzierà il componente dipendente, lo salverà in un contenitore di istanze e lo restituirà. Se non è la prima volta, allora restituirà la copia salvata nel contenitore. Una volta risolte tutte le dipendenze, il controllo può tornare al componente applicativo. Il pattern Dependency Injection coinvolge almeno tre elementi: * una componente dipendente, * la dichiarazione delle dipendenze del componente, definite come interface contract, * un injector (chiamato anche provider o container) che crea, a richiesta, le istanze delle classi che implementano delle dependency interface. (it) Dependency injection is een geavanceerd ontwerppatroon uit de informatica dat het mogelijk maakt klassen losjes te koppelen. Dit wil zeggen dat ze data kunnen uitwisselen zonder dat deze relatie hard (in de broncode) vastgelegd is; althans niet door de programmeurs van die (beide) klassen. Traditioneel gebeurt dat vaak wel, waardoor die klassen moeilijk te hergebruiken zijn. Soms wordt 'dependency injection' gezien als een bijzondere vorm van 'inversion of control', wat voor het eerst beschreven werd door Martin Fowler. (nl) 소프트웨어 엔지니어링에서 의존성 주입(dependency injection)은 하나의 객체가 다른 객체의 의존성을 제공하는 테크닉이다. "의존성"은 예를 들어 서비스로 사용할 수 있는 객체이다. 클라이언트가 어떤 서비스를 사용할 것인지 지정하는 대신, 클라이언트에게 무슨 서비스를 사용할 것인지를 말해주는 것이다. "주입"은 의존성(서비스)을 사용하려는 객체(클라이언트)로 전달하는 것을 의미한다. 서비스는 클라이언트 상태의 일부이다. 클라이언트가 서비스를 구축하거나 찾는 것을 허용하는 대신 클라이언트에게 서비스를 전달하는 것이 패턴의 기본 요건이다. 의존성 주입의 의도는 객체의 생성과 사용의 관심을 분리하는 것이다. 이는 가독성과 코드 재사용을 높혀준다. 의존성 주입은 광범위한 역제어 테크닉의 한 형태이다. 어떤 서비스를 호출하려는 클라이언트는 그 서비스가 어떻게 구성되었는지 알지 못해야 한다. 클라이언트는 대신 서비스 제공에 대한 책임을 외부 코드(주입자)로 위임한다. 클라이언트는 주입자 코드를 호출할 수 없다. 그 다음, 주입자는 이미 존재하거나 주입자에 의해 구성되었을 서비스를 클라이언트로 주입(전달)한다. 그리고 나서 클라이언트는 서비스를 사용한다. 이는 클라이언트가 주입자와 서비스 구성 방식 또는 사용중인 실제 서비스에 대해 알 필요가 없음을 의미한다. 클라이언트는 서비스의 사용 방식을 정의하고 있는 서비스의 고유한 인터페이스에 대해서만 알면 된다. 이것은 "구성"의 책임으로부터 "사용"의 책임을 구분한다. (ko) Wstrzykiwanie zależności (ang. Dependency Injection, DI) – wzorzec projektowy i wzorzec architektury oprogramowania polegający na usuwaniu bezpośrednich zależności pomiędzy komponentami na rzecz architektury typu plug-in. Polega na przekazywaniu gotowych, utworzonych instancji obiektów udostępniających swoje metody i właściwości obiektom, które z nich korzystają (np. jako parametry konstruktora). Stanowi alternatywę do podejścia, gdzie obiekty tworzą instancję obiektów, z których korzystają np. we własnym konstruktorze. Jest on często utożsamiany z odwróceniem sterowania (ang. Inversion of Control, IoC), jakkolwiek z technicznego punktu widzenia DI jest jedną ze szczególnych (obecnie najpopularniejszą) realizacji paradygmatu IoC. DI silnie preferuje zewnętrzne tworzenie połączeń (zależności) pomiędzy komponentami oprogramowania (np. asocjacje w klasach), nad zlecaniem tworzenia zależności im samym. Jest to wzorzec, w którym odpowiedzialność za tworzenie i łączenie obiektów jest przeniesiona z obiektów do fabryki (np. kontenera IoC). Na żądanie kodu fabryka tworzy obiekt, lub udostępnia obiekt z puli obiektów, ustawiając mu powiązania z innymi obiektami (np. wstrzykiwanie konstruktorem – Constructor Injection, wstrzykiwanie mutatorami – Setter Injection, użycie interfejsu – Interface Injection lub w mieszany sposób). DI jest więc realizacją „odwrócenia sterowania” w sensie tworzenia i wiązania obiektów. W rozbudowanych implementacjach fabryka może wykonywać czynności dodatkowe, np. Spring Framework pozwala na używanie aspektów, można więc do obiektu dodać automatycznie obsługę transakcji, logowania, itp. DI jest sposobem osiągnięcia (ang. loose coupling). Użycie tej techniki pozwala tworzyć łatwo testowalne obiekty. Sprawdza się szczególnie w powiązaniu z programowaniem sterowanym testami (ang. test-driven development). Polega ono w skrócie na następującym tworzeniu oprogramowania: opracowujemy interfejsy (diagram klas), opracowujemy testy jednostkowe, które testują funkcjonalność interfejsu (w jaki sposób przetestować, czy działanie jest poprawne), a dopiero później piszemy implementację. Unikanie zależności od konkretnych implementacji współpracujących klas, a bazowanie tylko na interfejsach umożliwia tworzenie kontrolowanych testów - jesteśmy w stanie skupić się wyłącznie na funkcjonalności wybranej klasy; zwłaszcza, gdy wykorzystamy obiekty-zaślepki (ang. mock-objects, proste pseudoimplementacje, używane w celu testowania). DI pozwala wstrzyknąć do obiektów testowanych zależności od obiektów-zaślepek. W środowisku produkcyjnym do obiektów tych wstrzykiwane są zależności od prawdziwych obiektów. (pl) Injeção de dependência (Dependency Injection, em inglês) é um padrão de desenvolvimento de programas de computadores utilizado quando é necessário manter baixo o nível de acoplamento entre diferentes módulos de um sistema. Nesta solução as dependências entre os módulos não são definidas programaticamente, mas sim pela configuração de uma infraestrutura de software que é responsável por "injetar" em cada componente suas dependências declaradas. A Injeção de dependência se relaciona com o padrão Inversão de controle mas não pode ser considerada um sinônimo deste. Alguns dos frameworks mais utilizados que fazem uso de injeção de dependência são o Spring, , Laravel e o AngularJS. (pt) 在软件工程中，依赖注入（dependency injection，缩写为 DI）是一种软件设计模式，也是实现控制反转的其中一种技术。這种模式能让一个物件接收它所依赖的其他物件。“依赖”是指接收方所需的对象。“注入”是指将“依赖”传递给接收方的过程。在“注入”之后，接收方才会调用该“依赖”。此模式确保了任何想要使用给定服务的物件不需要知道如何建立這些服务。取而代之的是，连接收方物件（像是 client）也不知道它存在的外部代码（注入器）提供接收方所需的服务。 注：编程语言层次下，“接收方”为对象和 class，“依赖”为变量。在提供服务的角度下，“接收方”为客户端，“依赖”为服务。 该设计的目的是为了分离关注点，分离接收方和依赖，从而提供松耦合以及代码重用性。 传统编程方式，客户对象自己创建一个服务实例并使用它。这带来的缺点和问题是： * 如果使用不同类型的服务对象，就需要修改、重新编译客户类。 * 客户类需要通过配置来适配服务类及服务类的依赖。如果程序有多个类都使用同一个服务类，这些配置就会变得复杂并分散在程序各处。 * 难以单元测试。本来需要使用服务类的 mock 或 stub，在这种方式下不太可行。 依赖注入可以解决上述问题： * 使用接口或抽象基类，来抽象化依赖实现。 * 依赖在一个服务容器中注册。客户类构造函数被注入服务实例。框架负责创建依赖实例并在没有使用者时销毁它。 (zh) Впровадження залежності (англ. Dependency injection, DI) — шаблон проєктування програмного забезпечення, що передбачає надання зовнішньої залежності програмному компоненту, використовуючи «інверсію управління» (англ. Inversion of control, IoC) для розв'язання (отримання) залежностей. Впровадження — це передача залежності (тобто, сервісу) залежному об'єкту (тобто, клієнту). Передавати залежності клієнту замість дозволити клієнту створити сервіс є фундаментальною вимогою до цього шаблону проєктування. Існує три найбільш поширені форми впровадження залежностей: * впровадження в конструктор, * впровадження у властивість, * впровадження в метод. (uk) Внедрение зависимости (англ. Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (англ. Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму. (ru)
dbo:thumbnail wiki-commons:Special:FilePath/DependencyInjectionServiceProvider.png?width=300
dbo:wikiPageExternalLink http://blog.ploeh.dk/2011/07/28/CompositionRoot/ http://blog.thecodewhisperer.com/2011/12/07/refactor-your-way-to-a-dependency-injection-container/ http://php-di.org/doc/understanding-di.html http://tutorials.jenkov.com/dependency-injection/index.html http://www.griffincaprio.com/blog/2018/04/design-patterns-dependency-injection.html http://www.javalobby.org/articles/di-heritage/ https://www.theserverside.com/news/1321158/A-beginners-guide-to-Dependency-Injection http://martinfowler.com/articles/injection.html http://martinfowler.com/eaaCatalog/plugin.html http://msdn.microsoft.com/en-us/library/dd460648.aspx https://medium.com/@wrong.about/you-dont-need-a-dependency-injection-container-10a5d4a5f878 https://web.archive.org/web/20080311121626/http:/www.developer.com/net/net/article.php/3636501 https://web.archive.org/web/20120425150101/http:/www.midmarsh.co.uk/planetjava/tutorials/language/WatchingtheObservables.PDF http://www.ddj.com/185300375 http://www.developer.com/net/net/article.php/3636501
dbo:wikiPageID 1484696 (xsd:integer)
dbo:wikiPageLength 30176 (xsd:nonNegativeInteger)
dbo:wikiPageRevisionID 1118304741 (xsd:integer)
dbo:wikiPageWikiLink dbr:Car dbr:Electric_car dbr:Member_variable dbr:Mock_object dbr:Architecture_description_language dbc:Component-based_software_engineering dbr:Value_object dbr:Interface_(computing) dbr:Internet_Message_Access_Protocol dbr:Inversion_of_control dbr:Object-oriented_programming dbr:Object_(computer_science) dbr:Quaject dbr:Circular_dependency dbr:Class_(computer_programming) dbr:Gasoline dbr:Constructor_(object-oriented_programming) dbr:Creational_pattern dbr:AngularJS dbr:Application_programming_interface dbr:Boilerplate_code dbr:Subroutine dbr:Client_(computing) dbr:Email dbr:Parameter_(computer_programming) dbr:Plug-in_(computing) dbr:Polymorphism_(computer_science) dbr:Post_Office_Protocol dbr:Method_stub dbr:State_(computer_science) dbr:Strategy_pattern dbr:Software_engineering dbr:C＃_(programming_language) dbc:Software_architecture dbr:Dr._Dobb's_Journal dbr:Diesel_fuel dbr:Object_composition dbr:Java_(programming_language) dbr:Coupling_(computer_programming) dbc:Articles_with_example_Java_code dbc:Software_design_patterns dbr:Code_refactoring dbr:Template_method_pattern dbr:Builder_pattern dbr:Plain_Old_Java_Object dbr:Software_design_pattern dbr:Software_framework dbr:Spring_Framework dbr:Factory_pattern dbr:Inheritance_(object-oriented_programming) dbr:Integrated_development_environment dbr:Loose_coupling dbr:Separation_of_concerns dbr:Service_(systems_architecture) dbr:Unit_testing dbr:Factory_(object-oriented_programming) dbr:Object_lifetime dbr:Service_locator_pattern dbr:Statically_typed_language dbr:Setter_method dbr:Andrew_McVeigh dbr:File:DependencyInjectionServiceProvider.png
dbp:align right (en)
dbp:date 2008-03-11 (xsd:date)
dbp:quote Dependency injection for five-year-olds When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy don't want you to have. You might even be looking for something we don't even have or which has expired. What you should be doing is stating a need, "I need something to drink with lunch," and then we will make sure you have something when you sit down to eat. (en)
dbp:source 0001-10-28 (xsd:gMonthDay)
dbp:url https://web.archive.org/web/20080311121626/http:/www.developer.com/net/net/article.php/3636501
dbp:width 33.0
dbp:wikiPageUsesTemplate dbt:Commons_category dbt:Quote_box dbt:Reflist dbt:Short_description dbt:Webarchive dbt:Design_Patterns_patterns
dcterms:subject dbc:Component-based_software_engineering dbc:Software_architecture dbc:Articles_with_example_Java_code dbc:Software_design_patterns
gold:hypernym dbr:Pattern
rdf:type yago:WikicatSoftwareDesignPatterns yago:Abstraction100002137 yago:Cognition100023271 yago:Concept105835747 yago:Content105809192 yago:Form105930736 yago:GrammaticalRelation113796779 yago:Idea105833840 yago:Inflection113803782 yago:LinguisticRelation113797142 yago:Paradigm113804375 yago:PsychologicalFeature100023100 yago:Relation100031921 dbo:Disease dbo:MusicGenre yago:Structure105726345 yago:WikicatProgrammingLanguageConcepts yago:WikicatProgrammingParadigms
rdfs:comment Vkládání závislostí (anglicky Dependency injection (DI)) je v objektově orientovaném programování technika pro vkládání závislostí mezi jednotlivými komponentami programu tak, aby jedna komponenta mohla používat druhou, aniž by na ni měla v době sestavování programu referenci. Dependency injection lze chápat jako novější název pro Inversion of Control (IoC), ale v užším významu.[zdroj?] Jedná se o konkrétní techniku IoC. (cs) Als Dependency Injection (DI, englisch dependency ‚Abhängigkeit‘ und injection ‚Injektion‘, deutsch Abhängigkeitsinjektion oder Einbringen von Abhängigkeiten) wird in der objektorientierten Programmierung ein Entwurfsmuster bezeichnet, welches die Abhängigkeiten eines Objekts zur Laufzeit reglementiert: Benötigt ein Objekt beispielsweise bei seiner Initialisierung ein anderes Objekt, ist diese Abhängigkeit an einem zentralen Ort hinterlegt – es wird also nicht vom initialisierten Objekt selbst erzeugt. (de) L'injection de dépendances (dependency injection en anglais) est un mécanisme qui permet d'implémenter le principe de l'inversion de contrôle. Il consiste à créer dynamiquement (injecter) les dépendances entre les différents objets en s'appuyant sur une description (fichier de configuration ou métadonnées) ou de manière programmatique. Ainsi les dépendances entre composants logiciels ne sont plus exprimées dans le code de manière statique mais déterminées dynamiquement à l'exécution. (fr) 依存性の注入（いぞんせいのちゅうにゅう、英: Dependency injection）とは、あるオブジェクトや関数が、依存する他のオブジェクトや関数を受け取るデザインパターンである。英語の頭文字からDIと略される。DIは制御の反転の一種で、オブジェクトの作成と利用について関心の分離を行い、疎結合なプログラムを実現することを目的としている。 dependencyを「依存性」と訳すのは本来の意味 から外れているため「依存オブジェクト注入」の用語を採用する文献も複数存在する。 (ja) Dependency injection is een geavanceerd ontwerppatroon uit de informatica dat het mogelijk maakt klassen losjes te koppelen. Dit wil zeggen dat ze data kunnen uitwisselen zonder dat deze relatie hard (in de broncode) vastgelegd is; althans niet door de programmeurs van die (beide) klassen. Traditioneel gebeurt dat vaak wel, waardoor die klassen moeilijk te hergebruiken zijn. Soms wordt 'dependency injection' gezien als een bijzondere vorm van 'inversion of control', wat voor het eerst beschreven werd door Martin Fowler. (nl) 在软件工程中，依赖注入（dependency injection，缩写为 DI）是一种软件设计模式，也是实现控制反转的其中一种技术。這种模式能让一个物件接收它所依赖的其他物件。“依赖”是指接收方所需的对象。“注入”是指将“依赖”传递给接收方的过程。在“注入”之后，接收方才会调用该“依赖”。此模式确保了任何想要使用给定服务的物件不需要知道如何建立這些服务。取而代之的是，连接收方物件（像是 client）也不知道它存在的外部代码（注入器）提供接收方所需的服务。 注：编程语言层次下，“接收方”为对象和 class，“依赖”为变量。在提供服务的角度下，“接收方”为客户端，“依赖”为服务。 该设计的目的是为了分离关注点，分离接收方和依赖，从而提供松耦合以及代码重用性。 传统编程方式，客户对象自己创建一个服务实例并使用它。这带来的缺点和问题是： * 如果使用不同类型的服务对象，就需要修改、重新编译客户类。 * 客户类需要通过配置来适配服务类及服务类的依赖。如果程序有多个类都使用同一个服务类，这些配置就会变得复杂并分散在程序各处。 * 难以单元测试。本来需要使用服务类的 mock 或 stub，在这种方式下不太可行。 依赖注入可以解决上述问题： * 使用接口或抽象基类，来抽象化依赖实现。 * 依赖在一个服务容器中注册。客户类构造函数被注入服务实例。框架负责创建依赖实例并在没有使用者时销毁它。 (zh) Внедрение зависимости (англ. Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (англ. Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму. (ru) في هندسة البرمجيات، يعد حقن التبعية (بالإنجليزية: dependency injection)‏ تقنية يتلقى فيها كائن كائنات أخرى يعتمد عليها. تسمى هذه الكائنات الأخرى التبعيات. في العلاقة النموذجية «باستخدام» يسمى الكائن المتلقي عميل (بالإنجليزية: Client)‏ ويسمى الكائن الذي تم تمريره (أي تم حقنه) خدمة (بالإنجليزية: Service)‏. يمكن أن يكون الكود الذي ينقل الخدمة إلى العميل أنواعًا كثيرة ويسمى الحاقن. بدلاً من تحديد العميل للخدمة التي سيستخدمها، يخبر الحاقن العميل بالخدمة التي سيستخدمها. تشير «الحقن» إلى تمرير التبعية (خدمة) إلى الكائن (العميل) الذي قد يستخدمها. (ar) In software engineering, dependency injection is a design pattern in which an object or function receives other objects or functions that it depends on. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services. Instead, the receiving 'client' (object or function) is provided with its dependencies by external code (an 'injector'), which it is not aware of. Dependency injection helps by making implicit dependencies explicit and helps solve the following problems: (en) En informática, inyección de dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase la que cree dichos objetos. Esos objetos cumplen contratos que necesitan nuestras clases para poder funcionar (de ahí el concepto de dependencia). Nuestras clases no crean los objetos que necesitan, sino que se los suministra otra clase 'contenedora' que inyectará la implementación deseada a nuestro contrato.​ (es) Dependency injection (DI) è un design pattern della Programmazione orientata agli oggetti il cui scopo è quello di semplificare lo sviluppo e migliorare la testabilità di software di grandi dimensioni. Il pattern Dependency Injection coinvolge almeno tre elementi: * una componente dipendente, * la dichiarazione delle dipendenze del componente, definite come interface contract, * un injector (chiamato anche provider o container) che crea, a richiesta, le istanze delle classi che implementano delle dependency interface. (it) 소프트웨어 엔지니어링에서 의존성 주입(dependency injection)은 하나의 객체가 다른 객체의 의존성을 제공하는 테크닉이다. "의존성"은 예를 들어 서비스로 사용할 수 있는 객체이다. 클라이언트가 어떤 서비스를 사용할 것인지 지정하는 대신, 클라이언트에게 무슨 서비스를 사용할 것인지를 말해주는 것이다. "주입"은 의존성(서비스)을 사용하려는 객체(클라이언트)로 전달하는 것을 의미한다. 서비스는 클라이언트 상태의 일부이다. 클라이언트가 서비스를 구축하거나 찾는 것을 허용하는 대신 클라이언트에게 서비스를 전달하는 것이 패턴의 기본 요건이다. 의존성 주입의 의도는 객체의 생성과 사용의 관심을 분리하는 것이다. 이는 가독성과 코드 재사용을 높혀준다. (ko) Wstrzykiwanie zależności (ang. Dependency Injection, DI) – wzorzec projektowy i wzorzec architektury oprogramowania polegający na usuwaniu bezpośrednich zależności pomiędzy komponentami na rzecz architektury typu plug-in. Polega na przekazywaniu gotowych, utworzonych instancji obiektów udostępniających swoje metody i właściwości obiektom, które z nich korzystają (np. jako parametry konstruktora). Stanowi alternatywę do podejścia, gdzie obiekty tworzą instancję obiektów, z których korzystają np. we własnym konstruktorze. DI jest sposobem osiągnięcia (ang. loose coupling). (pl) Injeção de dependência (Dependency Injection, em inglês) é um padrão de desenvolvimento de programas de computadores utilizado quando é necessário manter baixo o nível de acoplamento entre diferentes módulos de um sistema. Nesta solução as dependências entre os módulos não são definidas programaticamente, mas sim pela configuração de uma infraestrutura de software que é responsável por "injetar" em cada componente suas dependências declaradas. A Injeção de dependência se relaciona com o padrão Inversão de controle mas não pode ser considerada um sinônimo deste. (pt) Впровадження залежності (англ. Dependency injection, DI) — шаблон проєктування програмного забезпечення, що передбачає надання зовнішньої залежності програмному компоненту, використовуючи «інверсію управління» (англ. Inversion of control, IoC) для розв'язання (отримання) залежностей. Впровадження — це передача залежності (тобто, сервісу) залежному об'єкту (тобто, клієнту). Передавати залежності клієнту замість дозволити клієнту створити сервіс є фундаментальною вимогою до цього шаблону проєктування. Існує три найбільш поширені форми впровадження залежностей: (uk)
rdfs:label حقن التبعية (ar) Vkládání závislostí (cs) Dependency Injection (de) Inyección de dependencias (es) Dependency injection (en) Injection de dépendances (fr) Dependency injection (it) 의존성 주입 (ko) 依存性の注入 (ja) Wstrzykiwanie zależności (pl) Dependency injection (nl) Внедрение зависимости (ru) Injeção de dependência (pt) Впровадження залежностей (uk) 依赖注入 (zh)
owl:sameAs freebase:Dependency injection yago-res:Dependency injection wikidata:Dependency injection dbpedia-ar:Dependency injection dbpedia-cs:Dependency injection dbpedia-de:Dependency injection dbpedia-es:Dependency injection dbpedia-fa:Dependency injection dbpedia-fr:Dependency injection dbpedia-he:Dependency injection dbpedia-hu:Dependency injection dbpedia-it:Dependency injection dbpedia-ja:Dependency injection dbpedia-kk:Dependency injection dbpedia-ko:Dependency injection dbpedia-nl:Dependency injection dbpedia-pl:Dependency injection dbpedia-pt:Dependency injection dbpedia-ru:Dependency injection dbpedia-uk:Dependency injection dbpedia-zh:Dependency injection https://global.dbpedia.org/id/4otdD
prov:wasDerivedFrom wikipedia-en:Dependency_injection?oldid=1118304741&ns=0
foaf:depiction wiki-commons:Special:FilePath/DependencyInjectionServiceProvider.png
foaf:isPrimaryTopicOf wikipedia-en:Dependency_injection
is dbo:genre of dbr:Google_Guice
is dbo:wikiPageDisambiguates of dbr:Injection dbr:Di
is dbo:wikiPageRedirects of dbr:Dependency_Injection dbr:Contexts_and_Dependency_Injection
is dbo:wikiPageWikiLink of dbr:Canigó_(framework) dbr:Sandi_Metz dbr:Delphi_(software) dbr:Dependency_Injection dbr:Resin_(software) dbr:Dependency_inversion_principle dbr:Index_of_object-oriented_programming_articles dbr:Inversion_of_control dbr:Jakarta_Enterprise_Beans dbr:List_of_programmers dbr:Injection dbr:Object-oriented_design dbr:Quaject dbr:Citrine_(programming_language) dbr:Ember.js dbr:Google_Guava dbr:Google_Guice dbr:Creational_pattern dbr:AngularJS dbr:Apache_Struts_2 dbr:Appserver.io dbr:Colony_Framework dbr:Dagger_(disambiguation) dbr:Di dbr:PHP_Standard_Recommendation dbr:Strategy_pattern dbr:Test-driven_development dbr:Active_record_pattern dbr:Data,_context_and_interaction dbr:GlassFish_HK2 dbr:DIC dbr:ASP.NET_Core dbr:Parametrization_(geometry) dbr:List_of_JBoss_software dbr:Resource_management_(computing) dbr:Jakarta_EE dbr:Symfony dbr:ColdSpring_Framework dbr:Java_Management_Extensions dbr:Mock_trainwreck dbr:Play_Framework dbr:Software_design_pattern dbr:Spring_Framework dbr:Microsoft_Enterprise_Library dbr:Xtext dbr:Contexts_and_Dependency_Injection dbr:Real-Time_Object-Oriented_Modeling dbr:Plain_old_CLR_object dbr:Service_locator_pattern dbr:Seasar
is owl:differentFrom of dbr:Code_injection
is foaf:primaryTopic of wikipedia-en:Dependency_injection