Gumawa ng PHP5 Framework

() translation by (you can also view the original English article)

Sa pangunahing istraktura para sa ating Framework na matatag na, panahon na para simulang maglagay ng functionality dito. Sa pagtuturong ito gagawa tayo ng template manager at database handler, na magdadala sa atin sa magaling na Framework na akma sa paggamit ng halos anong proyekto. Kung wala ka pa, siguraduhin na suriin muna ang Unang Bahagi ng seryeng ito!

MVC: I-tweak ang istraktura

Sa unang bahagi ng pagtuturong ito,gumawa tayo ng folder na tinawag na controllers para i-store ang business logic para sa ating applications. Katulad ng binigyang punto ni daok sa komento, hindi ito ang pinakamagandang lugar para sa lahat ng business logic, at kailangang gamitin ang modelo para i-store itong logic. Dati,lagi kong ginagamit ang database mismo bilang modelo sa karamihan sa aking applications,gayunpaman,ang pagbubukod nito ng kaunti ay gagawing mas magaling ang ating framework, at mas madaling pahabain.

Kung kaya ano ang MVC? Ang MVC ay isang pattern ng disenyo (katulad ng Singleton at Registry patterns na tiningnan natin sa unang bahagi), at ang ibig sabihin ay Model View Controller, at ang layunin ay paghiwalayin ang business logic, user interface actions at ang user interface mula sa isa’t isa. Bagaman wala tayong ibang gagawin sa ating mga modelo at controllers sa ngayon, i-update natin ang istraktura ng ating frameworks folder para mailagay ang “models’ folder. Ang modelo ay maglalaman ng pangunahing business logic, at ang controller ang bahala sa user interaction (halimbawa pagpasa ng data, katulad ng komento). NB: Ang ating__autoload function ay hindi kailangang mabago.

Database Handler

Karamihan sa websites at web applications na gumagamit ng PHP ay gumagamit din ng database engine, katulad ng MySQL. Kung pananatilihin natin lahat ng may kaugnayan sa database functions sa parehong kinalalagyan, kung gayon maaari nating (sa teorya) mabilis na mabago ang database engine na ginagamit natin. Maaari din nating gawing mas madali ang ilang operasyon, katulad ng paglakip ng records, pag-update ng records at pagtanggal ng records mula sa database. Mas mapapadali din nito ang pagtatrabaho sa iba’t ibang koneksyon ng database.

Kung kaya, ano ang dapat gawin ng ating database handler:

I-manage ang mga koneksyon sa database
Subukang magbigay ng ilang antas ng abstraction mula sa database
Cache queries para magamit natin sila sa susunod
Gawing mas madali ang karaniwang operasyon sa database

Tingnan natin ang code para sa ating database handler, pagkatapos ay tatalakayin natin ito.


<?php

/**
 * Database management and access class
 * This is a very basic level of abstraction
 */
class database {
  
	/**
	 * Allows multiple database connections
	 * probably not used very often by many applications, but still useful
	 */
	private $connections = array();
	
	/**
	 * Tells the DB object which connection to use
	 * setActiveConnection($id) allows us to change this
	 */
	private $activeConnection = 0;
	
	/**
	 * Queries which have been executed and then "saved for later"
	 */
	private $queryCache = array();
	
	/**
	 * Data which has been prepared and then "saved for later"
	 */
	private $dataCache = array();
	
	/**
	 * Record of the last query
	 */
	private $last;
	
	
	/**
	 * Hello
	 */
    public function __construct()
    {
    	
    }
    
    /**
     * Create a new database connection
     * @param String database hostname
     * @param String database username
     * @param String database password
     * @param String database we are using
     * @return int the id of the new connection
     */
    public function newConnection( $host, $user, $password, $database )
    {
    	$this->connections[] = new mysqli( $host, $user, $password, $database );
    	$connection_id = count( $this->connections )-1;
    	if( mysqli_connect_errno() )
    	{
    		trigger_error('Error connecting to host. '.$this->connections[$connection_id]->error, E_USER_ERROR);
		} 	
    	
    	return $connection_id;
    }
    
    /**
     * Close the active connection
     * @return void
     */
    public function closeConnection()
    {
    	$this->connections[$this->activeConnection]->close();
    }
    
