Php Conference Brazil - Phalcon Giant Killer

1. Jacksonfdam
http://about.me/jacksonfdam
https://bitbucket.org/jacksonfdam
https://github.com/jacksonfdam
http://linkedin.com/in/jacksonfdam
@jacksonfdam

2. A
thanks
to
Encourage
and
believe
in
the
passage
of
knowledge.
(And
to
release
me
from
work
to
be
here.)
”

3. Why?
•
Use
of
frameworks
has
become
mandatory
in
professional
development
with
PHP
•
They
offer
a
philosophy
and
organized
structures
to
easily
maintain
projects
writing
less
code
and
making
work
more
fun

4. How
PHP
works?
1.
PHP
have
dynamic
and
weak
typing
discipline
2.
PHP
is
interpreted
(not
compiled)
3.
Every
time
a
script
is
loaded,
should
be
interpreted
by
PHP
4.
If
a
bytecode
cache
(like
APC)
isn’t
used,
syntax
checking
is
performed
every
time

5. How
traditional
php
frameworks
works?
1.
Many
files
with
classes
and
functions
are
read
at
every
request
made.
Disk
reading
is
expensive
in
terms
of
performance
2.
Modern
frameworks
use
lazy
loading
technique
(autoload)
for
load
and
execute
only
code
needed
3.
Continuous
loading/interpreting
could
be
expensive
and
impact
your
application
performance
4.
When
you
use
a
framework
most
of
the
code
remain
the
same
across
development.
Why
load
and
interpret
it
every
time?

6. How
PHP
works?

7. How
traditional
php
frameworks
works?

8. How
a
PHP
C
extension
works?
1.
C
extensions
are
loaded
together
with
PHP
one
time,
on
the
web
server
dispatch
process
2.
Classes
and
functions
provided
by
the
extension
are
ready
to
use
for
any
application
3.
The
code
isn’t
interpreted
because
it
is
compiled
to
a
specific
platform
and
processor

9. How
a
PHP
C
extension
works?

10. What
is
Phalcon?
Phalcon
is
an
open
source,
full
stack
framework
for
PHP
5
written
as
a
C-­‐extension,
optimized
for
high
performance.
You
don’t
need
to
learn
or
use
the
C
language,
since
the
functionality
is
exposed
as
PHP
classes
ready
for
you
to
use.
Phalcon
also
is
loosely
coupled,
allowing
you
to
use
its
objects
as
glue
components
based
on
the
needs
of
your
application.

11. How
Phalcon
works?
1.
Components
are
loosely
coupled.
You
may
use
the
components
you
want
without
depending
on
a
full
stack
2.
Low-­‐level
optimizations
provide
the
lowest
overhead
for
MVC-­‐based
applications
3.
Interact
with
databases
with
maximum
performance
by
using
a
C-­‐language
ORM
for
PHP
4.
Phalcon
is
directly
engaged
with
PHP,
so
it
can
directly
access
internal
structures
optimizing
execution
as
well

12. What
is
Phalcon?

13. Compare
how
Phalcon
is
faster
than
other
frameworks
Traditional
Frameworks
Phalcon
Interpretation
of
hundreds
or
thousands
of
PHP
lines
on
each
request
YES
NO
Load
dozens
of
files
in
each
request
YES
NO
Checking
the
existence
of
functions,
methods,
classes,
constants
at
each
request
YES
NO
Low-­‐level
optimizations
gaining
microseconds
for
each
request
NO
YES

14. HipHop/HHVM
While
HipHop/HHVM
(if
you
never
heard,
do
a
google
research
now)
is
a
real
virtual
machine
inside
your
server
that
pre-­‐compiles
and
serves
your
PHP,
Phalcon
is
a
“c-­‐
extension”
that
will
be
installed
into
your
operating
system
(can
be
installed
in
Linux,
Mac,
Windows),
not
downloaded
via
Git
like
usually.

15. HipHop/HHVM
With
native
PHP,
the
requested
.php
file
is
compiled
at
every
request
(which
means,
PHP,
which
is
itself
written
in
C,
will
do
a
syntax
check,
then
the
contents
will
be
translated
into
C,
then
compiled
and
then
executed).

16. HipHop/HHVM
It
does
mainly
the
same
thing
HHVM
does,
but
without
HHVM.
Phalcon
is
the
only
framework
that
does
not
come
as
pure
.php
files,
it’s
delivered
as
compiled
C(++)
binaries.It
also
comes
with
a
rich
set
of
excellent
professional
features,
so
it’s
definitly
not
stripped
down!

