View
176
Download
0
Category
Tags:
Preview:
DESCRIPTION
Php Conference Brazil - Phalcon Giant Killer
Citation preview
Jacksonfdam
http://about.me/jacksonfdam
https://bitbucket.org/jacksonfdam
https://github.com/jacksonfdam
http://linkedin.com/in/jacksonfdam
@jacksonfdam
A thanks to
Encourage and believe in the passage of knowledge. (And to release me from work to be here.) ”
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
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
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?
How PHP works?
How traditional php frameworks works?
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
How a PHP C extension works?
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.
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
What is Phalcon?
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
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.
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).
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!
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…
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.
Framework Benchmark
Framework Benchmark
Framework Benchmark
<h1>Hello!</h1>
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
Framework Benchmark
ab -‐n 1000 -‐c 5 http://localhost/bench/phalcon
Framework/Requests per Second
Framework Total Requests/Average Time
Number of Interpreted Files per Request
Allocated Memory per Request
Installation
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.
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)
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
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.
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.
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/
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>
Bootstrap <?php try { //Register an autoloader $loader = new \Phalcon\Loader(); $loader-‐>registerDirs(array( '../app/controllers/', '../app/models/' ))-‐>register(); //Create a DI $di = new Phalcon\DI\FactoryDefault();
//Setup the view component $di-‐>set('view', function(){ $view = new \Phalcon\Mvc\View(); $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 \Phalcon\Mvc\Url(); $url-‐>setBaseUri('/lab01//'); return $url; });
//Handle the request $application = new \Phalcon\Mvc\Application($di); echo $application-‐>handle()-‐>getContent(); } catch(\Phalcon\Exception $e) { echo "PhalconException: ", $e-‐>getMessage(); }
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 \Phalcon\Mvc\Controller { public function indexAction() { echo "<h1>Hello!</h1>"; } }
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
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 \Phalcon\Mvc\Controller { public function indexAction() { } }
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`) );
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 \Phalcon\Mvc\Model { }
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:
Setting a Database Connection <?php try { //Register an autoloader $loader = new \Phalcon\Loader(); $loader-‐>registerDirs(array( '../app/controllers/', '../app/models/' ))-‐>register(); //Create a DI $di = new Phalcon\DI\FactoryDefault(); /
/Setup the database service $di-‐>set('db', function(){ return new \Phalcon\Db\Adapter\Pdo\Mysql(array( "host" => "localhost", "username" => "root", "password" => "secret", "dbname" => "test_db" )); }); //Setup the view component $di-‐>set('view', function(){ $view = new \Phalcon\Mvc\View(); $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 \Phalcon\Mvc\Url(); $url-‐>setBaseUri('/tutorial/'); return $url; }); //Handle the request $application = new \Phalcon\Mvc\Application($di); echo $application-‐>handle()-‐>getContent(); } catch(Exception $e) { echo "PhalconException: ", $e-‐>getMessage(); }
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.
Volt: Template Engine
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 %}
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.
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
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();
Phalcon Query Language (PHQL)
Creating queries using the Query Builder // ’SELECT Robots.* FROM Robots’; $builder-‐>from(’Robots’);
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
Phalcon Developer Tools
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
Phalcon Developer Tools
• Installing via Composer • Installation via PEAR • Installing via GIT
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
Phalcon Incubator
Extending Phalcon: https://github.com/phalcon/incubator
Thank you!
jacksonfdam@gmail.com t
f
in
Email Social media
@jacksonfdam
@jacksonfdam
@jacksonfdam
Recommended