    /**
     * Change which database connection is actively used for the next operation
     * @param int the new connection id
     * @return void
     */
    public function setActiveConnection( int $new )
    {
    	$this->activeConnection = $new;
    }
    
    /**
     * Store a query in the query cache for processing later
     * @param String the query string
     * @return the pointed to the query in the cache
     */
    public function cacheQuery( $queryStr )
    {
    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )
    	{
		    trigger_error('Error executing and caching query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);
		    return -1;
		}
		else
		{
			$this->queryCache[] = $result;
			return count($this->queryCache)-1;
		}
    }
    
    /**
     * Get the number of rows from the cache
     * @param int the query cache pointer
     * @return int the number of rows
     */
    public function numRowsFromCache( $cache_id )
    {
    	return $this->queryCache[$cache_id]->num_rows;	
    }
    
    /**
     * Get the rows from a cached query
     * @param int the query cache pointer
     * @return array the row
     */
    public function resultsFromCache( $cache_id )
    {
    	return $this->queryCache[$cache_id]->fetch_array(MYSQLI_ASSOC);
    }
    
    /**
     * Store some data in a cache for later
     * @param array the data
     * @return int the pointed to the array in the data cache
     */
    public function cacheData( $data )
    {
    	$this->dataCache[] = $data;
    	return count( $this->dataCache )-1;
    }
    
    /**
     * Get data from the data cache
     * @param int data cache pointed
     * @return array the data
     */
    public function dataFromCache( $cache_id )
    {
    	return $this->dataCache[$cache_id];
    }
    
    /**
     * Delete records from the database
     * @param String the table to remove rows from
     * @param String the condition for which rows are to be removed
     * @param int the number of rows to be removed
     * @return void
     */
    public function deleteRecords( $table, $condition, $limit )
    {
    	$limit = ( $limit == '' ) ? '' : ' LIMIT ' . $limit;
    	$delete = "DELETE FROM {$table} WHERE {$condition} {$limit}";
    	$this->executeQuery( $delete );
    }
    
    /**
     * Update records in the database
     * @param String the table
     * @param array of changes field => value
     * @param String the condition
     * @return bool
     */
    public function updateRecords( $table, $changes, $condition )
    {
    	$update = "UPDATE " . $table . " SET ";
    	foreach( $changes as $field => $value )
    	{
    		$update .= "`" . $field . "`='{$value}',";
    	}
    	   	
    	// remove our trailing ,
    	$update = substr($update, 0, -1);
    	if( $condition != '' )
    	{
    		$update .= "WHERE " . $condition;
    	}
    	
    	$this->executeQuery( $update );
    	
    	return true;
    	
    }
    
    /**
     * Insert records into the database
     * @param String the database table
     * @param array data to insert field => value
     * @return bool
     */
    public function insertRecords( $table, $data )
    {
    	// setup some variables for fields and values
    	$fields  = "";
		$values = "";
		
		// populate them
		foreach ($data as $f => $v)
		{
			
			$fields  .= "`$f`,";
			$values .= ( is_numeric( $v ) && ( intval( $v ) == $v ) ) ? $v."," : "'$v',";
		
		}
		
		// remove our trailing ,
    	$fields = substr($fields, 0, -1);
    	// remove our trailing ,
    	$values = substr($values, 0, -1);
    	
		$insert = "INSERT INTO $table ({$fields}) VALUES({$values})";
		$this->executeQuery( $insert );
		return true;
    }
    
    /**
     * Execute a query string
     * @param String the query
     * @return void
     */
    public function executeQuery( $queryStr )
    {
    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )
    	{
		    trigger_error('Error executing query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);
		}
		else
		{
			$this->last = $result;
		}
		
    }
    
    /**
     * Get the rows from the most recently executed query, excluding cached queries
     * @return array 
     */
    public function getRows()
    {
    	return $this->last->fetch_array(MYSQLI_ASSOC);
    }
    
    /**
     * Gets the number of affected rows from the previous query
     * @return int the number of affected rows
     */
    public function affectedRows()
    {
    	return $this->$this->connections[$this->activeConnection]->affected_rows;
    }
    