17. HipHop/HHVM
The
code
you
add
will
not
be
precompiled
to
C
bins,
so
it’s
a
extra
point
for
HHVM.
To
be
honest,
there
was
a
lot
of
movement
in
the
HHVM
world
in
the
last
3
months,
and
with
the
upcoming
success
(I
really
think
so!)
and
easy
implementation
of
HHVM
basically
every
framework
can
gain
extremely
in
compiling
speed,
therefore
Phalcon
loses
it
main
killer
feature
a
little
bit,
that’s
true…

18. HipHop/HHVM
From
my
understanding
Phalcon
does
the
syntax-­‐check
and
the
compiling
to
C
only
once
until
the
php
file
changes,
so
basically
a
request
hits
compiled
C
code,
not
to-­‐be-­‐
compiled
PHP
code.

19. Framework
Benchmark

20. Framework
Benchmark

21. Framework
Benchmark
<h1>Hello!</h1>

22. Test
Environment
Operative
System:
Mac
OS
X
Snow
Leopard
10.6.8
•
Web
Server:
Apache
httpd
2.2.21
•
PHP:
5.3.8
+
APC
3.1.9
(Without
Xdebug)
•
CPU:
3.06
Ghz
Intel
Core
2
Duo
•
Main
Memory:
4GB
1067
MHz
DDR3
•
Hard
Disk:
500GB
SCSI/SAS
HDD

23. Framework
Benchmark
ab
-­‐n
1000
-­‐c
5
http://localhost/bench/phalcon

24. Framework/Requests
per
Second

25. Framework
Total
Requests/Average
Time

26. Number
of
Interpreted
Files
per
Request

27. Allocated
Memory
per
Request

28. Installation

29. Installation
To
use
phalcon
on
Windows
you
can
download
a
DLL
library.
Edit
your
php.ini
file
and
then
append
at
the
end:
extension=php_phalcon.dll
Restart
your
webserver.

30. Requirements
Prerequisite
packages
are:
PHP
>=
5.3
development
resources
GCC
compiler
(Linux/Solaris)
Git
(if
not
already
installed
in
your
system
-­‐
unless
you
download
the
package
from
GitHub
and
upload
it
on
your
server
via
FTP/SFTP)

31. Configure
Phalcon
automatically
detects
your
architecture,
however,
you
can
force
the
compilation
for
a
specific
architecture:
cd
cphalon/build
sudo
./install
32bits
sudo
./install
64bits
sudo
./install
safe

32. Installation
on
XAMPP
XAMPP
is
an
easy
to
install
Apache
distribution
containing
MySQL,
PHP
and
Perl.
Once
you
download
XAMPP,
all
you
have
to
do
is
extract
it
and
start
using
it.
Below
are
detailed
instructions
on
how
to
install
Phalcon
on
XAMPP
for
Windows.
Using
the
latest
XAMPP
version
is
highly
recommended.

33. Creating
a
project
File
structure
Phalcon
does
not
impose
a
particular
file
structure
for
application
development.
Due
to
the
fact
that
it
is
loosely
coupled,
you
can
implement
Phalcon
powered
applications
with
a
file
structure
you
are
most
comfortable
using.

34. Creating
a
project
For
the
purposes
of
this
tutorial
and
as
a
starting
point,
we
suggest
the
following
structure:
lab01/
app/
controllers/
models/
views/
public/
css/
img/
js/

35. Beautiful
URLs
#/tutorial/.htaccess
<IfModule
mod_rewrite.c>
RewriteEngine
on
RewriteRule
^$
public/
[L]
RewriteRule
(.*)
public/$1
[L]
</IfModule>
#/tutorial/.htaccess
<IfModule
mod_rewrite.c>
RewriteEngine
on
RewriteRule
^$
public/
[L]
RewriteRule
(.*)
public/$1
[L]
</IfModule>

