Weblabor

Foglalkoztat mostanában a kérdés, hogy hogyan hagyhatnám el a globális változók használatát. Bár engem nem zavar, de azért érzem, hogy gáz, meg egyéb okok is úgy döntöttem, hogy váltani kell. Innen indult a dolog, kutakodtam, keresgéltem, nézegettem többfelé, végül találtam egész érthető anyagot. Eredményeim megosztanám, várom az építő jellegű kritikákat, hozzászólásokat, megerősítéseket, pofonokat.

Én a programjaim futásának elején példányosítottam a szükséges osztályokat, majd ezeket adott helyen global kulcsszóval elértem.

$_DB=new DB();
# ...
# ...
class Ize{
	function bigyo(){
		global $_DB;

		$_DB->query('SELECT kisfroccs FROM kocsma');
	}
}

Értem én, hogy nem tudni mi van benne, meg bele lehet nyúlkálni. Engem a $_GET változó sem zavar, utána lehet nézni, valamint nincs az a biztonságos framework, ami ne lenne csodákra képes egy elég hülye programozó kezében. Menjünk tovább.

Osztályok singletonná alakítását hamar elvetettem. Felesleges bonyolítás, nem használhatok több példányt ha éppen szeretnék, ami elég nagy érvágás. A Singleton Multiton megoldás már tetszett, bár kissé feleslegesnek tartom a ketté választást. De az ötlet, hogy egy nyilvántartó osztályt használjunk megtetszett. Tehát igazából itt már el is érhettem volna a célomat, globális változóimat lecserélhettem volna ily' módon is, metódusaimból némi plusz gépelés árán eltűnhettek volna a global kulcsszavak és mindenki boldog. De feltűnt a láthatáron az egységtesztelés és a dependency injection (DI), úgyhogy muszáj volt tovább menni.

A DI lényege – ahogy sikerült megértenem –, hogy megmondom, mi kell nekem, a framework pedig alámrakja. Nem kertelek tovább, a megoldásom undefined property-n és __get() függvényen alapul. Van egy ősosztály.

class DI{
	function __get($name){
		/* so we'll have some cases when we'd like to return an object
		 * returned by so called InstanceManager
		 * */
		if($name[0]!='_'){ return null; }
		$instance=InstanceManager::get(substr($name,1));
		$this->$name=$instance;
		return $instance;
	}
}

Ha valamelyik osztályban szeretnénk DI-t használni, akkor a DI-ből kell származtatnunk.

Ezen kívül van egy InstanceManager.

class InstanceManager{
	private static $instances=array();
	private static $rules=array();
	
	public static function get($instanceID){
		if(!empty(self::$instances[$instanceID])){
			return self::$instances[$instanceID];
		}
		
		#not found we have to create the instance first
		if(isset(self::$rules[$instanceID])){
			$r=self::$rules[$instanceID];
			$class=$r[0];
			$args=$r[1];
			#TODO: have to handle calling a constructor with multiple arguments
			$instance=new $class($args); #for an object waiting for two params in construct this would fail..
			self::$instances[$instanceID]=$instance;
			return $instance;
		}else{
			return null;
		}
	}
	
	/**
	 * through this function we can initialize rules to map $instanceIDs
	 * to classes and arguments
	 * passed array should look like this
	 * array(
	 * 	$instanceID=>array($classname,$arguments)
	 * )
	 * */
	public static function setRules($array){
		if(empty(self::$rules)){
			self::$rules=$array;
		}else{
			throw new Exception('rules already loaded this is probably an error..');
		}
	}
}

Nem teljes, de az elgondolás talán látszik.

Teszteléshez példa pediglen így néz ki.

# ize
# bigyo
# DI, InstanceManager itt mar elerheto

InstanceManager::setRules(array('PATH'=>array('Path',null)));

class Path {

	protected $root;
	protected $www;
	protected $classes;
	protected $templates;
	
	function __construct() {
		$DS=DIRECTORY_SEPARATOR;
		$this->root=str_replace($DS . "classes".$DS."waf","",dirname(__FILE__)).$DS;
		$this->www=$this->root."www" . $DS;
		$this->classes=$this->root."classes" . $DS;
		$this->templates=$this->root."templates" . $DS;
	}
	
	function __get($name){
		if(property_exists($this,$name))	return $this->$name;
		else return false;
	}
}

class Jani extends DI{
	function test(){
		echo $this->_PATH->root,"\n";
	}
}

$j=new Jani();
$j->test();
$j->test();

Lássuk, mi történik itt. Janiban a test() metódusban hivatkozott $this->_PATH nincs definiálva, ezért meghívódik a DI::__get() függvénye, ami felismeri, hogy neki itt cselekednie kell, meghívja az InstanceManager::get() metódusát. Észreveszi, hogy a PATH indexű móka még nincs példányosítva, megteszi ezt, tárolja és visszaadja, és DI mindezt Janiban még el is tárolja. Végre lefuthat az első test() metódusa Janinak. A második test() hívásnál már a DI::__get()-ig sem jutunk el, hiszen itt már rendelkezésre áll az osztályváltozó.

Biztosan vannak a megvalósításban hibák, nem tudom, hogy mennyire tesztbarát a megoldás, vagy sem (a unit test egy következő lépés számomra), de nekem tetszik az egyszerűsége. Remélem nem nyúltam nagyon mellé.