Zend Framework dari awal - model dan mengintegrasikan Doctrine ORM

Indonesian (Bahasa Indonesia) translation by Afiff Soebarkah (you can also view the original English article)

Siap untuk mengambil keterampilan PHP Anda ke tingkat berikutnya? Dalam baru "Dari menggaruk" seri ini, kita akan fokus pada Zend Framework, kerangka kerja PHP penuh-tumpukan yang diciptakan oleh Zend Technologies. Tutorial ini kedua pada seri kami berhak "Model dan mengintegrasikan Doctrine ORM".

Tinjauan

Selamat datang kembali ke kami Zend Framework dari seri awal! Dalam penuntun ini terakhir, kita belajar beberapa hal dasar tentang Zend Framework, seperti:

Dimana untuk mendownload file Zend Framework terbaru
Dimana dan bagaimana untuk mengatur secara lokal
Menciptakan proyek Zend Framework pertama dan menyiapkan virtual pada server web Anda
Bagaimana tepatnya Zend Framework menerapkan pola MVC dan routing aplikasi standar yang
Lewat data dari controller ke view nya
Menciptakan layout situs-lebar untuk aplikasi Zend Framework
Menciptakan baru controller dan Action

Jika Anda belum, Anda harus memberikan tutorial sebelumnya membaca. Itu akan benar-benar membuat lebih mudah bagi Anda untuk memahami beberapa dasar Zend Framework dan membantu Anda memahami beberapa hal yang kita membahas dalam tutorial ini.

Dalam kedua ini bagian dari seri, kita akan berbicara tentang bagian penting dari aplikasi web-model. Kami juga akan mengambil melihat bagaimana mengintegrasikan sangat populer Doctrine ORM dengan proyek Zend Framework kami, dan mencari tahu mengapa itu jauh lebih baik untuk digunakan daripada Zend_Db asli Zend Framework. Jadi, tanpa basa-basi lagi, mari kita mulai!

Apa sebenarnya yang "Model"?

Ketika saya mulai mencoba untuk memahami konsep MVC, saya membaca cukup banyak analogi, yang berusaha untuk menjelaskan persis apa setiap komponen ini mewakili. Salah satu analogi terbaik yang saya telah membaca sejauh ini adalah dari artikel ini, cara lain untuk berpikir tentang MVC. Ia pergi sesuatu seperti ini:

Jadi, mari kita Bayangkan sebuah bank.

Aman adalah Database-ini adalah di mana semua barang paling penting disimpan, dan baik dilindungi dari dunia luar.

Kemudian kami memiliki para bankir atau dalam program syarat model. Para bankir adalah satu-satunya yang memiliki akses ke aman (DB). Mereka umumnya lemak, tua dan malas, yang mengikuti cukup baik dengan salah satu aturan MVC: * lemak model, kurus controller *. Kita akan melihat mengapa dan bagaimana analogi ini berlaku sedikit kemudian.
Sekarang kami punya pekerja bank rata-rata kami gophers, pelari, kontroler. Controller atau menghubungkan diri melakukan semua berjalan sekitar, itulah mengapa mereka harus menjadi bugar dan kurus. Mereka mengambil menjarah atau informasi dari para bankir (model) dan membawanya ke nasabah bank pandangan.

Para bankir (model) telah menjadi pekerjaan untuk sementara waktu, oleh karena itu mereka membuat semua keputusan penting. Yang membawa kita kepada aturan lain: * tetap sebanyak logika bisnis dalam Model sebagai mungkin *. Controller, pekerja kami rata-rata, harus tidak membuat keputusan seperti itu, mereka meminta bankir untuk rincian, mendapatkan info, dan menyampaikannya kepada nasabah (View). Oleh karena itu, kami terus mengikuti aturan * lemak model, kurus controller *. Gophers tidak membuat keputusan penting, tetapi mereka tidak dapat polos bodoh (dengan demikian sedikit logika bisnis dalam controller adalah OK). Namun, segera setelah gopher mulai berpikir terlalu banyak bankir marah dan bank Anda (atau Anda app) keluar dari bisnis. Jadi sekali lagi, selalu ingat untuk offload sebanyak bisnis logika (atau pengambilan keputusan) model.

