Symfony without bundles

Why your application code doesn’t need bundles.

Transcript

1. Aleš Šarkanj @alsar Symfony without bundles Why your application code doesn’t need bundles Symfony User Group Slovenia 30.6.2016
2. 2 In the beginning everything was...
3. 3 … a bundle
4. 4 The defnition
5. 5 A bundle is similar to a plugin in other software, but even better. The key diference is that everything is a bundle in Symfony, including both the core framework functionality and the code written for your application. Bundles are frst-class citizens in Symfony. symfony.com/doc/current/book/bundles.html
6. 6 A structured set of fles (PHP classes, templates, CSS fles, JS fles, images, ...)
7. 7 Implementing a single feature (eg. blog, forum, user management ...)
8. 8 Two types of bundles
9. 9 Reusable (standalone) bundles meant to be shared across many projects vendor/ Application-specifc bundles only used to build your application src/
10. 10 Bundle structure
12. 12 Bundle benefts
13. 13 Implementing specifc functionality (eg. FOSUserBundle)
14. 14 Solving cross-cutting concerns (eg. MonologBundle)
15. 15 Integrating libraries into the framework
16. 16 Reusable / shareable
17. 17 Bundle functionality available for your app through (fexible) confguration
18. 18 Easy to integrate into your app (install, enable, confgure, lean back)
19. 19 DIC setup through confguration
20. 20 All benefts apply to reusable bundles (nearly all)
21. 21 Everything is a bundle
22. 22 Reusable bundles == Application-specifc bundles
23. 23 Take #1
24. 24 CoreBundle UserBundle FrontendBundle BlogBundle ForumBundle ContactBundle AdminBundle BundleBundle BundleBundleBundle
25. 25 Problems?
26. 26 #1
27. 27 #2 Where to put comments? NewsBundle or BlogBundle?
28. 28 Eh… Just create a CommentBundle :)
29. 29 #3 Bundles are inter-depended
30. 30 #4 Bundle specifc structure Symfony specifc architecture (app coupled to the framework)
31. 31 #6 No real added value from bundles
32. 32 Solution
33. 33 Reusable bundles != Application-specifc bundles
34. 34 Take #2
35. 35 Move away from feature-per-bundle approach
36. 36 CoreBundle WebBundle
37. 37 Core functionality (domain) into CoreBundle Entities Repositories Services …
38. 38 “View” functionality into WebBundle Controllers Forms Templates ...
39. 39 Improvements
40. 40 Clear boundaries (we know what to put where)
41. 41 Less bundle overhead (no more 273 bundles)
42. 42 Problems?
43. 43 #1 Again, bundle specifc structure
44. 44 #2 Bundles are just a wrapper around layers
45. 45 Take #3
46. 46 Just one bundle for the whole app
47. 47 Official Symfony Best Practice since 2.6 https://symfony.com/blog/introducing-the-official-symfony-best-practices
48. 48 AppBundle
49. 49 New official understanding of bundles Reusable bundles != Application-specifc bundles
50. 50 Trying to remove unnecessary over complications
51. 51 Problems
52. 52 Basically the same as with Take #2
53. 53 Limited fexibility for your app logic
54. 54 Recap
55. 55 Bundles create (force) a Symfony specifc architecture inside src/
56. 56 No real beneft from bundles for your app logic
57. 57 A typical bundle inside src/ is not a real bundle Those are just directories grouped together inside a bundle directory
58. 58 Going one step further
59. 59 A natural evolution
60. 60 Symfony without bundles
61. 61 Why should I do that?
62. 62 Your app code should not be Symfony specifc (framework dependent)
63. 63 Freedom for your application architecture Framework agnostic architecture FTW
64. 64 First write your code Than integrate it with Symfony
65. 65 A typical Symfony app
66. 66 Basically everything can be confgured and moved out
67. 67 The easy stuf
68. 68 Confgs
69. 69 Just move everything into app/confg folder
70. 70 Translations
71. 71 # app/config/config.yml framework: translator: paths: - "%kernel.root_dir%/translations"
72. 72 Templates
73. 73 # app/config/config.yml twig: paths: "%kernel.root_dir%/../frontend/app/templates": app "%kernel.root_dir%/../frontend/admin/templates": admin
74. 74 @app/default/index.html.twig
75. 75 Entities
76. 76 # app/config/config.yml doctrine: orm: entity_managers: default: mappings: Core: type: yml prefix: Core dir: %kernel.root_dir%/app/config/mapping/Core is_bundle: false Foo: type: annotation prefix: Foo dir: %kernel.root_dir%/../src/Core/Model is_bundle: false
77. 77 Repositories
78. 78 Repositories can be anywhere by default
79. 79 # app/config/mapping/Core/Profile.orm.yml Core\Entity\Profile: type: entity repositoryClass: Core\Repository\ProfileRepository
80. 80 Controllers
81. 81 # app/config/routing.yml app_default: resource: App\Controller\DefaultController type: annotation
82. 82 Services in the DIC
83. 83 Services can be anywhere by default
84. 84 # app/config/services.yml services: user_importer: class: Import\UserImporter arguments: - "@user_manager"
86. 86 What about functionality tied to the bundle system? (eg. compiler passes, DI extensions...)
87. 87 Use the AppKernel directly
88. 88 Compiler passes
89. 89 Hook an compiler pass directly into the container build process in the AppKernel
90. 90 class AppKernel extends Kernel { [...] protected function buildContainer() { $containerBuilder = parent::buildContainer(); $containerBuilder->addCompilerPass(new ExampleCompilerPass()); return $containerBuilder; }
91. 91 Dependency Injection Extensions
92. 92 class AppConfiguration implements ConfigurationInterface { public function getConfigTreeBuilder() { $treeBuilder = new TreeBuilder(); $rootNode = $treeBuilder->root('app'); $rootNode->children() ->scalarNode('edit_interval')->isRequired()->end() ->booleanNode('foo')->isRequired()->end() ->end(); return $treeBuilder; } }
93. 93 # app/config/config.yml app: edit_interval: P7D foo: true
94. 94 class AppExtension extends Extension { public function load(array $configs, ContainerBuilder $container) { $configuration = new AppConfiguration(); $config = $this->processConfiguration($configuration, $configs); $d = new Definition(); $d->setClass('DateInterval'); $d->addArgument($config['edit_interval']); $container->setDefinition('edit_interval', $d); } public function getAlias() { return 'app'; } }
95. 95 Register the extension directly in AppKernel
96. 96 class AppKernel extends Kernel { [...] protected function prepareContainer(ContainerBuilder $container) { parent::prepareContainer($container); $container->registerExtension(new AppExtension()); } }
98. 98 Drawbacks
99. 99 Little bit more confguration
100. 100 Some “syntactic sugar” not available anymore (eg. Bundle:Controller notation)
101. 101 Console code generation commands don’t work (properly) anymore
102. 102 Benefts
103. 103 Your src/ folder is liberated from the bundle concept
104. 104 Framework agnostic development
105. 105 Adjust the framework to your architecture, not the other way around
106. 106 Should I never use bundles in my app anymore?
107. 107 Never, ever… again :)
108. 108 It’s nothing wrong with the AppBundle aproach
109. 109 Choose an approach that meets your needs
110. 110 https://github.com/alsar/symfony-bundleless-demo
111. 111 Resources https://symfony.com/doc/current/best_practices/creating-the-project.html#application-bundles https://knpuniversity.com/blog/AppBundle http://elnur.pro/symfony-without-bundles
112. 112 $presentation terminate(); →
113. 113 ?