Alloy HMVC PHP Framework

Alloy Framework
PHP 5.3+ Modular Hierarchical MVC
http://alloyframework.org

Wednesday, March 30, 2011

Who am I?
Vance Lucas
http://vancelucas.com
@vlucas
Business: http://actridge.com
PHP dev since 1999 (PHP 3)

I love good OOP code and concepts, but hate the
complexity it brings

Vance Lucas (@vlucas) http://alloyframework.org 2

A Few Points...
Kind of a disclaimer, but not really


You May NOT Like Alloy If...
You are an Object-Oriented Programming Purist
You don’t care how complex code is as long as it’s
“correct” OOP (because some guy’s book said so)
You LOVE using Zend Framework, Symfony, or FLOW3
You LOVE XML and Dependency Injection Containers
You are looking for a component library


You MIGHT Like Alloy If...
You think frameworks like Zend, Symfony, or FLOW3
make some things too difﬁcult and cumbersome
You don’t think any PHP framework has it quite right
You don’t like “too much magic”
You want to know what your framework is doing
You value ease of use over everything else
You want good OOP code that follows known coding
standards that is still easy to use and understand


Philosophy
Usefulness, Simplicity and Strong Design
Minimum code, maximum impact
Use OOP principles and design, but don’t over-do it
PHP is not Java with dollar signs
Explicitness > “Magic”
Easier to understand & see what is going on
Design patterns should never trump user experience or
get in the way
Users over “correctness”

Alloy Framework Goals
Lightweight
Modular Organization
Hierarchical MVC (HMVC)
Easy to understand and use
Easy to make REST APIs and HTML pages
No conﬁg/setup necessary, works anywhere
Follow PEAR/Zend Coding Standards
Strike a balance between good OOP concepts
and ease of use with low learning curve

Alloy Architecture
Inside & Out


Alloy Architecture Overview
Kernel
Plugins
Hierarchical MVC (HMVC)
Controllers as Resources
Events and Filters


All related ﬁles in a single
top-level named folder
No separate “controllers”,
“models” and “views”
directories at same level
Unlimited levels of nesting
Easier distributable
packages


Kernel

Core object available from anywhere in your app
Kernel() - only global-scope function in Alloy
Multiple uses:
Conﬁg access
Lazy-loading Factory / Service Locator
Extension Point for Modules and Plugins
Sole Dependency


Kernel - Conﬁg Access
Getter

Setter


Kernel - Lazy-Load Factory
Write This:

Not That:

Or This:


Kernel - Extension Point

Proxies to callbacks added at runtime via __call

Enables all kinds of custom functionality
Factory methods for loading & using 3rd party libs
Exposing plugin methods for global use
Helper or utility methods


Plugins
The primary way of extending Alloy


Plugin - Symfony2 Finder
File: app/Plugin/Finder/Plugin.php
Libs: app/Plugin/Finder/lib/Symfony/Component/ ...

Add ﬁnder method to Kernel for use


Plugin - Add to Conﬁg
File: app/conﬁg/app.php


Plugin - Usage
Use ﬁnder method on Kernel instance


Hierarchical MVC
Solves the “widget problem”


Hierarchical MVC
Multiple MVC dispatches to fulﬁll a single request
Solves the “widget problem”
Sidebar content can be self-contained module
Ads, tag clouds, blog headlines, etc.
Encourages module re-use & helps DRY
Not strictly “hierarchical” - more like nested
Hierarchy is not tracked or enforced in any way


Controllers
Respond to both internal and external requests


Controllers
Part of the Module package that handles requests
Special name “scope” for web-accessible actions
GET = <action>Action
POST, PUT, DELETE, etc = <action>Method
Ensures HTTP methods are required for access
AlloyRequest object is ﬁrst parameter
All named params from route set on Request object


Controllers (cont’d)
NOTHING is automatically or implicitly loaded
No views, models, or anything else
Explicitly return response or content to send
Controllers are not factories
Controllers are extremely lightweight
Controllers do not hold the context of their requests


Example REST Controller
Notice <name>Action vs <name>Method


