Achieving wise architecture with Symfony2

Web application's sector is exploding nowadays showing that browser based systems are most common approach to satisfy business needs. Building a product which is going to work on a long mile requires good architectural decisions and appropriate tools stack.
Symfony2 is the best shot, when it comes to framework. Accompanied by some modern tools, good design practises and well structured code base creates easy way for the system, to be open for extensions, robust and maintainable, prepared to handle high load.
In this talk some real life examples from working Symfony2 applications will be used to ilustrate ingredients of wise architecture.

Transcript

1. Achieving wise architecture with Symfony2 Wojciech Sznapka 4Developers 2013
2. Cześć!
3. Wojciech Sznapka Technical Manager @ XSolve Zend Certified Engineer since 2010 Symfony user since 2008 Coding in PHP since 2004 Besides: ice hockey, windsurfing, skiing, crime stories
4. What is architecture?
5. High level structure off the system
6. Components abstractions connectors
7. Understanding a system in its environment
8. How can architecture be bad?
9. Mixed responsibilities
10. Poor separations of concerns
11. Changes costs fortune
12. Overloading servers due to an inefficient solutions
13. Inability to scale
14. Yes, that's bad!
15. Make it wisely with Symfony2
16. Most popular framework in the PHP ecosystem
17. 2078 Forks 6245 Favorites 1910 Bundles
18. Built on top of best design patterns
19. So... is Symfony2 a silver bullet?
20. Symfony2 is only good tool ...
21. … but good tools don't build systems themselves
22. Universal rules to get system's design better
23. Rule #1: SOLID
24. ingle responsibility principle S O L I D pen/closed principle iskov substitution principle nterface segregation principle ependency inversion principle
25. Each service should have exactly one purpose
26. Side responsibilities should be placed in services and injected as dependencies
27. 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; } }
28. 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() ); } }
29. Services should be closed for modification but opened for extension
30. Extending system should not affect current behavior
31. Solution 1. inheritance
32. 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; } }
33. class SpecyficBusinessLogic extends ComplicatedBusinessLogic { protected function getPartialResult($param1, $param2) { // produce partial result in a specific way // to change whole class behavior return $partialResultAltered; } }
34. 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
35. Solution 2. DIC tags
36. 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'); } }
37. interface EvaluatorInterface { public function accepts($expression); public function calculate($expression); }
38. class PlusEvaluator implements EvaluatorInterface { public function accepts($expression) { return strpos($expression, '+') !== false; } public function calculate($expression) { // do some calculations return $result; } }
39. class MinusEvaluator implements EvaluatorInterface { public function accepts($expression) { return strpos($expression, '-') !== false; } public function calculate($expression) { // do some calculations return $result; } }
40. 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}
41. 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)) ); } } }
42. It should be possible to replace class with other implementation
43. ############## # 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
44. Interfaces should be fine grained
45. Many specific interfaces are better than one general­purpose
46. 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); }
47. Application should be decoupled into modules which depend upon abstractions
48. Do not depend upon concretions
49. Type­hint methods with interfaces and abstract classes
50. Rule #2: Testability
51. Live applications needs to be tested
52. Unit testing is quite easy if architecture is SOLID
53. Only testing in isolation makes sens !
54. 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); } } }
55. 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')); } }
56. 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); } }
57. Rule #3: Scalability
58. Forget about local disk !
59. Keep sessions in global storage like database or NoSQL
60. Store user files global storage for example in Amazon S3
61. Write logs to central logger like syslogd ...
62. … or logstash using GELF protocol supported by Monolog
63. Scale your DB with master/slave connections supported Doctrine since Symfony 2.1
64. Wise architecture ingredients
65. Design based on SOLID principles
66. Code covered with automatic tests
67. Testable and verbose (logging) application
68. Ready to scale horizontally
69. Dziękuję!
70. We are hiring!
71. Wojciech Sznapka wojciech@sznapka.pl blog.sznapka.pl @sznapka @wowo