Sekarang, para bankir yakin sebagai neraka tidak akan berbicara dengan pelanggan (View) secara langsung, mereka terlalu penting di kursi mereka nyaman untuk itu. Dengan demikian aturan lain diikuti: * model harus tidak berbicara dengan pemandangan *. Ini komunikasi antara bank dan nasabah (Model dan pandangan) selalu ditangani oleh gopher (Controller). (Ya, ada beberapa pengecualian untuk aturan ini untuk super Pelanggan VIP, tapi mari kita tetap berpegang pada dasar-dasar untuk saat ini).

Hal ini juga terjadi yang memiliki satu pekerja (Controller) untuk mendapatkan informasi dari lebih dari satu bankir, dan itu sempurna dapat diterima. Namun, jika para bankir berhubungan (jika tidak bagaimana lagi mereka akan mendarat pekerjaan bagus seperti itu?) ... para bankir (model) akan saling berkomunikasi pertama, dan kemudian melewati kumulatif informasi kepada mereka gopher, yang dengan senang hati akan mengirimkannya kepada nasabah (View). Jadi di sini adalah aturan lain: * model bersangkutan memberikan informasi ke controller melalui Asosiasi (hubungan) *.

Jadi bagaimana dengan customer (View)? Yah, Bank membuat kesalahan dan pelanggan harus cukup cerdas untuk menyeimbangkan account mereka sendiri dan membuat beberapa keputusan. Dalam MVC istilah kita mendapatkan aturan sederhana lain: * ini adalah sangat baik-baik saja untuk pandangan mengandung beberapa logika, yang berkaitan dengan pandangan atau presentasi *. Berikut kami analogi, pelanggan akan memastikan tidak lupa untuk memakai celana sementara mereka pergi ke bank, tetapi mereka tidak akan memberitahu para bankir bagaimana proses transaksi.

Diagram arsitektur MVC

Gambar milik abu. MVC (sekarang bernama Opendelight)

Singkatnya:

Model perwakilan dari Database, dan harus mana semua logika bisnis aplikasi berada
Controller berkomunikasi dengan model dan meminta mereka untuk mengambil informasi yang mereka butuhkan
Informasi ini kemudian melewati Controller ke tampilan dan dituliskan
Sangat jarang bahwa Model langsung berinteraksi dengan pemandangan, tapi kadang-kadang mungkin terjadi bila diperlukan
Model dapat berbicara dengan model-model lain dan tidak mandiri. Mereka memiliki hubungan yang terjalin dengan satu sama lain
Hubungan ini membuatnya lebih mudah dan cepat untuk Controller untuk mendapatkan informasi, karena itu tidak berinteraksi dengan model - model yang dapat melakukan itu sendiri

Kita bisa melihat betapa pentingnya model dalam aplikasi apapun, karena memiliki repsonsible untuk setiap tindakan yang dinamis yang terjadi dalam aplikasi. Sekarang bahwa kita memiliki pemahaman yang jelas tentang tanggung jawab dari Model, serta pemandangan dan Controller, Mari selami menerapkan model di aplikasi kita.

Langkah 1 - mengatur aplikasi Zend Anda hubungkan ke Database

Hal pertama yang kita harus lakukan adalah untuk membuat aplikasi Zend kita terhubung ke database. Untungnya, perintah zf dapat mengurus yang. Buka Prompt Perintah atau Terminal, cd ke folder thenextsocial Anda, dan ketik berikut:

zf configure db-adapter "adapter=PDO_MYSQL&dbname=thenextsocial&host=localhost&username=[your local database username]&password=[your local database password]" -s development

Jika benar, Anda harus mendapatkan output yang mirip dengan:

A db configuration for the development section has been written to the application config file.

Selain itu, Anda akan melihat dua baru baris dalam application.ini file:

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]

Kita dapat melihat dengan jelas bahwa SetEnv APPLICATION_ENV direktif menetapkan lingkungan aplikasi kita. Jika dan ketika kita pindah aplikasi untuk lingkungan lain, ini harus menjadi satu-satunya hal yang kita perlu berubah. Hal ini memastikan bahwa semua aplikasi kita bergantung pada karya didefinisikan dalam application.ini, yang akan memastikan bahwa aplikasi kita tidak mengandalkan pengaturan eksternal. Ini membantu menghilangkan masalah "itu bekerja pada mesin pengembangan saya, kenapa tidak bekerja di server produksi?".

Langkah 2 - membuat Database dan beberapa tabel

Sebelum kita membuat Anda Model kami pertama untuk aplikasi, kita akan membutuhkan Database yang Model akan mewakili pertama. Mari kita mulai dengan sesuatu yang sederhana-tabel User, di mana kita akan menyimpan semua pengguna terdaftar untuk TheNextSocial.

