浅谈依赖注入之基础篇

最新推荐文章于 2024-08-16 22:54:40 发布
最新推荐文章于 2024-08-16 22:54:40 发布
阅读量557 收藏 1
点赞数
分类专栏： 编程思想 文章标签： class string interface setter windows constructor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingshikk/article/details/7541273
版权

鄙人才疏学浅，若有不到之处，请多指教。

最近对依赖注入突然产生了浓厚的兴趣，所以决定搜索一些资料然后自己消化一下，并稍作整理，一来以后能够翻阅温习，二来能够为初识“依赖注入”的童鞋做一些参考。闲话少说，开始正题。

1.定义

说道“依赖注入”会联系到令一个词“控制反转”，其实他们说的都是一回事儿，以下摘自百度知道对“依赖注入的”定义：

控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。 控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI。

通过定义我们也能理解到 IOC不是什么技术，与GOF一样，是一种设计模式。其目的就是降低耦合度。

2.理解

既然为“依赖注入”，那我们先搞懂什么是依赖。

简单的理解，就是一个类A使用到了令一个类B,而这种使用关系是具有偶然行的、临时性的、非常脆弱的，但是B类的变化会影响到A；也就是B作为参数被A在某个方法中使用。

现在编程比较流行的是接口驱动（面向接口编程），什么时候用接口呢？比如说B类会有多种的形态存在，但是基本行为都一样。那么B类就可以抽象出来一个接口IB，这样A就依赖于IB，也就是A依赖于接口。但是接口只是方法的签名，那么具体的实现还得是继承了IB的B1或B2，也就是所A应该能够调用具体的B1或者B2的方法，最终依赖的是B1或者B2。

代码如下：

//定义接口IB
    public interface IB
    {
        void Method();
    }

    public class B1 : IB
    {
        public void Method()
        {
            Console.WriteLine("B1的Method");
        }
    }

    public class B2 : IB
    {
        public void Method()
        {
            Console.WriteLine("B2的Method");
        }
    }

    public class A
    {
        public IB instance;

        public A(IB b)
        {
            instance = b;//实例化IB
        }

        public void Method()
        {
            //调用IB的具体的实例的方法
            instance.Method();
        }
    }

这里描述了A和IB之间的依赖关系，在A类的构造函数中需要一个IB类型的参数，并且赋值给IB类型的instance属性，这样在A的方法中可以调用instance的方法。

客户端调用：

    internal class Program
    {
        private static void Main(string[] args)
        {
            IB b1 = new B1();
            A a = new A(b1);//将b1注入到了A中
            a.Method();
        }
    }
从客户端调用的代码中不难看出，依赖注入的基本原理。通过A的构造函数传递IB的实例的过程就是依赖注入。当然我们也可以不借助构造函数，也可以给IB类型的属性构造访问器，在客户端直接访问属性进行设置。这样也完成了注入操作。

到此我们可以重新理解依赖注入的定义，因为之前的定义很模糊不够具体。

依赖注入的正式定义：

依赖注入（Dependency Injection），是这样一个过程：由于某客户类只依赖于服务类的一个接口，而不依赖于具体服务类，所以客户类只定义一个注入点。在程序运行过程中，客户类不直接实例化具体服务类实例，而是客户类的运行上下文环境或专门组件负责实例化服务类，然后将其注入到客户类中，保证客户类的正常运行。

3.依赖注入的类别

依赖注入的方式不同，之前也提到了，下边就正式定义一下依赖注入的类别。

3.1 构造注入

顾名思义，是通过客户类（A类）的构造函数，像客户类注入服务类（IB类）实例。

构造注入（Constructor Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并以构造函数为注入点，这个构造函数接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。(上边的代码就用的构造注入)

3.2  Setter注入

Setter注入（Setter Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并设置一个Set方法作为注入点，这个Set方法接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。

也就是我刚刚上边提到的 定义属性访问器来赋值给IB类型的属性的方式进行注入。

