Stuur Kader Vanaf Kras - Model en Integreer ORM Leer

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:

MVC Argitektuur Diagram

Beeld met vergunning van ash.MVC (nou genaamd Opendelight)

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 &ldquo;inherit&rdquo; 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 aan user.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!