36. Bootstrap
<?php
try
{
//Register
an
autoloader
$loader
=
new
PhalconLoader();
$loader-­‐>registerDirs(array(
'../app/controllers/',
'../app/models/'
))-­‐>register();
//Create
a
DI
$di
=
new
PhalconDIFactoryDefault();
//Setup
the
view
component
$di-­‐>set('view',
function(){
$view
=
new
PhalconMvcView();
$view-­‐>setViewsDir('../app/views/');
return
$view;
});
//Setup
a
base
URI
so
that
all
generated
URIs
include
the
"tutorial"
folder
$di-­‐>set('url',
function(){
$url
=
new
PhalconMvcUrl();
$url-­‐>setBaseUri('/lab01//');
return
$url;
});
//Handle
the
request
$application
=
new
PhalconMvcApplication($di);
echo
$application-­‐>handle()-­‐>getContent();
}
catch(PhalconException
$e)
{
echo
"PhalconException:
",
$e-­‐>getMessage();
}

37. Creating
a
Controller
By
default
Phalcon
will
look
for
a
controller
named
“Index”.
It
is
the
starting
point
when
no
controller
or
action
has
been
passed
in
the
request.
The
index
controller
(app/controllers/IndexController.php)
looks
like:
<?php
class
IndexController
extends
PhalconMvcController
{
public
function
indexAction()
{
echo
"<h1>Hello!</h1>";
}
}

38. Creating
a
Controller
Sending
output
to
a
view
Sending
output
to
the
screen
from
the
controller
is
at
times
necessary
but
not
desirable
as
most
purists
in
the
MVC
community
will
attest.
Everything
must
be
passed
to
the
view
that
is
responsible
for
outputting
data
on
screen.
Phalcon
will
look
for
a
view
with
the
same
name
as
the
last
executed
action
inside
a
directory
named
as
the
last
executed
controller

39. Creating
a
Controller
In
our
case
(app/views/index/index.phtml):
<?php
echo
"<h1>Hello!</h1>";
Our
controller
(app/controllers/IndexController.php)
now
has
an
empty
action
definition:
<?php
class
IndexController
extends
PhalconMvcController
{
public
function
indexAction()
{
}
}

40. Creating
a
Model
Phalcon
brings
the
first
ORM
for
PHP
entirely
written
in
C-­‐language.
Instead
of
increasing
the
complexity
of
development,
it
simplifies
it.
Before
creating
our
first
model,
we
need
to
create
a
database
table
outside
of
Phalcon
to
map
it
to.
A
simple
table
to
store
registered
users
can
be
defined
like
this:
CREATE
TABLE
`users`
(
`id`
int(10)
unsigned
NOT
NULL
AUTO_INCREMENT,
`name`
varchar(70)
NOT
NULL,
`email`
varchar(70)
NOT
NULL,
PRIMARY
KEY
(`id`)
);

41. Creating
a
Model
A
model
should
be
located
in
the
app/models
directory
(app/models/Users.php).
The
model
maps
to
the
“users”
table:
<?php
class
Users
extends
PhalconMvcModel
{
}

42. Setting
a
Database
Connection
In
order
to
be
able
to
use
a
database
connection
and
subsequently
access
data
through
our
models,
we
need
to
specify
it
in
our
bootstrap
process.
A
database
connection
is
just
another
service
that
our
application
has
that
can
be
used
for
several
components:

43. Setting
a
Database
Connection
<?php
try
{
//Register
an
autoloader
$loader
=
new
PhalconLoader();
$loader-­‐>registerDirs(array(
'../app/controllers/',
'../app/models/'
))-­‐>register();
//Create
a
DI
$di
=
new
PhalconDIFactoryDefault();
/
/Setup
the
database
service
$di-­‐>set('db',
function(){
return
new
PhalconDbAdapterPdo
Mysql(array(
"host"
=>
"localhost",
"username"
=>
"root",
"password"
=>
"secret",
"dbname"
=>
"test_db"
));
});
//Setup
the
view
component
$di-­‐>set('view',
function(){
$view
=
new
PhalconMvcView();
$view-­‐>setViewsDir('../app/views/');
return
$view;
});
//Setup
a
base
URI
so
that
all
generated
URIs
include
the
"tutorial"
folder
$di-­‐>set('url',
function(){
$url
=
new
PhalconMvcUrl();
$url-­‐>setBaseUri('/tutorial/');
return
$url;
});
//Handle
the
request
$application
=
new
PhalconMvcApplication($di);
echo
$application-­‐>handle()-­‐>getContent();
}
catch(Exception
$e)
{
echo
"PhalconException:
",
$e-­‐>getMessage();
}

