第二节 控制反转和依赖注入

前端之家收集整理的这篇文章主要介绍了第二节 控制反转和依赖注入前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

从前有一个这样的业务

代码编号01 需求:在MSsqlServer数据库添加订单信息

step 1 构建MSsqlServer环境,有添加功能

public class MSsqlServer
{
    public void Insert(){...}
}

setp 2 构建订单服务,向MSsqlServer环境添加数据

public class OrderService
{
    private MSsqlServer _mssqlServer;

    public Order(MSsqlServer mssqlServer)
    {
        _mssqlServer = mssqlServer;
    }

    public void Add()
    {
        _mssqlServer.Insert();
    }
}

setp 3 整体贯通,实现需求

static void Main()
{
    var mssqlServer= new MSsqlServer();
    var orderService = new OrderService(mssqlServer);
    orderService.Insert();
}

一个蠢萌的员工是这样修改

代码编号04 需求:改造代码编号01的代码如下

step 1 构建MSsqlServer环境,有添加功能

public class MSsqlServer
{
    public void Insert(){...}
}

setp 2 构建订单服务,向MSsqlServer环境添加数据

public class OrderService
{
    private MSsqlServer _mssqlServer;

    public Order()
    {
        //变化点:_mssqlServer在OrderService中创建对象
        _mssqlServer = new MSsqlServer();
    }

    public void Add()
    {
        _mssqlServer.Insert();
    }
}

setp 3 整体贯通,实现需求

static void Main()
{
    var orderService = new OrderService();
    orderService.Insert();
}

Leader是这样评价的

首先,代码01和04都能实现原有的业务功能

其次,这样的业务实现必然需要数据存储的对象_mssqlServer。01中的_mssqlServer是在OrderService外创建,由构造中传入引用并使用的。04中的_mssqlServer是在OrderService内部创建并使用。相比起来,04不仅需要实现自身的业务,还需要构建需要用到的存储对象。

举个例子来说,你要造房子,在造之前需要一个梯子爬到屋顶。你需要直接拿来梯子用,不需要自己再建造个梯子,额外的工作量。

04 的代码中_mssqlServer是OrderService中new来创建的,01的代码只是传入使用,在外部创建就是控制反转。

控制反转IOC

控制反转:依赖的对象不在依赖使用的内部创建的。这里的依赖指的就是需要。

造房子需要的梯子、榔头就是依赖的对象。

大牛总结为:

控制反转(IoC),它为相互依赖的组件提供抽象,将依赖(低层模块)对象的获得交给第三方(系统)来控制,即依赖对象不在被依赖模块的类中直接通过new来获取

依赖注入DI

当理解了IOC后,发现依赖的对象是外部创建并传入的,前辈们把这种传入叫做了注入,并总结了注入有3种形式。

构造注入

setp 2 构建订单服务,向MSsqlServer环境添加数据

public class OrderService
{
    private MSsqlServer _mssqlServer;

    //依赖的_mssqlServer通过构造中获得引用
    public Order(MSsqlServer mssqlServer)
    {
        _mssqlServer = mssqlServer;
    }

    public void Add()
    {
        _mssqlServer.Insert();
    }
}

setp 3 整体贯通,实现需求

static void Main()
{
    var mssqlServer= new MSsqlServer();
    var orderService = new OrderService(mssqlServer);
    orderService.Insert();
}

属性注入

setp 2 构建订单服务,向MSsqlServer环境添加数据

public class OrderService
{
    private MSsqlServer _mssqlServer;
    public MSsqlServer sqlServerObject
    {
        get{
            return _mssqlServer;
        }
        set{
        //依赖的_mssqlServer通过属性中获得引用
            _mssqlServer = value;
        }
    }

    public void Add()
    {
        _mssqlServer.Insert();
    }
}

setp 3 整体贯通,实现需求

static void Main()
{
    var mssqlServer= new MSsqlServer();
    var orderService = new OrderService();
    orderService.sqlServerObject = mssqlServer;
    orderService.Insert();
}

接口注入

setp 2 添加接口,获得依赖的引用

public interface IOrderService
{
    void SetDependence(MSsqlServer mssqlServer);
}

setp 4 构建订单服务,向MSsqlServer环境添加数据

public class OrderService : IOrderService
{
    public void SetDependence(MSsqlServer mssqlServer)
    {
        _mssqlServer = mssqlServer;
    }

    public void Add()
    {
        _mssqlServer.Insert();
    }
}

setp 5 整体贯通,实现需求

static void Main()
{
    var mssqlServer= new MSsqlServer();
    var orderService = new OrderService();
    orderService.SetDependence(mssqlServer);
    orderService.Insert();
}

当理解了控制反转后,依赖注入就是想法让依赖的地方得到自己依赖的对象。

构造注入使用更多,接口注入倒是用的比较少。

public class OrderService
{
    private IDataAccess _dataAccess;

    public Order(IDataAccess dataAccess) //核心的一句
    {
        _dataAccess = dataAccess;
    }

    public void Add()
    {
        _dataAccess .Insert();
    }
}

首先,需要的_dataAccess 是传入的,是控制反转

其次,_dataAccess 是通过构造传入的是,是构造注入

第三,_dataAccess直接使用,不需要创建,符合单一职责原则。

最后,_dataAccess 是依赖的对象,是抽象的接口类型,并不知道实现是MSsqlServer、MysqL还是Oracel,是依赖倒置原则的实现。

设计原则是一种指导思想,指导思想是抽象的
IOC控制反转是DIP这种设计原则下的一种设计模式,是落地可见的
控制反转:依赖的对象外部创建
依赖注入:依赖的对象外部传入

IOC这种设计模式中提到,把依赖的对象交给第三方来创建,这就是为后面介绍AutoFac这种第三方框架的使用做铺垫。

原文链接:https://www.f2er.com/javaschema/282343.html

猜你在找的设计模式相关文章