代码如下：

    //定义接口IB（服务类）
    public interface IB
    {
        void Method();
    }

    public class B1 : IB
    {
        public void Method()
        {
            Console.WriteLine("B1的Method");
        }
    }

    public class B2 : IB
    {
        public void Method()
        {
            Console.WriteLine("B2的Method");
        }
    }

    //客户类
    public class A
    {
        private IB instance;

        public A()
        {
        }

        //注入点
        public IB Set_instance
        {
            set { instance = value; }
        }

        public void Method()
        {
            //调用IB的具体的实例的方法
            instance.Method();
        }
    }

    internal class Program
    {
        //客户端调用
        private static void Main(string[] args)
        {
            IB b1 = new B1();
            A a = new A();
            a.Set_instance = b1;//将b1注入到了A中
            a.Method();
        }
    }
3.3 依赖获取

依赖获取（Dependency Locate）是指在系统中提供一个获取点，客户类仍然依赖服务类的接口。当客户类需要服务类时，从获取点主动取得指定的服务类，具体的服务类类型由获取点的配置决定。

依赖获取变被动为主动

具体代码如下（摘自张洋http://www.cnblogs.com/leoo2sk/archive/2009/06/17/1504693.html）

下面给一个具体的例子，现在我们假设有个程序，既可以使用Windows风格外观，又可以使用Mac风格外观，而内部业务是一样的。

图1依赖获取示意

