Wie erstelle ich ein PlugIn System unter PHP?

[learnLinux]

Hallo,

ich habe mir ein kleines CMS geschrieben.
Jetzt soll man dieses CMS durch Zusatzmodule einfach erweitern können.

Wie würdet ihr die Struktur wählen?

Ein Plugin kann an sich alles ändern...

 

[Mordor]

Du musst dir eben eine genaue Struktur schaffen.
Zuerst musst du die Punkte definieren an welchen Plugins eingreifen dürfen. Dann musst du definieren an welchen Punkten die Plugins gespeichert werden, wo also das CMS danach suchen muss.

Aber das ist alles ziemlich algemein gehalten. Wo liegt dein generelles Problem?

 

[learnLinux]

Mein Problem ist wie man dies am besten aufbaut.

Es ist ja möglich das mehrere Plugins nacheinander zugreifen.

 

[SimonZ]

Schau dir halt mal Quellcodes von Skripten an, die Erweiterungsschnittstellen schon eingebaut haben: Joomla, Mambo oder Redaxo.

 

[counteam]

Wenn du ein CMS mittels PHP schreiben kannst, sollte die Logik bei dir auch funktionieren (außer du hast dir ein fertiges CMS genommen und dies nur abgeändert (Copyright entfernt, etc)...).

Was ist daran so schwer ein ordner anzulegen, was "module" heißt, und dieser ordner mittels PHP ausgelesen wird...
Würde im "module" ordner nun ein weiterer Ordner drinne sein (Beispielsweise "testmodul"), includet PHP vom "testmodul" beispielsweise eine index.php.

 

[d4f]

Ich fahr bei meinen Projekten gut mit onDemand-Loading der benoetigten Klassen.

Funktionieren tut es so:

<?php
class CallBackend extends CallBackendClass {
	public function __construct() {
		$this->CallBackendClassPath = dirname(__FILE__)."/api/";
		$this->Base = $this;
	}
}

class CallBackendClass {
	protected $Base;
	protected $CallBackendClassPath;
	protected $CallBackendClassCache = array();
	
	//Default constructor
	public function __get($Name) {
		return $this->CallBackendBuilder($Name);
	}
	
	//(Re)build with custom Constructor
	public function __call($Name,$Arguments) {
		return $this->CallBackendBuilder($Name,$Arguments);
	}
	
	//Delete
	public function __unset($Name) {
		if(isset($this->CallBackendClassCache[$Name])) unset($this->CallBackendClassCache[$Name]);
	}
	
	private function CallBackendBuilder($Name,$Arguments=false) {
		//Preliminary checks
		if(!$Arguments && isset($this->CallBackendClassCache[$Name])) return $this->CallBackendClassCache[$Name];
		if(!is_dir($this->CallBackendClassPath.$Name)) return NULL;
		require_once $this->CallBackendClassPath.$Name."/".$Name.".php";
		//Initialize class
		$reflect = new ReflectionClass("Call_".$Name);
		//Add values
		$this->CallBackendClassCache[$Name] = $Arguments ? $reflect->newInstanceArgs($Arguments) : $reflect->newInstance();
		$this->CallBackendClassCache[$Name]->CallBackendClassPath = $this->CallBackendClassPath.$Name."/";
		$this->CallBackendClassCache[$Name]->Base = $this->Base;
		//Return
		return $this->CallBackendClassCache[$Name];
	}
}
?>

Indem nun alle Module die Klasse "CallBackendClass" extenden kann man es recht einfach benutzen:

$Demo = new CallBackendClass();
$Demo->Frontend("webseite.de")->render->htmlPage("main")

Hier wuerden in folgender Reihenfolge die Module geladen:
api/Frontend/Frontend.php <-- Initialisiert mit der Konstrukturvariable "webseite.de"
api/Frontend/render/render.php

Die Klasse "render" beinhaltet im Beispiel die Funktion htmlPage welche dann mit dem Argument "main" aufgerufen wird.
Da eine bestehende Funktion Vorrang vor __call hat wird diese somit aufgerufen statt dass er eine Sub-Klasse aufrufen will.

Warum benutzt du nicht einfach ein bestehendes Framework auf welchem du dann dein Frontend aufbaust? Ich kann das (recht strikte) MVC-Framework Yii waermstens empfehlen; grosse Community, out-of-the-box Support fuer Ajax-Webseiten, sehr gute Performance und gute Dokumentation sowie praktische Buecher.

 

[JaEgErmEistEr]

Nimm ein fertiges (FLOW3/Typo3) und hab Spaß