Achieving wise architecture with Symfony2 Wojciech Sznapka Silesian PHP User Group Gliwice, 26.XI.2013 

Cześć! 

Wojciech Sznapka Technical Manager @ XSolve Zend Certified Engineer since 2010 Symfony user since 2008 Coding since 2004 Besides: ice hockey, windsurfing, skiing, crime stories 

What is architecture? 

High level structure off the system 

Components abstractions connectors 

Understanding a system in its environment 

How can architecture be bad? 

Mixed responsibilities 

Poor separations of concerns 

Overloading servers due to an inefficient solutions 

Inability to scale 

Changes costs fortune 

Make it wisely with Symfony2 

Most popular framework in the PHP ecosystem 

Source: GitHub symfony/symfony, 26.XI.2013 

Built on top of best design patterns 

Universal rules to get system's design better 

Rule #1: SOLID 

ingle responsibility principle S O L I D pen/closed principle iskov substitution principle nterface segregation principle ependency inversion principle 

Each service should have exactly one purpose 

Side responsibilities should be placed in services and injected as dependencies 

class MailingManager implements MailingManagerInterface { protected $templateManager; public function __construct(TemplateManagerInterface $templateManager) { $this->templateManager = $templateManager; } public function createMailing($data, Mailing $mailing) { $body = $this->templateManager->applyTemplate( $mailing->getBody(), $mailing->getTitle()); $mailing->setBody($body); $mailing->setSubject($data['subject']); return $mailing; } } 

class TemplateManager implements TemplateManagerInterface { protected $templateContentTag = '{{ content }}'; protected $templateTitleTag = '{{ title }}'; public function applyTemplate($body, $title) { return str_replace( array($this->templateContentTag, $this->templateTitleTag), array($body, $title), $this->getActiveTemplateBody() ); } } 

Services should be closed for modification but opened for extension 

Extending system should not affect current behavior 

Idea 1. inheritance 

