Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Dependency injection with Symfony 2


Published on

A presentation on getting to understand dependency injection as well as the service container in Symfony2

Published in: Technology, Business

Dependency injection with Symfony 2

  1. 1. Dependency Injection and Symfony
  2. 2. IntroductionCameron MandersonDeveloper, Director of Flint, Melbourne Symfony2 Organisercameronmanderson@gmail.comFollow:
  3. 3. Topic Highlight• More in-depth look at the background of “Dependency Injection”• Aiming to uncover in Symfony – Modularity in our implementation – Loose decoupling of dependencies – Managing scope and access to dependencies
  4. 4. Background
  5. 5. Some terminology• Dependency – Something that is required by another object to fulfill its function• Dependent – A client object that needs a dependency in order to perform its function
  6. 6. Shown easiest like this..Dependent Dependency Like… Emailer Spell Checker
  7. 7. Example in code
  8. 8. This seems fine.. Right?
  9. 9. What about English or French?
  10. 10. Can we test it was called? – no…
  11. 11. We need an approach to handling these dependencies. We need looser coupling.
  12. 12. Dependency InjectionSo what is Dependency Injection?
  13. 13. Dependency InjectionDependency Injection“A design pattern whose purpose is to improve thetestability of, and simplify deployment of components”Essentially something that takes care of creating andlinking our objectsInvolves 3 parts• Our 2 objects; dependency and dependent• And.. An Injector to instantiate objects at runtime
  14. 14. ExampleInjector configures our objects at runtime,figuring out the order of creation Injector reads the dependencies, and Injector creates and stiches them together Dependent Dependency
  15. 15. So.. Why dependency injection?• Why do we need better management? – Applications are full of objects and dependencies • We want automation of construction • We want easy management of objects • We don’t want hundreds of Factories – Hard to manage those dependencies • Applications become tightly coupled to one-another • Difficult to swap out implementations • Manage configuration of those dependencies
  16. 16. Pre-dependency injection• How do we currently do it? – Hand-written construction – Using Factory patterns
  17. 17. Hand-construction
  18. 18. Factory
  19. 19. Enter Dependency Injection• Offset the instantiation of those objects to something else, as well as the dependencies – Some behind the scenes magic – Read a definition of how these dependencies should be handled – Create the objects and associate their dependencies• Scope (talk about later)
  20. 20. Injector/idioms• Simple logic: – Can it create the object yet? If there is a dependency, go create it.. Loop etc.• Essentially… a role to.. – Creating the “new” object when needed – Managing the dependencies • Constructor Injection • Setter Injection
  21. 21. Injector Configuration
  22. 22. Plain PHP files..
  23. 23. Constructor Injection• Constructor injection has dependencies in the constructor – Need to create the dependencies for the dependent first – Inject them through the constructor
  24. 24. Setter Injection• Create the object first and inject the dependents through methods (setters)
  25. 25. Some stuff to be careful of…• Circular dependencies – Oops. Be careful. (There are ways to handle.. Not yet in Symfony) A C B
  26. 26. So how does this help?• We are all about building modular applications – Decoupling dependencies – Making clear what the intent of the module is – Separation of concerns – Improve testability
  27. 27. Decoupling• Reduce the specific hard-value reliance – Facilitate swapping out new implementations – Reduce that complexity – Hopefully reduce the risk..
  28. 28. Make clear what it is• We want clear intent to our application – Make it easy to use and modify – “Program to contract” • Implement interfaces that clearly defines the intent of our code
  29. 29. Separation of concerns• We want to better encourage design to separate the concerns in our application – Discreet features• Application Logic vs Infrastructure Logic Application Infrastructure
  30. 30. Testability• Keep it clean – Avoiding static calls or singletons – Out of container testing easy – Easy to test concerns individually and manually define dependencies and mocks
  31. 31. We are lazy• It is much easier utilising a dependency injector to handle creating objects and handle those dependencies than to worry about implementing patterns and configuration yourself.
  32. 32. Basics… check!• That’s the theory – Dependencies exist in our application – Dependency injection assists creating and managing those objects – Makes our life easier• Let’s talk about Symfony and Services..
  33. 33. Symfony Service Architecture• Symfony is an Event Driven application• Also provides a dependency injector and service locator
  34. 34. The ServiceService – An object that performs a well defined function when called upon – Separated from other parts of the application – Implements an action • e.g. Template Renderer, Mail, etc
  35. 35. Configuring the Injector
  36. 36. Service Locator (Service Container)• Assists by providing a way to access services by “key”
  37. 37. Finding Keys• Might be a problem?• Symfony makes it easy, use the CLI
  38. 38. Further stuff to read…• Topics – Aliasing – Public and Private – Specifying parameters in your config.yml• _container.html
  39. 39. Wrapping it up• My experience with it has been that: – You are encouraged to write services that others can use and extend – Your applications are much easier to test – Scope is much easier to manage – It encourages others to implement their own domain logic when needed, thanking you how easy it is to implement their own part. ;-)
  40. 40. Conclusion• Covered the concepts of dependency injection – The problem – Using dependency injection to remove (code)• Showed how it applies in Symfony – Better decoupling, modularity and reuse