    /**
     * Sanitize data
     * @param String the data to be sanitized
     * @return String the sanitized data
     */
    public function sanitizeData( $data )
    {
    	return $this->connections[$this->activeConnection]->real_escape_string( $data );
    }
    
    /**
     * Deconstruct the object
     * close all of the database connections
     */
    public function __deconstruct()
    {
    	foreach( $this->connections as $connection )
    	{
    		$connection->close();
    	}
    }
}
?>

Bago natin talakayin ito ng mas detalyado, kailangan kong bigyang-diin na ang database handler na ito ay napaka basic.Maaari tayong makapagbigay ng kumpletong abstraction sa pamamagitan ng pag-execute ng queries ng direkta, subalit sa halip ay pagbuo ng queries batay sa parameters sa query function, at pagkatapos ay pag-execute nito.

Sa ating delete, insert at update record methods ay nagiging mas madali na gawin ang ilang karaniwang trabaho (katulad ng nabanggit ko sa itaas maaari natin itong pahabain para mas madaming magawa), sa pamamagitan ng pagbibigay lang ng impormasyon katulad ng pangalan ng table, array of fields at katumbas na values, limit values at conditions. Ang Queries ay maaari ding i-cached para may magawa tayo dito sa susunod. Napagtanto ko na ang feature na ito (at gayon din ang kakayahan na i-cache ang arrays of data) ay kapaki-pakinabang kapag pinagsama sa template manager, dahil madali nating mauulit sa pamamagitan ng hanay ng data at paglagyan ito ng sa ating templates na may kaunting pagkaabala, katulad ng makikita mo kapag tiningnan natin ang template manager.


// insert record
$registry->getObject('db')->insertRecords( 'testTable', array('name'=>'Michael' ) );
// update a record
$registry->getObject('db')->updateRecords( 'testTable', array('name'=>'MichaelP' ), 'ID=2' );
// delete a record (well, upto 5 in this case)
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );

Maaari din tayong gumawa sa iba’t ibang koneksyon ng database ng medyo madali, basta mailipat natin sa pagitan ng tamang koneksyon kung kailangan (bagaman ay hindi ito uubra kapag magka-cache ng queries at ire-retrieve ang mga ito sa pamamagitan ng template manager ng walang trabahong gagawin), halimbawa, sa code snippet sa ibaba ay matatanggal natin ang records mula sa dalawang databases.


// our second database connection (let's assume we already have a connection to our main DB)
$newConnection = $registry->getObject('db')->newConnection('localhost', 'root', 'password', 'secondDB');
// delete from the primary db connection
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );
// change our active db connection, to allow future queries to be on the second connection
$registry->getObject('db')->setActiveConnection( $newConnection );
// delete from the secondary db connection
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );
// revert the active connection so future queries are on the primary db connection
$registry->getObject('db')->setActiveConnection( 0 );

Paano natin gustong pahabain ang class na ito?

Full abstraction
Gamitin ang inheritance, gumawa ng interface at gawing ma-inherit ito ng database classes mula dito, sa bawat isa para sa iba’t ibang database engines
I-store ang connection ID’s kasama ng query kapag magka-cache ng queries
Mas pagandahin ang data sanitizing, depende sa uri ng data na gusto nating i-sanitize

Ang template manager

Ang template manager na ang bahala sa lahat ng output, kailangan nitong gumana sa iba’t ibang template files, palitan ang placeholders (tinatawag ko silang tags) na may data at ulitin sa pamamagitan ng mga bahagi ng template na may iba’t ibang hanay ng data mula sa database.

Para mas mapadali ang mga bagay, gagamit tayo ng page class para maghawak ng content na may kinalaman sa page, mas mapapadali din nito para sa atin na mapahaba at makapaglagay ng features dito sa susunod. Ang template manager ang bahala na sa object na ito.


<?php

// prevent this file being called directly
if ( ! defined( 'PCAFW' ) ) 
{
	echo 'This file can only be called via the main index.php file, and not directly';
	exit();
}

/**
 * Template manager class
 */
class template {

	private $page;
	
	/**
	 * Hello!
	 */
    public function __construct() 
    {
	    include( APP_PATH . '/PCARegistry/objects/page.class.php');
	    $this->page = new Page();

    }
    
