✔ Dependency Injection

[Psychomentis]

So sieht meine Klasse jetzt aus ist.

class Core
{
	private static $instance = NULL;
	
	
	protected $registry = NULL;
	
	
	public function __construct()
	{
		if(!function_exists("spl_autoload_register"))
		{
			throw new Exception("autoload functions are not available in this PHP installation");
		}
		
		spl_autoload_register(array($this, 'autoload'));
	}
	
	
	private function __clone()
	{
	}
	
	
	public static function __set($key, $value)
	{
		if(!isset($key) || is_null($value))
		{
			throw new Exception(sprintf("Unable to set variable `%s`. It was already set.", $key));
		}
		
		self::$registry[$key] = $value;
	}
	
	
	public static function __get($key)
	{
		if(!array_key_exists($key, self::$registry))
		{
			throw new Exception(sprintf("%s couln´t found in services!", $key));
		}
		
		return is_callable(self::$registry[$key]) ? self::$registry[$key]($this) : self::$registry[$key];
	}
	
	
	public function __isset($key)
	{
		return array_key_exists(self::$registry[$key]);
	}
	
	
	public static function __unset($key)
	{
		unset(self::$registry[$key];
	}
	
	
	public static function getInstance()
	{
		if(is_null(self::$instance))
		{
			self::$instance = new self();
		}
		
		return self::$instance;
	}
	
	
	public function autoload($class)
	{
		$file = strtolower($class).'.php';
		
		if(!file_exists($file) || !is_readable($file))
		{
			throw new LogicException(sprintf("%s does not exist or is not readable",$file));
		}

		return include_once($file);
	}
}

Jetzt müsste ich nur noch im Konstruktor die Klassen definieren und initialisieren?

class Core
{
	protected $language = NULL;
	protected $template = NULL;

	public function __construct()
	{
		self::$language = new Language();
		self::$template = new Template();
	}
}

oder später wie folgt

$core = new Core();
$core->language = new Language();
$core->template = new Template();

Ist das so richtig?

 

[Raisch]

Hallo Psychomentis,

wenn Du die Coreklasse als Singleton laufen lassen willst, solltest Du den Konstruktor noch auf private setzen.

Und das

protected $registry = NULL;

kannst Du in

private static $registry = array();

ändern. Oder willst Du die Coreklasse in anderen Klassen extenden?

Da Du von der Coreklasse ein Objekt erstellst, brauchst Du bis auf die getInstance().Methode keine andere als static deklarieren/definieren.

Zur __clone()-Methode muss ich sagen, dass ich diese nicht einfach durch private sperren würde (finde ich unschön diese Variante).

Eleganter wäre (mMn) sowas:

    public function __clone()
    {
        trigger_error( 'Klonen ist nicht erlaubt.', E_USER_ERROR );
    }

Zum Thema Instanzieren der Klassen:
Würde ich im Konstruktor nur Klassen instanzieren die Du wirklich immer und überall brauchst und alle anderen über den anderen Weg.

Und wenn die Instanzierung im Konstruktor sein muss, dann würde ich das so machen:

    private function __construct() 
    { 
        self::$registry['language'] = new Language(); 
        self::$registry['template'] = new Template(); 
    }

(vorher natürlich die Autoloadmethode registrieren)

Ich hoffe das hilft dir etwas.

Gruß

 

[Psychomentis]

Hmm im moment will ich die Klasse nicht erweitern.
Aber ich weiß nocht nicht was die Zukunft bringt. ^^
Also lass ich erstmal

public function __construct()
{
...
}
private $registry = array();

und entferne

private function __clone(){}

Danke du hast mir sehr geholfen.

 

[Raisch]

Kein Thema!

Wenn Du noch Fragen hast, kannst Du mir auch ne PM senden.

Gruß