Afrikaans (Afrikaans) translation by Meyria (you can also view the original English article)
Gereed om jou PHP vaardighede na die volgende vlak te neem? In hierdie nuwe "From Scratch" -reeks fokus ons uitsluitlik op Zend Framework, 'n volledige stapel PHP raamwerk wat deur Zend Technologies geskep is. Hierdie tweede handleiding oor ons reeks is getiteld 'Modelle en Integrasie van Leerstelling ORM''.
Resensie
Welkom terug na ons Zend Framework van Scratch reeks! In ons laaste tutoriaal het ons 'n paar basiese dinge oor Zend Framework geleer, soos:
- Waar om die nuutste Zend Framework lêers af te laai
- Waar en hoe om dit plaaslik op te stel
- Skep jou eerste Zend Framework projek en stel 'n VirtualHost op jou webbediener op
- Hoe implementeer Zend Framework die MVC patroon en sy standaardprogramrigting
- Gegee data van 'n kontroleerder na sy siening
- Skep 'n volledige uitleg vir jou Zend Framework program
- Skep nuwe beheerders en aksies
As jou nog nie het nie, moet jou die vorige handleiding lees. Dit sal dit vir jou makliker maak om 'n paar Zend Framework-basiese beginsels te verstaan en jou te help om sommige dinge wat ons in hierdie tutoriaal bespreek, te verstaan.
In hierdie tweede deel van die reeks sal ons praat oor 'n belangrike deel van enige web program - die MODELS. Ons sal ook kyk hoe om die baie gewilde Leerstelling ORM te integreer met ons Zend Framework projek, en vind uit hoekom dit baie beter is om te gebruik as Zend Framework se inheemse Zend_Db
. Dus, sonder verdere ado, kom ons begin!
Wat is presies ''Modelle''?
Toe ek die konsep MVC begin probeer het, het ek 'n hele paar analogieë gelees, wat probeer het om presies te verduidelik wat elk van hierdie komponente verteenwoordig. Een van die beste analogieë wat ek tot dusver gelees het, was uit hierdie artikel, Another way to think about MVC. Dit gaan so iets soos volg:
Kom, ons stel 'n bank voor.
Die kluis is die Databasis - dit is waar al die belangrikste goedjies gestoor word, en is mooi beskerm teen die buitewêreld.
Dan het ons die bankiers of in programmatiese terme die Modelle. Die bankiers is die enigste wat toegang tot die kluis het (die DB). Hulle is oor die algemeen vet, oud en lui, wat redelik mooi volg met een van die reëls van MVC: *vet modelle, skraal beheerders*. Ons sal sien hoekom en hoe hierdie analogie 'n bietjie later van toepassing is.
Nou het ons ons gemiddelde bankwerkers, die gophers, die hardlopers, die beheerders. Controllers of gophers doen al die rondloop, daarom moet hulle fiks en skraal wees. Hulle neem die buit of inligting van die bankiers (die Modelle) en bring dit aan die bank kliënte die Views.
Die bankiers (Modelle) is al 'n rukkie by die werk, daarom maak hulle al die belangrike besluite. Dit bring ons by 'n ander reël: *Hou soveel besigheidslogika in die Model as moontlik*. Die beheerders, ons gemiddelde werkers, moet sulke besluite nie neem nie, hulle vra die bankier vir besonderhede, kry die inligting en stuur dit aan die kliënt (die View). Daarom gaan ons voort om die reël van *vet Modelle, skinny beheerders* te volg. Die gophers maak nie belangrike besluite nie, maar hulle kan nie dom wees nie (dus 'n bietjie besigheids logika in die kontroleerder is OK). Maar sodra die gopher te veel begin dink, word die bankier ontsteld en word jou bank (of jou app) uit die sak. So onthou altyd om soveel besigheidslogika (of besluitneming) aan die model af te laai.
Nou, die bankiers is seker, soos die hel, gaan nie direk met die kliënte (die View) praat nie, hulle is te belangrik in hul sagte stoele hiervoor. So 'n ander reël word gevolg: *Modelle moet nie met Views* praat nie. Hierdie kommunikasie tussen die bankier en die kliënt (die model en die aansig) word altyd deur die gopher (die kontroleur) hanteer. (Ja, daar is 'n mate van uitsondering op hierdie reël vir super VIP-kliënte, maar laat ons basies vir basiese beginsels bly).
Dit gebeur ook dat 'n enkele werker (Kontroleur) inligting van meer as een bankier moet kry, en dit is heeltemal aanvaarbaar. Maar as die bankiers verband hou (anders sal hulle so lekker bane land?) ...Die bankiers (Modelle) sal eers met mekaar kommunikeer en dan kumulatiewe inligting aan hul gopher oorhandig, wat dit gelukkig aan die kliënt sal gee (View). So hier is 'n ander reël: *Verwante Modelle verskaf inligting aan die beheerder via hul assosiasie (verhouding)*.
So hoe gaan dit met ons kliënt (die View)? Wel, banke maak foute en die kliënt moet slim wees om hul eie rekening te balanseer en besluite te neem. In MVC terme kry ons 'n ander eenvoudige reël: *Dit is redelik goed dat die sienings 'n paar logika bevat, wat handel oor die aansig of aanbieding*. Na aanleiding van ons analogie, sal die kliënt seker maak nie vergeet broek te dra terwyl hulle na die bank gaan nie, maar hulle gaan nie die bankiers vertel hoe om die transaksies te verwerk nie.
In 'n neutedop:
- Modelle is verteenwoordigers van die Databasis, en moet wees waar al die besigheids logika van 'n aansoek woon
- Kontroleerders kommunikeer met Modelle en vra hulle om inligting wat hulle nodig het te herwin
- Hierdie inligting word dan deur 'n Kontroleur aan die Vertoning oorgedra en word gelewer
- Dit is baie skaars dat 'n model direk met 'n Vertoning reageer, maar soms kan dit gebeur wanneer dit nodig is
- Modelle kan met ander modelle praat en is nie selfstandig nie. Hulle het verhoudings wat mekaar met mekaar meng
- Hierdie verhoudings maak dit makliker en vinniger vir 'n Kontroleur om inligting te kry, aangesien dit nie met verskillende modelle hoef te reageer nie - die Modelle kan dit self doen
Ons kan sien hoe belangrik Modelle in enige aansoek is, aangesien dit repsonsible is vir enige dinamiese aksies wat in 'n aansoek gebeur. Noudat ons 'n redelike duidelike begrip van die verantwoordelikhede van die Model, sowel as die View and Controller het, kan ons die Modelle in ons aansoek implementeer.
Stap 1 - Stel Jou Stuur Program In Om Aan 'n Databasis te Koppel
Die eerste ding wat ons moet doen is om ons Send-toepassing aan 'n databasis te koppel. Gelukkig kan die zf
bevel daarvoor sorg. Open jou Command Prompt (of Terminal), cd
in jou thenextsocial
folder en tik die volgende in:
zf configure db-adapter "adapter=PDO_MYSQL&dbname=thenextsocial&host=localhost&username=[your local database username]&password=[your local database password]" -s development
As dit korrek is, moet jou 'n uitset kry wat soortgelyk is aan:
A db configuration for the development section has been written to the application config file.
Daarbenewens moet jou twee nuwe lyne in jou application.ini
lêer sien:
resources.db.adapter = "PDO_MYSQL" resources.db.params.dbname = "thenextsocial" resources.db.params.host = "localhost" resources.db.params.username = "[your local database username]" resources.db.params.password = "[your local database password]" </p></code> <h3>The application.ini explained</h3> <p>The <code>application.ini</code> is a configuration file which should contain all of the configuration we have for an application. This includes, for example, what kind of database we're using, what the database name is, the username and password we'll be using with the database, even custom PHP settings like error display and include paths.</p> <div class="tutorial_image"> <img src="http://nettuts.s3.amazonaws.com/1122_zend2/images/application_ini.png" alt="The application.ini file" title="The application.ini file" /> <small>The <code>application.ini</code> file</small> </div> <p>I'm sure you've noticed that the <code>application.ini</code> file has sections enclosed in [square brackets]. One of the great things about the <code>application.ini</code> is that you can define different settings depending on what environment your code is in. For example, the database parameters we created earlier falls under the <code>[development : production]</code> section, which means that the set of settings under this section will be used when the application is being run on the <code>development</code> environment.</p> <p>To add to that, you can “inherit” settings from another section. For example, the <code>[development : production]</code> section is the configuration for the <code>development</code> environmnent, but inherits all the settings from the <code>production</code> environment as well. This means that any setting which you haven't explicitly overwritten in <code>development</code> will use the setting from <code>production</code>. This allows you to configure settings that are the same in all environments in one place, and just override the ones that you need. Pretty nifty huh?</p> <p>To configure our project to use the <code>development</code> configuration settings, open or create an <strong>.htaccess</strong> file inside the <strong>public_html</strong> folder, and make sure that it looks like this:</p> [php] SetEnv APPLICATION_ENV development RewriteEngine On RewriteCond %{REQUEST_FILENAME} -s [OR] RewriteCond %{REQUEST_FILENAME} -l [OR] RewriteCond %{REQUEST_FILENAME} -d RewriteRule ^.*$ - [NC,L] RewriteRule ^.*$ index.php [NC,L]
Ons kan duidelik sien dat die SetEnv APPLICATION_ENV
richtlijn ons omgewing se omgewing bepaal. As en wanneer ons die aansoek na 'n ander omgewing verskuif, moet dit die enigste wees wat ons moet verander. Dit verseker dat alles wat ons aansoek steun op werk, gedefinieer word in die application.ini
, wat verseker dat ons aansoek nie op enige eksterne instelling staatmaak nie. Dit help om die ''Dit werk op my ontwikkelingsmasjien, hoe kom dit nie op die produksie bediener nie?''probleem.
Stap 2 - Skep die Databasis en Sommige Tafels
Voordat ons jou eerste Model vir die program skep, benodig ons 'n databasis wat die Model eerste sal verteenwoordig. Kom ons begin met iets eenvoudig - 'n gebruikers tabel, waar ons al die geregistreerde gebruikers vir TheNextSocial sal stoor.
Teken in op jou MySQL databasis en skep 'n databasis genaamd thenextsocial. Sodra jou geskep het, voer die volgende navraag uit om 'n gebruikers tabel te skep, en 'n meegaande gebruikers instellings tabel:
CREATE TABLE `thenextsocial`.`user` ( `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `email` VARCHAR(100) NOT NULL, `password` TEXT NOT NULL, `salt` TEXT NOT NULL, `date_created` DATETIME NOT NULL, PRIMARY KEY (`id`), UNIQUE INDEX `Index_email`(`email`) ) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE `thenextsocial`.`user_settings` ( `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `user_id` INTEGER UNSIGNED NOT NULL, `name` VARCHAR(100) NOT NULL, `value` TEXT NOT NULL, PRIMARY KEY (`id`), CONSTRAINT `FK_user_settings_user_id` FOREIGN KEY `FK_user_settings_user_id` (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE ) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;
Hierdie SQL navrae moet twee tabelle skep. 'N Gebruikers tabel met die volgende kolomme:
- ID - 'n unieke ID vir elke gebruiker
- e-pos - die e-posadres van die gebruiker, ook uniek
- wagwoord - die gebruiker se wagwoord, wat ons sal hê
- sout - 'n ewekansige sout, wat ons sal gebruik om die gebruikers se wagwoord te gebruik
- Date_created - die datum en tyd waarop die gebruiker rekord geskep is
En 'n user_settings tabel, waar ons enige gebruikersverwante instellings sal stoor, met die kolomme:
- ID - 'n unieke ID vir elke instelling
- user_id - die
gebruiker_id
wat 'n vreemde sleutel is aanuser.id
- naam - 'n string teks wat die instelling voorstel
- waarde - die waarde van die instelling
Dit is die moeite werd om daarop te let dat die tabel Gebruiker en Gebruikerinstellings 'n Een-tot-Baie verhouding verdeel, wat beteken dat 'n enkele gebruiker rekord verband hou met verskeie Gebruikers Instellings rekords. Dit sal dit makliker maak om enige soort inligting wat verband hou met 'n gebruiker, byvoorbeeld, hul naam of profielfoto te stoor.
Noudat ons 'n paar tafels het om rond te speel, leer ons hoe om ons eerste Model te skep: die gebruikers model.
Stap 3 - Skep jou eerste model
Die DAO Ontwer Patroon
Soos met baie toepassings, is die gebruiklike maakmodelle in Zend Framework die gebruik van 'n gewilde ontwerppatroon wat die "DAO" patroon genoem word. In hierdie patroon het ons die volgende komponente:
- Table Data Gateway (DataSource) wat ons toepassing verbind met die gegee bron, die MySQL tabel
- Data Mapper (DataAccessObject) wat die data van die databasis na die
- Data Objek (Data) wat 'n ry uit ons databasis verteenwoordig, nadat die DataMapper die data daarheen gekaart het
Kom ons begin met die skep van 'n Table Data Gateway vir die gebruikers
tabel met behulp van die zf
CLI tool:
zf create db-table User user Creating a DbTable at thenextsocial/application/models/DbTable/User.php Updating project profile 'thenextsocial/.zfproject.xml'
Die zf skep db-tabel
neem twee parameters in:
- Klasnaam - die naam van die klas
- database_table - die naam van die tabel
Maak die User.php
lêer oop wat in die program / modelle /DbTable
lêer gevind word en dit moet so lyk:
<?php class Application_Model_DbTable_User extends Zend_Db_Table_Abstract { protected $_name = 'user'; }
Kom ons skep nou 'n Data Mapper klas. Weereens, met behulp van die ZF CLI-instrument:
zf create model UserMapper Creating a model at thenextsocial/application/models/UserMapper.php Updating project profile 'thenextsocial/.zfproject.xml'
Die lêer UserMapper.php
sal nou leeg wees, maar ons sal later 'n kode
inbring. Vir nou moet ons die Data Objek skep, wat die Gebruikers
model
is:
zf create model User Creating a model at thenextsocial/application/models/User.php Updating project profile 'thenextsocial/.zfproject.xml' </p></code> <p>Now that we have all three components of the DAO pattern, we create the code for the files. Open the <code>UserMapper.php</code> file and put in the following code:</p> [php] <?php class Application_Model_UserMapper { protected $_db_table; public function __construct() { //Instantiate the Table Data Gateway for the User table $this->_db_table = new Application_Model_DbTable_User(); } public function save(Application_Model_User $user_object) { //Create an associative array //of the data you want to update $data = array( 'email' => $user_object->email, 'password' => $user_object->password, ); //Check if the user object has an ID //if no, it means the user is a new user //if yes, then it means you're updating an old user if( is_null($user_object->id) ) { $data['salt'] = $user_object->salt; $data['date_created'] = date('Y-m-d H:i:s'); $this->_db_table->insert($data); } else { $this->_db_table->update($data, array('id = ?' => $user_object->id)); } } public function getUserById($id) { //use the Table Gateway to find the row that //the id represents $result = $this->_db_table->find($id); //if not found, throw an exsception if( count($result) == 0 ) { throw new Exception('User not found'); } //if found, get the result, and map it to the //corresponding Data Object $row = $result->current(); $user_object = new Application_Model_User($row); //return the user object return $user_object; } }
Hier het ons drie metodes:
- __construct() - konstruktor vir die klas. Sodra dit geopenbaar is, skep dit 'n voorbeeld van die Table Data Gateway en stoor dit
- stoor (Application_Model_User $user_object) neem 'n
Application_Model_User
in en stoor die data van die voorwerp na die databasis - getUserById($id) - neem 'n heelgetal $id in wat 'n enkele ry uit die databasis tabel voorstel, haal dit, terug en gee dan 'n
Application_Model_User
terug met die gegewe data
Open User.-php
en sit die volgende kode in:
<?php class Application_Model_User { //declare the user's attributes private $id; private $email; private $password; private $salt; private $date_created; //upon construction, map the values //from the $user_row if available public function __construct($user_row = null) { if( !is_null($user_row) && $user_row instanceof Zend_Db_Table_Row ) { $this->id = $user_row->id; $this->email = $user_row->email; $this->password = $user_row->password; $this->salt = $user_row->salt; $this->date_created = $user_row->date_created; } } //magic function __set to set the //attributes of the User model public function __set($name, $value) { switch($name) { case 'id': //if the id isn't null, you shouldn't update it! if( !is_null($this->id) ) { throw new Exception('Cannot update User\'s id!'); } break; case 'date_created': //same goes for date_created if( !is_null($this->date_created) ) { throw new Exception('Cannot update User\'s date_created'); } break; case 'password': //if you're updating the password, hash it first with the salt $value = sha1($value.$this->salt); break; } //set the attribute with the value $this->$name = $value; } public function __get($name) { return $this->$name; } }
- __construct ($ user_row) - neem 'n opsionele
Zend_Db_Table_Row
voorwerp in, wat een ry uit die databasis voorstel en die data na homself kaarteer - __set ($ naam, $ waarde) - 'n magiese funksie wat sorg dat al die eienskappe vir die model gestel word.
- __get($name) - 'n magiese funksie wat sorg dat jou 'n kenmerk van die model kry.
Kom ons probeer dit uit! As jou die vorige handleiding gevolg het, moet jou 'n IndexController.php
lêer hê. Maak dit oop en sit hierdie kode in wat 'n nuwe gebruiker skep:
public function indexAction() { // action body $this->view->current_date_and_time = date('M d, Y - H:i:s'); $user = new Application_Model_User(); $user->email = 'nikko@test.local'; $user->salt = sha1(time()); $user->password = 'test'; $user->date_created = date('Y-m-d H:i:s'); $user_mapper = new Application_Model_UserMapper(); $user_mapper->save($user); }
Gaan nou na http://thenextsocial.local/
. Sodra dit laai, gaan na die thenextsocial.user
tabel op MySQL en as alles gewerk het, moet jou 'n nuwe gebruiker
rekord hê!

'N nuwe Gebruiker
rekord!
Nou, laat ons hierdie rekord opdateer. Gaan terug na IndexController.php
en werk die kode op om by die volgende te pas:
public function indexAction() { // action body $this->view->current_date_and_time = date('M d, Y - H:i:s'); $user_mapper = new Application_Model_UserMapper(); $user = $user_mapper->getUserById(1); $user->email = 'new_email@test.local'; $user_mapper->save($user); }
Kyk weer na die MySQL tabel, en jou moet sien dat die e-pos vir die rekord opgedateer is!

Opgedateer Gebruiker
rekord
Baie geluk! Jou het jou eerste SEND Framework Model suksesvol geskep!
Die Leerstelling ORM
Inleiding
Van die Leerstoel ORM webwerf, http://doctrine-project.org/projects/orm:
Object relationele mapper (ORM) vir PHP wat sit op die top van 'n kragtige databasis abstraksie laag (DBAL). Een van sy belangrikste kenmerke is die opsie om databasisnavrae te skryf in 'n eie objekgeoriënteerde SQL-dialek genaamd Doctrine Query Language (DQL), geïnspireer deur Hibernates HQL. Dit bied ontwikkelaars 'n kragtige alternatief vir SQL wat buigsaamheid behou sonder om onnodige kode duplisering te vereis.
Basies, die Leer ORM biblioteek trek die meeste uit, of nie al die Model implementering vir 'n toepassing nie. Van die ongelooflike voordele wat ek ontdek het toe ek die Doctrine with Zend Framework gebruik het, is:
- Baie maklik om te gebruik, gewaarborg om jou ontwikkelingstyd in die helfte te sny
- Werk net so goed met verskillende soorte DB's met baie min tweak nodig. Byvoorbeeld, Doktrine het dit vir my baie maklik gemaak om 'n aansoek wat ek van voorheen gebruik het, van toepassing te maak van MySQL na MSSQL
- 'N Steierwerkinstrument, genaamd
Doctrine_Cli
, wat baie vinnig modelle uit die databasis skep
Om te begin, moet jy die Leer ORM-biblioteek eers van hul webwerf aflaai. Ek gebruik die 1.2.4 weergawe. Gaan na http://www.doctrine-project.org/projects/orm/1.2/download/1.2.4 en klik op die Download 1.2.4 Packag pakket.

Laai die Leerstelling ORM af
Sodra dit afgelaai is, maak dit oop en trek die inhoud uit. Binne, moet jou Doctrine-1.2.4 gids en 'n package.xml lêer sien. Gaan in die gids en jou moet 'n Doctrine lêer, 'n doktrine.php lêer en 'n LICENSE lêer sien.

Doctrine aflaai inhoud
Kopieer die Doctrine gids en die Doctrine.php lêer en plaas dit binne die sluitpad van jou PHP-installasie. As jou onthou hoe ons die Zend Framework uit die laaste handleiding opstel, is dit waarskynlik dieselfde gids wat jou die lêers van die Zend biblioteek geplaas het.

Doctrine biblioteek met Zend biblioteek in PHP se insluiting_spad
Nou is ons gereed om dit te integreer met ons Send-aansoek! Begin deur application.ini
weer oop te maak en voeg die volgende konfigurasie by die [development: production]
blok by:
;Doctrine settings resources.doctrine.connection_string = "mysql://[replace with db username]:[replace with db password]@localhost/thenextsocial" resources.doctrine.models_path = APPLICATION_PATH "/models" resources.doctrine.generate_models_options.pearStyle = true resources.doctrine.generate_models_options.generateTableClasses = true resources.doctrine.generate_models_options.generateBaseClasses = true resources.doctrine.generate_models_options.classPrefix = "Model_" resources.doctrine.generate_models_options.baseClassPrefix = "Base_" resources.doctrine.generate_models_options.baseClassesDirectory = resources.doctrine.generate_models_options.classPrefixFiles = false resources.doctrine.generate_models_options.generateAccessors = false
Nou ons konfigurasie opgestel het, maak die program se Bootstrap.php
lêer oop. Jou sal dit binne die thenextsocial/application
folder vind.
Die Bootstrap.php
Die Bootstrap.php
stel ons in staat om enige hulpbronne wat ons in ons aansoek kan gebruik, te initialiseer. Basies, moet al die hulpbronne wat ons moet instel, hier geplaas word. Ons sal later in hierdie reeks later in die reeks ingaan, maar vir eers moet jou net weet dat die formaat van metodes hier soos volg is:
protected function _initYourResource() { //Do your resource setup here }
Binne die Bootstra.php
lêer, voeg die volgende kode by om die Doctrine met die aansoek te initialiseer:
<?php class Bootstrap extends Zend_Application_Bootstrap_Bootstrap { public function _initDoctrine() { //require the Doctrine.php file require_once 'Doctrine.php'; //Get a Zend Autoloader instance $loader = Zend_Loader_Autoloader::getInstance(); //Autoload all the Doctrine files $loader->pushAutoloader(array('Doctrine', 'autoload')); //Get the Doctrine settings from application.ini $doctrineConfig = $this->getOption('doctrine'); //Get a Doctrine Manager instance so we can set some settings $manager = Doctrine_Manager::getInstance(); //set models to be autoloaded and not included (Doctrine_Core::MODEL_LOADING_AGGRESSIVE) $manager->setAttribute( Doctrine::ATTR_MODEL_LOADING, Doctrine::MODEL_LOADING_CONSERVATIVE); //enable ModelTable classes to be loaded automatically $manager->setAttribute( Doctrine_Core::ATTR_AUTOLOAD_TABLE_CLASSES, true ); //enable validation on save() $manager->setAttribute( Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_ALL ); //enable sql callbacks to make SoftDelete and other behaviours work transparently $manager->setAttribute( Doctrine_Core::ATTR_USE_DQL_CALLBACKS, true ); //not entirely sure what this does :) $manager->setAttribute( Doctrine_Core::ATTR_AUTO_ACCESSOR_OVERRIDE, true ); //enable automatic queries resource freeing $manager->setAttribute( Doctrine_Core::ATTR_AUTO_FREE_QUERY_OBJECTS, true ); //connect to database $manager->openConnection($doctrineConfig['connection_string']); //set to utf8 $manager->connection()->setCharset('utf8'); return $manager; } protected function _initAutoload() { // Add autoloader empty namespace $autoLoader = Zend_Loader_Autoloader::getInstance(); $resourceLoader = new Zend_Loader_Autoloader_Resource(array( 'basePath' => APPLICATION_PATH, 'namespace' => '', 'resourceTypes' => array( 'model' => array( 'path' => 'models/', 'namespace' => 'Model_' ) ), )); // Return it so that it can be stored by the bootstrap return $autoLoader; } }
Die opstelling wat ek hier gedoen het, is gebaseer op 'n skrif wat ek in die verlede gevind het op http://dev.juokaz.com, wat deur Juozas Kaziukenas, een van die spanlede by die Doctrine projek onderhou word. Ongelukkig is die blog reeds gesluit, dus ek sal nie meer daaraan kan koppel nie. Let ook daarop dat ons 'n ander metode genoem _initAutoload()
het. Dit begin basies die Send Autoloader, wat alle gegenereerde modelle in die modelle
gyds sal outoloë. Dit spaar ons die moeite om hierdie lêers een vir een in te sluit.
Vervolgens, moet ons die leerstuk CLI script opstel wat ons sal gebruik om modelle uit die databasis te genereer. Gaan terug na die thenextsocial
folder en maak 'n gids genaamd scripts
. Binne, maak 'n lêer genaamd leer cli.php
en plaas die volgende binne:
<?php /** * Doctrine CLI script * * @author Juozas Kaziukenas (juozas@juokaz.com) */ define('APPLICATION_ENV', 'development'); define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application')); set_include_path(implode(PATH_SEPARATOR, array( realpath(APPLICATION_PATH . '/../library'), './', get_include_path(), ))); require_once 'Zend/Application.php'; // Create application, bootstrap, and run $application = new Zend_Application( APPLICATION_ENV, APPLICATION_PATH . '/configs/application.ini' ); $application->getBootstrap()->bootstrap('doctrine'); // set aggressive loading to make sure migrations are working Doctrine_Manager::getInstance()->setAttribute( Doctrine::ATTR_MODEL_LOADING, Doctrine_Core::MODEL_LOADING_AGGRESSIVE ); $options = $application->getBootstrap()->getOptions(); $cli = new Doctrine_Cli($options['doctrine']); $cli->run($_SERVER['argv']);
Gaan terug na jou modelle
gids en verwyder die Gebruikers model lêers wat ons daar het. As jou wil, kan u dit eers na 'n ander plek skuif, maar dit moet nie in die gids wees nie. Open dan jou opdrag prompt (of terminale), cd
na die scripts
gids en tik die volgende opdrag in:
php doctrine-cli.php
Jou moet so iets sien:

Verwagte Leerstelling CLI uitset
As alles uitwerk, kom ons begin met die maak van 'n paar modelle! Tik die volgende in:
php doctrine-cli.php generate-models-db
Jou behoort nou die volgende uitset te sien:

Genereer Modelle deur gebruik te maak van Doctrine CLI
As jou dit gedoen het, kyk weer na jou modelle
lêergids en jou moet 'n paar splinternuwe Gebruikers
en GebruikersInstellings
modelle sien wat deur Doctrine gegenereer is!

Genereerde Modelle!
As jou die lêers oopmaak, sal jou nie veel binne sien nie. Die meeste van die kode vir die modelle word opgevang deur die doktrinebiblioteek. Deur die Doctrine_Record
klas uit te brei, het ons 'n hele paar voorbeboude metodes van die biblioteek beskikbaar. Maak IndexController.php
weer oop en vervang die ou toetskode met die volgende:
public function indexAction() { // action body $this->view->current_date_and_time = date('M d, Y - H:i:s'); $user = new Model_User(); $user->email = 'new_user_2@test.local'; $user->password = 'test'; $user->salt = sha1(time()); $user->date_created = date('Y-m-d H:i:s'); $user->save(); }
Sodra dit klaar is, gaan terug na http://thenextsocial.local. As die bladsy laai, gaan na jou MySQL tabel en jou moet sien dat 'n splinternuwe Gebruiker
rekord ingevoeg is!

Gebruiker
rekord via Leerstelling ORM
Kom ons probeer nou meer ingewikkelde dinge - die opgradering van 'n bestaande Gebruiker
via voorafgeboude leerstellingsmetodes en die opdatering daarvan. Dateer die kode op sodat dit so lyk:
public function indexAction() { // action body $this->view->current_date_and_time = date('M d, Y - H:i:s'); $user = Doctrine_Core::getTable('Model_User')->findOneByEmailAndPassword('new_user_2@test.local', 'test'); $user->password = 'new_password'; $user->save(); }
Die metode FindOneByEmailAndPassword()
is 'n geriefsmetode wat deur die leerstuk voorafgegee is om dit makliker te maak om een ry uit die databasis te kies. Die groot ding daaroor is dat jy tabelkolomme kan meng en pas in die metode. Byvoorbeeld, jou kan iets soos FindOneByIdAndNameAndPasswordAndSalt()noem
en dit sal steeds werk!

Opdateer 'n Gebruiker
rekord via Leerstelling ORM
Daar is heelwat meer wat ons nou kan doen as ons die Leerstelling ORM gebruik vir die implementering van die toepassing. Stukke soos die Leerstellingsnavraagtaal (DQL), gebruik voordeel van modelverhoudings en genereer modelle van YAML. Vir die res van die reeks gebruik ons Leerstelling ORM vir die Model implementering van die aansoek, dus jou sal eintlik twee dinge in die reeks leer, in plaas van net een! Score!
Konklusie
Teen hierdie tyd moet jou die volgende ken:
- Wat is ''Modelle''
- Koppel jou Stuur aansoek aan 'n databasis
- Hoe die
application.ini
werk - Die DAO Ontwer Patroon
- Skep van Modelle met behulp van die ZF CLI instrument
- Waar om die Leerstelling ORM af te laai en hoe om dit te installeer
- Die integrasie van die leerstelling ORM met jou Send aansoek
- Die
Bootstrap.php
- Genereer Modelle deur gebruik te maak van die Doctrine CLI instrument
- Basiese gebruik van Modelle gegenereer met Leer
Noudat jou weet hoe om die Modelle in 'n Zend Framework-aangedrewe program te implementeer, het jou die kennis om dinamiese webwerwe te skep. Probeer om met die program rond te speel, maak 'n paar nuwe beheerders en modelle wat lees, werk, stoor en uitvee uit die databasis.
In ons volgende handleiding leer ons oor sommige van die dikwels gebruikte komponente van die Zend Framework biblioteek, die Zend_Auth en Zend_Acl komponente en bou TheNextSocial se verifikasiestelsel!
Tot dan, bly ingestel, en onthou dat al die kode wat hier gebruik word, beskikbaar is op TheNextSocial se GitHub repository!
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Update me weeklyEnvato Tuts+ tutorials are translated into other languages by our community members—you can be involved too!
Translate this post