    /**
     * Add a template bit onto our page
     * @param String $tag the tag where we insert the template e.g. {hello}
     * @param String $bit the template bit (path to file, or just the filename)
     * @return void
     */
    public function addTemplateBit( $tag, $bit )
    {
		if( strpos( $bit, 'skins/' ) === false )
		{
		    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;
		}
		$this->page->addTemplateBit( $tag, $bit );
    }
    
    /**
     * Put the template bits into our page content
     * Updates the pages content
     * @return void
     */
    private function replaceBits()
    {
	    $bits = $this->page->getBits();
	    foreach( $bits as $tag => $template )
	    {
		    $templateContent = file_get_contents( $bit );
		    $newContent = str_replace( '{' . $tag . '}', $templateContent, $this->page->getContent() );
		    $this->page->setContent( $newContent );
	    }
    }
    
    /**
     * Replace tags in our page with content
     * @return void
     */
    private function replaceTags()
    {
	    // get the tags
	    $tags = $this->page->getTags();
	    // go through them all
	    foreach( $tags as $tag => $data )
	    {
		    if( is_array( $data ) )
		    {
			  
			    if( $data[0] == 'SQL' )
			    {
				    // it is a cached query...replace DB tags
				    $this->replaceDBTags( $tag, $data[1] );
			    }
			    elseif( $data[0] == 'DATA' )
			    {
				     // it is some cached data...replace data tags
				    $this->replaceDataTags( $tag, $data[1] );
			    }
	    	}
	    	else
	    	{	
		    	// replace the content	    	
		    	$newContent = str_replace( '{' . $tag . '}', $data, $this->page->getContent() );
		    	// update the pages content
		    	$this->page->setContent( $newContent );
	    	}
	    }
    }
    
    /**
     * Replace content on the page with data from the DB
     * @param String $tag the tag defining the area of content
     * @param int $cacheId the queries ID in the query cache
     * @return void
     */
    private function replaceDBTags( $tag, $cacheId )
    {
	    $block = '';
		$blockOld = $this->page->getBlock( $tag );
		
		// foreach record relating to the query...
		while ($tags = PCARegistry::getObject('db')->resultsFromCache( $cacheId ) )
		{
			$blockNew = $blockOld;
			// create a new block of content with the results replaced into it
			foreach ($tags as $ntag => $data) 
	       	{
	        	$blockNew = str_replace("{" . $ntag . "}", $data, $blockNew); 
	        }
	        $block .= $blockNew;
		}
		$pageContent = $this->page->getContent();
		// remove the seperator in the template, cleaner HTML
		$newContent = str_replace( '<!-- START ' . $tag . ' -->' . $blockOld . '<!-- END ' . $tag . ' -->', $block, $pageContent );
		// update the page content
		$this->page->setContent( $newContent );
	}
    
	/**
     * Replace content on the page with data from the cache
     * @param String $tag the tag defining the area of content
     * @param int $cacheId the datas ID in the data cache
     * @return void
     */
    private function replaceDataTags( $tag, $cacheId )
    {
	    $block = $this->page->getBlock( $tag );
		$blockOld = $block;
		while ($tags = PCARegistry::getObject('db')->dataFromCache( $cacheId ) )
		{
			foreach ($tags as $tag => $data) 
	       	{
		       	$blockNew = $blockOld;
	        	$blockNew = str_replace("{" . $tag . "}", $data, $blockNew); 
	        }
	        $block .= $blockNew;
		}
		$pageContent = $this->page->getContent();
		$newContent = str_replace( $blockOld, $block, $pageContent );
		$this->page->setContent( $newContent );
    }
    
    /**
     * Get the page object
     * @return Object 
     */
    public function getPage()
    {
	    return $this->page;
    }
    
    /**
     * Set the content of the page based on a number of templates
     * pass template file locations as individual arguments
     * @return void
     */
    public function buildFromTemplates()
    {
	    $bits = func_get_args();
	    $content = "";
	    foreach( $bits as $bit )
	    {
		    
		    if( strpos( $bit, 'skins/' ) === false )
		    {
			    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;
		    }
		    if( file_exists( $bit ) == true )
		    {
			    $content .= file_get_contents( $bit );
		    }
		    
	    }
	    $this->page->setContent( $content );
    }
    
