Smart reference use cases

• Caching slow method execution
• Logging
• Event triggering
• Mocking
• AOP in general

Smart reference example

Let's cache a complex/slow method call

    /** @AOP\Cache(ttl=3600) */
    public function doHeavyStuff() {
        // [...]
    }

Could become:

class APICachingProxy extends API {
    public function __construct(API $api, Cache $cache) {
        $this->api = $api; $this->cache = $cache;
    }

    public function doHeavyStuff() {
        if ($cached = $this->cache->get('doHeavyStuff')) {
            return $cached;
        }

        $result = $this->api->doHeavyStuff();

        $this->cache->set('doHeavyStuff', $result, 3600);

        return $result;
    }
}

Implementing a Proxy in PHP

Poor coder's proxy implementation:

class MyProxy {
    // ...

    public function __call($method, $args) {
        return call_user_func_array(
            $this->someWrappedStuff,
            $args
        );
    }
}

class BankAccount { /* ... */ }

function pay(BankAccount $account) { /* ... */ }

class PoorProxy {
    public function __construct($wrapped) {
        $this->wrapped = $wrapped;
    }

    public function __call($method, $args) {
        return call_user_func_array(
            $this->wrapped,
            $args
        );
    }
}

$account = new PoorProxy(new BankAccount());

pay($account); // KABOOM!

Implementing a
(generic) Proxy

1. MUST respect the LSP!

2. Not so trivial!

PHP is a maze!

• magic getters
• magic setters
• serialization
• cloning
• public properties

A lot of stuff to consider!

Proxies are NOT nice:

<?php
namespace Proxy\__PM__;

class A extends \A
{
    private $valueHolder;
    private $initializer;

    public function getFoo()
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, 'getFoo', array(), $this->initializer);

        return $this->valueHolder->getFoo();
    }

    public function __construct($initializer)
    {
        unset($this->foo);

        $this->initializer = $initializer;
    }

    public function __get($name)
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__get', array('name' => $name), $this->initializer);

        return $this->valueHolder->$name;
    }

    public function __set($name, $value)
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__set', array('name' => $name, 'value' => $value), $this->initializer);

        $this->valueHolder->$name = $value;
    }

    public function __isset($name)
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__isset', array('name' => $name), $this->initializer);

        return isset($this->valueHolder->$name);
    }

    public function __unset($name)
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__unset', array('name' => $name), $this->initializer);

        unset($this->valueHolder->$name);
    }

    public function __clone()
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__clone', array(), $this->initializer);

        $this->valueHolder = clone $this->valueHolder;
    }

    public function __sleep()
    {
        $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__sleep', array(), $this->initializer);

        return array('valueHolder');
    }

    public function __wakeup()
    {
        unset($this->foo);
    }

    public function setProxyInitializer(\Closure $initializer = null)
    {
        $this->initializer = $initializer;
    }

    public function getProxyInitializer()
    {
        return $this->initializer;
    }

    public function initializeProxy()
    {
        return $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, 'initializeProxy', array(), $this->initializer);
    }

    public function isProxyInitialized()
    {
        return null !== $this->valueHolder;
    }

    public function getWrappedValueHolderValue()
        {
        return $this->valueHolder;
    }
}

Introducing ProxyManager

https://github.com/Ocramius/ProxyManager

Avoid bringing out the generated garbage yourself!

(Currently) deals with Virtual Proxies, Smart References, Null Objects, Ghost Objects and Remote Objects

Virtual Proxy with ProxyManager

namespace My\Slow;

class Foo
{
    public function __construct()
    {
        sleep(10);
    }

    public function doFoo()
    {
        echo 'foo!';
    }
}

require_once 'vendor/autoload.php';
use ProxyManager\Factory\LazyLoadingValueHolderFactory;

$factory = new LazyLoadingValueHolderFactory();

$proxy = $factory->createProxy(
    'My\Slow\Foo',
    function (& $wrappedObject, $proxy) {
        $wrappedObject = new My\Slow\Object();

        $proxy->setProxyInitializer(null);
    }
);

$proxy->doFoo();

Smart Reference with ProxyManager

require_once 'vendor/autoload.php';
use ProxyManager\Factory\AccessInterceptorValueHolderFactory;

$factory = new AccessInterceptorValueHolderFactory();
$db = $factory->createProxy(
    new \My\Db\Connection(),
    ['query' => function () {
        echo "Query being executed!\n";
    }],
    ['query' => function () {
        echo "Query completed!\n";
    }]
);

$db->query();

Yes, I'm no good at naming classes - really.

Integrates with
Symfony2
and
Zend Framework 2

Virtual (Service) Proxies + Zend Framework 2

return [
    'service_manager' => [
        'delegators' => [
            'MyServiceName' => ['LazyServiceFactory']
        ],
    ],
    'lazy_services' => [
        'map' => ['MyServiceName' => 'My\Service\ClassName']
    ]
]

Virtual (Service) Proxies + Symfony 2

<services>
    <service
        id="MyServiceName"
        class="My\Service\ClassName"
        lazy="true"
    />
</services>

Some useful libraries

Doctrine's Proxy Generator

ProxyManager

Flow (Typo3)

schmittjoh/cg-library

Proxies and AOP

lisachenko/go-aop-php

Uses proxies for AOP purposes

Very interesting usage of autoloaders!

And before we get to the dirty stuff...

Questions?

Ocramius/proxy-pattern-in-php

Ocramius

Proxying Fluent Interfaces

Breaks Virtual Proxies, Protection Proxies, and Smart References

More important:

Possible broken Encapsulation!

class BankAccount {
    protected $amount = 0;

    public function pay($amount) {
        $this->amount -= $amount;

        return $this;
    }
}

$account = new BankAccount();

$account->pay(100)->pay(200)->pay(300);

Caution!

Dirty hacks!

class BankAccountProxy extends BankAccount {
    public function __construct(BankAccount $wrapped) {
        $this->amount = & $wrapped->amount;
    }

    public function pay($amount) {
        echo 'Paid ' . $amount . "!\n";

        return parent::pay($amount);
    }
}

$account = new BankAccountProxy(new BankAccount());

$account->pay(100)->pay(200)->pay(300);

Paid 100
Paid 200
Paid 300

Public properties proxying

(without property accessors!)

class Customer {
    public $name;
    public $surname;
}

Caution!

Dirty hacks!

class Customer {
    public $name;
    public $surname;
}

class CustomerProxy extends Customer {
    public function __construct(Customer $customer) {
        unset($this->name, $this->surname);
        $this->customer = $customer;
    }

    public function __set($name, $value) {
        $this->customer->$name = $value;
    }

    public function __get($name) {
        return $this->customer->$name;
    }

    // __isset, __unset
}

Don't do this at home!

Thank you!

Ocramius/proxy-pattern-in-php