Vous devriez vérifier le livre Design Patterns: Elements of Reusable Object-Oriented Software
Le problème avec Faire des classes extensibles, comme vous l'avez découvert, est en train de décomposer le système en objets utiles et réutilisables. La tâche est difficile car de nombreux facteurs entrent en jeu: encapsulation, granularité, dépendance, flexibilité, performance, évolution, réutilisabilité, etc. Essayez-vous de modéliser un scénario réel ou vous concentrez-vous sur la communication/collaboration et les dépendances au sein de votre application?
Voici un exemple qui montre un peu ce que vous cherchez. Il y a certainement beaucoup plus, de bien meilleurs exemples:
Je voulais développer un système de mise en cache qui offrait à mes développeurs une API simple et normalisée, peu importe où/où ils mettaient en cache quelque chose. Qu'est-ce que je veux dans un système de cache (au niveau de base)?
- Je veux être en mesure de mettre en cache quelque chose (set)
- Je veux être en mesure de récupérer que quelque chose (obtenir)
- Je veux être en mesure d'invalider le cache (supprimer)
je suis venu avec ceci:
abstract class MyNs_Cache
{
abstract public function Set($key, $data, $ttl);
abstract public function Get($key);
abstract public function Delete($key, $ttl);
}
Il y a ma classe de base extensible.Je l'ai ensuite eu trois classes de mise en cache MyNs_Cache_Fs, MyNs_Cache_Apc et MyNs_Cache_Memcache
class MyNs_Cache_Fs
{
...
public function Set($key, $data, $ttl)
{
// here I use fopen/fwrite/etc. to create the cached data
}
public function Get($key)
{
// here I retrieve the file from the filesystem (if it exists)
}
public function Delete($key) { ... }
}
C'est assez simple. Il implémente le cache en termes de FileSystem. Il n'offre rien après ma classe originale.
class MyNs_Cache_Apc
{
...
public function Set($key, $data, $ttl)
{
return apc_add($key, $data, $ttl); // NOT A FILESYSTEM CALL
}
public function Get($key) { ... } // you get the idea.
// This is specific to APC, so I add the functionality HERE
// NOT in my main Caching class.
public function PurgeCache()
{
return apc_clear_cache();
}
}
Mon cache APC fait tout ce que je veux dans un système de mise en cache (set/get/supprimer) mais il offre également la possibilité d'effacer l'intégralité du cache (quelque chose qui est pas utile pour mon cache FileSystem et impossible avec memcached)
class MyNs_Cache_Memcache
{
// Memcached needs a pool of servers. APC and filesystem don't.
private $servers = array(..);
// It also uses a memcached object.
private $conn;
public function __construct()
{
$this->conn = new Memcached;
foreach ($this->$servers as $server)
$this->AddServer($server);
}
... // we do all the standard stuff using memcached methods
// We also want to be able to manage our connection pool
public function AddServer($server)
{
$this->conn->addServer(...);
}
// And in some cases, we use inc/dec from memcached
// APC doesn't have this, and it makes little sense in a filesystem
public function Increment($key) { ... }
}
maintenant, je sais que je peux toujours obtenir un de mes objets de cache et juste avec obj- $> get (« some_key ») et je vais toujours obtenir un résultat.
De même, j'ai également accès à des fonctionnalités spécifiques à ce que je suis en train de travailler.