    /**
     * Convert an array of data (i.e. a db row?) to some tags
     * @param array the data 
     * @param string a prefix which is added to field name to create the tag name
     * @return void
     */
    public function dataToTags( $data, $prefix )
    {
	    foreach( $data as $key => $content )
	    {
		    $this->page->addTag( $key.$prefix, $content);
	    }
    }
    
    public function parseTitle()
    {
	    $newContent = str_replace('<title>', '<title>'. $page->getTitle(), $this->page->getContent() );
	    $this->page->setContent( $newContent );
    }
    
    /**
     * Parse the page object into some output
     * @return void
     */
    public function parseOutput()
    {
	    $this->replaceBits();
	    $this->replaceTags();
	    $this->parseTitle();
    }
    
    
    
}
?>

Kung kaya, ano ang eksaktong ginagawa ng class na ito?

Ginagawa ang ating page object, at binabatay ito sa template files, ang page object ay naglalaman ng content at impormasyon na kailangan para sa magiging HTML ng page. Kung kaya gumagawa tayo ng buildFromTemplate('templatefile.tpl.php', 'templatefile2.tpl.php') para makuha ang panimulang content para sa ating page, ang paraang ito ay kinukuha ang kahit na anong bilang ng template files bilang argument nito, at inaayos uli ang mga ito, mahalaga para sa header, content at footer templates.

Nagma-manage ng content na may kinalaman sa page sa pamamagitan ng pagtulong sa page object na mapanatili ang record ng data na papalitan sa page, at saka karagdagang template bits na kailangang isama sa page (addTemplateBit('userbar','usertoolsbar.tpl.php')).

Naglalagay ng data at content sa page sa pamamagitan ng paggawa ng iba’t ibang replace operations sa page content, kasama ang pagre-retrieve ng mga resulta mula sa cached query at paglagay ng mga ito sa page.

Ang template file ay kailangang maglagay ng marka mismo sa loob nito kung saan ang cached query ay kailangang i-retrieve at ang data mula sa query ay kailangang mapalitan. Kapag ang template manager ay nakahanap ng tag na papalitan na isang query, kinukuha nito ang chunk ng page kung saan kailangan nitong ulitin sa pamamagitan ng pagtawag sa getBlock(‘block’) sa page object. Ang chunk ng content na ito ay kinokopya sa bawat record sa query, at may tags sa loob nito na napalitan ng mga resulta mula sa query. Titingnan natin kung paano ang itsura nito sa template mamaya sa pagtuturong ito.

Ang Template Manager: Pahina

Ang page object ay mina-manage ng template manager, at ginagamit ito para hawakan lahat ng mga detalye na may kaugnayan sa page. Dahil dito ay malaya na nama-manage ito ng template manager, habang ginagawang madali nito para sa atin ang pahabain ang functionality nito sa hinaharap.


<?php

/**
 * This is our page object
 * It is a seperate object to allow some interesting extra functionality to be added
 * Some ideas: passwording pages, adding page specific css/js files, etc
 */
class page {

	// room to grow later?
	private $css = array();
	private $js = array();
	private $bodyTag = '';
	private $bodyTagInsert = '';
	
	// future functionality?
	private $authorised = true;
	private $password = '';
	
	// page elements
	private $title = '';
	private $tags = array();
	private $postParseTags = array();
	private $bits = array();
	private $content = "";
	
	/**
	 * Constructor...
	 */
    function __construct() { }
    
    public function getTitle()
    {
    	return $this->title;
    }
    
    public function setPassword( $password )
    {
    	$this->password = $password;
    } 
    
    public function setTitle( $title )
    {
	    $this->title = $title;
    }
    
    public function setContent( $content )
    {
	    $this->content = $content;
    }
    
    public function addTag( $key, $data )
    {
	    $this->tags[$key] = $data;
    }
    
    public function getTags()
    {
	    return $this->tags;
    }
    
    public function addPPTag( $key, $data )
    {
	    $this->postParseTags[$key] = $data;
    }
    
    /**
     * Get tags to be parsed after the first batch have been parsed
     * @return array
     */
    public function getPPTags()
    {
	    return $this->postParseTags;
    }
    
