Proxy Pattern in PHP Explained

MARCO PIVETTA
Doctrine core team
Zf2 contributor
Wasting time on:
OcraDiCompiler
OcraServiceManager
OcraCachedViewResolver
Doctrine ZF2 Modules
ZeffMu
AssetManager
KJSencha
Follow @Ocramius
Follow @Ocramius

WHAT IS A PROXY?
A proxy is generally an object whose
interface is a layer between us and a
different object with the same
interface.

Simplified, in PHP

Even if we're not implementing an
interface, the interface of
C s o e P o yis the same as the
utmrrx
one of C s o e
utmr

WHERE TO USE PROXIES?
As of the LSP , a proxy can be used in
any place where the "proxied" object
can be used.

WHEN TO USE A PROXY?
Lazy loading
Remote objects
Smart reference/Weak reference
Protection
AOP
Null object fallback

LAZY LOADING
We may want to use lazy loading to
avoid IO operations or heavy loading
operation until really needed

LAZY LOADING PATTERNS
1. Virtual Object
2. Value Holder
3. Ghost Object

VIRTUAL OBJECT
An object whose properties are all set
to n l , and where each access to the
ul
properties is tracked.
Access triggers lazy loading on the
property.

VALUE HOLDER
An object that can hold an instance of
the original proxied object, and loads it
only when needed.

GHOST OBJECT
An object whose properties are the
same of the proxied object, but n l .
ul
Accessing any method causes loading of
the properties.
Doctrine Proxies are generated this
way.

VALUE HOLDER EXAMPLE
(1/3)
casIae{
ls mg
pbi fnto _cntut$ah {
ulc ucin _osrc(pt)
$hs>mg =iaeraermpg$
ti-iae mgcetfoje(p
ah;
t)
}

pbi fnto gtie){
ulc ucin eSz(
rtr aryiaex$hs>mg) i
eun ra(mgs(ti-iae,
mgs(ti-iae)
aey$hs>mg);
}
}

(2/3)
casIaerx etnsIae{
ls mgPoy xed mg
poetd$mg;
rtce iae
pbi fnto _cntut$ah {
ulc ucin _osrc(pt)
$hs>ah=$ah
ti-pt pt;
}

piaefnto ii( {
rvt ucin nt)
i (!$hs>mg){
f ti-iae
$hs>mg =nwIae$hs>
ti-iae e mg(ti-
pt)
ah;
}
}

pbi fnto gtie){
ulc ucin eSz(
$hs>nt)
ti-ii(;
rtr $hs>mg-gtie)
eun ti-iae>eSz(;
}
}

(3/3)
$m1=nwIaerx(/aht/mg1jg)
ig e mgPoy'pt/oiae.p'
;
vrdm(eoygtuae);/ ~0K
a_upmmr_e_sg() / 20b
;
;

$ie =$m1>eSz(;
sz1 ig-gtie)
vrdm(eoygtuae);/ ~M
a_upmmr_e_sg() / 4b
$ie =$m2>eSz(;
sz2 ig-gtie)
vrdm(eoygtuae);/ ~M
a_upmmr_e_sg() / 8b

LAZY LOADING PROS/CONS
Advantages
Low memory impact
Low overhead
Easy to implement
Useful to determine object "dirty"
status
Dis-advantages
Not optimal for data that is always
loaded
Lazy loading means lazy failing

REMOTE OBJECT
It basically is a specific form of lazy
loading