上图乍看有点复杂，不过如果读者熟悉Abstract Factory模式，应该能很容易看懂，这就是Abstract Factory在实际中的一个应用。这里的Factory Container作为获取点，是一个静态类，它的“Type构造函数”依据外部的XML配置文件，决定实例化哪个工厂。下面还是来看示例代码。由于不同组件的代码是相似的，这里只给出Button组件的示例代码.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal interface IButton
    {
        String ShowInfo();
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal sealed class WindowsButton : IButton
    {
        public String Description { get; private set; }
  
        public WindowsButton()
        {
            this.Description = "Windows风格按钮";
        }
  
        public String ShowInfo()
        {
            return this.Description;
        }
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal sealed class MacButton : IButton
    {
        public String Description { get; private set; }
  
        public MacButton()
        {
            this.Description = " Mac风格按钮";
        }
  
        public String ShowInfo()
        {
            return this.Description;
        }
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal interface IFactory
    {
        IWindow MakeWindow();
  
        IButton MakeButton();
  
        ITextBox MakeTextBox();
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal sealed class WindowsFactory : IFactory
    {
        public IWindow MakeWindow()
        {
            return new WindowsWindow();
        }
  
        public IButton MakeButton()
        {
            return new WindowsButton();
        }
  
        public ITextBox MakeTextBox()
        {
            return new WindowsTextBox();
        }
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    internal sealed class MacFactory : IFactory
    {
        public IWindow MakeWindow()
        {
            return new MacWindow();
        }
  
        public IButton MakeButton()
        {
            return new MacButton();
        }
  
        public ITextBox MakeTextBox()
        {
            return new MacTextBox();
        }
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
  
namespace DependencyLocate
{
    internal static class FactoryContainer
    {
        public static IFactory factory { get; private set; }
  
        static FactoryContainer()
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load("http://www.cnblogs.com/Config.xml");
            XmlNode xmlNode = xmlDoc.ChildNodes[1].ChildNodes[0].ChildNodes[0];
  
            if ("Windows" == xmlNode.Value)
            {
                factory = new WindowsFactory();
            }
            else if ("Mac" == xmlNode.Value)
            {
                factory = new MacFactory();
            }
            else
            {
                throw new Exception("Factory Init Error");
            }
        }
    }
}
?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace DependencyLocate
{
    class Program
    {
        static void Main(string[] args)
        {
            IFactory factory = FactoryContainer.factory;
            IWindow window = factory.MakeWindow();
            Console.WriteLine("创建 " + window.ShowInfo());
            IButton button = factory.MakeButton();
            Console.WriteLine("创建 " + button.ShowInfo());
            ITextBox textBox = factory.MakeTextBox();
            Console.WriteLine("创建 " + textBox.ShowInfo());
  
            Console.ReadLine();
        }
    }
}

这里我们用XML作为配置文件。配置文件Config.xml如下:

<?xml version="1.0" encoding="utf-8" ?>
<config>
    <factory>Mac</factory>
</config>
这里我们将配置设置为Mac风格，编译运行上述代码，运行结果如下：

图2 配置Mac风格后的运行结果

当然我们也可以利用反射来简化工厂中的创建实例的方法。具体的不在这里说了。









乐居猫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈依赖注入思想与面向接口编程
iOS学堂
01-07 3599
依赖注入(Dependency Injection) 今天我们讨论的内容核心是面向接口编程，我决定还是要从依赖注入开始讲起，因为DI的思想可以说是面向接口编程思想的特殊表现，也可以说是与面向接口编程相辅相成。 先撇开让人头脑发晕的文字定义，我们还是用我们最忠实和伙伴——代码来了解依赖注入。我们先来一个粗略的例子，由浅入深： 我们有一个公交车类(Bus)，每天早上6点钟需要发车(work)
浅谈spring4泛型依赖注入
新手程序猿的学习日记
12-08 1万+
本文简单分析了Spring 4.0的新特性泛型依赖注入。本文以我自己编写的代码为例子，详细论述了泛型依赖注入的两种实现方式，同时讨论了泛型依赖注入的优点，部分原理，以及各种实现的优缺点。
依赖注入那些事儿
weixin_34166847的博客
06-17 487
目录 目录 1 IGame游戏公司的故事     1.1 讨论会     1.2 实习生小李的实现方法     1.3 架构师的建议     1.4 小李的小结 2 探究依赖注入     2.1 故事的启迪     2.2 正式定义依赖注入 3 依赖注入那些事儿     3.1 依赖注入的类别         3.1.1 Setter注入         3.1.2 Co...
浅谈spring框架之依赖注入（DI）机制
qq_32403043的博客
11-27 632
今天我们来看一下spring的第二大特性，依赖注入，英文名称“Dependency Injecttion”,简称DI。在上一篇博客中我们讨论了IOC的作用就是降低程序之间的耦合性。简单说依赖注入就是给系统中的某个变量赋值。 那问题来了，那这种依赖关系由谁来管理那？毫无疑问，肯定是交给我们的spring容器了，我们只需在配置文件中说明即可。这种依赖关系的维护就称之为依赖的注入。 接下来我们 创建一个...
浅谈Spring IoC依赖注入(DI)——从配置文件到纯注解（二）
不与三的毛竹
07-14 251
这是上一篇的续集，上一篇主要搭建了环境，完成了一个小功能，采用的配置文件的方式完成bean装配与DI，这一篇开头将把CURD的功能全部完善，然后按照步骤把xml配置文件改成注解方式，最后再进行一些配置信息抽取的优化以及Spring整合单元测试。两篇文章合二为一，介绍了Spring的常用配置和注解。
转载--浅谈spring4泛型依赖注入
weixin_30852451的博客
11-21 37
转载自某SDN-4O4NotFound Spring 4.0版本中更新了很多新功能，其中比较重要的一个就是对带泛型的Bean进行依赖注入的支持。Spring4的这个改动使得代码可以利用泛型进行进一步的精简优化。 1. 泛型依赖注入的优点 泛型依赖注入就是允许我们在使用spring进行依赖注入的同时，利用泛型的优点对代码进行精简，将可重复使用的代码全部放到一个类之中，方便...
浅谈IOC--说清楚IOC是什么
热门推荐
哲
03-29 26万+
转载自：http://www.cnblogs.com/DebugLZQ/archive/2013/06/05/3107957.html1.IOC的理论背景2.什么是IOC3.IOC也叫依赖注入(DI)4.IOC的优缺点5.IOC容器的技术剖析6.IOC容器的一些产品7.参考博文本文旨在用语言(非代码)说清楚IOC到底是什么，没有什么高深的技术，园中的老牛、大虾们看到这里可以绕行了，以免浪费您宝贵的...
浅谈前端研发链路之脚手架
Taotao's Blog
08-05 599
大家好，我是徐徐。今天我们来聊聊前端研发链路中的脚手架。
浅谈Spring IOC的理解
崔安兵
05-09 274
浅谈Spring IOC的理解 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。 一、分享Iteye的开涛对Ioc的精彩讲解 首先要分享的是Iteye的...
架构浅谈之MVC
02-25
很多人表示对架构没有任何概念，想了解下架构，但是看了网上的一些文章又觉得云里雾里，其实架构远没有那么难，今天从这篇文章开始我来给大家谈谈架构，争取让大家都看得懂。对于架构，业界从来没有一个统一的定义，...
spring依赖注入知识点分享
08-25
在本篇文章中，我们将详细介绍 Spring 依赖注入的知识点，并提供相关的代码内容。 什么是 IoC IoC（Inversion of Control），即控制反转，是一种软件设计模式。它将对象之间的依赖关系管理方式，称作 IoC。IoC 是...
EFcore Repository 依赖注入方式实现数据库基本操作
02-08
本篇文章将深入探讨如何使用EF Core结合依赖注入来实现数据库的基本操作。 1. **EF Core 简介** EF Core 提供了模型化数据库对象和SQL语句之间的桥梁，使得开发者可以使用面向对象的方式来处理数据库操作。它支持...
Spring依赖注入的三种方式实例详解
10-19
Spring依赖注入（Dependency Injection, DI）是Spring框架的核心特性之一，它允许我们解耦组件间的依赖关系，使得代码更加灵活和可测试。本篇将详细解释Spring中的三种依赖注入方式：接口注入、Setter方法注入和构造...
AngularJs动态加载模块和依赖注入详解
10-22
AngularJs作为一款广泛使用的前端框架，其动态加载模块与依赖注入的机制是现代Web开发中不可或缺的技术之一。本文将深入探讨AngularJs如何实现动态加载模块与依赖注入，并通过分析具体的项目结构与代码示例来解析...
模板中class与typename的辨析
2302_80190394的博客
08-12 490
模板中class与typename的辨析
【C++】list的模拟实现
2301_77954967的博客
08-16 911
在 C++ 编程中，模拟实现标准模板库（STL）中的list具有重要意义和广泛的应用场景。list作为一种常用的数据结构，其独特的特性使得在许多情况下能够提供高效和灵活的操作。模拟实现list有助于深入理解其内部工作原理。通过亲手编写代码来模拟 list 的各种功能，如节点的创建、插入、删除、遍历等，可以清晰地掌握数据在链表中的存储和流动方式，这对于提升对数据结构的理解和编程能力至关重要。在实际应用中，list 常用于需要频繁进行插入和删除操作的场景。
FSOP，glibc-2.23攻击IO_list_all
最新发布
yjh_fnu_ltn的博客
08-16 554
FSOP 是 File Stream Oriented Programming 的缩写，根据前面对 FILE 的介绍得知进程内所有的 _ IO_FILE 结构会使用 _ chain 域相互连接形成一个链表，这个链表的头部由_IO_list_all维护。FSOP 的核心思想就是劫持_IO_list_all 的值来伪造链表和其中的_IO_FILE 项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。FSOP 选择的触发方法是调用_，这个函数会刷新_IO_list_all 链表中所有项的文件流，相当于。
Spring cloud是如何继承Feign的
不知跬步无至千里
08-16 202
从源码维度分析，Spring cloud是如何集成Feign的，帮助快速理解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值