    /**
     * Add a template bit to the page, doesnt actually add the content just yet
     * @param String the tag where the template is added
     * @param String the template file name
     * @return void
     */
    public function addTemplateBit( $tag, $bit )
    {
	    $this->bits[ $tag ] = $bit;
    }
    
    /**
     * Get the template bits to be entered into the page
     * @return array the array of template tags and template file names
     */
    public function getBits()
    {
	    return $this->bits;
    }
    
    /**
     * Gets a chunk of page content
     * @param String the tag wrapping the block ( <!-- START tag --> block <!-- END tag --> )
     * @return String the block of content
     */
    public function getBlock( $tag )
    {
		preg_match ('#<!-- START '. $tag . ' -->(.+?)<!-- END '. $tag . ' -->#si', $this->content, $tor);
		
		$tor = str_replace ('<!-- START '. $tag . ' -->', "", $tor[0]);
		$tor = str_replace ('<!-- END '  . $tag . ' -->', "", $tor);
		
		return $tor;
    }
    
    public function getContent()
    {
	    return $this->content;
    }
  
}
?>

Paano ang class na ito mas mapapahaba at mapapaganda?

Maaaring gusto mong mapalitan ang tags pagkatapos na karamihan sa page ay ma-parse, marahil ang content sa database ay naglalaman ng tags na kailangang i-parse.
Pahina na may password. Maglagay ng password sa page, tingnan kung ang user ay may password sa cookie o session kung saan maaari nilang makita ang page.
Limitadong pages (bagaman ay kailagan muna natin ng authentication components!)
Pagpapalit ng
Paglalagay ng references sa javascript at css files batay sa page o application.

Naglo-load ng core objects

Ngayon na mayroon na tayong ilang objects kung saan ang ating registry ay ii-store para sa atin, kailangan nating sabihin sa regisgry kung aling objects ang mga ito. Gumawa ako ng method sa PCARegistry object na tinatawag na loadCoreObjects kung saan (gaya ng sinasabi nito) ay nilo-load ang core objects. Ibig sabihin nito maaari natin itong tawagin mula sa ating index.php file para i-load ang registry sa mga objects na ito.


public function storeCoreObjects()
{
	$this->storeObject('database', 'db' );
	$this->storeObject('template', 'template' );
}

Ang method na ito ay maaaring mapalitan sa susunod para isama ang ilang pangunahing objects na kailangang i-load ng registry, siyempre maaaring mayroong objects na gusto nating i-manage ng ating registry, subalit depende sa application kung saan ang framework ay ginamit. Ang objects na ito ay ilo-load sa labas ng method na ito.

Ilang Data

Para maipakita natin ang bagong features na nadagdag sa ating framework, kailangan natin ng database para magamit natin ang database handler, at ilang template management functions(kung saan natin papalitan ang block ng content sa hanay sa database).

Ang demonstration site na gagawin natin sa ating framework sa dulo ng serye ng pagtuturong ito ay isang website na may directory ng mga miyembro, kung kaya gumawa tayo ng napaka basic na database table para sa profile ng mga miyembro, na naglalaman ng ID, pangalan, at email address.

Halata naman, kailangan natin ng ilang hanay ng data sa table na ito!

Mabilis na template

Para lahat ay maipakita, kailangan natin ng basic template, kung saan ililista natin ang data mula sa ating members table.


<html>
<head>
	<title> Powered by PCA Framework</title>
</head>
<body>
<h1>Our Members</h1>
<p>Below is a list of our members:</p>
<ul>
<!-- START members -->
<li>{name} {email}</li>
<!-- END members -->
</ul>
</body>
</html>

Ang START members at END members HTML comments ay tumutukoy sa members block(kung saan ay nakukuha sa pamamagitan ng getBlock()method sa page), dito ay kung saan ang template manager ay mauulit sa records sa database at ipapakita ang mga ito.

Ginagamit na Framework

Ngayon, kailangan nating pagsama-samahin ang lahat ng ito, sa ating index.php file:


// require our registry
require_once('PCARegistry/pcaregistry.class.php');
$registry = PCARegistry::singleton();

// store those core objects
$registry->storeCoreObjects();

// create a database connection
$registry->getObject('db')->newConnection('localhost', 'root', '', 'pcaframework');

