Using a custom provider class to remove tight coupling

Question

I have a custom framework where i have a class/method which uses my own Cache class.

Currently it is tightly coupled. So a method instantiates the

Answer 1

As per OP request

Especially since it will be part of the framework, you should inject the Cache. A DI Container is the best solution here, you can config the actually Cache implementation as a singleton. Your proposed solution is tightly coupled to some service and hard to test in isolation. Actually it looks more of a service locator pattern rather than provider.

If you're using a Factory that won't replace the DI Container. THe point of DI is that the code shouldn't be coupled to an outside static service. Unless you have a very good reason, any object should use only the injected (via constructor or as method argument) dependencies.

Answer 2

_{Note: "provider" means nothing. There is not pattern by that name.}

Instead of making some magical "privider", you should take a look at factory pattern. Basically the idea is a follows:

1. You inject a factory in classes that will use some services (assuming that Cache is not the only form of service that you aim for).

2. The class request from factory the service that it needs:

   • if service has been already initialized once, it just returns an instance to your
   • else it creates new instance, stores it and returns you to "consumer"

The simplest code example would be something like this:

class ServiceFactory
{
    private $storage = [];

    public function create( $name )
    {
        if ( false === array_key_exists( $name, $this->storage ))
        {
            $instance = new $name;
            $this->storage[$name] = $instance;
        }

        return $this->storage[$name];
    }

}

This is an extremely simplified example, but even in this case, if you inject an instance of this factory in any number of objects, they all will have access to same pool of instances.

If you ever decide to look into concept of DI Containers, then factories are also the place where it is appropriate to utilize them, without degrading them to as service locator anti-pattern.

.. and few lectures that you might find valuable:

• The Clean Code Talks - Don't Look For Things!
• The Clean Code Talks - Global State and Singletons