依赖注入和抽象之间的平衡在哪里？

Question

许多建筑师和工程师推荐Dependency Injection和其他Inversion of Control模式作为improve the testability of your code的一种方式。不可否认的是，依赖注入使代码更易于测试，但是，它是否也是Abstraction的总体目标？

我感到矛盾！我写了一个例子来说明这一点;它不是超现实的，我不会这样设计，但我需要一个快速简单的具有多个依赖关系的类结构的例子。第一个示例没有依赖注入，第二个示例使用Injected依赖项。

非DI示例

package com.stackoverflow.di;


public class EmployeeInventoryAnswerer()
{
    /* In reality, at least the store name and product name would be
     * passed in, but this example can't be 8 pages long or the point
     * may be lost.
     */
    public void myEntryPoint()
    {
        Store oaklandStore = new Store('Oakland, CA');
        StoreInventoryManager inventoryManager = new StoreInventoryManager(oaklandStore);
        Product fancyNewProduct = new Product('My Awesome Product');

        if (inventoryManager.isProductInStock(fancyNewProduct))
        {
            System.out.println("Product is in stock.");
        }
    }
}


public class StoreInventoryManager
{
    protected Store store;
    protected InventoryCatalog catalog;

    public StoreInventoryManager(Store store)
    {
        this.store = store;
        this.catalog = new InventoryCatalog();
    }

    public void addProduct(Product product, int quantity)
    {
        this.catalog.addProduct(this.store, product, quantity);
    }

    public boolean isProductInStock(Product product)
    {
        return this.catalog.isInStock(this.store, this.product);
    }
}


public class InventoryCatalog
{
    protected Database db;

    public InventoryCatalog()
    {
        this.db = new Database('productReadWrite');
    }


    public void addProduct(Store store, Product product, int initialQuantity)
    {
        this.db.query(
            'INSERT INTO store_inventory SET store_id = %d, product_id = %d, quantity = %d'
        ).format(
            store.id, product.id, initialQuantity
        );
    }

    public boolean isInStock(Store store, Product product)
    {
        QueryResult qr;

        qr = this.db.query(
            'SELECT quantity FROM store_inventory WHERE store_id = %d AND product_id = %d'
        ).format(
            store.id, product.id
        );

        if (qr.quantity.toInt() > 0)
        {
            return true;
        }

        return false;
    }
}

依赖注入的示例

package com.stackoverflow.di;


public class EmployeeInventoryAnswerer()
{
    public void myEntryPoint()
    {
        Database db = new Database('productReadWrite');
        InventoryCatalog catalog = new InventoryCatalog(db);

        Store oaklandStore = new Store('Oakland, CA');
        StoreInventoryManager inventoryManager = new StoreInventoryManager(oaklandStore, catalog);
        Product fancyNewProduct = new Product('My Awesome Product');

        if (inventoryManager.isProductInStock(fancyNewProduct))
        {
            System.out.println("Product is in stock.");
        }
    }
}

public class StoreInventoryManager
{
    protected Store store;
    protected InventoryCatalog catalog;

    public StoreInventoryManager(Store store, InventoryCatalog catalog)
    {
        this.store = store;
        this.catalog = catalog;
    }

    public void addProduct(Product product, int quantity)
    {
        this.catalog.addProduct(this.store, product, quantity);
    }

    public boolean isProductInStock(Product product)
    {
        return this.catalog.isInStock(this.store, this.product);
    }
}


public class InventoryCatalog
{
    protected Database db;

    public InventoryCatalog(Database db)
    {
        this.db = db;
    }


    public void addProduct(Store store, Product product, int initialQuantity)
    {
        this.db.query(
            'INSERT INTO store_inventory SET store_id = %d, product_id = %d, quantity = %d'
        ).format(
            store.id, product.id, initialQuantity
        );
    }

    public boolean isInStock(Store store, Product product)
    {
        QueryResult qr;

        qr = this.db.query(
            'SELECT quantity FROM store_inventory WHERE store_id = %d AND product_id = %d'
        ).format(
            store.id, product.id
        );

        if (qr.quantity.toInt() > 0)
        {
            return true;
        }

        return false;
    }
}

（如果您有任何想法，请感觉让我的榜样更好！这可能不是最好的例子。）

在我的例子中，我觉得EmployeeInventoryAnswerer已经完全违反了抽象，了解了StoreInventoryManager的基本实现细节。

EmployeeInventoryAnswerer不应该有这样的观点，“好吧，我会抓住一个StoreInventoryManager，给它客户正在寻找的产品的名称，以及我要检查的商店，它会告诉我产品是否在股票。”？它不应该对Databases或InventoryCatalogs一无所知，从它的角度来看，这是一个它不需要关注的实现细节吗？

那么，可测试代码与注入依赖关系和信息隐藏作为抽象主体之间的平衡点在哪里？即使中间类只是传递依赖关系，构造函数签名本身也会显示无关的细节，对吧？

更现实的是，让我们说这是一个长期运行的后台应用程序处理来自DBMS的数据;在调用图的“层”是否适合创建和传递数据库连接器，同时仍然使您的代码在没有运行DBMS的情况下可测试？

我非常有兴趣在这里学习OOP理论和实用性，以及澄清DI和信息隐藏/抽象之间似乎是一个悖论。