Login ke Anda MySQL database dan membuat sebuah database yang disebut thenextsocial. Setelah dibuat, mengeksekusi query berikut untuk membuat tabel User, dan sebuah meja pengaturan pengguna yang menyertainya:

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;

Query SQL ini harus membuat dua tabel. Tabel user dengan kolom berikut:

id - ID yang unik untuk setiap pengguna
email - alamat email dari pengguna, juga unik
sandi - sandi pengguna, yang kita akan hash
garam - garam acak, yang kita akan gunakan untuk hash password pengguna
date_created - tanggal dan waktu catatan pengguna diciptakan

Dan sebuah meja user_settings, di mana kita akan menyimpan pengaturan terkait dengan pengguna, dengan kolom:

id - ID yang unik untuk setiap pengaturan
id - id yang foreign key untuk user.id
nama - string teks yang mewakili pengaturan
nilai - nilai pengaturan

It's worth mengambil catatan bahwa tabel User dan pengaturan pengguna berbagi satu-ke-banyak hubungan yang berarti satu catatan data pengguna dapat berhubungan dengan beberapa pengaturan pengguna catatan. Ini akan membuat lebih mudah untuk menyimpan informasi terkait dengan pengguna, untuk contoh, nama atau profil mereka foto apapun.

Sekarang bahwa kita memiliki beberapa meja untuk bermain-main dengan, mari kita belajar cara membuat Model pertama kami: User Model.

Langkah 3 - membuat Model pertama Anda

Pola desain DAO

Seperti banyak aplikasi, cara yang biasa untuk menggunakan membuat model pada Zend Framework untuk membuat penggunaan pola desain populer disebut "DAO" pola. Dalam pola ini, kami memiliki komponen-komponen berikut:

The DAO Design Pattern

Pola desain DAO

Gambar milik http://www.informit.com

Tabel Data Gateway (DataSource) yang menghubungkan aplikasi kita ke sumber data, Tabel MySQL
Data Mapper (DataAccessObject) yang memetakan data yang Diperoleh dari database untuk
Objek data (Data) yang mewakili baris dari database kami, setelah DataMapper peta data untuk itu

Mari kita mulai dengan membuat Gateway Data Tabel untuk tabel User menggunakan zf CLI alat:

zf create db-table User user
Creating a DbTable at thenextsocial/application/models/DbTable/User.php
Updating project profile 'thenextsocial/.zfproject.xml'

Zf membuat db-tabel mengambil dua parameter:

ClassName - nama kelas
database_table - nama tabel

Buka file User.php yang ditemukan di folder aplikasi/model/DbTable dan itu akan terlihat seperti ini:

<?php

class Application_Model_DbTable_User extends Zend_Db_Table_Abstract
{

    protected $_name = 'user';


}

Sekarang mari kita membuat kelas Data Mapper. Sekali lagi, menggunakan zf CLI alat:

zf create model UserMapper
Creating a model at thenextsocial/application/models/UserMapper.php
Updating project profile 'thenextsocial/.zfproject.xml'

UserMapper.php file akan kosong sekarang tapi kami akan menempatkan beberapa kode kemudian. Untuk saat ini, kita perlu membuat objek Data, yang merupakan User model:

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;
	}
}

Di sini kita memiliki tiga metode:

__construct() - konstruktor untuk kelas. Setelah dipakai, itu membuat instance tabel Data Gateway dan toko
Simpan (Application_Model_User $user_object) - mengambil dalam Application_Model_User dan menyimpan data dari objek ke database
getUserById($id) - mengambil integer $id yang mewakili satu baris dari tabel database, mengambil itu, kemudian kembali Application_Model_User dengan data yang dipetakan

Membuka User.php dan meletakkan kode berikut:

<?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) - mengambil objek Zend_Db_Table_Row opsional, yang mewakili satu baris dari database, dan peta data untuk dirinya sendiri
__set ($name, $value) - fungsi sihir yang mengurus pengaturan semua atribut untuk model.
__get($Name) - sebuah fungsi sihir yang mengurus mendapatkan atribut model.

Mari kita coba! Jika Anda mengikuti tutorial sebelumnya, Anda harus memiliki IndexController.php file. Membukanya dan dimasukkan ke dalam kode yang menciptakan pengguna baru:

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);
}

Sekarang pergi ke http://thenextsocial.local/. Setelah beban, periksa thenextsocial.user tabel di MySQL dan jika semuanya bekerja, Anda harus memiliki catatan pengguna baru!

