依赖倒置原则

一，依赖倒置原则

1.1，什么是依赖倒置？

高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。也就是说要面向接口编程，不能面向实现编程。

1.2，应用场景

做一个订单处理系统，主要的操作是往数据库里添加记录，下面实现的是面向实现编程的版本，例如：

// SQLServer
class SQLServer
{
public:
	void insert()
	{
		// 往SQL数据库添加一条记录
	}
};

// Access
class Access
{
public:
	void insert()
	{
		// 往Access库添加一条记录
	}
};

// 订单类
class Order
{
public:
	SQLServer *m_pSQLServer;
	Access *m_pAccess;
	String m_sDBName;

	Order(String sDBName):m_sDBName(sDBName)
	{
		m_pSQLServer = new SQLServer();
		m_pAccess = new Access();
	}

	void insert()
	{
		switch(m_sDBName)
		{
		case "SQLServer":
			m_pSQLServer->insert();
			break;
		case "Access":
			m_pAccess->insert();
			break;
		}
	}
};
           

程序分析：

如果此时底层的数据库变成Oracle数据库，那就要重新修改原来的Order类，如果有更多的数据库添加进来，就要在Order中增加更多的case语句，只要底层的数据库发生变动，Order类就要跟着变动。造成这个问题的主要原因就是，Order高层模块直接依赖于底层的具体实现。根据依赖倒置原则，重构前面的系统，下面是重构后的系统图与具体实现

// 数据库访问接口
class DBManager
{
public:
	void insert();
}

// SQLServer
class SQLServer : public DBManager
{
public:
	void insert()
	{
		// 往SQL数据库添加一条记录
	}
};

// Access
class Access : public DBManager
{
public:
	void insert()
	{
		// 往Access库添加一条记录
	}
};

// 订单类
class Order
{
public:
	DBManager *m_pDBManager;

	Order(DBManager *manager) : m_pDBManager(manager){}

	void insert()
	{
		m_pDBManager->insert();
	}
};
           

程序分析： 重构后的系统，高层与底层模块都是依赖于DBManager接口，DBManager接口相对来说是比较固定不容易发生变化的。此时，及时底层的数据库更换成Oracle，只用添加一个新的类实现DBManager接口，Order类不会发生变动。