// set the default skin setting (we will store these in the database later...)
$registry->storeSetting('default', 'skin');

// populate our page object from a template file
$registry->getObject('template')->buildFromTemplates('main.tpl.php');

// cache a query of our members table
$cache = $registry->getObject('db')->cacheQuery('SELECT * FROM members');

// assign this to the members tag
$registry->getObject('template')->getPage()->addTag('members', array('SQL', $cache) );

// set the page title
$registry->getObject('template')->getPage()->setTitle('Our members');

// parse it all, and spit it out
$registry->getObject('template')->parseOutput();
print $registry->getObject('template')->getPage()->getContent();

Kung titingnan na natin ang page na ito sa ating web browser, ang mga resulta ng query ay ipinakita sa pahina:

Parating sa ikatlong bahagi…

Sa ikatlong bahagi ay medyo lilihis tayo mula sa development na panig ng ating Framework at tingnan kung paano mag-disenyo gamit ang framework na nasa isip natin, at kung paano hahatiin ang HTML templates para umakma sila sa ating framework. Kapag magsisimula pa lang tayong gumawa ng ating unang application sa framework, titingnan natin ng mas detalyado ang ilan sa mga ginagawa ng mga classes na ito. At ang panghuli, salamat sa iyong mga komento noong nakaraan!

Mag-subscribe sa NETTUTS RSS Feed para sa mas marami pang tutoryal at artikulo tungkol sa web development.

1
2	<?php
3
4	/**
5	* This is our page object
6	* It is a seperate object to allow some interesting extra functionality to be added
7	* Some ideas: passwording pages, adding page specific css/js files, etc
8	*/
9	class page {
10
11	// room to grow later?
12	private $css = array();
13	private $js = array();
14	private $bodyTag = '';
15	private $bodyTagInsert = '';
16
17	// future functionality?
18	private $authorised = true;
19	private $password = '';
20
21	// page elements
22	private $title = '';
23	private $tags = array();
24	private $postParseTags = array();
25	private $bits = array();
26	private $content = "";
27
28	/**
29	* Constructor...
30	*/
31	function __construct() { }
32
33	public function getTitle()
34	{
35	return $this->title;
36	}
37
38	public function setPassword( $password )
39	{
40	$this->password = $password;
41	}
42
43	public function setTitle( $title )
44	{
45	$this->title = $title;
46	}
47
48	public function setContent( $content )
49	{
50	$this->content = $content;
51	}
52
53	public function addTag( $key, $data )
54	{
55	$this->tags[$key] = $data;
56	}
57
58	public function getTags()
59	{
60	return $this->tags;
61	}
62
63	public function addPPTag( $key, $data )
64	{
65	$this->postParseTags[$key] = $data;
66	}
67
68	/**
69	* Get tags to be parsed after the first batch have been parsed
70	* @return array
71	*/
72	public function getPPTags()
73	{
74	return $this->postParseTags;
75	}
76
77	/**
78	* Add a template bit to the page, doesnt actually add the content just yet
79	* @param String the tag where the template is added
80	* @param String the template file name
81	* @return void
82	*/
83	public function addTemplateBit( $tag, $bit )
84	{
85	$this->bits[ $tag ] = $bit;
86	}
87
88	/**
89	* Get the template bits to be entered into the page
90	* @return array the array of template tags and template file names
91	*/
92	public function getBits()
93	{
94	return $this->bits;
95	}
96
97	/**
98	* Gets a chunk of page content
99	* @param String the tag wrapping the block ( <!-- START tag --> block <!-- END tag --> )
100	* @return String the block of content
101	*/
102	public function getBlock( $tag )
103	{
104	preg_match ('#<!-- START '. $tag . ' -->(.+?)<!-- END '. $tag . ' -->#si', $this->content, $tor);
105
106	$tor = str_replace ('<!-- START '. $tag . ' -->', "", $tor[0]);
107	$tor = str_replace ('<!-- END ' . $tag . ' -->', "", $tor);
108
109	return $tor;
110	}
111
112	public function getContent()
113	{
114	return $this->content;
115	}
116
117	}
118	?>

Gumawa ng PHP5 Framework - Bahagi 2