44. Volt:
Template
Engine
Volt
is
an
ultra-­‐fast
and
designer
friendly
templating
language
written
in
C
for
PHP.
It
provides
you
a
set
of
helpers
to
write
views
in
an
easy
way.
Volt
is
highly
integrated
with
other
components
of
Phalcon,
just
as
you
can
use
it
as
a
stand-­‐alone
component
in
your
applications.

45. Volt:
Template
Engine

46. Volt:
Template
Engine
Volt
views
are
compiled
to
pure
PHP
code,
so
basically
they
save
the
effort
of
writing
PHP
code
manually:
{#
app/views/products/show.volt
#}{%
block
last_products
%}{%
for
product
in
products
%}
*
Name:
{{
product.name|e
}}
{%
if
product.status
==
"Active"
%}
Price:
{{
product.price
+
product.taxes/100
}}
{%
endif
%}{%
endfor
%}{%
endblock
%}

47. Phalcon
Query
Language
(PHQL)
Phalcon
Query
Language,
PhalconQL
or
simply
PHQL
is
a
high-­‐level,
object-­‐oriented
SQL
dialect
that
allows
to
write
queries
using
a
standardized
SQL-­‐like
language.
PHQL
is
implemented
as
a
parser
(written
in
C)
that
translates
syntax
in
that
of
the
target
RDBMS.

48. Phalcon
Query
Language
(PHQL)
In
PHQL,
we’ve
implemented
a
set
of
features
to
make
your
access
to
databases
more
secure:
•
Bound
parameters
are
part
of
the
PHQL
language
helping
you
to
secure
your
code
•
PHQL
only
allows
one
SQL
statement
to
be
executed
per
call
preventing
injections
•
PHQL
ignores
all
SQL
comments
which
are
often
used
in
SQL
injections
•
PHQL
only
allows
data
manipulation
statements,
avoiding
altering
or
dropping
tables/databases
by
mistake
or
externally
without
authorization
•
PHQL
implements
a
high-­‐level
abstraction
allowing
you
to
handle
tables
as
models
and
fields
as
class
attributes

49. Phalcon
Query
Language
(PHQL)
Creating
queries
using
the
Query
Builder
//Getting
the
first
row
$robots
=
$this-­‐>modelsManager-­‐>createBuilder()
-­‐>from(’Robots’)
-­‐>join(’RobotsParts’)
-­‐>orderBy(’Robots.name’)
-­‐>getQuery()
-­‐>getSingleResult();

50. Phalcon
Query
Language
(PHQL)
Creating
queries
using
the
Query
Builder
//
’SELECT
Robots.*
FROM
Robots’;
$builder-­‐>from(’Robots’);

51. Phalcon
Query
Language
(PHQL)
PHQL
Lifecycle
Being
a
high-­‐level
language,
PHQL
gives
developers
the
ability
to
personalize
and
customize
different
aspects
in
order
to
suit
their
needs.
The
following
is
the
life
cycle
of
each
PHQL
statement
executed:
• The
PHQL
is
parsed
and
converted
into
an
Intermediate
Representation
(IR)
which
is
independent
of
the
SQL
implemented
by
database
system
• The
IR
is
converted
to
valid
SQL
according
to
the
database
system
associated
to
the
model
• PHQL
statements
are
parsed
once
and
cached
in
memory.
Further
executions
of
the
same
statement
result
in
a
slightly
faster
execution

52. Phalcon
Developer
Tools

53. Phalcon
Developer
Tools
What
are
Devtools?
This
tools
provide
you
useful
scripts
to
generate
code
helping
to
develop
faster
and
easy
applications
that
use
with
Phalcon
framework.
Requirements
PHP
>=
5.3.9
Phalcon
>=
0.7.0

54. Phalcon
Developer
Tools
• Installing
via
Composer
• Installation
via
PEAR
• Installing
via
GIT

55. Phalcon
Developer
Tools
phalcon
commands
• commands
(alias
of:
list,
enumerate)
•
controller
(alias
of:
create-­‐controller)
•
model
(alias
of:
create-­‐model)
•
all-­‐models
(alias
of:
create-­‐all-­‐models)
•
project
(alias
of:
create-­‐project)
•
migration
•
scaffold
•
webtools
https://github.com/phalcon/phalcon-­‐devtools

56. Phalcon
Incubator
Extending
Phalcon:
https://github.com/phalcon/incubator

57. Thank you!
Email Social media
jacksonfdam@gmail.com
t
f
in
@jacksonfdam
@jacksonfdam
@jacksonfdam