class ComplicatedBusinessLogic { public function __construct(DependencyOne $depOne, DependencyTwo $depTwo, DependencyThree $depThree, DependencyFour $depFour) { $this->depOne = $depOne; $this->depTwo = $depTwo; $this->depThree = $depThree; $this->depFour = $depFour; } public function performLogic($param1, $param2) { $partialResult = $this->getPartialResult($param1, $param2); // [...] do some really complicated logic return $finalResult; } protected function getPartialResult($param1, $param2) { // [...] produce partial result return $partialResult; } } 

class SpecyficBusinessLogic extends ComplicatedBusinessLogic { protected function getPartialResult($param1, $param2) { // produce partial result in a specific way // to change whole class behavior return $partialResultAltered; } } 

parameters: complicated_business_logic.class: ComplicatedBusinessLogic specyfic_business_logic.class: SpecyficBusinessLogic services: complicated_business_logic: class: %complicated_business_logic.class% arguments: - @dependency.one - @dependency.two - @dependency.three - @dependency.four specyfic_business_logic: class: %specyfic_business_logic.class% parent: complicated_business_logic 

Idea 2. Dependency Injection Container tags 

class Calculator { protected $evaluators; public function __construct() { $this->evaluators = array(); } public function registerEvaluator(EvaluatorInterface $evaluator) { $this->evaluator[] = $evaluator; } public function calculate($expression) { for ($this->evaluators as $evaluator) { if ($evaluator->accepts($expression)) { return $expression->calculate($expression); } } throw new \RuntimeException('No suitable evaluator here'); } } 

interface EvaluatorInterface { public function accepts($expression); public function calculate($expression); } 

class PlusEvaluator implements EvaluatorInterface { public function accepts($expression) { return strpos($expression, '+') !== false; } public function calculate($expression) { // do some calculations return $result; } } 

class MinusEvaluator implements EvaluatorInterface { public function accepts($expression) { return strpos($expression, '-') !== false; } public function calculate($expression) { // do some calculations return $result; } } 

parameters: plus_evaluator.class: PlusEvaluator minus_evaluator.class: MinusEvaluator calculator.class: Calculator services: calculator: class: %calculator.class% plus_evaluator: class: %plus_evaluator.class% tags: - {name: calculator.evaluator} minus_evaluator: class: %minus_evaluator.class% tags: - {name: calculator.evaluator} 

use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\Reference; class EvaluatorCompilerPass implements CompilerPassInterface { public function process(ContainerBuilder $container) { $definition = $container->getDefinition('calculator'); $svcs = $container->findTaggedServiceIds('calculator.evaluator'); foreach ($svcs as $id => $attributes) { $definition->addMethodCall( 'registerEvaluator', array(new Reference($id)) ); } } } 

It should be possible to replace class with other implementation 

The derived class should not change parent interface 

############## # services.yml ############## parameters: webservice_consumer.class: Wowo\Webservice\Consumer webservice_api_client.class: Wowo\Webservice\ApiClient services: webservice_consumer: class: %webservice_consumer.class% arguments: - @webservice_api_client webservice_api_client: class: %webservice_api_client.class% ################ # config_dev.yml ################ parameters: webservice_api_client: Wowo\Mocks\FakeDataMockProvider 

Interfaces should be fine grained 

Many specific interfaces are better than one general­purpose 

interface PlaceholderProcessorInterface { public function process($object, $body); } interface TemplateManagerInterface { public function setAvailableTemplates(array $templates); public function getAvailableTemplates(); public function applyTemplate($body, $title); } interface MediaManagerInterface { public function embed($body, \Swift_Message $message); public function getRegex($name); } interface BuilderInterface { public function buildMessage($mailingId, $contactId, $contactClass); } interface SenderInterface { public function send($mailingId, $contactId, $contactClass); } 

Application should be decoupled into modules which depend upon abstractions 

Do not depend upon concretions 

Type­hint methods with interfaces and abstract classes 

Rule #2: Testability 

Automated testing is a must have! 

Unit testing is quite easy if architecture is SOLID 

Only testing in isolation makes sens! 

class WebserviceConsumer { protected $client; protected $logger public function __construct(WebserviceApiClient $client, Logger $logger) { $this->client = $client; $this->logger = $logger; } public function getUser($name) { try { $this->logger->info(sprintf('Attempting get user %s', $name)); $user = $this->client->callGetUserDataFunction($name); // do something with data // wrap into suitable class // or transform it somehow $this->logger->info(sprintf('Got user data for %s', $name), array('user' => $user)); return $user; } catch (\Exception $e) { $this->logger->error(sprintf('%s occured while getting user: %s', get_class($e), $e->getMessage), array('exception' => $e)); throw new WebserviceException('GetUser error' , 0, $e); } } } 

class WebserviceTest extends \PHPUnit_Framework_TestCase { public function tearDown() { \Mockery::close(); } public function testSuccessfulGetUser() { $testData = array('name' => 'Wojciech', 'company' => 'Xsolve'); $clientMock = \Mockery::mock('WebserviceApiClient'); $clientMock ->shouldReceive('callGetUserDataFunction') ->times(1) ->andReturn($testData); $loggerMock = \Mockery::mock('\Monolog\Logger') ->shouldReceive('info') ->times(2); $consumer = new WebserviceApiClient($clientMock, $loggerMock); $this->assertEquals($testData, $consumer->getUser('Wojciech')); } } 

class WebserviceTest extends \PHPUnit_Framework_TestCase { public function tearDown() { \Mockery::close(); } /** @expectedException WebserviceException */ public function testFailuerWhileGettingUser() { $clientMock = \Mockery::mock('WebserviceApiClient'); $clientMock ->shouldReceive('callGetUserDataFunction') ->times(1) ->andThrow('\RuntimeException'); $loggerMock = \Mockery::mock('\Monolog\Logger') ->shouldReceive('info') ->times(1); $loggerMock ->shouldReceive('error') ->times(1); $consumer = new WebserviceApiClient($clientMock, $loggerMock); } } 

Rule #3: Scalability 

Forget about local disk! 

Keep sessions in global storage (memcached?) 

Store users' files global storage (S3/CDN?) 

Write logs to central logger like syslogd ... 

… or logstash using GELF protocol supported by Monolog 

Scale your DB with master/slave connections supported by Doctrine 

Wise architecture Ingredients (summary) 

Design based on SOLID principles 

Code covered with automatic tests 

Testable and verbose (logging) application 

Ready to scale horizontally 

Dziękuję! 

We are hiring! 

Wojciech Sznapka [email protected] blog.sznapka.pl @sznapka @wowo