Catatan pengguna baru!

Sekarang, mari kita coba memperbarui Catatan ini. Kembali ke IndexController.php dan memperbarui kode untuk mencocokkan berikut:

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);
}

Periksa Tabel MySQL kembali, dan Anda akan melihat bahwa email untuk catatan telah diperbarui!

Diperbarui catatan pengguna

Selamat! Anda telah berhasil membuat pertama Anda pernah Zend Framework Model!

Doktrin ORM

Pengenalan

Dari situs Doctrine ORM, http://doctrine-project.org/projects/orm:

Objek relasional mapper (ORM) untuk PHP yang duduk di atas lapisan abstraksi kuat database (DBAL). Salah satu fitur utamanya adalah pilihan untuk menulis query database dalam dialek SQL berorientasi objek yang berpemilik yang disebut doktrin Query Language (DQL), terinspirasi oleh Hibernates HQL. Ini menyediakan pengembang dengan alternatif yang kuat untuk SQL yang mempertahankan fleksibilitas tanpa memerlukan kode yang tidak perlu duplikasi.

Pada dasarnya, Perpustakaan Doctrine ORM abstrak kebanyakan, jika tidak semua Model implementasi untuk aplikasi. Beberapa keuntungan luar biasa yang saya menemukan ketika menggunakan Doctrine dengan Zend Framework adalah:

Sangat mudah digunakan, dijamin untuk memotong waktu pengembangan Anda setengah
Bekerja hanya serta dengan berbagai jenis DB's dengan sangat sedikit tweaker diperlukan. Sebagai contoh, doktrin membuatnya sangat mudah bagi saya untuk port aplikasi saya bekerja di sebelum menggunakan MySQL untuk MSSQL
Alat perancah, yang disebut Doctrine_Cli yang menciptakan model dari database sangat cepat

Untuk memulai, Anda harus mengunduh Doctrine ORM Perpustakaan pertama dari situs mereka. Aku akan menggunakan 1.2.4 versi. Pergi ke http://www.doctrine-project.org/projects/orm/1.2/download/1.2.4 dan klik pada link Download 1.2.4 paket.

Mengunduh Doctrine ORM

Setelah download, membukanya dan ekstrak isi. Di dalam, Anda harus melihat doktrin-1.2.4 folder dan package.xml file. Masuk ke dalam folder dan Anda harus melihat folder doktrin, Doctrine.php file dan file lisensi.

Doktrin download isi

Salin folder doktrin dan Doctrine.php file dan meletakkannya di dalam jalan termasuk instalasi PHP Anda. Jika Anda ingat bagaimana kita mengatur Zend Framework dari tutorial terakhir, itu adalah kemungkinan folder yang sama Anda menempatkan Zend file di Perpustakaan.

Doctrine library with Zend library in PHP's include_path

Pustaka Doctrine dengan Zend Perpustakaan dalam PHP include_path

Sekarang kita siap untuk mengintegrasikan dengan aplikasi Zend kami! Mulai dengan membuka application.ini lagi dan menambahkan konfigurasi berikut dalam [pengembangan: produksi] blok:

;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

Sekarang bahwa kita memiliki konfigurasi kami mengatur, buka aplikasi Bootstrap.php file. Anda akan menemukan ini di dalam folder thenextsocial aplikasi.

Bootstrap.php

Bootstrap.php Mari kita menginisialisasi sumber daya yang kita mungkin menggunakan di aplikasi kita. Pada dasarnya, semua sumber daya yang kita perlu instantiate harus ditempatkan di sini. Kita akan menyelam ke dalam ini secara lebih rinci nanti dalam seri, tetapi untuk sekarang, semua perlu Anda ketahui adalah bahwa format untuk metode di sini adalah seperti ini:

protected function _initYourResource()
{
	//Do your resource setup here
}

Di dalam Bootstra.php file, tambahkan kode berikut untuk menginisialisasi doktrin dengan aplikasi:

<?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;
	}
}

Setup yang telah saya lakukan di sini didasarkan pada sebuah script yang saya temukan di masa lalu di http://dev.juokaz.com, yang dikelola oleh Juozas Kaziukenas, salah satu anggota tim di proyek doktrin. Sayangnya, blog sudah dimatikan, jadi saya tidak akan dapat link ke sana lagi. Juga, perhatikan bahwa kita memiliki metode lain yang disebut _initAutoload(). Ini pada dasarnya menginisialisasi Zend Autoloader, yang akan autoload semua model yang dihasilkan di dalam models folder. Ini menghemat kerumitan harus menyertakan file ini satu per satu.