Controller Response Types
Sending output and manipulating control ﬂow


Simple Strings
Sends 200 OK status with string content as body


Any object with __toString
Sends 200 OK status with string content as body


View Templates
Most common Module response type
Returns object - template not yet rendered


Resource Objects
Auto-converts array to JSON or XML for API response
Accepts objects with toArray methods


Generic Response
Body + HTTP Status
Base AlloyModuleResponse that view templates and
resources extend from
Can set custom layout, errors, headers, etc. using a
ﬂuent interface just like templates and resources


Boolean False
Generic 404 (Throws AlloyExceptionFileNotFound)
Plugins can ﬁlter on ‘dispatch_exception’ event to
produce a custom global response


Why Explicit Returns?
Easier to manipulate responses and control ﬂow


Easier to re-use Actions
Re-use form template from ‘newAction’
No forwarding or other indirection necessary
Object return lets you modify it further before display
through ﬂuent interface


Modify Dispatches at Will
Template object returned is not yet rendered so we
can modify it at will
Change path to a local template
Change layout
Add errors
Change response code or headers, etc.
Very ﬂexible


... Even pull out values
Since the template is not yet rendered, we can even
pull out values that have been set and re-use them
however we want to
We don’t even have to render the dispatch result at all
No wasted resources


URL Routing
Simple named parameters, full control


Parameter Types
<:alpha>
Matches [a-zA-Z0-9_-+%s]+
<#numeric>
Matches [0-9]+
<*wildcard>
Marches .*

Does NOT split the URL by “segment”


Some Default Routes
Fluent interface allows route modiﬁcation
REST verb params will override defaults and matches
POST /module/add => Module::postMethod


Custom Routes
Can be literally anything
URL does not have to map <controller>/<action>

Example from Autoridge.com
/<#year>/<:make>/<:model>


Static Routes
Map arbitrary static path to Module::action
No PREG matching overhead
Path can include slashes and be as long as necessary
Router does not split URL into segments


Making an App
HTML + JSON API, single Controller method


app/Module/Blog/Post.php

Using Spot ORM (Ships with Alloy, but NOT required)
Spot provided with a plugin, not tied to Alloy in any way


Blog Example
app/Module/Blog/Controller.php


app/Module/Blog/views/index.html.php


http://localhost/path/blog


Magic Datagrid?
Alloy has View Generics
Extensions of view templates
Generic HTML template markup with custom
functions that accept Closures to enable fully
custom PHP markup in designated areas (like table
cells) with no special syntax or recursive includes
You don’t have to use them, but they can be huge
time-savers if you do


Adding an API
Template for HTML, Resource object for API


http://localhost/path/blog/index.json

Array -> JSON via Resource response type


API Errors?


HTML

JSON


Layouts & Blocks
Make your App Look Nice


Layouts
Really just another view template with a special location
Includes both header & footer, content placed inside


Blocks
Named regions that content can be pushed to from
any view template in your app
Static to current request so no data has to be passed


app/layouts/app.html.php


app/Module/Blog/views/viewAction.html.php

Post tag list in layout sidebar


app/Module/Blog/views/viewAction.html.php

HMVC dispatches as “widgetized” content
Promotes better code re-use, DRY principle, allows
polymorphic associations for generic types of content

Events & Filters
Dynamic Behavior & Manipulating Responses


Layout Plugin
Layout wrapping is achieved with a plugin in Alloy
Filters ‘dispatch_content’ event


Main Dispatch Content Filter

Many other events and ﬁlters not shown in this diagram

Layout Plugin - wrapLayout
Returns template wrapped in template


Thanks!
Alloy on the web:
http://alloyframework.org
http://github.com/alloyphp

Vance Lucas
Personal: http://vancelucas.com
Business: http://actridge.com


Alloy HMVC PHP Framework

Recommandé

Recommandé

Contenu connexe

Similaire à Alloy HMVC PHP Framework

Similaire à Alloy HMVC PHP Framework (20)

Plus de Vance Lucas

Plus de Vance Lucas (7)

Dernier

Dernier (20)

Alloy HMVC PHP Framework

Notes de l'éditeur