谈谈我对DI的理解

最新推荐文章于 2019-10-03 16:52:14 发布

最新推荐文章于 2019-10-03 16:52:14 发布 · 114 阅读

文章标签：

#电子商务

本文中DI指依赖倒置 。

依赖的概念

Baidu百科：依靠别人或事物而不能自立或自给。

软件开发中的依赖：依赖描述了两个模型元素之间的关系，如果被依赖的模型元素发生变化就会影响到另一个模型元素。

DI的概念

A. 上层模块不应该依赖于下层模块，它们共同依赖于一个抽象。
B. 抽象不能依赖于具象，具象依赖于抽象。

实例谈开

在分层开发中，通常会有这样的两个模块：DAL（数据访问层)和BLL(业务逻辑层) 。下面就以电子商务系统中的订单、产品、用户为例来说说这两个模块之间的依赖关系。

正向依赖

DAL：

public class OrderDao
{
public List < Orders > GetOrderByUserID( int userid)
{
throw new NotImplementedException();
}
public List < Orders > GetOrderByProductID( int productID)
{
throw new NotImplementedException();
}
}

BLL：

public class Order
{
private OrderDaoorderDao; // 对DAL中OrderDao的引用
public Order(OrderDaoorderDao)
{
orderDao = orderDao;
}
public List < Orders > GetOrderByUserID ( int userid)
{
List < Orders > list = null ;
list = orderDao.GetOrderByUserID (userid);
return list;
}
public List < Orders > GetOrderByProductID( int productID)
{
List < Orders > list = null ;
list = orderDao.GetOrderByProductID(productID);
return list;
}
}

BLL中Order持有了DAL中OrderDao的引用，这个时候BLL模块依赖于DAL模块。他们之间构成了紧耦合。如果要更换DAL模块，显然需要修改BLL中的代码。

引入抽象

依赖倒置的思想告诉我们上层模块（BLL）和下层模块（DAL）都应当依赖于抽象。那么我们引入一个抽象模块。

抽象模块：

public interface IOrderDao
{
List < Orders > GetOrderByUserID( int userid);

List < Orders > GetOrderByProductID( int productID);
}

DAL：

public class OrderDao:IOrderDao// 继承于抽象
{
public List < Orders > GetOrderByUserID( int userid)
{
throw new NotImplementedException();
}
public List < Orders > GetOrderByProductID( int productID)
{
throw new NotImplementedException();
}
}

BLL：

public class Order
{
private IOrderDaoorderDao; // 依赖于抽象
public Order(IOrderDaoorderdao)
{
orderDao = orderdao;
}
public List < Orders > GetOrderByUserID( int userid)
{
List < Orders > list = null ;
list = orderDao.GetOrderByUserID(userid);
return list;
}
public List < Orders > GetOrderByProductID( int productID)
{
List < Orders > list = null ;
list = orderDao.GetOrderByProductID(productID);
return list;
}
}

现在BLL持有了对抽象模块的引用，而DAL也依赖于该抽象模块。抽象模块的引入消除了BLL和DAL之间的依赖。那么这种方法是否完美呢？

接口的单一性

在一个业务驱动的系统中，如果与订单相关的业务发生变化，会导致我们去修改 IOrderDao ，相应的DAL中的OrderDao 和BLL的Order都会被修改。

什么原因呢？
上面的这种设计让我们无法保持一个稳定的接口。面向对象设计中，有这样的两个原则：
单一职责原则(SRP)：保证对象的细粒度和单一性。

开放-封闭原则(OCP)：对于扩展开放，对于更改封闭。

于是有了下面的设计。

抽象模块：

public interface IOrderUserDao
{
List < Orders > GetOrderByUserID( int userid);
}
public interface IOrderProductDao
{
List < Orders > GetOrderByProductID( int productID);
}

DAL：

public partial class OrderDao:IOrderUserDao
{
public List < Orders > GetOrderByUserID( int userid)
{
throw new NotImplementedException();
}
}
public partial class OrderDao:IOrderProductDao
{
public List < Orders > GetOrderByProductID( int productID)
{
throw new NotImplementedException();
}
}

BLL：

public class User
{
private IOrderUserDaoorderDao; // 依赖于抽象
public User(IOrderUserDaoorderdao)
{
orderDao = orderdao;
}
public List < Orders > GetOrderByUserID( int userid)
{
List < Orders > list = null ;
list = orderDao.GetOrderByUserID(userid);
return list;
}
}

public class Product
{
private IOrderProductDaoorderDao; // 依赖于抽象
public Product(IOrderProductDaoorderdao)
{
orderDao = orderdao;
}
public List < Orders > GetOrderByProductID( int productID)
{
List < Orders > list = null ;
list = orderDao.GetOrderByProductID(productID);
return list;
}
}

那么您的意见呢？