✔ Mehrere Klassen über eine Hauptklassen ansprechen

[eternitysoft]

Hallo erstmal,

ich habe folgendes Problem.

Ich schreibe momentan Klassen (bin noch bei der ersten) um Daten wie z.B. von Last.fm zu hohlen.

Das sieht momentan so aus:

Klasse

class LastFM extends Request implements ApiInterface
{ 
    
    //Funktionen ....

}

weiter geplant zum Beispiel:

 class Youtube extends Request implements ApiInterface
 { 
    
    //Funktionen ....
 
 }

Und so weiter.


So dann habe ich eine Oberklasse die dann dafür da ist die jeweiligen Funktionen aufzurufen, damit im Hauptscript nur eine Klasse eingebunden werden muss.

class API
{
    
    private $ApiObj = NULL;
    
    
    
    
    
    public function __construct()
    {
    
    }
    

    
    public function selectApi($api)
    {
        
        $this->ApiObj = NULL;
        $this->ApiObj = new $api;
            
        
        if(!($this->ApiObj instanceof ApiInterface))
        {
            trigger_error($api." ist keine gültige Api Klasse.",E_USER_ERROR);
            $this->ApiObj = NULL;    
        }
        
    }

//...

Diese Klasse sollte nun alias Funktionen haben, die dann über das jeweilige Objekt mit die richtige Funktion aufruft:

//fortsetzung Api


    public function getAlbumInfo($artist,$album,$options = array())
    {
        $data = $this->ApiObj->getAlbumInfo($artist,$album,$options);
        return $data;    
    }

Das war mein erster Ansatz.
Mein Problem an der Sache ist, das ja nun die Information der jeweiligen Seiten sehr unterschiedlich sind.

Sprich auf last.fm kann ich Charts auslesen, Künstlerinformationen e.t.c auf Youtube kann ich Channels auslesen, Video hohlen e.t.c, das macht diesen Ansatz ja relativ sinnlos, da ich ja die alias Funktionen ja dann überflüssig sind, aufgrund der verschiedenen Informationen.
(ich müsste ja für jede API-Klasse neue alias Funktionen schreiben = doppelte Arbeit.)

Nun hatte / habe ich noch folgenden Ansatz:

class MusicApi
{

    static private $instance = null;
  
    static public function getInstance($api)
    {
          if (null === self::$instance[$api]) 
          {
             self::$instance[$api] = new $api;
        }
        return self::$instance[$api];
     }
 
     private function __construct(){}
     private function __clone(){}
      
}

Ich erstelle also über die Klasse also nur ein Objekt der jeweiligen Klasse und habe so den Zugriff auf die jeweiligen Funktionen.

Die Frage ist, ob das so überhaupt eine gute Lösung ist, mir kommt das nicht so vor.
Es soll ja auch wenn es geht einfach sein und einheitlich (umso weniger Funktionen in der Oberklasse umso besser).

Also gibt es da noch andere Ansätze, Möglichkeiten ?


(Ich hoffe, es blickt jemand durch wie das gemeint ist)

mfg

 

[Yaslaw]

Overloading heisst dein gesuchtes Stichwort.

<?php 
// Interface
interface ApiInterface{
    function myName();  
}

// 2 Testimplementierungen des Interfaces mit
// verschiedenen Funktionen und Parameter
class Api1 implements ApiInterface{ 
    public function getTest(){
        return "test";
    }
    function myName(){
        return "Api1";
    }
} 

class Api2 implements ApiInterface{
    public $prop = 13; 
    public function getProp(){
        return $this->prop;
    }
    public function plusEins($a){
        return $a+1;
    }
    function myName(){
        return "Api2";
    }
} 

// Wrapperklasse
class API implements ApiInterface{
    private $ApiObj = NULL;

    public function __construct($api){
        $this->selectApi($api);
    }

    public function selectApi($api){
        
        $this->ApiObj = NULL;
        $this->ApiObj = new $api;
        
        if(!($this->ApiObj instanceof ApiInterface))
        {
            trigger_error($api." ist keine gültige Api Klasse.",E_USER_ERROR);
            $this->ApiObj = NULL;    
        }        
    }

    /**
     * (non-PHPdoc)
     * @see ApiInterface#myName()
     */
    function myName(){
        return "API.{$this->ApiObj->myName()}";
    }
    
    /**
     * Overloading der Klasse API um Parameters apzurufen
     * @param $varName
     * @return unknown_type
     */
    public function __get($varName){
        print "\n<br />Get {$varName} aufgerufen\n<br />";
        return $this->ApiObj->$varName;
    }

    /**
     * Overloading der Klasse API um Parameters zu setzen
     * @param unknown_type $varName
     * @param unknown_type $value
     * @return unknown_type
     */
    public function __set($varName, $value){
        print "\n<br />Set {$varName} aufgerufen (new value: {$value})\n<br />";
        $this->ApiObj->$varName = $value;
    }
    
    /**
     * Overloading der Klasse API um methoden apzurufen
     * @param $methode
     * @param $params
     * @return unknown_type
     */ 
    public function __call($methode, $params){
        print "\n<br />Methode {$methode} aufgerufen\n<br />";
        if (method_exists($this->ApiObj, $methode)){
            return call_user_func_array(array($this->ApiObj, $methode), $params);
        }
    }
    
}

// Tests
$api1 = new API('Api1');
echo $api1->myName();
echo $api1->getTest();

$api2 = new API('Api2');

echo $api2->myName();
echo $api2->getProp();
$api2->prop = 15;
echo $api2->prop;
echo $api2->plusEins(2);
echo $api2->plusEins($api2->prop);
?>

 

[eternitysoft]

Hi,

danke auch gleich für das Beispiel.

mfg