| 

.NET C# Java Javascript Exception

1
Hallo Codekicker,
ich arbeite mich gerade in die OOP in PHP ein. Jetzt wollte eines meiner CMS- System auf ein Objektorientiertes umstellen. Das erste Problem, vor dem ich stehe ist folgendes:
Ich möchte das mein komplettes System über eine Klasse gestartet wird

index.php
<?php

include('sys.php');
$sys = new sys();

?>

<html>
....
</html>


sys.php
<?php
include_once('definitions.php'); //$host,$db...
include_once('db.class.php'); //DB-Connection...
include_once('user.class.php'); //Userklasse, Queries...

class sys{

private $db = new sql($host,$db,$user,$pass);
private $user = new usr($db);

public function __construct(){

}

}

?>


Irgendwie haut das hinten und vorne nicht hin. Hab ich irgendeinen Denkfehler, ist das bei PHP anders?
Sind die Includes an der richtigen Stelle?
Sind die Initialisierungen an der richtigen Stelle?

Ich möchte das System eben so abstrakt wie möglich und kenne es nicht anders aus der Windowsprogrammierung.
Hoffe da steigt jemand durch.

Danke im voraus.

Spicejam
News:
22.12.2011
spicejam 853 2 6
2 Antworten
3
Hallo Spicejam,

grundsätzlich würde ich dir erst mal davon abraten, HTML und PHP gemeinsam zu verwenden. Besser wäre es wohl, das über ein Template-System voneinander zu trennen.
Also HTML in Templates abzulegen und dynamische Elemente hinein zu implementieren. Erleichtert die Wartung und du kannst Design von Logik trennen. Was die Teamarbeit erleichtert.
Hier gibt es verschiedene Frameworks, z.B. im Zend Framework, bei PEAR oder das Template System Smarty.

