zoukankan      html  css  js  c++  java
  • Inversion of Control vs Dependency Injection

    Inversion of Control vs Dependency Injection

    回答1

    IoC is a generic term meaning that rather than having the application call the implementations provided by a library (also know as toolkit), a framework calls the implementations provided by the application.

    DI is a form of IoC, where implementations are passed into an object through constructors/setters/service lookups, which the object will 'depend' on in order to behave correctly.

    IoC without using DI, for example would be the Template pattern because the implementation can only be changed through sub-classing.

    DI frameworks are designed to make use of DI and can define interfaces (or Annotations in Java) to make it easy to pass in the implementations.

    IoC containers are DI frameworks that can work outside of the programming language. In some you can configure which implementations to use in metadata files (e.g. XML) which are less invasive. With some you can do IoC that would normally be impossible like inject an implementation at pointcuts.

    See also this Martin Fowler's article.

    回答2

    In short, IoC is a much broader term that includes, but is not limited to, DI

    The term Inversion of Control (IoC) originally meant any sort of programming style where an overall framework or run-time controlled the program flow

    Before DI had a name, people started to refer to frameworks that manage Dependencies as Inversion of Control Containers, and soon, the meaning of IoC gradually drifted towards that particular meaning: Inversion of Control over Dependencies.

    Inversion of Control (IoC) means that objects do not create other objects on which they rely to do their work. Instead, they get the objects that they need from an outside source (for example, an xml configuration file).

    Dependency Injection (DI) means that this is done without the object intervention, usually by a framework component that passes constructor parameters and set properties.

    回答3

    https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO

    IoC (Inversion of Control) :- It’s a generic term and implemented in several ways (events, delegates etc).

    DI (Dependency Injection) :- DI is a sub-type of IoC and is implemented by constructor injection, setter injection or Interface injection.

    But, Spring supports only the following two types :

    • Setter Injection
      • Setter-based DI is realized by calling setter methods on the user’s beans after invoking a no-argument constructor or no-argument static factory method to instantiate their bean.
    • Constructor Injection
      • Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator.Using this we can validate that the injected beans are not null and fail fast(fail on compile time and not on run-time), so while starting application itself we get NullPointerException: bean does not exist. Constructor injection is Best practice to inject dependencies.
  • 相关阅读:
    mysql千万级数据量根据索引优化查询速度
    Centos 7 开放查看端口 防火墙关闭打开
    Spring-Quartz 配置执行时间参数
    Curl命令查看请求响应时间
    Centos 7 安装 Mongodb
    配置Docker加速器
    TCP端口状态说明ESTABLISHED、TIME_WAIT
    Maven依赖项Scope属性设置含义
    实战JAVA虚拟机 JVM故障诊断与性能优化(十)---字节码的执行
    代理模式(Proxy)_java实现
  • 原文地址:https://www.cnblogs.com/chucklu/p/15507804.html
Copyright © 2011-2022 走看看