25/02/2015
1
CSCI110 brought you
PHP
and
More PHP
1
Now it’s time for
Still More PHP
2
What more could there be?
• Some cleanups
• Worthwhile additions
– ADOdb
• Automation of data persistence
– Smarty
• Separate display generation (view) from logic code and data
• A whole new “ball game”
– Zend framework
• A new model
• Automation of development
3
Some cleanups …
• (I’m not yet in the habit of using these – so don’t expect to 
see them in my examples!)
• “Never use $_GET again!”
–Instead, use PHP’s filter functions
– Why?
• You are less likely to miss out on sanitising your data
4
Filter functions
• You should use them (even if I don’t)
• Example “filter_input”
– Use to access $_GET, or $_POST (or $_COOKIE or 
$_SERVER)
– Request named data item
– Provide a filter function (from standard set)
• E.g FILTER_SANITIZE_EMAIL, 
FILTER_SANITIZE_NUMBER_INT, …
5
Filtering input
• Lerdorf’s name and age again …
$yourname = filter_input(INPUT_GET, ‘name’, 
FILTER_SANITIZE_SPECIAL_CHARS);
$yourage = filter_input(INPUT_GET, ‘age’, 
FILTER_SANITIZE_NUMBER_INT);
// Get NULL if variable (‘age’, ‘name’) not set
// Get FALSE if data failed by filter
6
25/02/2015
2
Other tidying up
• Namespaces – yes supported now
• “traits”
– As in Java, you can inherit from one class but you 
can “implement many interfaces” (or in PHP “use 
many traits”)
• …
7
Xdebug & Netbeans
• I think that I’ve correctly configured the lab so that 
you can use xdebug (from within Netbeans)
– Open PHP file that needs debugging (don’t they all?)
– Set some breakpoints
– Select project, right click and pick debug
8
Caveat
• Remember Drupal from CSCI110?
• Most of the examples that will be used in this 
“Still More PHP” section are relatively simple and 
could be implemented using the Drupal content 
management system and its various extension 
modules.
– Examples are kept simple so that you can learn about 
Smarty or Zend rather than some complex application 
domain.
9
Use Drupal when you can
• In practice, you should always consider Drupal 
before you commit yourself to developing new 
code for an application
– Your development time will be shorter
– Your maintenance burden will be smaller
– OK, run‐time performance might be poorer with a Drupal‐based solution; 
you do have to consider that too.
• In some cases, Drupal project performance is pretty woeful!
• Not everything can be done with Drupal or 
similar content management systems, but if they 
will suffice – use them!
10
A good programmer …
• Remember Larry Wall’s dictum
– Characteristics of a programmer
• Impatience
• Laziness
• Hubris
• You goal should be to work less while 
achieving more in less time 
– Achieved in part through use of automation tools
11
What do all web apps do?
• All (well, almost all) web apps use a relational 
database.
• What does that mean for you?
– Lots of messy SQL code
– Lots of code for copying data between your 
program’s structs/objects and SQL‐related 
structures like “prepared statements” and “result 
set rows”
– And, in conventional PHP, re‐doing it all if you 
need to work with a different database.
12
25/02/2015
3
Can we fix it?
• Database independent code
– Well that shouldn’t be too hard to fix
• Think of Java’s JDBC – same code, just different drivers 
loaded
– Try fixing this first
• Messy repetitive boring code
– Sounds like work for an automatic code generator. 
• Don’t want to have database specific code generators, 
so deal with this second
13
Can we fix it?
Yes we can
• ADOdb
– ADOdb started as a database‐neutral, procedural 
interface – something like ODBC, JDBC, or Perl’s 
DBI – which then grew into an automated “Object 
Relational Mapping” (ORM) system
There are several alternative PHP libraries that provide for database neutrality, and
lots of other PHP‐based ORM systems (we will be working mostly with the ORM created
for the Zend framework).  ADOdb is just an example.  If there is another one that you like,
or one that you learnt because your boss liked it, then use it.
http://adodb.sourceforge.net/
14
Database specific interfaces
• Database systems such as Oracle, DB2, SQLServer
etc were initially used from (C) programs through 
special libraries – e.g. the Oracle Call level 
Interface.
– These libraries defined a set of C functions and structs
(along with COBOL equivalents etc) that could be 
added to a program so that it could work with a 
database.
• Of course, each database system had a different 
library with different function names and 
different types of struct
– Your code was very much database specific
15
Database specific interfaces
• The libraries differed, but they all provided much 
the same functionality
– Connect to database
– Supply user credentials and specify schema required
– Submit SQL queries to be run by database
– Retrieve result sets, process row by row extracting 
data.
• Couldn’t a higher level abstraction capture all 
this?
16
Database neutral interfaces
Embedded SQL
• First attempt at a higher level abstraction (late 
1980s) was “Embedded SQL”
– Define a standard set of macros for those standard 
database operations
– Each database vendor provides a set of macro expansion 
templates that map onto their call level interface
• Works, but really messy and ugly
17
EXEC SQL BEGIN DECLARE SECTION;
varchar dbuser[10];
varchar dbpassword[15];
EXEC SQL END DECLARE SECTION;
strlcpy((char*)dbuser.arr, name, 9);
dbuser.len = strlen((char*)dbuser.arr);
strlcpy((char*)dbpassword.arr, password, 16);
dbpassword.len = strlen((char*)dbpassword.arr);
EXEC SQL CONNECT :dbuser IDENTIFIED BY :dbpassword;
18
25/02/2015
4
Database neutral interfaces
ODBC
• Second attempt – Open Database Connectivity
– “Open Group” (an industrial collaborative) defined a 
database‐neutral, procedural interface;
DB vendors were to provide function libraries that 
would have functions having the neutral interface that 
invoked work via the database specific call level 
interface
• Disadvantage – each database vendor very proud of the 
proprietary features and optimizations present in their own 
call level interface; these features lost when using ODBC
– Initially, only Microsoft bothered with ODBC
• Provided an implementation shortly after standard 
published in ~1992
19
ODBC copies
• ODBC model copied in other implementations 
in the 1990s
– DBI/DBD – Perl
– JDBC ‐ Java
• (The ODBC variants are very similar, differing primarily in the 
names that they give to various parts of the system – e.g. 
“database handle” or “connection”)
20
But PHP
• Traditionally, PHP programs used the database 
call level interfaces
– Remember, the PHP interpreter is in C, 
– It’s relatively easy to define a “PHP function” which is 
simply a direct call to a C function in a linked library.
• Why make the code database specific?
– Because
• It allows an application to exploit those special features and 
optimizations that the database vendors extol
• And, anyway, how often do you change your database? !
– In house developments will always use same database.
21
PHP extensions
Database neutral interfaces
• Some PHP developers did want database 
neutral interfaces
– Developing an application, e.g. a bulletin board 
system, that was intended to be configurable so 
that it would work with whatever database was 
available at site where installed
– Contract workers who develop many small 
applications and didn’t want to have to remember 
the many different call level interfaces
22
PHP variants on ODBC theme
• Several such libraries created
– ADOdb is just one
• Illustrate here with a simple web‐application
– Web application – select a toy for boy/girl in particular 
age group
– Databases (Oracle and MySQL versions) have a table 
with details of toys
• Illustrate first the database neutral bit – then move 
on to automation through Object Relational Mapping
23
ADOdb
• A generic database interface (equivalent to JDBC, 
ODBC, Perl’s DBI, …)
• Example
Static HTML form Script generated response
24
25/02/2015
5
Data table
• Same table defined in MySQL and Oracle
– MySQL version of definition:
CREATE  TABLE `mark`.`XmasStockingItems` (
`itemid` INT NOT NULL AUTO_INCREMENT ,
`name` VARCHAR(45) NOT NULL ,
`price` DECIMAL(8,2) NOT NULL ,
`agegroup` ENUM('Infant', 'Toddler', 'PreSchool', 
'Primary', 'Secondary') NOT NULL ,
`gender` ENUM('Boy', 'Girl', 'Either') NOT NULL ,
PRIMARY KEY (`itemid`) )
ENGINE = MyISAM
DEFAULT CHARACTER SET = latin1;
25
Oracle table
CREATE  TABLE XmasStockingItems (
itemid INT PRIMARY KEY ,
name VARCHAR(90) NOT NULL ,
price DECIMAL(8,2) NOT NULL ,
agegroup varchar(12) constraint ageconstrain
check (agegroup in ('Infant', 'Toddler', 'PreSchool', 'Primary', 'Secondary')),
gender varchar(8) constraint genderconstrain
check (gender in('Boy', 'Girl', 'Either'))
);
create sequence XmasSeq increment by 1 start with 1;
insert into XmasStockingItems values ( XmasSeq.NEXTVAL,
'Baby Einstein Take Along Tunes', 9.51, 'Infant', 'Either‘ );
insert into XmasStockingItems values ( XmasSeq.NEXTVAL,
'Yookidoo Flow N Fill Spout', 14.51, 'Infant', 'Either');
I made the prices in the two tables slightly different so that I could see from glance at results which table was being used
26
27
Database specific code: MySQL


A selection of suitable gifts

HEAD;
if ($gender == "Either") {
$stmt = $mysqli->prepare(
"select name,price from XmasStockingItems where agegroup=?");
$stmt->bind_param("s", $agegroup);
} else {
$stmt = $mysqli->prepare(
"select name,price from XmasStockingItems where agegroup=? and gender=?");
$stmt->bind_param("ss", $agegroup, $gender);
}
The usual – a mingling of
presentation and code;
will be resolved later 
via Smarty
30
25/02/2015
6
Database specific code: MySQL
$stmt->execute();
$stmt->bind_result($name, $price);
while ($stmt->fetch()) {
echo "";
}
$mysqli->close();
echo <<
FOOT;
?>
31
Database specific code: Oracle

A selection of suitable gifts

Gift
Price
$name
\$$price
HEAD;
if ($gender == "Either") {
$stmt = oci_parse($myoracle, 
"select name,price from XmasStockingItems where agegroup= :aged");
oci_bind_by_name($stmt, ":aged", $agegroup);
} else {
$stmt = oci_parse(
"select name,price from XmasStockingItems where agegroup= :aged and gender= :gnd");
oci_bind_by_name($stmt, ":aged", $agegroup);
oci_bind_by_name($stmt, ":gnd", $gender);
}
Note some of SQL differences: with this version of OCI library, parameters must be
named, e.g. :aged; cannot have ? parameters as in MySQL code. 34
Database specific code: Oracle
…
oci_execute($stmt);
while ($row = oci_fetch_row($stmt)) {
$name = $row[0]; $price=$row[1];
echo "";
}
oci_close($myoracle);
echo <<
FOOT;
?>
35
ADOdb: 1: 
Database independence
Param('age');
} else {
$data['age'] = $agegroup;
$data['gender'] = $gender;
$sql = "select name,price from XmasStockingItems where agegroup=" .
$myadodb->Param('age') .
" and  gender=" .
$myadodb->Param('gender');
}
39
Param() when generating SQL
• ADOdb has to generate different SQL for the 
different databases
– Its MySQL usage works with ? parameters –
select name, price from XmasStockingItems where age=?
– Its Oracle usage works with named parameters –
select name, price form XmasStockingItems where age=:agegroup
40
ADOdb: 1: 
Database independence
$stmt = $myadodb->Prepare($sql);
$rs = $myadodb->Execute($stmt,$data);
while (!$rs->EOF) {
$name = $rs->fields[0];
$price = $rs->fields[1];
echo "";
$rs->MoveNext();
}
$rs->Close();
$myadodb->Close();
echo <<
FOOT;
?>
41
Automating data base access
• Code for accessing database and retrieving data 
is:
– Simple
– Stereotyped
– Repetitious – cut & paste style
– Long winded
– Tiresome
• Computers are supposed to help us by doing all 
simple, tiresome, repetitious tasks
• So get the computer to generate database access 
code
42
25/02/2015
8
Automatic generation of database 
access code
• Quite straightforward
1. “Code generator tool” reads meta‐data from the database
• Meta‐data identifies columns in a table and their data types
• Meta‐data may identify things like use of database supplied 
surrogate primary keys (the “record identifiers” from associated sequences or 
auto‐increment numeric fields – the things Janusz tells you not to use)
• Meta‐data should include “relationships” – from “foreign key” 
constraints.
2. “Code generator tool” defines source code for a 
programming language class corresponding to each table
• Data members derived from columns of table
• Accessor and mutator methods
• Relationships may be modelled by “collection class” data 
members
3. …
43
Automatic generation of database 
access code
• Quite straightforward
1. … 
2. …
3. “Code generator tool” can create SQL statements that will 
be used in code for data access
• This code may be hidden, not exposed to developer
4. “Code generator tool” can create code used to bind‐
parameters and to extract data from a row in a result set, 
putting these data into members of an instance of the 
data‐object class that was defined earlier
• This code may use “reflection” if this is supported by the 
language (Java and some Microsoft languages)
– Inefficient at run‐time, but code generation greatly simplified as 
essentially the same implementation function can be used everywhere
44
Automatic code
• Object‐relational mapping
– Classes created by the code generator define the run‐
time objects
– Relations
• Objects with data members that are instances of other auto‐
generated classes
• Objects with a “collection class” data member, e.g. 
java.util.ArrayList, that may contain instance of other auto‐
generated classed
– Code to map data between objects and SQL
• Bind parameters for prepared statements
• Extract data from row in result set 
45
ORM
• Object Relational Mapping!
– We will be seeing several variants
• ADOdb, and Zend’s for PHP
• Java Persistence (JPA)
• Started to appear in the 1990s
– Java
• Enterprise Java Beans 1 and 2 (1998 and later)
– Version 1 – too limited; version 2 – clumsy and tied to EJB container
• Hibernate, Kodo, JDO – open source ORM projects for Java (2000 and 
later)
• JPA – Java standard derived from Hibernate and Oracle projects
– Microsoft: “Data Access Objects” for ASP and ASPX (.Net) 
– PHP
• Lots of variants from 2000 and later
46
ADOdb : 2:
Automated Object‐Relational‐Mapping
• Object‐Relational‐Mapping (ORM)
– Row in table (or, sometimes, rows in tables) gets converted into object 
in memory
– You don’t write any SQL;
instead you write code that is generally of form
intermediary_object.fetch_me(
the object corresponding to this key)
intermediary_object.fetch_me_collection(
objects with attributes satisfying this relation)
…
intermediary_object.save(updated object);
• We will explore ORM more fully in context of Java Persistence 
Architecture;
ADOdb provides some ORM functionality for PHP
http://phplens.com/lens/adodb/docs‐active‐record.htm 47
ADOdb_Active_Record
• ADOdb_Active_Record
– Class defined in ADOdb
• Static methods
– Handle things like setting up database connection and ORM subsystem
• Base class for the classes that you will use for objects that are to 
represent entities in database
• So, for example, will need our own subclass of Active Record 
to represent an item in the XmasStockingItems data table.
include("adodb/adodb.inc.php");
include("adodb/adodb-active-record.inc.php");
class XmasStockingItem extends ADOdb_Active_Record{}
48
25/02/2015
9
Active_Record & ordinary SQL
• Open a database connection, associated with the 
Active_Record ORM, then use it whichever way is 
best
– Use it to run SQL operations
• Operations that select only a few fields from table, and 
operations that affect large numbers of records, are better done 
using standard SQL
– Use it ORM style
• Retrieve individual objects or collections of objects
49
Class XmasStockingItem extends …
• It is possible to define additional methods,
but typically leave everything to ADOdb
• ADOdb’s ORM system will use meta data in table to 
determine what data members should be defined 
for the class
– You can view it’s definition of a class based on your table by invoking 
var_dump() on an instance of the class that it generates.
• object(XmasStockingItem)#5 (13) { ["_dbat"]=> int(0) ["_table"]=> string(17) 
"XmasStockingItems" ["_tableat"]=> string(17) "XmasStockingItems" ["_where"]=> 
NULL ["_saved"]=> bool(false) ["_lasterr"]=> bool(false) ["_original"]=> bool(false) 
["foreignName"]=> string(16) "xmasstockingitem" ["itemid"]=> NULL ["name"]=> 
NULL ["price"]=> NULL ["agegroup"]=> NULL ["gender"]=> NULL }
50
ADOdb_Active_Record
Find($quest);
foreach($itemArray as $anitem) {
echo "";
}
echo << 
FOOT;
?>
Maybe not the best API; you have
to create a dummy instance of class
to run the Find() method – would have
been more appropriate to have a static function
54
25/02/2015
10
A slightly more elaborate object model …
• An “aggregation relation” in your database –
– A class whose instances each own a collection of objects from some 
other class
– 1‐to‐many relation
• Example
Schools SchoolTeachers
1 1..*
Caution, ADOdb builds in some naming assumptions that can
be difficult to override;
you want a table Items for class Item; primary key of table should
be an Int called id
(This example is a small part of the schools/teachers/pupils example used to illustrate Java Persistence –
see http://uow.edu.au/~nabg/399/JPA/JPA.pdf or use Google to search for Java Persistence Architecture.
55
Table definitions
CREATE TABLE `homer`.`schools` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`schoolname` varchar(45) NOT NULL,
`streetaddress` varchar(45) NOT NULL,
`suburb` varchar(45) NOT NULL,
`postocde` varchar(8) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT 
CHARSET=latin1;
Sorry Janusz, you cannot use this ORM system; this one insists on the use of a surrogate
primary key.  In some of the more sophisticated systems, e.g. JPA, you can define a primary
key class that is a composite of several simple data attributes – so Janusz, JPA should serve 
you adequately (but none of the ORM systems can create code as good as your hand‐ crafted code). 56
School owns teachers.
CREATE  TABLE `mark`.`schoolteachers` (
`id` INT NOT NULL ,
`surname` VARCHAR(45) NOT NULL ,
`initials` VARCHAR(8) NOT NULL ,
`title` ENUM('Mr', 'Mrs', 'Ms', 'Miss') NOT NULL ,
`id_school` INT(11) NOT NULL ,
`role` ENUM('Principal','Kindergarten','Year-1','Year-2',
'Year-3','Year-4','Year-5','Year-6','Sport','Music and Drama', 
'ESL', 'Special needs', 'Auxiliary', 'Relief') NOT NULL ,
PRIMARY KEY (`id`) ,
INDEX `fk_schoolteacher_1` (`id_school` ASC) ,
CONSTRAINT `fk_schoolteacher_1`
FOREIGN KEY (`id_school` )
REFERENCES `homer`.`schools` (`id` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1; As usual, a school’s “ownership”of teachers is implicit from the
foreign key constraint.
57
Data …
insert into homer.schools values ( NULL, 'Kogarah Public School', 
'123 Dean Street', 'Kogarah', 'NSW2343');
insert into homer.schools values ( NULL, 'Hurstville Public 
School', '64 Market Street', 'Hurstville', 'NSW2332');
insert into homer.schoolteachers values ( 8239391, 'Green', 
'M.B.', 'Mr', 2, 'Principal');
insert into mark.schoolteachers values ( 8467134,'Howard', 
'P.P.', 'Mrs', 3, 'Principal');
insert into homer.schoolteachers values ( 8766523,'Pauls', 
'A.S.', 'Ms', 2, 'Kindergarten');
….
58
Application …
• Dynamically generated form shows list of schools in 
a 
• Pick a school and submit
• Receive a list of teachers at that school
59
Schoolies.php
Close();
?>
61
Schoolies.php
function connectToDatabase($dsn) {
global $db;
$db = ADONewConnection($dsn);
if (!$db) { die("Failed to connect to database : " . $dsn); }
ADOdb_Active_Record::SetDatabaseAdapter($db);
ADODB_Active_Record::ClassHasMany(
'school', 'schoolteachers', 'id_school');
}
ClassHasMany(parent, child, foreign‐key)
62
function doGet() {
global $db;
$self = $_SERVER['PHP_SELF'];
echo <<




Select school

                 
HEAD;
$stmt = $db->Prepare(
"select id, schoolname from mark.schools");
$rs = $db->Execute($stmt);
…
}
Just want two fields, not complete objects, so better to use “SQL style” here 63
$stmt = $db->Prepare(
"select id, schoolname from mark.schools");
$rs = $db->Execute($stmt);
while (!$rs->EOF) {
$id = $rs->fields[0];
$name = $rs->fields[1];
echo "$name";
$rs->MoveNext();
}
$rs->Close();
echo <<






FOOT;
} 


Kogarah Public School
64
function doPost() {
echo <<




HEAD;
$whichone = $_POST['schoolid'];
$chosen = new school();
$chosen->Load("id=?", array($whichone));
echo "
$chosen->schoolname
";
Create a school object; load it with data from specified
database row
65
function doPost() {
…
echo "
Gift
Price
$name
\$$price
$name
\$$price
$anitem->name
\$$anitem->price
";
foreach ($chosen->schoolteachers as $c) {
echo "";
$str = $c->title . " " . $c->initials . " " .
$c->surname;
echo "";
echo "";
echo "";
}
echo <<
FOOT;
}
$chosen‐>schoolteachers;
when collection is used, ORM library code
will generate and run a select query to retrieve
those schoolteacher records whose foreign key,
id_school, matches request 66
25/02/2015
12
ADOdb
• Should be installed on machines in lab
• php.ini files have to have references to the 
database drivers
– Typical PHP install will include MySQL driver
– Need to edit the php.ini file to support Oracle
• This should all have been done for machines in lab
67
The need for Smarty …
• The code of those examples …
– Code
– Embedded echo … statements outputting strings with embedded 
computed values.
• PHP first sold on the premise that it was just a little code 
embedded in a HTML page
– So easy for a web‐designer to restyle the page
• Real PHP programs have a lot of code with a some embedded 
HTML and some output statements
– Web‐designers will just mess things up if they attempt to restyle the page. 
68
Can we separate compute and display 
better?
• Compute
– Work out some values by combining input data and stored 
information
• Display
– Embed computed values inside a lot of HTML and static 
content text.
• Maybe delegate display to a helper?
69
Model‐View‐Control
• One small step toward a “Model‐View‐Control” framework
– Idea dates back to Smalltalk systems created at Xerox‐Park in 
the late 1970s
• Model
– Your data objects
• View
– How you display chosen data, and how your user inputs requests
• Control
– Receive input requests (submitted via a view)
– Determine which data model they apply to and which request handler
» You could have a monolithic “control” object with methods that handle all 
requests and which operate on the data objects.  
» Alternatively, the control object can act primarily as a dispatcher to a group of 
specialized handler objects.
– Decide what data are to be shown to user to confirm success of operation, 
invoke appropriate view object.
70
ADOdb and Smarty
• ADOdb
– Essentially the “model”
• Smarty
– View system
• Control
– Ad hoc
• You write your own code
– With full MVC frameworks (CodeIgniter, Cake, Zend), 
the “control” element is considerably elaborated and 
is derived from classes provided by the framework
While ADOdb and Smarty do roughly correspond to the model and view components of an
MVC framework, they are somewhat simpler than typical framework components. 71
Smarty approach
1. “Template files”
– HTML with a little “Smarty script code”
• They are meant to be close enough to standard HTML so that 
your colleagues (the ones with IT or ‘Creative Arts – Web’ 
degrees) can edit them with their favourite HTML editor and 
make the pages all “pretty”
– Smarty script code
• Place value of some named variable here in the HTML
• Iterate through collection of values
– Generate some HTML (e.g. row of table) with current data value 
here
2. Smarty object
– …
72
25/02/2015
13
Smarty approach
2. “Smarty object”
– Instance of class supplied by Smarty library
– Has a field that you can set to contain a hash‐map 
(PHP associative array) of (name, value) pairs.
– “Compiles” the template into a PHP class
• Methods with lots of echo statements to output the 
HTML
• Code to deal with things like processing members of a 
collection
• Code to extract values from the associative array and 
output them – embedded into the standard HTML
Kind of similar to way that Java Server Pages work (JSPs – which get compiled into servlet
classes – are many years older, dating back to 1998). 73
Smarty object …
• Smarty object
– Will own a hash array (name=> value)
• Your PHP code loads this with the elements whose values are to be included in the 
generated web page
– Is given a template
• HTML and static content text
• Smarty tags
– “Compilation” will generate a file (that no‐one ever need see) that has these tags expanded into PHP
– PHP code for smarty tags outputs selected elements from hash array etc
– Is told to display the template
• This is when it generates the hidden PHP file (essentially defining a subroutine with 
lots of echo statements) and then loads the file and runs the subroutine.
74
Lab
• Not the smartest of Smartys
– The lab will have Smarty 2.6.26 as installed by 
Synaptic Package Manager
– Smarty 3 has been around for sometime
• Improvements related to PHP‐5
• Some changes to scripting language
• See http://www.smarty.net/v3_overview
75
Smarty version
• With Ubuntu 14, now using Smarty 3
• One little trouble
– Changes in syntax of smarty language
• For 2015 have had to rework examples
– (Not all examples updated; some, especially those using Smarty in the 
simpler Zend related exercises will still show old syntax for Smarty for‐
loops etc)
76
Smarty language
77
http://www.smarty.net/docsv2/en/
Lab and Netbeans
• Smarty plugin should be installed in the 
Netbeans system in the lab
– Essentially adds another specialized editor module 
to Netbeans – one that is aware of the syntax of 
Smarty’s scripting language
– PHP code will “require_once” from standard install
• Smarty requires four directories for files
– templates, templates_c, configs, cache
• The cache and templates_c directory need to be 
writeable by the web‐server process
78
25/02/2015
14
Picking presents Smarty style
• The application
– HTML form file
– PHP code
– A template file (.tpl)
• Netbeans project
– Set up with all directories (little bit overkill for this 
simple example)
79
Netbeans Smarty Present Chooser
Directories must be given appropriate 
permissions –
80
Project
• HTML file
– Nothing of consequence, same as first ADOdb example
• PHP file
– “require” code for Smarty and ADOdb
– Initialize Smarty object
• It needs to be told the location of the directories that Smarty 
engine is to use
– Retrieve data – ADOdb ORM style
– Attach data to Smarty object
– Tell Smarty object to use specified template to display data
• Template file
– Mix of HTML and Smarty scripting
81
PHP code
Include the library code for ADOdb
and Smarty
Global smarty object
Code to configure the smarty object
ADOdb connection function
Pick up form data, connect to
chosen database, invoke function
to initialize smarty object
82
PHP code
Create, parameterize and run ORM style 
ADOdb request
Add data to the smarty object
Smarty object uses template to
display data
83
Template file
Just name a data
element that was added
to Smarty object, its
value will be displayed.
Smarty script “foreach” loop working
with “XmasStockingItem[]”;
access fields of each to get values that
are to be displayed.
84
25/02/2015
15
Template file
• How is it working?
• You can look at the “compiled” template:
85
Compiled template
86
Irritation
• You may have to force recompilation of .tpl
files after edits.
– Remove contents of templates_c directory
– Run the example again
87
Smarty script language
• Duplicates/overlaps with CSS in places
– You can have config files that contain data like 
background colour for all your scripts
• Simple flow‐control
– foreach
– if else
88
Some script examples from Smarty 
manual
• PHP (loading data)
$arr = array(1000, 1001, 1002);
$smarty->assign('myArray', 
$arr);
$arr = array(9 => 'Tennis', 
3 => 'Swimming', 
8 => 'Coding');
$smarty->assign('myArray', 
$arr);
• Smarty (displaying data)

{foreach $myArray as $item}
{$item}
{/foreach}


{foreach $myArray as $k=>$v}
{$k}: {$v}
{/foreach}

89
Also, in Smarty 3, note a “foreachelse” feature – simplifies things like showing a list orset of table rows for 
a populated array, or a message “
No matching data
” for an empty array
A larger example … Schoolies
• Code and display largely separated
• Smarty allows for “include” files so can build up 
pages from different components
90
25/02/2015
16
A larger example … Schoolies
• Smarty allows for “include” files in templates so can 
build up pages from different components
Really there are two pages – form and
report.  They share the same “header”
‐ a block with an image; also, the same 
“footer” – just a centred paragraph.
Script: doGet() shows form, doPost() handles inputs. 91
The templates






The School Board


92
The templates – form.tpl
93
This version is passed an array $schools, each entry is itself a two‐element array
with school‐id and school‐name.
The templates – form.tpl
94
This version is passed an associative array $schools with the school‐ids as keys
and the names as values.  (This {html‐options … } construct can take additional
arguments such as data defining the options(s) selected by default.)
The templates – report.tpl




{include file="header.tpl"}
{$schoolname}

Teachers employed
$str
$c->role
{foreach $staff as $teach}

{/foreach}

Teachers employed

{$teach->title}. {$teach->initials} {$teach->surname}
{$teach->role}

{include file="footer.tpl"}

95
Code – with no messy outputs

97 98
doGet:SQL style get schoolnames, pass to 
Smarty for use with form.tpl
99
(Shows both versions of code for the two templates
$data[$id]=$name; is for the template using html_options;
$data[] = array($id,$name); is for the for‐each loop version.
form.tpl (as shown earlier)




{include file="header.tpl"}
Select school


{foreach $schools as $schoolrec}
{$schoolrec[1]}
{/foreach}





{include file="footer.tpl"}

100
doPost:SQL style get schoolnames, pass to 
Smarty for use with report.tpl
function doPost() {
global $db;global $smarty;
connectToDatabase("mysqli://homer:doh@localhost/homer");
$whichone = $_POST['schoolid'];
$chosen = new school();
$chosen->Load("id=?", array($whichone));
$teachers = $chosen->schoolteachers;
$schoolname = $chosen->schoolname;
$smarty->assign('schoolname', $schoolname);
$smarty->assign('staff', $teachers);
$smarty->display('report.tpl');   
}
101
Smarty and ADOdb
• ADOdb Active Record – automated ORM
– Classes for your entities
– “The Model”
• Smarty
– Templates
– Automated View
• Control?
– Well it’s still in code that you write yourself 
102
25/02/2015
18
Zend Framework
103
Current version (release Feb 2015) of Zend Framework 1 is 1.12.11; version for Ubuntu 14 is 1.11.11)
Zend Framework
• Pain!
• It is “sophisticated” i.e. complicated.
• There are tutorials but
– For the most part, they don’t work
• They miss out little but vital configuration details!
– They are often unnecessarily complex
• Trying to illustrate too many features in the one example.
– They may be just plain wrong
• Illustrating an exciting feature introduced in version x (but deprecated in 
subsequent version y, and totally removed in version z) –
tutorials don’t necessarily disappear from the Internet when no longer valid
• So let us take this thing … slowly.
104
Simple scripts to frameworks : 1
• When you start PHP, it really is just a little bit 
of script code in amongst the HTML
105
Simple scripts to frameworks : 2
• It very soon becomes “script code with little 
embedded sections outputting chunks of HTML”
– Output some HTML for head of page (echo from 
“here” document)
– Connect to database, run query, get result set
– Loop through result set
• Output a little standard HTML
• Output some HTML with embedded values from row of result 
set
• Output some more standard HTML
– Output more HTML for links, and for foot of page
106
Simple scripts to frameworks : 3
• Code for data access, blocks of text, code to output 
text, code to embed values in blocks of text and output 
result
– As it grows, it all gets increasingly messy
• Smarty style templates can represent a major 
improvement
– Code runs, builds a data structure of key=>value pairs 
representing the dynamic information required by the user
– Template for HTML output, template engine takes values 
out of data structure and embeds them
– Complete page output
107
Simple scripts to frameworks : 4
• But most realistic “web applications” involve 
multiple scripts 
– You are creating an application that has several 
different classes of user who each have numerous 
“use cases” in your original design
• Often, similar but non‐identical use cases for different 
classes of user
– You typically end up with a PHP script (doGet => give 
me the form, doPost => process my inputs) for each 
use case
• Quite possibly with a lot of code to check which class of user 
and therefore which variant of the form, and what 
differences in the handling of allowed inputs
108
25/02/2015
19
Simple scripts to frameworks : 5
• Web application
– Lots of different PHP scripts
• Each implements some unique aspect of the business logic (a 
particular use case in your design)
• But lots and lots of duplication
– Authenticate user – authorize this action?
– Access data base
– Handle error
– …
• Maintenance problem
– Fragmentation of code in scripts by original authors (who have 
long since left the company) makes it difficult for maintenance 
programmer to even find the code that has problems
• Probable outcome is also partial fixes; problem fixed in one script but 
not in another that has some similar buggy code.
109
Simple scripts to frameworks : 6
• Frameworks?
– A whole variety
• Struts (and many others) for Java since ~2000
• Rails for Ruby ~2003
• Zend, Symfony, Cake, CodeIgniter ~2005+
– On the whole, the frameworks have a similar 
approach
110
Simple scripts to frameworks : 7
• A similar approach:
1. “It is a web application”
• One program, not many different scripts
2. Based in some way on user inputs, it determines first 
which “use case” is required and then in a standard 
way performs the necessary authentication checks 
and authorization controls.
3. It acts as a dispatcher to “use case handlers” that 
will all be based on a standardized structure.
111
Simple scripts to frameworks : 8
• A similar approach:
4. Use case handlers will typically invoke operations of 
other simpler components that will each return a 
chunk of HTML; 
these HTML chunks will be gathered up for later 
assembly into a response page
5. Components will access persistent data through a 
standardized persistence component,
probably one implementing a form of Object 
Relational Mapping scheme
6. A layout stage will combine the chunks of HTML 
generated by the individual components into a final 
presentation page based on some defined template
Chunks of HTML, layout engine using a template – much the same principles as in Drupal etc 112
Simple scripts to frameworks : 9
• A similar approach:
7. All “configuration details” – what database, what 
password, what collection of error messages etc – are 
held in separately editable configuration files.
A standard “configuration initialization” module 
provided in the framework
• Configures standard framework components
• Can be utilized to configure application specific 
structures as well
113
Complexity
• Before you can use such frameworks, you need to 
understand
– How are use case requests recognized and dispatched?
– How do you create “use case handlers”?  
They are going to be concrete subclasses of some class provided 
by the framework – but what class? 
What methods must you define? 
How are they registered with the application so that it can 
recognize them?
– Those components that generate chunks of HTML – again 
subclasses of some framework class.  
So once again, what class, what methods, how registered?
How are they supposed to return “chunks of HTML”?
– How does this configuration system work?
114
25/02/2015
20
Model‐View‐Control
• The frameworks generally realize some form of 
Model‐View‐Control partitioning of the work
– The Model
• Essentially, the persistent data
• Generally handled as programming language classes auto‐
generated by an Object Relational Mapping Subsystem
– The View
• Building the content of a response page by having 
components return page elements (chunks of HTML)
• Using a template engine to layout the page elements and 
compose the complete response page
– The Control
• The dispatcher and use‐case handlers
115
Model‐View‐Control
• Model
– Well, only a little more complex than ADOdb (and that 
really wasn’t hard was it)
• View
– Somewhat more elaborate than Smarty
• It is the two‐part nature (components building elements to go 
into a final page, layout manager assembling a page) that can 
make it seem more complex
• Control
– This is where the challenges come.
116
So, onto the Zend Framework
• The framework code
• An approach to mastering it
117
Zend Framework
• Zend Framework
– Firstly, it isn’t monolithic
• There is a core framework that embodies an MVC approach to 
building a PHP based web application
• But there are also support libraries
– Useful PHP classes (like everything else in the modern programming 
world, it’s all based on classes) that can be employed in programs that 
don’t require the full framework
– You can slot in other subsystems
• Zend Framework uses its own PHP‐based view generation 
templates – but you can substitute Smarty
• Zend Framework has a relatively simple Object Relational Mapping 
subsystem (based on PDO – an alternative to ADOdb that is about the 
same level of sophistication) but you can substitute something more 
sophisticated like Doctrine
http://www.doctrine‐project.org/
118
Our approach
• Explore some parts of the framework library that can 
be used independently
– Simple generally useful classes, 
• e.g. a “paginator” that can help when a search has retrieved many 
records, more than you wish to show in a single response page (the 
paginator helps you show page 1 with matching records 1…10, page 2 
with records 11…20 etc)
– Zend’s data persistence classes (another simple ORM like 
ADOdb)
• These will illustrate Zend coding styles, its classes etc
and illustrate its approach to configuring applications
• When some basics have been covered, we can look at 
the MVC framework
http://www.uow.edu.au/~nabg/399/ZF/ZendFramework3.pdf
119
Zend Framework 1
Using classes from the library 
independently of the overall 
framework
120
25/02/2015
21
Haven’t we done this before?
• We need to let persons on the Internet apply 
to become members of our group and get 
privileged access to our site.
• But we want to keep out the spammers, 
hackers, bots, and other riff‐raff
121
The application form
• Data fields for name, address, email etc – all need to be 
validated;
email validation? How detailed?
and how about a “CAPTCHA” to reduce the number of 
applications by “bots”
Completely Automated Public Turing test to tell Computers and Humans Apart 122
You can write it all yourself (again)
• Or you can make use of standard library 
classes for data validation, captcha generation 
and checking etc.
Example Netbeans project;
Using the Zend library – classes like
the CAPTCHA generator, and an email
checker.
Starting to adopt Zend’s approach to
configuration.
(Using Smarty for “view”)
It is not yet a “Framework” application;
none of the core framework classes used.
123
Using assorted Zend classes from PHP
• Code for classes has to be added to your application
– Specify library (standard)
– But also then require_once(this), require_once(that), …
• Made easier via the Zend “auto‐loader” class
– Just create an Autoloader object in your program, it will 
sort out loading of any Zend class that you use directly (or 
indirectly via code in classes)
124
Application form script
• GET
– Create a CAPTCHA image
• Zend code creates an image with a partially concealed string;
it also places some data in $_SESSION (data used when checking 
whether user has entered string correctly)
• (Needs a writeable directory for the images)
– Generate form
• POST
– Validate inputs
• First the CAPTCHA
• So the usual …  
if method==Post handleApplication else displayform
125
Functions etc
• smartysetup() –
– the usual, configure Smarty engine for template output
• display_member_form() –
– select data elements, e.g. the CAPTCHA’s id, and add these to 
the Smarty object,
– Invoke Smarty template engine using a template for the form
• rejectCandidate() –
– Attach reasons for rejecting a candidate to Smarty object and 
generate rejection page using a template
• handle_member_application()
– Validate inputs, maybe reject application, otherwise for now just 
an acknowledgement
126
25/02/2015
22
generate()
• Returns an id for image and places data in session state
– Library code looks after the images directory, gets rid of 
outdated images
128
The form
Template needs script name (for “action”
attribute of form) and captcha id (can
compose  file name)
129
Pass id along, it is needed when checking.
Smarty template file form.tpl
130
Pass id along, it is needed when checking.
Image identifier
Input text fields for name, email etc
Smarty template file form.tpl (continued) 131
(Actually not the approved way to locate
templates – and may not work in all versions
of Smarty)
A really simple Smarty template file!
132
25/02/2015
23
Validating inputs
• Pick up the posted inputs, and check them
– First, the CAPTCHA
$captcha object has an isValid() method; this requires a hash map array with
id of captcha and text of user input;  it is using data that Zend code placed in $_SESSION
(so really need session id cookies etc – but that is all handled by the Zend library code).
133
Validating inputs
• The rest of the inputs
– Well typically you would
• “white list” check inputs corresponding to  etc
• Check  inputs using regex etc
• Maybe contorted validation of dates
• …
– Lots of similar code in lots of different scripts 
belonging to lots of different projects
• But you could just use Zend validator classes!
134
Checking email
• Checking an email?
– Maybe find some horrible regex on the Internet 
that promises to check that the input string is 
something like ead432@uow.edu.au
• Or use the Zend email checker!
– You can ask it to check not just the form of the 
email but whether the host specified 
(uow.edu.au) is actually an email handler 
135
Checking email
Create an instance of the Zend email
validator class; arguments specify that
do want it to check site handles email.Ask email checker object tovalidate the email address entered in the form
136
Checking numerics and text
• Easy enough to code for yourself – but Zend
has helper classes that make it even easier 
(remember – laziness, impatience)
A validator may find multiple things wrong with an input; so may need
to report on more than one error.
“Validate between” object created 
with min and max
137
Validator chains
• With text inputs, there may be multiple checks
– Is it at least minimum prescribed length?
– Is it too long?
– Does it only contain valid characters.
• With Zend library, can build a validator chain 
that comprises a whole set of validator objects 
each of which will perform checks
138
25/02/2015
24
Validator chain
Chain includes a standard Zend string‐length checker object, and a standard
Zend “alphanumerics” checker object.
isValid() method of chain runs the checks and reports success/failure (if
failure, a collection of error messages will have been built up and can be
used in a report)
139
What else can we check?
• Well we asked for input of both “postcode” 
and “country”, we could check if these data 
are mutually consistent
– Doesn’t stop hackers, just forces them to take more time – so 
hopefully discourages them a little
• Zend library has a “postcode” checker
– Won’t work for some countries e.g. Afghanistan as Zend
programmers don’t know the post code conventions
• Bug in checking of UK post codes – these are supposed to include space characters, 
but this feature not properly implemented
140
Checking post code and country
141
Extending the Zend library
• Zend provides a large number of pre‐defined validator
classes
but sometimes, you want your own more specialized 
class.
• I wanted to “validate” names as far as is possible
– Hackers and script‐kiddies are often lazy (they have some of the 
characteristics of a good programmer) and choose names like Sexxxxy or 
Oghbnaanoviclk
– What do I expect in a name?
• Not just letters, there are names like O’Brien and Lloyd‐Davis
• Maybe something like first‐name optional initials last‐name
– First name – should start with a capital then letters
– Last name – look out for the O’Briens and Lloyd‐Daviss, what about von 
Beethoven?
– Need my own validator class
142
Extending the validation framework
• Defining a class
– It will have to extend a class that is provided by 
the validation framework
– It will have to implement the methods that the 
validation framework expects
– It will have to get “registered” into the application 
and framework in some way
143
MyValid_Name
• Based on the Zend_Validate_Abstract class
– Has an isValid() method, and a getName() method that 
returns a “cleaned up” name based on input string given.
– Also a few constants for things like error messages
• Utilizes some regex checks to look for strings that are 
acceptable (and things that are not)
• Defined in with the application code (not a separate 
library) and require_once by the code
144
25/02/2015
25
MyValid_Name
145
My checks
• Is the name length acceptable?
• Does it contain only letters (upper or lower 
case) spaces, “.” (for initials as in B. H. Obama), 
“’” (apostrophe), and hyphens?
• At most one hyphen, at most one apostrophe?
• Junk sequences such as xxxxx?
• An more regex checks on letter patterns!
146
My checks
147
My checks
148
Can use my validator in checking code
• Add another check, after the one on looking at 
postcodes
149
What else?
• Would be members are asked for a nickname by 
which they wish to be known on site
– Added to their postings etc
• Some names are popular –
– D&D adventure game sites must encounter many 
would‐be Gandalfs, Elminsters, and Merlins.
• So best check that the requested nickname is not 
in use
– That means checking in a data table that contains 
member details.
150
25/02/2015
26
It is all automated (of course!)
• To check against a database:
1. Get a database adapter object
• Database specific class (in this example, I was using a MySQL
database) so the class was
Zend_Db_Adapter_Pdo_Mysql
(uses the Pdo library)
• It is basically the same as a JDBC “Connection” object
2. Create a “Zend_Validate_Db_RecordExists” object!
• Tell it which data base adapter it is using
• Tell it the table name
• Tell it the column name it is to check
3. Ask the Validate_Db_RecordExists object whether there is 
already a record with the nickname that the user desires
151
The data table
Maybe a bit more on this later – note how a “trigger” is being used, when
a new record is inserted, two date stamp fields are initialized.
Currently only interested in the “username” field  ‐ since this is supposed to
be unique it could be a primary key but the ORM system wants an integer (hence
the surrogate key – sorry Janusz but I just had to do it) 152
Does that user name exist?
153
It all looks ok
• If the application gets past the various 
validation checks, then will need to
– Store all the data in some data table until the 
administrator has time to create new accounts
– Send a message to the administrator 
• All just straightforward PHP coding,
but remember – impatience, laziness!
– Exploit Zend classes to simplify the work.
154
Automation of data save and email
• Since we already have a database adapter, we can 
use it to insert a record
– This isn’t being done using program objects to 
represent the new record;
the data are just passed as an array of (column‐name 
=> value) pairs.
The database adapter works out the SQL for the insert 
and does the work.
• The mail handler – well its just a wrapper around 
some of the email functions in the PHP standard 
library.
155
Data save
156
25/02/2015
27
Email
157
Problems!
• Look at all those “configuration” data buried 
in the code!
– It is a MySQL database, using the PDO library
– The user name, password, and schema are …
– Mail the administrator at this address …
• But such configuration data are subject to 
change – much better to have them in a 
configuration file
158
Zend Framework configuration
• Framework itself has lots of configuration data
• In response, framework authors built a “configuration 
engine” component as part of the framework
– Configuration data stored in a text file
• Name and value strings
– Configuration data read in and used to construct a data 
object (or several objects)
• Each has data members corresponding to names
• Each data member has value from input
– All data objects as members of a “config” object
– Standardized code for finding these data objects and 
accessing fields when need value of some config. data
159
While we are making improvements …
• How about logging the IP addresses of 
persons whose applications are rejected
– Might be appropriate to put these IP addresses on 
a “Deny from” list
• Zend framework has useful “logging” classes 
(you just knew that didn’t you);
so can create an instance (it will need some 
configuration data – like where to put the log) and 
use in the code.
160
Configuration files
• Several format supported, including XML, but 
“.ini” format (simple text) is often easiest
– Name             value
• Name is like a pathname
– mail.smtpserver (create a “mail” data object with field 
smtpserver)
– mail.from.id (add a “from” field to that “mail” object and get 
it to reference a “from” object, and then add an “id” field to a 
“from” object
– mail.from.name (add a name to the from object)
– …
161 162
25/02/2015
28
Loading the configuration data
• Load the .ini file during application start up
163
Get data from $config object
Getting data
from the config
object
164
Log that hacker
• If reject an applicant, note in log
165
Zend Framework 2
Zend Framework’s data persistence 
classes
166
Zend Database classes
• Really quite similar to ADOdb
– Some classes with member functions (possibly static 
member functions) that simplify procedural style 
access to the database
• No need to construct statement objects and insert SQL 
strings as with lower level ODBC/JDBC interfaces
– A simple object‐relational mapping system
• Use
– Procedural style for bulk operations
– ORM style for handling specific records and 
collections of records
167
Procedural style
• Zend classes
– Zend_DB_Adapter, Zend_DB_Statement, 
Zend_DB_Select; also Zend_Paginator
• PHP scripting still establishes connection, 
builds a statement, runs statement, works 
with result set.
168
25/02/2015
29
The data
• “Schools” example (copied from my 
Introduction to Java Persistence Architecture)
“School board” administers a set of schools (school id, name, address);
“School board” employs teachers (id, name, initials) – maybe unassigned, but
most teachers belong to specific schools and have responsibilities (kindergarten, ESL, sports, …)
“School board” enrols pupils (id, name) – pupils initially unallocated but quickly assigned to 
classes (kindergarten, 1, 2, …) in specific school. 169
The application
• Administer schools database and handle 
queries like “List names of teachers assigned 
to school …”
Assorted scripts, still using Smarty for output
170
Oracle tables
“.ini” config file
171
Smarty templates
• Exploit Smarty’s “include file” directive
– Makes it easy to have standard header and footer elements
172
List teachers, teacher details
Common header – just the image; common footer – the centred “The School Board” tag.
173
Getting a database adapter
• Database properties (“driver” – e.g. PDO_MySQL, 
Oracle, …; database name, password etc) should be in a 
configuration (.ini) file.
• Configuration data loaded using Zend’s
Config_Ini class.
• Zend_Db class has factory method that 
creates adapter
174
25/02/2015
30
DB adapter
• Variety of methods including “fetchAll”
– This takes a SQL string as an argument along with 
a bind array (name => value) for any parameters in 
the SQL string.
– Data can be returned as an object or hash‐map 
array.
• Simplest to let Smarty template iterate 
through a returned “result set” collection
175
DBDemo1
• Get – display form; Post – handle input
– Form needs a HTML  with options being the 
names of schools as found in database
Require the libraries;
create a Zend “auto‐loader”,
read the config file,
create the Smarty template
interpreter.
Invoke initialization functions;
then “Get” or “Post” – call
appropriate handler
176
Initialization
• Smarty object needs initialization as before; a 
database adapter must be created.
My smarty template files are actually in a project
sub‐directory and not the template directory that
I specified here!
177
Get ‐> display form
• Run a query to get collection with all school names, 
pass data to Smarty template
– Here still using SQL strings composed “by hand”
178
Display form template
• As shown earlier
Iterate through “result set”;
each row as array indexed
by column‐names
179
Processing response
• Pick up input from form (school name) and bind to 
argument in SQL string
• Run request to get teachers in that school
No error checking?  Well it is meant to be an “in‐house” application and so less
need for hacker defences.  (Of course, that is a poor excuse and it is really 
just laziness – some hacker is bound to have enough free time to try to break it.) 180
25/02/2015
31
Teacher list template
• Smarty creates a HTML 
 list with names of 
teachers acting as links to the “TeacherDetail” script
181
TeacherDetail script
• Accessed via a  link; therefore a get 
request with query string being teacher identifer.
• Retrieve all data from teacher table.
• If teacher is a class teacher (rather than something special like 
ESL, Sport, Drama, Principal) then run a request against pupil 
database to retrieve pupils in that school/class 
combinations
The usual code – require libraries,
create the auto‐loader, config object,
and Smarty object.
Initialize Smarty object.
Create a DB adapter. 182
TeacherDetail script
• Handling the request
Here fetch data as an“object” 
rather than hash‐map array; 
requires slightly different code in
Smarty template
183
Retrieve object or array
• Not much of a difference here
– Array style
• Hashmap array of name=>value pairs
– Object style
• PHP object with (public) data members named after the 
columns
• Here using Oracle adapter which follows Oracle habit of 
making column names fully capitalized – so public data 
members with fully capitalized names.
184
Teacher detail template
• Illustrates different access style
185(This is using Smarty 2 syntax in the foreach loop).
DB_Select
• Zend_DB_Select class
– A different approach to building up a complex SQL 
select statement
• One that doesn’t require you to remember SQL syntax
• Methods
– Add SQL clauses such as “From” (the table, the 
columns required), “Where” (expression with field 
selectors) (“bind” – needed if Where expression is 
parameterized), “Order” etc.
– Each method returns a reference to the same “Select” 
object – so get coding style that chains together the 
clause building calls.
186
25/02/2015
32
DB_Select
• Similar to teachers example
– List of schools shown
– Request is for pupils in chosen school
• Pick up school name from request
• Bind into request (now built using DB_Select object)
• Run query getting collection of pupils
• Pass result data to a Smarty template
187
Using the select object
188
Pagination
• Report pages that have very long lists or tables 
and which require scrolling are not an attractive 
way of presenting data. 
• Users generally prefer a system that paginates 
the data and allows them to move from page to 
page. 
• It's hard work implementing a reporting system 
that has pagination – unless you have the option 
of using the Zend_Paginator when everything is 
easy.
189
Pagination example
• All pupils in a school
– There could be a few hundred
– Would like them presented a few at a time with 
“previous” and “next” links
190
How achieved?
• SQL queries allow for constraints like “Limit” 
and “Offset”
– So if a request is going to return hundreds of rows, 
can request
LIMIT 20 OFFSET 200
along with an order‐by constraint
• With Zend’s Paginator class, you specify the 
main SQL request (as a “Select” object) and 
leave it to the library code to add Limit and 
Offset clauses
191
“DBDemo3/UsePaginator” example
• DBDemo3
– Displays the form with list of schools
– Selection of a school results in a “Get” request to UsePaginator with 
school name (and an implicit page number)
• UsePaginator
– Get request will always include school name; and will generally include 
a page number (defaulting to page 1 if omitted)
– Runs a SQL request with Limit and Offset clauses
– Displays data in Smarty template (along with lots of links for page 
numbers, previous, next etc)
• These are all  links back to the same script with appropriate query string  
arguments
192
25/02/2015
33
Zend documentation
• All the Zend classes are documented; you would need to read the details 
of a class like the Paginator to make full use of it because it does have 
many methods and properties
193 194
Select object
• Created by database adapter, clauses defined 
(using member functions) to run a query that 
selects and sorts the pupils at a chosen school
195
Paginator object
• Factory method (static) of class creates paginator
object – with reference to the select object that it 
works with
– Parameters set to select subset of records that are to be 
retrieved
– Paginator runs modified selection request
196
Output via a Smarty template
197(Smarty 2 syntax used in foreach loops; in Smarty 3 can use < as alternative to lt)
Create, Read, Update, Delete
• Zend’s procedural database interfaces can be used to 
perform all the standard CRUD operations
198
25/02/2015
34
CRUD Teachers
• Code using the procedural interface doesn’t make 
use of any “Teacher” objects in memory – instead 
the data will be held in individual variables, or in 
hash‐map (name=>value) arrays
– This is ok for a limited application such as “insert new 
record” but is not desirable if the code performs any 
elaborate processing of records
199
Insert an additional teacher
• Record creation is easy! 
• The data base adapter's insert method is invoked with 
arguments giving the table name and a name => value 
array with known values to be inserted into the 
specified columns of the new row. 
– For the Teacher data table, the primary key is an employee 
number which is assigned as part of the recruitment 
process; it is not an auto‐generated identifier. 
• Different data base systems use varying means for automatically 
assigning identifiers; the Zend documentation explains the minor 
changes needed for specific data bases. 
– Columns that do not have values assigned in the data table 
passed as an argument to the insert() function will have to 
take default values as defined for that table.
200
Insert teacher
Hash‐map array of data
Invoke “insert” method
of db adapter
201
Zend style ORM
• All the example scripts in the previous section suffer from the 
problem of SQL and database concepts intruding into the logic of 
the program. 
• Rather than have something in the style “compose SQL query, run 
query, collect results and extract data” you might well prefer to 
have a program that worked with School, Teacher, and Pupil entity 
objects and some helper intermediary class(es) that could be asked 
to
– “load a Pupil entity”, 
– “get me a collection of all Teacher entities where their role is Principal”, 
– “save this new School entity”. 
• Zend_DB_Table and related classes provide a means of 
creating code with this more object‐oriented style.
202
Program classes based on table 
definitions
• The mechanisms are similar to those shown 
earlier for ADOdb.
The library code reads the database “meta‐data” 
to get the column names and data types for the 
fields in records.
Using these data, the library code creates classes 
that work with the tables.
– There are again naming conventions – name of table, 
name of primary key field
• If you don’t follow the conventions, you can explicitly define 
such details
203
Zend_Db_Table_Abstract
• The framework provides an abstract base class
• The application declares a concrete class 
derived from this base class.
204
25/02/2015
35
Using a “table object”
• Create a database adapter
– Use configuration data from the application's .ini file. 
• Set this as the “default adapter”. 
– An instance of a table gateway class must be given a 
reference to a database adapter when it is created. 
• If only one database is in use it is simplest to define an 
adapter to this database as the “default adapter”, then it 
isn't necessary maintain and pass around adapter 
references.
• Create an instance of the table class
• Use it to perform an operation such as fetchAll()
205
DBTable examples
• Examples illustrate some of uses of ORM style
– DBTable1
• Just a page with the list of schools
206
Create the database
adapter and set it as
the “default adapter”
Load the Zend library;
then own “table class”;
Read configuration data.
Create instance of table class, 
use it to run fetchAll() – getting a
collection of objects representing
the schools;
data members are public
207
Using dummy instances of classes
• Created an instance of SchoolTable1 simply to run 
fetchAll
• I don’t like this style
– The dummy SchoolTable1 object really has no purpose
– I feel that fetchAll() should be a static class method
208
Retrieved objects for schools
• Basically instances of PHP’s std_class with 
extra properties corresponding to the fields of 
the database record
– Field names fully capitalized to match Oracle’s 
internal usage.
209
Creating a record
• Create a SchoolTable1 object,
Tell it to insert data supplied in hash‐map 
array
210
25/02/2015
36
Table_Select
• If you want to select records, you create a 
Zend_DB_Table_Select object and use its 
methods to define constraints
• You can then run the table object’s “fetchAll” 
method with the select object as an argument 
and get back a collection of objects that match 
the constraints.
• Illustrated in the DBTable2 script that displays the 
school names, and retrieves teachers for a 
chosen school
211
Another table class
• A simple definition of a “TeacherTable” class 
needed to work with the TEACHER database:
212
DBTable2
Get: show form with
 listing the schools.
Post: $_POST[] data with
selected school;
run a query retrieving teachers
at the school.
213
Retrieving teachers at school
Zend_DB_Table_Select object created using the “select” method of the table object.
214
Table_Row classes
• The instances of std_class (with extra properties) 
returned by fetchAll on a Table object are OK if 
you are simply going to display data
• If you want more functionality, you can define a 
“Table_Row” class associated with the Table class
– You can then add extra functions to your own row 
class.
– You can manipulate instances of the row class using 
your functions.
215
Table and Table_Row class
• Teachers:
Define any extra functionality that you require
216
25/02/2015
37
std_class and _get
• See documentation on PHP’s standard class
• Fullname is a function, so get code inconsistency 
// Have a teacher class object $aTeacher
…
// Need surname 
$sname = $aTeacher‐>SURNAME; // access as property
…
// Need full name 
$fullname = $aTeacher‐>FULLNAME(); // access via function
217
Redefine __get
218
Example use of a Table_Row object
• Reassign teacher
– ChangeSchool.php script displays a form that 
allows a user to enter an employee number and 
select a school, and processes these data by re‐
allocating the employee to a new school. 
– The entity object, instance of TeacherClass is 
loaded using the TeacherTable2 class; 
– it is modified as an object; and saved in its 
modified form:
219
Fetch single
row  object
Modify it; then
put modified 
version back into
table
220
Aren’t they RELATIONAL databases?
• Examples so far have used single tables – but 
what about those relationships defined via those 
foreign keys?
– After all, a School object in some sense own a 
collection of Teacher objects and another collection of 
Pupil objects
• Zend table classes can be extended to express 
such relationships
– Can then, for example, fetch a row from the school 
table and have in the resulting object a field that is a 
collection of teacher records.
221
Defining the relations among classes
A school owns records from the Teacher table;
details of relation defined in specialized Table class
for the Teacher table.
Foreign key relation described;
‘schoolname’ column in teacher
table is a foreign key referencing
‘schoolname’ column in school
table.
Use that TeacherClass
(Zend_DB_Table_Row) 
222
25/02/2015
38
Using the relation
• Creating a school object doesn’t automatically 
load the collection of teachers
– You wouldn’t want it to
• Load data when required
• But there is a findDependentRowset() method 
that can be called to load the data
– Method takes arguments identify the Table class 
for the related table, and the “mapping rule” that 
describes the foreign key relationship
223
Listing teachers at a school
Create a dummy SchoolTable2 object
and use it to fetch the row for chosen school
Load the collection of related
Teacher records
224
Data mapper classes
• Table and Table_Row derived classes should suffice for 
most applications.
• Sometimes, more elaborate data models are useful
• Most Zend tutorials on the Internet illustrate a more 
elaborate model – the “Data Mapper” model
– Two classes defined in program for all persistent data 
types, in addition to the basic Zend_DB_Table class
• One is an application defined class with private data, get/set 
methods and additional functionality as needed
– Its instances represent the application’s view of the data objects
• Second is the mapper
– It creates and works with instances of the application class
– It uses methods of the Table class when transferring data to persistent 
storage 
225
Using Zend without the framework
• Zend libraries quite generally useful
– There are of course alternatives
• In themselves, don’t make any dramatic 
change to your programming style.
226
Zend Framework 3
A new structure for a web application
227
Model‐View‐Control
• Thirty odd years ago, the guys at Smalltalk’s Palo Alto 
Research Centre were arguing that, for interactive 
programs, the best design approach would be to 
separate
– The Model
• The data that the application works with
– The View
• The parts of the application that present the data to the user and 
maybe allow for input of new data
– The Control
• Interpret user actions to determine what data elements are to be 
manipulated and what operations are to be applied
• Dispatch operations, these update the model
• Notify view elements – they need to refresh themselves
228
25/02/2015
39
MVC
• The Smalltalk guys at Xerox‐Parc were thinking of 
desktop applications in a windowing environment
– Most of their applications were specialized document 
editors
• But the same model applies to web‐applications
– The Model
• The persistent data in the data bases
– The View
• The HTML form pages and response pages
– The Control
• What control?
229
Web Apps
• Control is fragmented
– It is in all the different scripts
• Kind of using the web‐server/file‐system to act as 
the dispatcher
– The URL identifies the script
• A separate script for each data‐operation combination
– The Web‐server loads the script into the PHP 
interpreter
– Script runs
230
Multi‐script web apps
• Most applications require multiple scripts
• Entire concept of “application” is fragmented
– There is no “application program” – just different scripts
• Code is frequently duplicated
– Very similar code to check user credentials and enable 
particular actions has to exist in each of many different 
scripts
231
“Front‐controller” design pattern
• Re‐invents “the application”
• All user requests handled by a single control element
– The control role from MVC
• Interpret the request
• Identify the data that are to be manipulated
• Identify the operation that is to be performed on the data
• Evaluate user credentials – does this user have the right to 
perform that operation on those data
• Dispatch valid requests to code that makes the changes
• Compose the response by invoking “display()” operation of some 
view element that composes the response using sub‐views to 
show appropriate data elements
232
Front controller models
• Various extensions to Java servlets from ~2000 
(Struts, Tapestry, …)
• Ruby on Rails ~2004
• PHP variants ~2006 including Zend framework
Java frameworks differ a bit from Ruby/PHP.  Java servlets etc are “persistent” – once
instantiated in a servlet engine they remain in existence “forever” (well, they can
be destroyed if not in use and memory is low).  Ruby/PHP code gets reloaded on
each request.  Java can afford more elaborate and slower initialization steps as 
these only performed once.  
233
A single application – “index.php”
• Actually, there is only one web application – it is an instance 
of an application class defined by the Zend library
1. It is “the front controller”
2. It receives the requests 
• URLs plus optional query string and posted data
3. It interprets requests to identify data and operations
4. It loads classes (code) that you defined (as subclasses of 
framework classes); it instantiates objects as needed
• It can work out the classes needed; there is a highly structured naming 
system employed that helps map requests to classes
5. It invokes operations on instances of classes
• Change data, and produce little chunks of response HTML that get 
stored for later display
6. It invokes display() operation of a layout manager
234
25/02/2015
40
The requests
• A request has to
– Identify the part of the model (data) that is to be updated
– Identify the operation on those data
– Supply arguments – data as entered in form fields.
• In a conventional web application, identification of 
model and operation is achieved by specifying the 
required script in the “action=…” attribute of a form 
(or target script an AJAX request)
• But now there is just the one script – index.php
235
Request data
• Could possibly identify the data and operation as part 
of a query string e.g.


…
• But that isn’t the preferred approach
• Instead, the operation and data identification get 
incorporated into the “pathname” part of the URL –
giving a URL like 
“www.schoolboard.org/teacheradmin/create?employeeid=...”
236
Puzzled web server!
• Of course, there is no resource at the location 
specified by a path like teacheradmin/create
• The web‐server needs to be re‐configured so that 
such a request gets passed to the index.php script
– The index.php script can request the original pathname 
(it’s one of the standard environment variables) and so 
identify what work is to be done.
237
Zend approach
• Front controller and action controllers
– Front controller is in the standard code provided 
by the library.
• You define “ActionController” classes
– Each class can implement many different 
operations
– Usually, define a different ActionController for 
each major element in data model
238
Schoolboard application
• School Administration (SchoolController) 
– List schools
– Add a school
• Teacher Administration (TeacherController)
– List teachers at school
– Create new teacher
– Delete teacher
– Update teacher record
– List pupils in teacher's class
• Pupil Administration (PupilController)
– List pupils at school
– Create pupil
– Delete pupil
– Update pupil record
239
Zend Application class
• Gets instantiated by index.php code
• Reads initialization file (.ini) and creates a $config object with the 
data
• Notices that there is a database adapter object required (could be 
more than one) – creates it, initializes it, probably sets it as the 
“default adapter”
• Looks at the request data (pathname), determines which controller 
class has to be loaded, finds the code, and instantiates an instance
• Initializes controller.
• Looks at the request data (pathname), determines the operation 
requested
• Verifies whether this is permitted for this user
• Invokes operation
• …
240
25/02/2015
41
Dynamic linking
• Essentially all the systems (Java/Ruby/PHP/…) that 
implement these front‐controller models rely on 
dynamic linking
– The system works out at run‐time what code to compile 
and link in (Java would typically already be in compiled 
.class files)
• Zend’s application class will rely on its auto‐loader to 
find the code
– Configuration files will be necessary
• Identify location of standard Zend library code
• Identify location of application specific classes
– Much relies on standard naming and directory structures 241
Class naming conventions
• Zend relies on naming conventions to help it find 
class definition files (“SchoolTable.php” etc)
• Conventions are similar to those in Java where a class belongs 
to a “package” (and maybe to a package within a package e.g. class HTML in 
javax.swing.text.html)
– Java class = a file
– Java package = a directory
• Zend framework similar
242
Naming
• Take care naming files, placing files in 
directories, and then naming your classes 
appropriately
243
Routing requests to index.php
• HTML pages from a Zend application will contain 
references to Javascript, CSS files, images etc (, , )
– These should NOT be routed to index.php
– Just want the web server to return the requested file
• The “funny” URLS like 
www.schoolboard.org/teacheradmin/update should 
be routed to index.php
244
How? With Apache rewrite rules
• Apache ReWrite module –
– originally introduced to remap file paths; it changes the 
paths that appear in requests into different paths that 
correspond to the true location of resources. 
• Probably, when first introduced, this module simply facilitated 
reorganisation of the contents of an htdocs folder – resources 
could be moved even though their original URLs had been 
published. 
– Subsequently, other uses have been found –
• such as dealing with embedded session keys for those paranoid 
web users who disable cookies. 
– The rewrite module can also be given the rules needed to 
map appropriate requests to a front controller.
245
Adding some rewrite rules to a 
.htaccess file
• Modify the .htaccess file in the directory where the 
Zend framework application is to exist e.g. 
public_html/ZFSchools_1
– Don’t modify the Apache’s httpd.conf file – you only want 
the rewrite rules to apply when running your Zend
framework application.
• Different styles possible
– Basically want a rule that says don’t change pathnames for 
.css, .js, .jpeg etc files
– Do change all others to index.php
246
25/02/2015
42
Rewrite rules
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} s [OR]
RewriteCond %{REQUEST_FILENAME} l [OR]
RewriteCond %{REQUEST_FILENAME} d
RewriteRule ^.*$ [NC,L]
RewriteRule ^.*$ index.php [NC,L] 
• A rough translation from Apache into English is
– “check if the file‐name in the request is that of an 
existing file, or link, or directory – in such a case leave 
it alone, and don't try any more rules; 
for all other cases change the file‐name to index.php”. 
Puzzled? Go read the Apache manual pages! 247
But where is the index.php file?
• Zend framework tutorials on Internet mostly 
show a rather elaborate way of configuring the 
application
– Define a virtual host (e.g. www.schoolboard.org) in 
your Apache’s httpd.conf file
• Part of the configuration data include the file path of this 
host’s “htdocs” directory – which you make the directory 
containing the index.php file for your application.
• Trouble with this virtual host approach is that you 
then have to fiddle with “hosts” files, and DNS 
servers, and browser settings.
248
Simpler alternative
• Alternative not appropriate for real world deployment – but 
ok for learning exercise.
• Has an extra element in the rewrite rules file specifying the 
path where index.php file will be found
• One ugly feature of this approach is that the URL that you must type will be 
something like
http://localhost/~nabg/SchoolBoard/public
249
OK, can route request to index.php
• As previously explained, 
– index.php will instantiate a Zend_Application object
• Application object will load configuration data, create any 
database adapters needed and complete other initialization
– Request will be examined to identify specialized 
“ActionController” that is required
• Class code linked in, instance created, and initialized
– Request will be examined to identify operation required
• Checks on admissibility of action performed; method invoked
– Output will be generated and composed into a 
response page
250
Zend Framework output
• A somewhat elaborate model – it is as sophisticated as the 
page layout schemes that you met with Drupal and similar 
content management systems
• Remember Drupal had
– A layout engine that works with some overall template for a page
• This defined regions in which one can place output from different modules –
navigation elements, content elements, advertisments etc
• Zend framework rather similar
– Your action controllers will have updated data and saved 
details from which they can compose reports (as chunks of 
HTML similar to those returned by Drupal components)
– An overall layout manager will then compose these 
outputs into a complete page
– Uses “.phtml” files (analogous to Smarty template files) 
251
.phtml files (=“sub Views”)
• These are just HTML with a little embedded 
PHP code
• There are .phtml files associated with each 
ActionController
– Actually a .phtml file for each operation defined 
by that controller
• The PHP code in a .phtml file can access data 
saved in the ActionController (data that report 
on the operation performed)
252
25/02/2015
43
Eeeeek!
• Zend Framework
– A complex directory structure for an application that must be 
created just right
• Contains some pre‐defined files such as index.php and bootstrap.php
– It needs some other components like an ErrorController which 
has an associated error.phtml file; also an IndexController and 
its index.phtml file
– Must remember the application.ini file, the .htacess file, a 
layout.phtml file (all must be in the correct directories)
– It needs library paths set
– When you want to do something like create a Zend_DB_Table
class you must edit the application.ini file, you must create 
subdirectories in the model directory, you must name your class 
correctly and place its file in the appropriate directory
– …
253
Script file (.sh or .bat)
• Fortunately, much is automated!
• There is a script file (.sh version for Linux, .bat 
version for Windows) that can do much of the 
work for you
– Can be used at command line, but is integrated into 
NetBeans.
• NetBeans provides dialogs for entry of arguments – such as 
which script option, and then more detailed dialogs for 
supplementary data (e.g. name of database)
• The complete directory structure (with lots of 
empty directories) can be set up with a single 
invocation of the script
254
Starting Zend (inside Netbeans)
255
A Zend Project
• You can specify use of the Zend framework when 
creating a new PHP project in Netbeans.
Netbeans will run the script provided by Zend that 
sets up all the required directory structures and 
which adds the core files
– index.php, bootstrap.php, application.ini;
ErrorController.php etc
• (This initial setup is actually a complete Zend application – one that 
presents an advertisement for the framework)
256
The project “directories”
• Some of the “directories” in Netbeans’ 
“project view” are conceptual – for example, 
there isn’t any real “Sources” directory.
Actual directories
257
Actual directories and files
• Application
– Subdirectories for Zend parts, and 
bootstrap.php file
• Docs
– Any documentation that you 
create for your project
• Library
– Own specialized helper classes 
(use shown in a later example)
• Public
– The actual “web application” 
(index.php) along with the 
.htacess control file.
258
25/02/2015
44
How was that advert created : 1
• Entering the URL localhost/~nabg/ZF01/public resulted in 
Apache trying to “index” that directory –
– Apache sees the index.php file and runs it in the interpreter.
• “index.php”
– Few lines doing things like setting some variables to hold the 
pathnames for the directories containing libraries etc;
– Then “create and instance of Zend Applicaton, process any ‘bootstrap’ 
code, and then let it run”
259
How was that advert created : 2
• Bootstrap.php code –
– Essentially none!  This example uses only defaults
– More complex examples might define a Bootstrap class 
with a real initConfig() method that performs additional 
initialization of components.
• So what gets run?
– By default, run the “IndexController”
• First initialize it (init())
• Then run its default index() action
Why is the IndexController.index() action the default?  Well “index” is the standard
default operation for a web server asked for a directory – so just by extension it became
Zend’s standard default action. 260
How was that advert created : 3
• The IndexController class
– init()
• Nothing to do
– indexAction()
• Nothing to do
261
How was that advert created : 4
• Generating output
– More typically, there would be a “layout” component in 
the configuration (own directory containing .phtml file)
• This would specify how the response page was to be assembled 
using standard template text and output for any action(s) 
performed.
– Here, there was just the one action (the 
IndexController.indexAction) – which didn’t actually do 
very much.
• To show its output, the response page generating code must run 
the index.phtml file in the appropriate subdirectory of views
– views/scripts/index/index.phtml
262
How was that advert created : 5
• views/scripts/index/index.phtml
– Not a HTML page, just a chunk of markup (along with 
some CSS styling)
263
Anything else?
• The .ini file
Nothing of much
interest; more constants
with paths;
Settings for some flags,
e.g. error flags (settings
define the level of detail
in any error reports).
264
25/02/2015
45
Ini files
• Note the sections in the .ini file [production], [development : 
production ]
• The index.php file specifies which section gets used – by default it’s 
the production section.
• [development : production]
– Means use all the settings as in [production] apart from any overrides 
(here override to get more detailed error messages) and extras.
• Basic idea is that can have one .ini file with configuration data for all 
versions
– E.g. the “production” and the “development” versions of an application might 
use different data bases –
• in which case, the production section would have configuration data for the production 
data base, 
• these data being overridden in the development section which could specify a different 
database
265
The default application
• It is your starting point
– Just edit the files, 
– Put some real action code into the action controller
• If you have a variety of data elements to work with, start creating 
new controllers with specialized actions
– For each controller/action combination you need a .phtml
file in an appropriate subdirectory of views/scripts.
Detail: remember to edit the .htaccess file before doing anything else;
add the line that specifies the RewriteBase directory!
266
A real Zend application: ZFSchools_1
• ZFSchools_1 will list schools and their teachers.
– It is a simple application, so can continue to work with 
just an IndexController
• index() action
– Display page with options (links) that will show schools or 
teachers
• viewschools() action
– Show page with list of schoolnames
• viewteachers() action
– Use paginator while showing names of all teachers employed by 
school board.
267
Uses persistent data – access to 
database and a data model
• Application needs to use those database 
tables
– Will need configuration data specifying “driver”, 
database password etc
– Will need Zend_DB_Table classes for both School 
and Teacher tables
• Classes must be placed within appropriate sub‐
directory of the “models” component of the 
application.
268
Netbeans & Zend scripts
• Netbeans simplifies the running of the Zend scripts 
that are needed to do things like add a database and 
create a model.
– New “right‐click” menu option for Zend command
269
Modified .ini file
270
25/02/2015
46
Another Zend command to create a 
table model class
271
Files, directories, and code created
272
Additional actions
• Again, use of a Zend script is advised
– Option to add a named action to a chosen controller
273
Updated IndexController & associated 
phtml files
274
Don’t expect it to write the actual 
code!
• The action method is of course empty, and the 
generated .phtml file contains only some 
placeholder text
– The programmers who implemented the Zend
framework may be smart, but they cannot 
prospectively read your mind and work out what 
code and output you actually want.
275
index.phtml
• The default index() action should again just 
display some pre‐defined HTML in its 
associated .phtml file
– This should now have links that reference the new 
“view teachers” and “view schools” actions.
• URLs in links have to be generated by Zend
functions because they are going to have to 
have the controller and action embedded 
properly in the URL
276
25/02/2015
47
index.phtml
URL method passed data as a hashmap with ‘controller’ and ‘action’ values.
Actual link in page: 277
Run incomplete application!
278
Viewing the schools
1. Define an effective implementation for the viewschools
action
1. Create a DB table object
2. Run its fetchAll method to get a collection of “school” objects 
(just PHP std_class objects augmented with some extra 
properties based on table columns – here school name and 
address)
3. Assign collection to a (newly invented) property “schooldata” 
of the view associated with this action.
2. Edit the corresponding .phtml file
1. Output standard HTML markup and headers etc
2. Pick up collection (function “compiled” from the .phtml is a 
method of the view object – so just access our “schooldata”)
3. Iterate outputting data
279 280
$this‐>escape
• Code is outputting strings to HTML page
– Suppose string contains a character like “>”
• Problems for browser’s layout engine!
– Should always “escape” any user supplied string 
(usually I’m too lazy to bother about this – but here it’s 
easy to do it right)
• Any undesirable characters will be encoded (so “>” 
becomes >)
281
Run the partial application
• Use of view schools link should now result in the 
IndexController running its viewschools action, and 
the output coming from the “view” object being as 
follows:
(The .phtml files are “compiled” into “View” objects that are attached to the controllers.)282
25/02/2015
48
View teachers
• Code for the “view teachers” action will be a little 
more complex as it has to work with a paginator
– Can be invoked as result of click on “index” page’s link – in 
which case should default to showing first page in 
paginated set of pages showing teachers
– Can be invoked as result of click in one of the page links, or 
next/previous links – in which case there should be a 
parameter specifying the page number of the page to be 
displayed.
283 284
$this‐>getParam(,)
• Method of controller class
• Either gets a parameter, or if none there uses 
default provided
285
The corresponding .phtml (view) file
286
Action!
287
Pain?
Gain?
• It’s the same application as shown earlier being 
developed using conventional coding style (with some 
help from Zend support library e.g. the paginator)
• The programmer might well feel that the current 
framework based approach was more convoluted, 
more painful.
• The gain?
– That would be perceived by “maintenance” programmers 
who have to support the code base after the original 
programmer has left.
288
25/02/2015
49
Structure
• The highly stylized structure of a Zend
framework application is going to simplify 
maintenance
– No longer a process of scrabbling through a 
collection of different PHP files to find the one 
that must be changed
– It’s all obvious
• There must be an “action” in an appropriate controller 
with an associated .phtml (view) file.
289
Gain for the programmer?
• As examples get more elaborate, there will 
also be gains for the programmer
– Code sharing across the application
• Don’t need to duplicate code such as authentication 
and authorization tests
– Additional automation
• Later will meet Zend “form”, which links in easily with 
those Zend “validators”
290
Layout
• Outputs so far have just been the “view” for the 
action invoked – a fragment of fixed HTML and 
something like a table generated via a PHP loop 
through a collection.
• But really want something more impressive
– A little like a page from Drupal
• Elaborate layout
• Places for output from different components (actions)
• Need to use Zend’s “layout” features.
291
Layout
• Zend (.sh) command “enable layout”
– Creates an extra “layout” section in the project 
with a default layout.phtml script
• Create your own CSS 
– Probably best placed in a css subdirectory of 
your Zend project’s public directory
• Also create an images directory if appropriate
CSS file here just set a
background, font family
and colour, and modified
styles (re‐sizing) for headers
292
layout.phtml
• Provide overall page structure
• Supply a 
 where “content” (output from 
actions) will get inserted
293
layout.phtml
294
25/02/2015
50
ZFSchools_2 and ZFSchools_2b
• A standard Create Read Update Delete application
• Could put all the actions in the 
IndexController but more sensible to define 
new ActionControllers (there is, of course, a Zend .sh script 
option that can be used to define a controller – it creates the directories 
for controller and associated views)
Lots of controllers
Lots of “views”
295
Example ‐ SchoolController
• indexAction()
– List the schools
• And in view displayed offer options for adding schools or viewing 
more detailed data like listing the pupils at the school
296
Use of jQuery
• I am using jQuery for user interface elements 
such as the tab pane.
• I include jQuery via