Object Relational Mapping (kurz ORM) ist eine Technologie, die darauf abzielt, die Diskrepanz zwischen objektorientierten und relationalen Datenbanken zu beheben. Einfach ausgedrückt speichert ORM Objekte in einem Programm automatisch in einer relationalen Datenbank, indem es Metadaten verwendet, die die Zuordnung zwischen Objekten und Datenbanken beschreiben. Im Wesentlichen werden Daten von einem Formular in ein anderes konvertiert.
ORM sorgt für die Generierung aller SQL-Anweisungen, und Programmierer sind weit entfernt von Datenbankkonzepten. Die Zuordnung einer konzeptionellen Anforderung (z. B. einer HQL) zu einer SQL-Anweisung kostet nichts, nicht einmal 1 % Leistungsverlust. Der eigentliche Leistungseinbruch erfolgt während des Mapping-Prozesses und genauer gesagt während der Objektinstanziierung.
Zu den bekannteren PHP-Open-Source-ORMs gehören derzeit die folgenden:
1. Propel
Propel ist ein für PHP5 geeignetes ORM-Mapping-Framework (Object Relational Mapping). Bietet Unterstützung für die Objektpersistenzschicht basierend auf Apache Torque. Es generiert SQL und Klassen über Schemadefinitionsdateien im XML-Format und entsprechende Konfigurationsdateien. Es ermöglicht Ihnen, Objekte anstelle von SQL zu verwenden, um Datensätze in Datenbanktabellen zu lesen und zu schreiben. Propel bietet einen Generator zum Erstellen von SQL-Definitionsdateien und PHP-Klassen für Ihr Datenmodell. Entwickler können die generierten Klassen auch problemlos über XML, PHP-Klassen und Phing-Build-Tools integrieren. Standardmäßig werden Versionen vor 1.2 des PHP-Frameworks Symfony verwendet dient als Standard-ORM-Framework.
Offizielle Website: http://www.propelorm.org/
2. Doctrine
Doctrine ist ein PHP-ORM-Framework, es muss auf >=php5 .2.3 laufen Version ist es eine leistungsstarke Datenabstraktionsschicht.
Eines seiner Hauptmerkmale ist, dass es einen objektorientierten Ansatz zum Implementieren des Datenbankabfrageabschlusses verwendet. Die unterste Ebene verwendet eine DQL-Abfrageanweisung ähnlich wie Hibernate HQL, um Datenbankabfragen durchzuführen, was die Entwicklung erheblich flexibler macht reduzierter doppelter Code. Im Vergleich zu Propel besteht der Vorteil von Doctrine darin, dass die Dokumentation von Doctrine immer umfassender und umfangreicher ist als von Propel, die Community aktiver ist und natürlicher, einfacher zu lesen und näher an nativem SQL ist . Die Leistung ist auch etwas besser als bei Propel. Ebenso können Sie Doctrine problemlos in bestehende Anwendungs-Frameworks integrieren. Beispielsweise verwenden die 1.3 und späteren Versionen des PHP-Frameworks Symfony Doctrine als Standard-ORM-Framework, und Sie können Doctrine auch mit Codeigniter integrieren.
Offizielle Website: http://www.doctrine-project.org/
3. EZPDO
EZPDO ist ein sehr leichtes PHP-ORM-Framework. Die ursprüngliche Absicht des Autors von EZPDO besteht darin, die komplexe ORM-Lernkurve zu verkürzen und ein größtmögliches Gleichgewicht zwischen ORM-Betriebseffizienz und -Funktionalität herzustellen. Es ist das einfachste ORM-Framework, das ich bisher verwendet habe und das ich immer noch integrieren möchte Kommen Sie zu meinem CoolPHP SDK, die Laufeffizienz ist recht gut und die Funktionen können grundsätzlich die Anforderungen erfüllen, aber die Aktualisierung von EZPDO ist relativ langsam.
Offizielle Website: http://www.ezpdo.net/
4. RedBean
RedBean ist ein benutzerfreundliches, leichtes PHP-ORM-Framework, das Unterstützung bietet für MySQL, SQLite- und PostgreSQL-Unterstützung. Die RedBean-Architektur ist sehr flexibel und der Kern ist sehr einfach. Entwickler können Funktionen problemlos durch Plug-Ins erweitern.
Offizielle Website: http://www.redbeanphp.com/
Andere
Das inländische Fleaphp-Entwicklungsframework implementiert nicht nur die ORM-Implementierung basierend auf dem TableDataGateway; Bietet neben der Kapselung von SQL-Anweisungen auch die Implementierung von TableGateway, TableRowSet und TableRow. Es gibt auch einige Lösungen, die der ActiveRecord-Implementierung von Rails ähneln.
Im Allgemeinen kann das allgemeine ORM-Framework die Grundanforderungen einfacher Anwendungssysteme erfüllen, was die Entwicklungsschwierigkeiten erheblich verringern und die Entwicklungseffizienz verbessern kann. In Bezug auf die SQL-Optimierung ist es jedoch definitiv schlechter. Die Verarbeitung komplexer Beziehungen und eingebetteter SQL-Ausdrücke ist möglicherweise nicht ideal. Möglicherweise liegt dies hauptsächlich am Problem der Objektpersistenz in PHP selbst, was dazu führt, dass ORM zu ineffizient und im Allgemeinen langsamer als reines SQL ist. Es gibt jedoch Möglichkeiten, diese Probleme zu lösen. Die einfachste Lösung für die Leistung besteht darin, dass wir die Effizienz durch Caching verbessern können. Obwohl die Konfiguration kompliziert ist, wird das Problem durch die flexible Verwendung von Second-Level-Cache und Abfrage-Cache erheblich gemindert. Der Abfragedruck der Datenbank verbessert die Leistung des Systems erheblich.
Wenn Sie selbst ein PHP ORM implementieren möchten, können Sie sich auf Folgendes beziehen:
<?php
abstract class Model{
protected $pk = 'id';
protected $_ID = null;
protected $_tableName;
protected $_arRelationMap;
protected $_modifyMap;
protected $is_load = false;
protected $_blForDeletion;
protected $_DB;
public function __consturct($id = null){
$this->_DB = mysql_connect('127.0.0.1','root','') ;
$this->_tableName = $this->getTableName();
$this->_arRelationMap = $this->getRelationMap();
if(isset($id))$this->_ID = $id;
}
abstract protected function getTableName();
abstract protected function getRelationMap();
public function Load(){
if(isset($this->_ID)){
$sql = "SELECT ";
foreach($this->_arRelationMap as $k => $v){
$sql .= '`'.$k.'`,';
}
$sql .= substr($sql,0,strlen($sql)-1);
$sql .= "FROM ".$this->_tableName." WHERE ".$this->pk." = ".$this->_ID;
$result =$this->_DB->mysql_query($sql);
foreach($result[0] as $k1 => $v1){
$member = $this->_arRelationMap[$key];
if(property_exists($this,$member)){
if(is_numeric($member)){
eval('$this->'.$member.' = '.$value.';');
}else{
eval('$this->'.$member.' = "'.$value.'";');
}
}
}
}
$this->is_load = true;
}
public function __call($method,$param){
$type = substr($method,0,3);
$member = substr($method,3);
switch($type){
case 'get':
return $this->getMember($member);
break;
case 'set':
return $this->setMember($member,$param[0]);
}
return false;
}
public function setMember($key){
if(property_exists($this,$key)){
if(is_numeric($val)){
eval('$this->'.$key.' = '.$val.';');
}else{
eval('$this->'.$key.' = "'.$val.'";');
}
$this->_modifyMap[$key] = 1;
}else{
return false;
}
}
public function getMember($key,$val){
if(!$this->is_load){
$this->Load();
}
if(property_exists($this,$key)){
eval('$res = $this->'.$key.';' );
return $this->$key;
}
return false;
}
public function save(){
if(isset($this->_ID)){
$sql = "UPDATE ".$this->_tableName." SET ";
foreach($this->arRelationMap as $k2 => $v2){
if(array_key_exists( $k2, $this->_modifyMap)){
eval( '$val = $this->'.$v2.';');
$sql_update .= $v2." = ".$val;
}
}
$sql .= substr($sql_update,0,strlen($sql_update));
$sql .= 'WHERE '.$this->pk.' = '.$this->_ID;
}else{
$sql = "INSERT INTO ".$this->_tableName." (";
foreach($this->arRelationMap as $k3 => $v3){
if(array_key_exists( $k3,$this->_modifyMap)){
eval('$val = $this->'.$v3.';');
$field .= "`".$v3."`,";
$values .= $val;
}
}
$fields = substr($field,0,strlen($field)-1);
$vals = substr($values,0,strlen($values)-1);
$sql .= $fields." ) VALUES (".$vals.")";
}
echo $sql;
//$this->_DB->query($sql);
}
public function __destory(){
if(isset($this->ID)){
$sql = "DELETE FROM ".$this->_tableName." WHERE ".$this->pk." = ".$this->_ID;
// $this->_DB_query($sql);
}
}
}
class User extends Model{
protected function getTableName(){
return "test_user";
}
protected function getRelationMap(){
return array(
'id' => USER_ID,
'user_name'=> USER_NAME,
'user_age' => USER_AGE
);
}
public function getDB(){
return $this->_DB;
}
}
$UserIns = new User();
print_r($UserIns);
?>Nach dem Login kopieren
