Abstract, Interface and design patterns - php

Question

I developed many years in PHP, using a small home-made MVC framework in PHP 5, never using PHP 5.2+ advantages.
I know what is a abstract class, and interface, and know the namespaces, and some design patters, but always struck in one simple thing, when is better use interfaces, abstract class or pattern design.
In my Framework I have a Core with Router class, the Router Calls the Core and the Core load the Controller and call the controller function using the Router vars.
The Controller extends the Core, and can use a function in the Core to load "components", this function is a simple singleton pattern, using a Static array, to instance the classes I "call" from the controller or other components, this is extremely fast and uses low memory, but is there a better way.
In the Controller or Component I write:
function example() {
$this->loadComponent(array('Cache', 'Template', 'Email'));
$this->Email->X();
}
This create the instances (if not exists, if exists return a pointer "&" tho the instance, not a copy) and set to the controller or component to allow using $this->ComponentName->XXXX
The function creates a copy, using $this->loadComponent(array('Cache' => 'Cache2')); if I need some copy and not the same. (for example for multiple DB connections)
I think this can be made better.
Now I am stuck in another design problem:
I have a Cache class, this class has 3 ways of cache, Memcache, Redis or File Cache.
The is a simple class (no abstract or interface), and cache functions are in separated class CacheMem, CacheRes, CacheFile, when the Cache class is loaded using loadComponent, the class reads a define config, and using this define do this:
function __construct() {
private $engine;
switch (CONFIG_CACHE_TYPE) {
case "MEM":
$class = 'CacheMem'
require ('Components'.DS.$class.'.php');
$this->engine = new CacheMem();
break;
case "RES":
$class = 'CacheRedis'
require ('Components'.DS.$class.'.php');
$this->engine = new CacheRedis();
break;
default:
$class = 'CacheFile';
require ('Components'.DS.$class.'.php');
$this->engine = new Cachefile();
break;
}
}
function read($key) {
$this->engine->read($key);
}
function write($key, $value, $time=3800) {
$this->engine->write($key, $value, $time=3800);
}
It there a better way to solve this? Its a simple simple problem, but I am stuck in one thing: I need to load the cache Class using the "Cache" name NOT CacheMem, CacheFile or CacheRes?
I tried using abstract class Cache, and extends with the Mem, Res or File, but I need to instance in the Cache class the children because I want to use "Cache" not "CacheXXX", and I know its wrong.
How do you recommend solve this?

Answer 1

there are many ways in oop to solve things bad :).
The Controler extends the Core, and can use a function in the Core
If you don't know whether to extend a class, ask yourself: is the controller a core? Hopefully it isn't. If your controller needs a core, then pass it in the constructor. The reason is 1. hide implementation, means 'injecting' the core and use is inside hides access to core over the controller, 2. only one extends is allowed, so use it carefully and smart, e.g. a car or bike is a vehicle, thus extending might be okay, if our vehicle has some implementation the car and bike use, but maybe Vehicle is just an interface without implementation.
This create the instances (if not exists, if exists return a pointer "&" tho the instance, not a copy)
PHP is using reference counted variables. Return a object means returning the reference. To copy an object, there is the clone operator in PHP.
switch (CONFIG_CACHE_TYPE)
What is CONFIG_CACHE_TYPE ? If it's a const defined before calling the construct, this is a bad idea. Just pass it as variable. And remember, that some switch cases like you use are violating the open-closed principle which is bad design.
switch(...) {
case ...:
... = new A();
case ...:
... = new B();
case ...:
... = new C();
...
}
In your special case I would create an interface CacheInterface and let your classes implement read and write, then just pass a CacheInterface to where you need caching.
As a rule of thumb: a good design does not need extends or abstract. oop beginners, but also some senior coders think, that oop is cool and reuse their code with extending lots of classes. Understanding extends and abstract does not mean you must use them whenever it's possible.
// edit: you've asked 2 questions and I've overlooked the first one. Check out DI (dependency injection) as creational pattern.