72 | Hello! 73 |
74 |
77 | 
78 | Marco Pivetta
79 |
80 |
83 |
84 | Ocramius
85 |
86 | 
89 |
90 |
91 | 
118 | 119 |
120 |(And we love <marquee/>)
121 |Awesome:
124 |
125 |
128 | 
134 | octrine team
135 |
136 |
139 | 
145 | contributor
146 |
147 |
150 | 
156 | 
162 | Ocramius
163 |
164 | Current projects
169 |170 | ProxyManager, 171 | BjyAuthorize, 172 | AssetManager, 173 | ZeffMu, 174 | ZfrRest, 175 | OcraDiCompiler, 176 | OcraServiceManager, 177 | OcraCachedViewResolver, 178 | DoctrineModule, 179 | DoctrineORMModule, 180 | DoctrineMongoODMModule, 181 | VersionEyeModule 182 |
183 |WHY?
187 |
190 |
194 | The Proxy Pattern
195 |
196 | in PHP
197 |
198 | What is a Proxy?
202 |205 | A proxy 206 | is a class functioning as an interface to 207 | something else 208 |
209 | 210 |(carefully pasted from wikipedia)
211 |Simple put
214 |
217 | 
220 | 
223 | A Proxy implements a Subject's interface
228 |231 | A proxy replaces 232 | subject thanks to the 233 | 234 | LSP 235 | 236 |
237 |
245 | Client consumes SubjectInterface
248 |
256 | Client consumes RealSubject
259 |
267 | Client consumes SubjectProxy
270 |
278 | Simplified:
282 |283 | SubjectProxy extending RealSubject 284 |
285 |class SubjectProxy extends RealSubject { /* ... */ }
290 | 
295 |
Though you should use interfaces!
298 |
305 | What do Proxies do?
309 |Some definitions here:
313 |
314 | And here:
318 |
322 | And a lot of confusion over the internets :(
326 |From the GoF
330 |334 | Remote proxy 335 |
336 |337 | Virtual proxy 338 |
339 |340 | Protection proxy 341 |
342 |343 | Smart reference 344 |
345 |I'm a software architect
349 |
354 | Let's get practical!
358 |Remote Proxy
362 |
370 | 
378 | Remote Object example
382 |class Tweet {
386 | protected $data;
387 |
388 | public function __construct(array $data) {
389 | $this->data = $data;
390 | }
391 |
392 | public function getText() {
393 | return $this->data['text'];
394 | }
395 | }class TweetProxy extends Tweet {
400 | protected $api;
401 | protected $id;
402 |
403 | public function __construct(TwitterApi $api, $id) {
404 | $this->api = $api;
405 | $this->id = $id;
406 | }
407 |
408 | public function getText() {
409 | return $this->api->getTweetText($this->id);
410 | }
411 | }$tweet = new Tweet(array('text' => 'Proxies in PHP!'));
416 | var_dump($tweet->getText()); // Proxies in PHP!
417 |
418 | $api = new TwitterApi(/* yadda */);
419 |
420 | $remoteTweet = new TweetProxy($api, 280643708968386560);
421 | var_dump($remoteTweet->getText()); // Tweet text!
422 |
423 | $remoteTweet = new TweetProxy($api, 280643708968386561);
424 | var_dump($remoteTweet->getText()); // Another text!remote object pros/cons
429 |Share objects across multiple systems
430 |No local memory usage
431 |Can act as an adapter for a completely different remote object
432 |Complex setup
433 |Fails on adapter failure
434 |As slow as the protocol
435 |Lazy Loading
439 | 440 |
441 | For very expensive objects:
445 |-
446 |
- DB Connections 447 |
- Files (I/O in general) 448 |
- Large objects (memory) 449 |
- Objects with long instantiation time (hashes/parsed values/etc) 450 |
(A pattern, not a proxy type)
452 |Lazy Loading example
455 |class Customer {
458 | public function __construct(DbConnection $db, $id) {
459 | $this->db = $db;
460 | $this->id = $id;
461 | }
462 |
463 | public function getName() {
464 | $this->init();
465 | return $this->data['name'];
466 | }
467 |
468 | private function init() {
469 | if (!isset($this->data)) {
470 | $this->data = $this->db->load($this->id);
471 | }
472 | }
473 | }Problems with Lazy Loading
478 | 479 |Instantiation logic mixed with class logic
480 |Dependency to loader objects in the object
481 |Not really optimized, and unreadable if optimized
482 |Harder to test
483 |Lazy loading via Proxies
486 | 487 |
488 | Virtual Proxy
489 |
490 | An object that looks like the RealSubject, but just holds a lazy reference to it.
491 |
493 | Ghost Object
494 |
495 | An object that looks like the RealSubject, but with all properties not being
496 | set and being lazy loaded.
497 |
Virtual Proxy
510 |class Image {
514 | protected $image;
515 | public function __construct($path) {
516 | $this->image = imagecreatefromjpeg($path);
517 | }
518 |
519 | public function getSize() {
520 | return array(
521 | imagesx($this->image),
522 | imagesy($this->image),
523 | );
524 | }
525 | }class ImageVirtualProxy extends Image {
530 | protected $wrapped;
531 | public function __construct($path) {
532 | $this->path = $path;
533 | }
534 |
535 | public function getSize() {
536 | $this->init();
537 | return $this->wrapped->getSize();
538 | }
539 |
540 | private function init() {
541 | if ( ! $this->wrapped) {
542 | $this->wrapped = new Image($this->path);
543 | }
544 | }
545 | }$img1 = new ImageProxy('/path/to/image1.jpg');
550 | var_dump(memory_get_usage()); // ~200Kb
551 | $img2 = new ImageProxy('/path/to/image2.jpg');
552 | var_dump(memory_get_usage()); // ~200Kb
553 | $img3 = new ImageProxy('/path/to/image3.jpg');
554 | var_dump(memory_get_usage()); // ~200Kb
555 |
556 | $size1 = $img1->getSize();
557 | var_dump(memory_get_usage()); // ~4Mb
558 | $size2 = $img2->getSize();
559 | var_dump(memory_get_usage()); // ~8MbVirtual Proxy pros/cons
564 |Abstracts initialization logic away
565 |Improved memory/performance impact
566 |Low overhead
567 |Easy to implement
568 |Not optimal for data that is always loaded
569 |Lazy loading means lazy failing
570 |Actually, not the same object as RealSubject (different identity)
571 |Ghost Object
575 |
576 | An object whose properties are the same of the proxied object, but null.
577 |
579 | Accessing any method causes loading of the properties. 580 |
581 |Useful when the identity of the object has to be preserved
582 |583 | Doctrine Proxies 584 | are generated this way. 585 |
586 |Ghost Object (simplified) example
590 |class ImageGhostProxy extends Image {
593 | protected $initialized = false;
594 | public function __construct($path) {
595 | $this->path = $path;
596 | }
597 | public function getSize() {
598 | $this->init();
599 | return parent::getSize();
600 | }
601 | private function init() {
602 | if ( ! $this->initialized) {
603 | $image = new Image($this->path);
604 | $this->image = $image->image;
605 | $this->initialized = true;
606 | }
607 | }
608 | }Ghost Object pros/cons
613 |Same identity as RealSubject
614 |Abstracts initialization logic away
615 |Improved memory/performance impact
616 |Low overhead
617 |Harder to implement
618 |May require reflection to access parent class's properties
619 |Not optimal for data that is always loaded
620 |Lazy loading means lazy failing
621 |Protection proxy
628 |629 | A Protection Proxy comes into play when you want to transparently 630 | limit access to an API through a set of rules (ACL/limits/custom logic). 631 |
632 |It actually is a decorator to the proxied RealSubject.
633 |class APIProtectionProxy extends API {
637 | protected $count = 0;
638 | public function __construct(API $api, $limit) {
639 | $this->api = $api; $this->limit = $limit;
640 | }
641 |
642 | public function doStuff() {
643 | $this->count();
644 | return $this->api->doStuff();
645 | }
646 |
647 | private function count() {
648 | if (++$this->count > $this->limit) {
649 | throw new RemoteApiLimit('STAHP!');
650 | }
651 | }
652 | }$api = new APIProtectionProxy(new API(/* ... */), 50);
657 |
658 | while (true) {
659 | $api->doStuff(); // RemoteApiLimit exception!
660 | }Protection Proxy pros/cons
665 |Limiting access to an API does not require changes in the API
666 |Modifies proxied object behavior
667 |Smart reference
671 |672 | A Smart reference executes additional operations when the 673 | RealSubject is accessed 674 |
675 |676 | Smart reference is actually DecoratorPattern 677 |
678 |Good for AOP
679 |Smart reference use cases
682 |-
683 |
- Caching slow method execution 684 |
- Logging 685 |
- Event triggering 686 |
- Mocking 687 |
- AOP in general 688 |
Smart reference example
693 |Let's cache a complex/slow method call
694 | /** @AOP\Cache(ttl=3600) */
698 | public function doHeavyStuff() {
699 | // [...]
700 | }Could become:
702 |class APICachingProxy extends API {
703 | public function __construct(API $api, Cache $cache) {
704 | $this->api = $api; $this->cache = $cache;
705 | }
706 |
707 | public function doHeavyStuff() {
708 | if ($cached = $this->cache->get('doHeavyStuff')) {
709 | return $cached;
710 | }
711 |
712 | $result = $this->api->doHeavyStuff();
713 |
714 | $this->cache->set('doHeavyStuff', $result, 3600);
715 |
716 | return $result;
717 | }
718 | }Implementing a Proxy in PHP
723 |Poor coder's proxy implementation:
727 |class MyProxy {
728 | // ...
729 |
730 | public function __call($method, $args) {
731 | return call_user_func_array(
732 | $this->someWrappedStuff,
733 | $args
734 | );
735 | }
736 | }
741 | class BankAccount { /* ... */ }function pay(BankAccount $account) { /* ... */ }class PoorProxy {
747 | public function __construct($wrapped) {
748 | $this->wrapped = $wrapped;
749 | }
750 |
751 | public function __call($method, $args) {
752 | return call_user_func_array(
753 | $this->wrapped,
754 | $args
755 | );
756 | }
757 | }$account = new PoorProxy(new BankAccount());
759 |
760 | pay($account); // KABOOM!Implementing a
(generic) Proxy
765 | 1. MUST respect the LSP!
769 |2. Not so trivial!
773 |PHP is a maze!
777 | 778 |-
779 |
- magic getters 780 |
- magic setters 781 |
- serialization 782 |
- cloning 783 |
- public properties 784 |
A lot of stuff to consider!
789 |Proxies are NOT nice:
793 |<?php
794 | namespace Proxy\__PM__;
795 |
796 | class A extends \A
797 | {
798 | private $valueHolder;
799 | private $initializer;
800 |
801 | public function getFoo()
802 | {
803 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, 'getFoo', array(), $this->initializer);
804 |
805 | return $this->valueHolder->getFoo();
806 | }
807 |
808 | public function __construct($initializer)
809 | {
810 | unset($this->foo);
811 |
812 | $this->initializer = $initializer;
813 | }
814 |
815 | public function __get($name)
816 | {
817 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__get', array('name' => $name), $this->initializer);
818 |
819 | return $this->valueHolder->$name;
820 | }
821 |
822 | public function __set($name, $value)
823 | {
824 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__set', array('name' => $name, 'value' => $value), $this->initializer);
825 |
826 | $this->valueHolder->$name = $value;
827 | }
828 |
829 | public function __isset($name)
830 | {
831 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__isset', array('name' => $name), $this->initializer);
832 |
833 | return isset($this->valueHolder->$name);
834 | }
835 |
836 | public function __unset($name)
837 | {
838 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__unset', array('name' => $name), $this->initializer);
839 |
840 | unset($this->valueHolder->$name);
841 | }
842 |
843 | public function __clone()
844 | {
845 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__clone', array(), $this->initializer);
846 |
847 | $this->valueHolder = clone $this->valueHolder;
848 | }
849 |
850 | public function __sleep()
851 | {
852 | $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, '__sleep', array(), $this->initializer);
853 |
854 | return array('valueHolder');
855 | }
856 |
857 | public function __wakeup()
858 | {
859 | unset($this->foo);
860 | }
861 |
862 | public function setProxyInitializer(\Closure $initializer = null)
863 | {
864 | $this->initializer = $initializer;
865 | }
866 |
867 | public function getProxyInitializer()
868 | {
869 | return $this->initializer;
870 | }
871 |
872 | public function initializeProxy()
873 | {
874 | return $this->initializer && $this->initializer->__invoke($this->valueHolder, $this, 'initializeProxy', array(), $this->initializer);
875 | }
876 |
877 | public function isProxyInitialized()
878 | {
879 | return null !== $this->valueHolder;
880 | }
881 |
882 | public function getWrappedValueHolderValue()
883 | {
884 | return $this->valueHolder;
885 | }
886 | }Introducing ProxyManager
891 |
892 |
898 | https://github.com/Ocramius/ProxyManager
899 |
Avoid bringing out the generated garbage yourself!
904 |905 | (Currently) deals with 906 | Virtual Proxies, 907 | Smart References, 908 | Null Objects, 909 | Ghost Objects and 910 | Remote Objects 911 |
912 |Virtual Proxy with ProxyManager
916 |namespace My\Slow;
919 |
920 | class Foo
921 | {
922 | public function __construct()
923 | {
924 | sleep(10);
925 | }
926 |
927 | public function doFoo()
928 | {
929 | echo 'foo!';
930 | }
931 | }require_once 'vendor/autoload.php';
937 | use ProxyManager\Factory\LazyLoadingValueHolderFactory;
938 |
939 | $factory = new LazyLoadingValueHolderFactory();
940 |
941 | $proxy = $factory->createProxy(
942 | 'My\Slow\Foo',
943 | function (& $wrappedObject, $proxy) {
944 | $wrappedObject = new My\Slow\Foo();
945 |
946 | $proxy->setProxyInitializer(null);
947 | }
948 | );
949 |
950 | $proxy->doFoo();Smart Reference with ProxyManager
955 |require_once 'vendor/autoload.php';
958 | use ProxyManager\Factory\AccessInterceptorValueHolderFactory;
959 |
960 | $factory = new AccessInterceptorValueHolderFactory();
961 | $db = $factory->createProxy(
962 | new \My\Db\Connection(),
963 | ['query' => function () {
964 | echo "Query being executed!\n";
965 | }],
966 | ['query' => function () {
967 | echo "Query completed!\n";
968 | }]
969 | );
970 |
971 | $db->query();Yes, I'm no good at naming classes - really.
973 |
977 | Integrates with
978 |
979 | Symfony2
980 |
981 | and
982 |
983 | Zend Framework 2
984 |
985 | Virtual (Service) Proxies + Zend Framework 2
989 |return [
990 | 'service_manager' => [
991 | 'delegators' => [
992 | 'MyServiceName' => ['LazyServiceFactory']
993 | ],
994 | ],
995 | 'lazy_services' => [
996 | 'map' => ['MyServiceName' => 'My\Service\ClassName']
997 | ]
998 | ]Virtual (Service) Proxies + Symfony 2
1003 |<services>
1004 | <service
1005 | id="MyServiceName"
1006 | class="My\Service\ClassName"
1007 | lazy="true"
1008 | />
1009 | </services>Some useful libraries
1014 |1015 | 1016 | Doctrine's Proxy Generator 1017 | 1018 |
1019 |1020 | ProxyManager 1021 |
1022 | 1023 |1024 | schmittjoh/cg-library 1025 |
1026 |Proxies and AOP
1029 |
1030 |
1036 | lisachenko/go-aop-php
1037 |
1039 | Uses proxies for AOP purposes 1040 |
1041 |1042 | Very interesting usage of autoloaders! 1043 |
1044 |And before we get to the dirty stuff...
1048 |Questions?
1052 |
1053 |
1054 |
1060 |
1061 | Ocramius/proxy-pattern-in-php
1062 |
1064 |
1070 |
1076 | Ocramius
1077 |
Proxying Fluent Interfaces
1082 |1086 | Breaks Virtual Proxies, 1087 | Protection Proxies, and 1088 | Smart References 1089 |
1090 |More important:
1094 |Possible broken Encapsulation!
1098 |class BankAccount {
1102 | protected $amount = 0;
1103 |
1104 | public function pay($amount) {
1105 | $this->amount -= $amount;
1106 |
1107 | return $this;
1108 | }
1109 | }$account = new BankAccount();
1111 |
1112 | $account->pay(100)->pay(200)->pay(300);
1113 | Caution!
1118 |
Dirty hacks!
1120 |class BankAccountProxy extends BankAccount {
1124 | public function __construct(BankAccount $wrapped) {
1125 | $this->amount = & $wrapped->amount;
1126 | }
1127 |
1128 | public function pay($amount) {
1129 | echo 'Paid ' . $amount . "!\n";
1130 |
1131 | return parent::pay($amount);
1132 | }
1133 | }$account = new BankAccountProxy(new BankAccount());
1135 |
1136 | $account->pay(100)->pay(200)->pay(300);
1137 | Paid 100
1139 | Paid 200
1140 | Paid 300Public properties proxying
1145 |(without property accessors!)
1146 |class Customer {
1150 | public $name;
1151 | public $surname;
1152 | }Caution!
1158 |
Dirty hacks!
1160 |class Customer {
1164 | public $name;
1165 | public $surname;
1166 | }class CustomerProxy extends Customer {
1169 | public function __construct(Customer $customer) {
1170 | unset($this->name, $this->surname);
1171 | $this->customer = $customer;
1172 | } public function __set($name, $value) {
1175 | $this->customer->$name = $value;
1176 | }
1177 |
1178 | public function __get($name) {
1179 | return $this->customer->$name;
1180 | }
1181 |
1182 | // __isset, __unset
1183 | }Don't do this at home!
1188 |
1189 | Thank you!
1193 |
1194 |
1195 |
1201 |
1202 | Ocramius/proxy-pattern-in-php
1203 |