Dann solltest du dir mal die Autoload Funktion (http://php.net/manual/de/language.oop5.autoload.php) von PHP anschauen. Hier lässt sich über eine Funktion oder Klasse das automatische Einbinden von Klassen realisieren.
Beispiel:
$xy = new sql($host,$db,$user,$pass);

function __autoload($str_classname) {
AutoLoadClass::process($str_classname);
return true;
}


class AutoLoadClass {
public function process($str_classname) {
try {
$bool_successful = false;
# $str_classname validieren ...
if (!preg_match('=^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$=m',$str_classname)) throw new AutoloadException("Klasse '$str_classname' ist ung?ltig");
# Existenz Pr?fen
if (class_exists($str_classname)) {
$bool_successful = TRUE;
}
else {
$arr_parthes = array( 1 => '',
'src/',
'class/',
);
foreach ($arr_parthes AS $int_key => $str_value) {
if (TRUE == $bool_successful = AutoLoadClass::tryToOpenFile(sprintf('%s%s.php', $str_value, $str_classname)) ) {
break;
}
if (TRUE == $bool_successful = AutoLoadClass::tryToOpenFile(sprintf('%s%sClass.php', $str_value, $str_classname)) ) {
break;
}
if (TRUE == $bool_successful = AutoLoadClass::tryToOpenFile(sprintf('%sclass%s.php', $str_value, $str_classname)) ){
break;
}
}
}
$arr_files = array(
'File.php',
'File.php',
...
);
if (!class_exists($str_classname)) {
foreach ($arr_files AS $int_key => $str_value) {
require_once($str_value);
if (class_exists($str_classname)) {
$bool_successful = TRUE;
break;
}
if (TRUE == $bool_successful) {
break;
}
}
}
if (FALSE == $bool_successful) {
die('Could not find a Class-File vor class '.$str_classname.'!<br />');
}

# Klasse auch definiert?
if (!class_exists($str_classname)) {
throw new AutoloadException("Datei '$str_fname' enthält keine Klasse '$str_classname'");
}

}
catch (AutoloadException $e) {
die( $e->getMessage());
}
return TRUE;
}
public function tryToOpenFile($str_fileName) {
if (file_exists($str_fileName)) {
try {
require_once($str_fileName);
return TRUE;
}
catch (AutoloadException $e) {
die('Can not include File ' . $str_fileName . '<br />');
}
}
}
}


Der Autoload prüft, ob diese Klasse schon implementiert ist, dann wird sie verwendet. Ansonsten wird deine definierte Autoload Funktion/Klasse angesprungen um einen automatischer include (so wie du in definiert hast) zu erzeugt. Das bringt den Vorteil, dass du nur an einer Stelle deine Includes definierten must und ggfls. Fehler direkt abfangen kannst. In diesem Sinne würde ich dir von der Funktion "include_once" abraten und stattdessen die Funktion "require_once" zu verwenden. (Ist weniger Fehleranfällig.)

Dein Problem, warum deine Sourcen nicht laufen liegt in der Deklarierung der Variablen:
Du musst die Variablen im Constructor oder in einer Init Methode deklarieren.
Beispiel:
class sys{

private $db = False;
private $user = False;

public function __construct($host,$db,$user,$pass){
$this->setDb($host,$db,$user,$pass);
$this->setUser();
}

private function setDb($host,$db,$user,$pass) {
$this->db = new sql($host,$db,$user,$pass);
}

private function setUser() {
$this->user = new usr($this->db);
}
}

Soweit ich weiß, kannst du bei der Deklarierung der Variablen im Klassenkopf keine Objekte erzeugen. Außerdem sind die Variablen $host,$db,$user,$pass natürlich nicht gesetzt.

Ich hoffe, ich konnte dir ein wenig helfen.

Gruß Jens
22.12.2011
XJenso 332 7
+1: gute Antwort. Aber ist würde kein eigenständiges Templatesystem verwenden, weil PHP selbst ein Templatesystem ist.
LiRo 23.12.2011
Seit wann ist PHP ein Templatesystem?
Nicolai Schönberg 23.12.2011
<viel html>
<div>Dein Name ist <?php echo $name; ?></div>
</viel html>
LiRo 23.12.2011
Wobei man das echo auch weglassen kann: <?= $name ?>. Was aber wiederum deaktiviert sein kann.
LiRo 23.12.2011
allerdings hast du dann das selbe Problem, wie ich es oben beschrieben habe. Angenommen du gibst das Design an eine Agentur, dann muss diese sich auch mit PHP auskennen.
Mein Beispiel zielt darauf ab, dass der Designer fertiges HTML mit entsprechenden Platzhalten liefert. Die eigentliche Logik ist dann ausschließlich in PHP gekapselt und kann komplett getrennt bearbeitet werden.
Übrigens würde ich von Shortcuts immer die Finger weg lassen. In den meisten Fällen sind die Webserver so eingestellt, dass <? ?> nicht sauber interpretiert wird.
Grup Jens
XJenso 23.12.2011
Auskennen muss dieser sich nicht unbedingt, die Logik kannst du immer noch in PHP schreiben. Der Designer müsste dann nur noch die Variablen in den html-code einfügen. Dies müsste er aber auch bei einer "echten" Template-Engine.
LiRo 23.12.2011
okay, das Argument ist gut.
Wie sieht es aber mit sauberem OOP Design in diesem Zusammenhang aus.
Was machst du beim Fehlerhandling?
Was machst du bei verschachteltem HTML Code? Also z.B. Tabellenzeilen die man aufbaut und an einer Stelle implementiert.
Am Ende stehen hier wohl nur noch die persönlichen Vorlieben. Grundsätzlich spreche ich mich nicht komplett dagegen aus, das so zu tun.
Wahrscheinlich bist du mit deinem Ansatz Speicherschonender. Ich könnte mir aber vorstellen das mein Ansatz wartbarer ist.
XJenso 23.12.2011
XJenso: Echte Vorteile einer Template Engine sind zum Beispiel:
1) Du wirst gezwungen Code und Präsentation zu zwingen, das ist nicht der Fall wenn du <?php ?> in deiner HTML Datei einbettest. Das kann nervig sein, aber am Ende provitierst du davon das du eine Technik / Pattern sauber implementiert hast
2) Du brauchst einem Designer nicht unbedingt erklären wie Smarty funktioniert wenn er sie schon kennt - Deine eignen "Gehirnschmalz" musst du ihm immer erst erklären
Nicolai Schönberg 23.12.2011
*Du wirst gezwungen Code und Präsentation zu TRENNEN
Nicolai Schönberg 23.12.2011
0
Nicolai: genau das ist das was ich versuchte zu sagen. Du hast es mit einem Satz auf den Bildschirm gezaubert. Ich stimmte dir zu 100% zu.
Was ich allerdings schon oben erwähnte, du benötigst damit wahrscheinlich mehr Speicher durch das aufbewahren des Template Objektes.
23.12.2011
XJenso 332 7
shi.... sollte eigentlich ein Kommentar werden.
XJenso 23.12.2011
Also Smarty compiliert die templates und chachet sie auch. Der performance verlust ist sehr gering, aber er ist natürlich vorhanden. Gruß
Nicolai Schönberg 23.12.2011
ich arbeite seit Jahren mit dem PEAR (http://pear.php.net/package/HTML_Template_Sigma) und bin sehr zufrieden damit. Allerdings ist es vielleicht so langsam mal Zeit sich die anderen mal anzuschauen
Gruß
XJenso 23.12.2011

Stelle deine Php-Frage jetzt!