Objektorientierung mit Models

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Ein Model wird beim Model-View-Controller genutzt und enthält die Daten auf die der Controller zugreift um sie in der View darzustellen.
    == Erläuterung ==
    Der Code ist zur Hilfenahme entstanden, als die Frage geklärt werden sollte ob man die Validierung im Controller oder im Model praktizieren sollte: Überprüfung von Werten in $_POST Feldern. Mehr Informationen zum Basismodel sollen noch folgen. Jeder ist aber angehalten den Artikel zu verbessern.

    Das hier erläutere Verfahren nutzt object-relational mapping bzw Objektrelationale Abbildung - kurz ORM.

    == Basismodel ==

    Quellcode

    1. abstract class Model {
    2. protected $primarykey = 'id';
    3. protected $data = array();
    5. abstract public function getColumns();
    7. function __construct($data = array()) {
    8. $this->data = $data;
    9. }
    11. public static function findById($id, $className) {
    12. $sql = "SELECT *
    13. FROM ".$this->getTablename()."
    14. WHERE ".$this->primarykey." = :id ";
    15. $stmt = MyDB::getInstance()->prepare($sql);
    16. $stmt->execute(array(
    17. ':id' => $id
    18. ));
    19. return new $className($stmt->fetch());
    20. }
    22. protected function _findById() {
    23. }
    25. public function __set($name, $value) {
    26. $this->data[$name] = $value;
    27. }
    29. public function __get($name) {
    30. return $this->data[$name];
    31. }
    33. /**
    34. * empty() on a __get function will not work as expected if isset has not been overriden
    35. */
    36. public function __isset($key) {
    37. if (isset($this->data[$key])) {
    38. return (false === empty($this->data[$key]));
    39. } else {
    40. return null;
    41. }
    42. }
    44. public function validate() {
    46. }
    48. public function getTablename() {
    49. return get_class($this);
    50. }
    52. public function delete() {
    53. $primaryval = $this->{$this->primarykey};
    55. $sql = 'DELETE FROM '.$this->getTablename().' WHERE '.$this->primarykey.' = :primaryval';
    56. $stmt = MyDB::getInstance()->prepare($sql);
    57. $stmt->execute(array(
    58. ':primaryval' => $primaryval
    59. ));
    60. }
    62. public function save($override = null) {
    63. if($override !== null) {
    64. $this->data = array_merge($this->data, $override);
    65. }
    67. $this->validate();
    68. $params = array();
    69. $primaryval = $this->{$this->primarykey};
    71. // insert or update
    72. if($primaryval === null) {
    73. $sql = 'INSERT INTO '.$this->getTablename().' ('.implode(',', $this->getColumns()).') VALUES (';
    74. foreach($this->getColumns() as $key) {
    75. $sql .= ':'.$key.',';
    76. $params[':'.$key] = $this->$key;
    77. }
    78. $sql = rtrim($sql,',').')';
    79. if(count($params)) {
    80. $stmt = MyDB::getInstance()->prepare($sql);
    81. $stmt->execute($params);
    83. // remember auto increment key
    84. $this->{$this->primarykey} = MyDB::getInstance()->lastInsertId();
    85. }
    86. } else {
    87. $sql = 'UPDATE '.$this->getTablename().' SET ';
    88. foreach($this->getColumns() as $key) {
    89. $sql .= $key.' = :'.$key.',';
    90. $params[':'.$key] = $this->$key;
    91. }
    92. $sql = rtrim($sql,',').' WHERE '.$this->primarykey.' = :primaryval';
    93. if(count($params)) {
    94. $params[':primaryval'] = $primaryval;
    95. $stmt = MyDB::getInstance()->prepare($sql);
    96. $stmt->execute($params);
    97. }
    98. }
    99. }
    100. }
    Alles anzeigen


    == Beispielimplementierung eines Benutzers ==

    Quellcode

    1. class User extends Model {
    2. public function getTablename() {
    3. return get_class($this); // user
    4. }
    5. public function getColumns() {
    6. return array('email', 'password');
    7. }
    9. public function validate() {
    10. if(...) {
    11. throw new ValidateException('message');
    12. }
    13. }
    14. }
    Alles anzeigen


    == Beispiele ==
    === Neuen Benutzer anlegen ===

    Quellcode

    1. <form method="post">
    2. email: <input type="text" name="email" /><br/>
    3. password: <input type="password" name="password" /><br/>
    4. <input type="submit">
    5. </form>
    6. <?php
    7. if(count($_POST)) {
    8. $user = new User($_POST);
    9. $user->save();
    10. }
    11. ?>
    Alles anzeigen


    === Benutzer bearbeiten ===

    Quellcode

    1. <form method="post" action="edit.php?userid=123">
    2. email: <input type="text" name="email" /><br/>
    3. password: <input type="password" name="password" /><br/>
    4. <input type="submit">
    5. </form>
    6. <?php
    7. if(count($_POST) && isset($_GET['userid'])) {
    8. $user = User::findById($_GET['userid']);
    9. $user->save($_POST);
    10. }
    11. ?>
    Alles anzeigen

    8.148 mal gelesen

Kommentare 0

  • vince -

    Was ich ein bischen unschön finde ist, das der Konstruktor das gesamte Post Array entgegennimmt / entgegennehmen kann.
    [syntax="php"]$user = new User($_POST);[/syntax]

    Das ist natürlich sehr einfach und praktisch, aber wird später sehr unübersichtlich.
    Man selber und vorallem auch andere wissen nicht, welche Felder es denn überhaupt gibt und was required ist oder was selber von dem Model intern ggf. übernommen wird.

    Um das zu wissen müsste man immer in die Datenbank gucken, welche Felder es gibt und wie diese heissen und dann nochmal in die Klasse schauen falls es noch weitere interne Verarbeitungen gibt.


    Ich finde die längere Variante, alles einzeln über den Konstruktor zu setzen und / oder für alle einen Getter & Setter zu implementieren, vorallem hinsichtlich der Lesbarkeit & Wiederverwendbarkeit , schöner.


    Zum Beispiel Doctrine nutzt die magischen Getter & Setter, setzt aber als ausgleich alle Felder als Kommentar, so das die IDE´s das bei, Autocomplete trotzdem alles sauber anzeigen.


    Aber ansonsten wieder ein schöner Artikel :)