Selanjutnya, kita perlu men-setup script CLI doktrin yang kita akan gunakan untuk auto-menghasilkan model dari database. Kembali ke thenextsocial folder dan membuat sebuah folder bernama script. Di dalam, membuat sebuah file bernama doktrin-cli.php dan meletakkan berikut di dalamnya:

<?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']);

Kembali di dalam folder model dan menghapus file model pengguna kami ada (jika Anda ingin, Anda dapat memindahkannya ke lokasi lain pertama, tapi itu tidak boleh di dalam folder). Selanjutnya, membuka prompt perintah Anda (atau terminal), cd ke script folder dan ketik perintah berikut:

php doctrine-cli.php

Anda harus melihat sesuatu seperti ini:

Diharapkan doktrin CLI output

Jika semuanya bekerja, mari kita mulai membuat beberapa model! Ketik berikut:

php doctrine-cli.php generate-models-db

Anda sekarang harus melihat output berikut:

Menghasilkan model menggunakan CLI doktrin

Jika Anda melakukannya, periksa folder model Anda lagi dan Anda akan melihat beberapa merek baru model User dan UserSettings yang telah dihasilkan oleh doktrin!

Dihasilkan model!

Jika Anda membuka file, Anda tidak akan melihat banyak di dalam. Sebagian besar kode untuk model Disarikan oleh pustaka Doctrine. Dengan memperpanjang kelas Doctrine_Record, kami memiliki tersedia untuk kita banyak prebuilt metode dari perpustakaan. Buka IndexController.php kembali dan mengganti kode tes lama dengan berikut:

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();
}

Setelah selesai, kembali ke http://thenextsocial.local. Apakah halaman dimuat, periksa Tabel MySQL Anda dan Anda akan melihat bahwa catatan pengguna baru telah dimasukkan!

Catatan pengguna melalui Doctrine ORM

Sekarang, mari kita coba beberapa hal yang lebih rumit — mengambil pengguna yang ada melalui prebuilt doktrin metode dan memperbarui. Memperbarui kode sehingga terlihat seperti ini:

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();
}

Metode findOneByEmailAndPassword() adalah metode kenyamanan prebuilt oleh doktrin untuk membuatnya lebih mudah untuk memilih satu baris dari database. Hal yang besar tentang hal itu adalah Anda bisa campur-dan-mencocokkan tabel kolom dalam metode. Misalnya, Anda dapat memanggil sesuatu seperti findOneByIdAndNameAndPasswordAndSalt() dan akan masih bekerja!

Mengupdate record User melalui Doctrine ORM

Ada jauh lebih banyak yang bisa kita lakukan sekarang bahwa kita menggunakan Doctrine ORM untuk aplikasi Model implementasi. Hal-hal seperti doktrin Query Language (DQL), mengambil keuntungan dari Model hubungan dan menghasilkan model dari YAML. Untuk sisa seri, kita akan menggunakan Doctrine ORM untuk penerapan Model aplikasi, sehingga Anda akan benar-benar belajar dua hal dalam seri bukan hanya satu! Skor!

Kesimpulan

Sekarang, Anda harus dapat mengetahui berikut:

Apa yang "Model"
Menghubungkan aplikasi Zend Anda ke database
Bagaimana application.ini bekerja
Pola desain DAO
Membuat model menggunakan alat ZF CLI
Dimana untuk mendownload Doctrine ORM dan bagaimana cara menginstalnya
Mengintegrasikan Doctrine ORM dengan aplikasi Zend
Bootstrap.php
Menghasilkan model-model yang menggunakan alat doktrin CLI
Dasar penggunaan model-model yang dihasilkan dengan doktrin

Sekarang bahwa Anda tahu bagaimana menerapkan model dalam aplikasi Zend Framework didukung, Anda memiliki pengetahuan untuk membuat situs web dinamis. Cobalah untuk bermain-main dengan aplikasi, membuat beberapa controller yang baru dan model yang membaca, memperbarui, menyimpan dan menghapus dari database.

Dalam tutorial kami berikutnya, kita akan mempelajari beberapa komponen yang sering digunakan Zend Framework Library, Zend_Auth dan Zend_Acl komponen dan membangun sistem autentikasi TheNextSocial's!

Sampai saat itu, menantikan, dan ingat bahwa semua kode yang digunakan di sini juga tersedia di TheNextSocial's GitHub repositori!