REMOTE OBJECT EXAMPLE
(1/3)
casTet{
ls we
poetd$aa
rtce dt;

pbi fnto _cntutary$aa
ulc ucin _osrc(ra dt)
{
$hs>aa=$aa
ti-dt dt;
}

pbi fnto gtet){
ulc ucin eTx(
rtr $hs>aa'et]
eun ti-dt[tx';
}
}

(2/3)
casTetrx etnsTet{
ls wePoy xed we
poetd$p;poetd$we;poe
rtce ai rtce tet rtc
td$d
e i;

pbi fnto _cntutTitrp $
ulc ucin _osrc(wteAi
ai $d {
p, i)
$hs>p =$p;$hs>d=$d
ti-ai ai ti-i i;
}
piaefnto ii( {
rvt ucin nt)
i (!$hs>we){
f ti-tet
$hs>we =nwTet$hs>
ti-tet e we(ti-
ai>e(ti-i);
p-gt$hs>d)
}
}
pbi fnto gtet){
ulc ucin eTx(
$hs>nt)
ti-ii(;
rtr $hs>we-gtet)
eun ti-tet>eTx(;
}
}

(3/3)
$we =nwTetary'et = 'rxe i
tet e we(ra(tx' > Pois
nPP')
H!);
vrdm(tet>eTx() / 'rxe i P
a_up$we-gtet); / Pois n
H!
P'

$p =nwTitrp(*yda*) / z,b
ai e wteAi/ ad /; / f u
z,ec
z t

$eoewe =nwTetrx(ai 20478
rmtTet e wePoy$p, 8630
98850;
6366)
vrdm(rmtTet>eTx() / 'we
a_up$eoewe-gtet); / Tet
tx!
et'
$eoewe =nwTetrx(ai 20478
rmtTet e wePoy$p, 8630
98851;
6366)
vrdm(rmtTet>eTx() / 'nte
a_up$eoewe-gtet); / Aoh
rtx!
et'

REMOTE OBJECT PROS/CONS
Advantages
Abstraction of a remote object
You can re-define the proxied
object's API locally
Dis-advantages
To use such a proxy, you almost
always need a configured remote
client
Remote objects fail very easily

SMART REFERENCE
Smart reference can be used to:
swap the proxied object at runtime
reference singletons or use internal
static registries
Optimize memory usage

SMART REFERENCE WITH
WEAKREF
Using Weakref to save memory on
long-running processes
casIaerx etnsIae{
ls mgPoy xed mg
/ [.](e peiu eape
/ .. se rvos xml)
piaefnto ii( {
rvt ucin nt)
i (!$hs>mgRf| !$hs>m
f ti-iaee | ti-i
aee-vld) {
gRf>ai()
$hs>mgRf=nwWaRfnw
ti-iaee e eke(e
Iae$hs>ah)
mg(ti-pt);
}

rtr $hs>mgRf>e(;
eun ti-iaee-gt)
}

pbi fnto gtie){
ulc ucin eSz(
rtr $hs>nt)>eSz(;
eun ti-ii(-gtie)
}
}

SMART REFERENCE WITH A
REGISTRY
casIaerx etnsIae{
ls mgPoy xed mg
/ [.](e peiu eape
/ .. se rvos xml)
piaefnto ii( {
rvt ucin nt)
i (ul==$hs>mg){
f nl = ti-iae
$hs>mg =Iaeeity:e
ti-iae mgRgsr:gt
(ti-pt)
$hs>ah;
}
}

pbi fnto gtie){
ulc ucin eSz(
$hs>nt)
ti-ii(;
rtr $hs>mg-gtie)
eun ti-iae>eSz(;
}
}

SMART REFERENCE
PROS/CONS
Mainly memory usage, but it depends
on how you setup your "smart"
reference

PROTECTION PROXY
Protection proxy comes into play when
you want to transparently limit access
to an API through a set of rules
(ACL/limits)

PROTECTION PROXY (1/2)
casRmtAirx etnsRmtAi{
ls eoepPoy xed eoep
poetd$on =0
rtce cut ;
pbi fnto _cntutRmtAi$
ulc ucin _osrc(eoep a
p,$ii){
i lmt
$hs>p =$p;$hs>ii =$
ti-ai ai ti-lmt l
ii;
mt
}

piaefnto cut){
rvt ucin on(
i (+ti-cut>$hs>ii){
f +$hs>on ti-lmt
trwnwRmtAiii(SAP
ho e eoepLmt'TH!
';
)
}
}

pbi fnto dSuf){
ulc ucin otf(
$hs>on(;
ti-cut)
rtr $hs>p-dSuf)
eun ti-ai>otf(;
}
}

PROTECTION PROXY (2/2)
$p =nwRmtAirx(e RmtAi/ .
ai e eoepPoynw eoep(* .
.*) 5)
/, 0;

wie(){
hl 1
$p-dSuf) / RmtAiii ecp
ai>otf(; / eoepLmt xet
in
o!
}

PROTECTION PROXY
PROS/CONS
Advantages
Transparent filtering or limiting of
access to an object
Dis-advantages
Modifies proxied object behavior!
More like a decorator!

NULL OBJECT FALLBACK
PROXY
A null object is an object that
implements an interface, but produces
no side effects. It replaces n l .
ul
Using null objects allows us to work
with the assumption that an object will
always be available, reducing checks
against n l by a lot.
ul

PROXY EXAMPLE
casCsoePoyetnsCsoe {
ls utmrrx xed utmr
pbi fnto _cntutD $b $d
ulc ucin _osrc(b d, i)
{
$hs>utmr=$b>id$d;
ti-csoe d-fn(i)

i (!$hs>utmr {
f ti-csoe)
$hs>utmr=nwNlCsoe
ti-csoe e ulutm
r)
(;
}
}

pbi fnto dSuf){
ulc ucin otf(
rtr $hs>utmr>otf(;
eun ti-csoe-dSuf)
}
}

PROXY PROS
Performance (with small # of
instances)
Reduced NPaths, therefore code is
easier to test

AOP AND PROXIES
Proxies basically enable us to have logic
between us and any object, making
AOP easy even when the language
doesn't allow it.
We can use code generation to create
on-the-fly proxies with our custom AOP
logic executed pre- and post- any
method of the proxied object.

AOP EXAMPLES
/*
*
*@Oah(t=60
APCcetl30)
*/
pbi fnto dHaytf( {
ulc ucin oevSuf)
/ [.]
/ ..
}

Becomes:
pbi fnto dHaytf( {
ulc ucin oevSuf)
i(cce =$hs>ah-gt'oevS
f$ahd ti-cce>e(dHayt
uf,fn_e_rs)){
f' ucgtag()
rtr $ahd
eun cce;
}

$eun=$hs>rgnlbet>oevS
rtr ti-oiiaOjc-dHay
tf(;
uf)
$hs>ah-st$eun 'oevSuf
ti-cce>e(rtr, dHaytf'
,fn_e_rs);
ucgtag()

rtr $eun
eun rtr;
}

IMPLEMENTATION DETAILS IN
PHP

IMPLEMENTING THE PUBLIC
API
1. The Proxy class MUST extend the
proxied class
2. Each of the proxied methods must be
rewritten
3. Proxies should be serializable
4. Proxies should handle public
properties

PUBLIC PROPERTIES
PROXYING
casCsoe {
ls utmr
pbi $ae
ulc nm;
pbi $unm;
ulc srae
}

casCsoePoyetnsCsoe {
ls utmrrx xed utmr
pbi fnto _cntutCsoe $u
ulc ucin _osrc(utmr cs
tmr {
oe)
ust$hs>ae $hs>unm)
ne(ti-nm, ti-srae;
$hs>utmr=$utmr
ti-csoe csoe;
}

pbi fnto _st$ae $au){
ulc ucin _e(nm, vle
$hs>utmr>nm =$au;
ti-csoe-$ae vle
}
pbi fnto _gt$ae {
ulc ucin _e(nm)
rtr $hs>utmr>nm;
eun ti-csoe-$ae
}
/ _ist _ust
/ _se, _ne
}

A COMPLETE GHOST OBJECT
IMPLEMENTATION
https://gist.github.com/4038004

SOME USEFUL LIBRARIES
http://flow.typo3.org
https://github.com/schmittjoh/cg-
library
https://github.com/doctrine/common
https://github.com/lisachenko/go-
aop-php

CODE GENERATION
See Doctrine's Proxy Generator

Proxy Pattern in PHP Explained

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Proxy Pattern in PHP Explained

Similaire à Proxy Pattern in PHP Explained (20)

Dernier

Dernier (20)

Proxy Pattern in PHP Explained